diff --git a/CHANGELOG.md b/CHANGELOG.md index e27b8bb90..64c7d8dd3 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -11,5 +11,7 @@ - [Feature：support pushGateway push metrics](https://github.com/Tencent/spring-cloud-tencent/pull/504) - [Refactor : optimize project and code](https://github.com/Tencent/spring-cloud-tencent/pull/506) - [Fix typo & Code optimization](https://github.com/Tencent/spring-cloud-tencent/pull/507) +- [Code optimization for rpc-enhancement module](https://github.com/Tencent/spring-cloud-tencent/pull/510) - [Bugfix：BeanFactoryUtils returns all beans including beans defined in ancestor bean factories](https://github.com/Tencent/spring-cloud-tencent/pull/515) - [fix:fix only config file metadata can be used in routing bug.](https://github.com/Tencent/spring-cloud-tencent/pull/518) +- [optimize：optimize config module code](https://github.com/Tencent/spring-cloud-tencent/pull/520) diff --git a/spring-cloud-starter-tencent-polaris-config/src/main/java/com/tencent/cloud/polaris/config/spring/annotation/PolarisProcessor.java b/spring-cloud-starter-tencent-polaris-config/src/main/java/com/tencent/cloud/polaris/config/spring/annotation/PolarisProcessor.java index f0ee2753d..42f69f8d7 100644 --- a/spring-cloud-starter-tencent-polaris-config/src/main/java/com/tencent/cloud/polaris/config/spring/annotation/PolarisProcessor.java +++ b/spring-cloud-starter-tencent-polaris-config/src/main/java/com/tencent/cloud/polaris/config/spring/annotation/PolarisProcessor.java @@ -27,6 +27,7 @@ import org.springframework.beans.BeansException; import org.springframework.beans.factory.config.BeanPostProcessor; import org.springframework.core.Ordered; import org.springframework.core.PriorityOrdered; +import org.springframework.lang.NonNull; import org.springframework.util.ReflectionUtils; /** @@ -37,9 +38,9 @@ import org.springframework.util.ReflectionUtils; public abstract class PolarisProcessor implements BeanPostProcessor, PriorityOrdered { @Override - public Object postProcessBeforeInitialization(Object bean, String beanName) + public Object postProcessBeforeInitialization(Object bean, @NonNull String beanName) throws BeansException { - Class clazz = bean.getClass(); + Class clazz = bean.getClass(); for (Field field : findAllField(clazz)) { processField(bean, beanName, field); } @@ -50,7 +51,7 @@ public abstract class PolarisProcessor implements BeanPostProcessor, PriorityOrd } @Override - public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { + public Object postProcessAfterInitialization(@NonNull Object bean, @NonNull String beanName) throws BeansException { return bean; } @@ -77,15 +78,15 @@ public abstract class PolarisProcessor implements BeanPostProcessor, PriorityOrd return Ordered.LOWEST_PRECEDENCE; } - private List findAllField(Class clazz) { + private List findAllField(Class clazz) { final List res = new LinkedList<>(); - ReflectionUtils.doWithFields(clazz, field -> res.add(field)); + ReflectionUtils.doWithFields(clazz, res::add); return res; } - private List findAllMethod(Class clazz) { + private List findAllMethod(Class clazz) { final List res = new LinkedList<>(); - ReflectionUtils.doWithMethods(clazz, method -> res.add(method)); + ReflectionUtils.doWithMethods(clazz, res::add); return res; } } diff --git a/spring-cloud-starter-tencent-polaris-config/src/main/java/com/tencent/cloud/polaris/config/spring/annotation/SpringValueProcessor.java b/spring-cloud-starter-tencent-polaris-config/src/main/java/com/tencent/cloud/polaris/config/spring/annotation/SpringValueProcessor.java index da71bd70f..24279e07e 100644 --- a/spring-cloud-starter-tencent-polaris-config/src/main/java/com/tencent/cloud/polaris/config/spring/annotation/SpringValueProcessor.java +++ b/spring-cloud-starter-tencent-polaris-config/src/main/java/com/tencent/cloud/polaris/config/spring/annotation/SpringValueProcessor.java @@ -87,7 +87,7 @@ public class SpringValueProcessor extends PolarisProcessor implements BeanFactor } @Override - public Object postProcessBeforeInitialization(Object bean, String beanName) + public Object postProcessBeforeInitialization(Object bean, @NonNull String beanName) throws BeansException { if (polarisConfigProperties.isAutoRefresh()) { super.postProcessBeforeInitialization(bean, beanName); diff --git a/spring-cloud-starter-tencent-polaris-config/src/main/java/com/tencent/cloud/polaris/config/spring/property/PlaceholderHelper.java b/spring-cloud-starter-tencent-polaris-config/src/main/java/com/tencent/cloud/polaris/config/spring/property/PlaceholderHelper.java index 2d7515661..a2223dc78 100644 --- a/spring-cloud-starter-tencent-polaris-config/src/main/java/com/tencent/cloud/polaris/config/spring/property/PlaceholderHelper.java +++ b/spring-cloud-starter-tencent-polaris-config/src/main/java/com/tencent/cloud/polaris/config/spring/property/PlaceholderHelper.java @@ -71,7 +71,7 @@ public class PlaceholderHelper { if (beanFactory.getBeanExpressionResolver() == null) { return value; } - Scope scope = (beanDefinition != null ? beanFactory + Scope scope = (beanDefinition != null && beanDefinition.getScope() != null ? beanFactory .getRegisteredScope(beanDefinition.getScope()) : null); return beanFactory.getBeanExpressionResolver() .evaluate(value, new BeanExpressionContext(beanFactory, scope)); @@ -92,7 +92,7 @@ public class PlaceholderHelper { public Set extractPlaceholderKeys(String propertyString) { Set placeholderKeys = Sets.newHashSet(); - if (Strings.isNullOrEmpty(propertyString) || (!isNormalizedPlaceholder(propertyString) && !isExpressionWithPlaceholder(propertyString))) { + if (!isPlaceholder(propertyString)) { return placeholderKeys; } @@ -147,6 +147,11 @@ public class PlaceholderHelper { return placeholderKeys; } + private boolean isPlaceholder(String propertyString) { + return !Strings.isNullOrEmpty(propertyString) && + (isNormalizedPlaceholder(propertyString) || isExpressionWithPlaceholder(propertyString)); + } + private boolean isNormalizedPlaceholder(String propertyString) { return propertyString.startsWith(PLACEHOLDER_PREFIX) && propertyString.contains(PLACEHOLDER_SUFFIX); } diff --git a/spring-cloud-starter-tencent-polaris-config/src/main/java/com/tencent/cloud/polaris/config/spring/property/SpringValue.java b/spring-cloud-starter-tencent-polaris-config/src/main/java/com/tencent/cloud/polaris/config/spring/property/SpringValue.java index c092b96d5..ddde1f525 100644 --- a/spring-cloud-starter-tencent-polaris-config/src/main/java/com/tencent/cloud/polaris/config/spring/property/SpringValue.java +++ b/spring-cloud-starter-tencent-polaris-config/src/main/java/com/tencent/cloud/polaris/config/spring/property/SpringValue.java @@ -86,7 +86,7 @@ public class SpringValue { private void injectMethod(Object newVal) throws InvocationTargetException, IllegalAccessException { Object bean = beanRef.get(); - if (bean == null) { + if (bean == null || methodParameter.getMethod() == null) { return; } methodParameter.getMethod().invoke(bean, newVal); @@ -131,7 +131,12 @@ public class SpringValue { .format("key: %s, beanName: %s, field: %s.%s", key, beanName, bean.getClass() .getName(), field.getName()); } - return String.format("key: %s, beanName: %s, method: %s.%s", key, beanName, bean.getClass().getName(), - methodParameter.getMethod().getName()); + if (null != methodParameter.getMethod()) { + return String.format("key: %s, beanName: %s, method: %s.%s", key, beanName, bean.getClass().getName(), + methodParameter.getMethod().getName()); + } + else { + return String.format("key: %s, beanName: %s", key, beanName); + } } } diff --git a/spring-cloud-starter-tencent-polaris-config/src/test/java/com/tencent/cloud/polaris/config/spring/annotation/SpringValueProcessorTest.java b/spring-cloud-starter-tencent-polaris-config/src/test/java/com/tencent/cloud/polaris/config/spring/annotation/SpringValueProcessorTest.java new file mode 100644 index 000000000..fb57206bb --- /dev/null +++ b/spring-cloud-starter-tencent-polaris-config/src/test/java/com/tencent/cloud/polaris/config/spring/annotation/SpringValueProcessorTest.java @@ -0,0 +1,153 @@ +/* + * Tencent is pleased to support the open source community by making Spring Cloud Tencent available. + * + * Copyright (C) 2019 THL A29 Limited, a Tencent company. All rights reserved. + * + * Licensed under the BSD 3-Clause License (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://opensource.org/licenses/BSD-3-Clause + * + * Unless required by applicable law or agreed to in writing, software distributed + * under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR + * CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + * + */ + +package com.tencent.cloud.polaris.config.spring.annotation; + +import java.lang.reflect.Method; +import java.util.Collection; +import java.util.Objects; +import java.util.Optional; + +import com.tencent.cloud.polaris.config.PolarisConfigBootstrapAutoConfiguration; +import com.tencent.cloud.polaris.config.enums.RefreshType; +import com.tencent.cloud.polaris.config.spring.property.SpringValue; +import com.tencent.cloud.polaris.config.spring.property.SpringValueRegistry; +import com.tencent.polaris.api.utils.CollectionUtils; +import org.junit.Assert; +import org.junit.Test; + +import org.springframework.beans.factory.BeanFactory; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.boot.autoconfigure.AutoConfigurations; +import org.springframework.boot.autoconfigure.EnableAutoConfiguration; +import org.springframework.boot.test.context.runner.ApplicationContextRunner; +import org.springframework.cloud.autoconfigure.RefreshAutoConfiguration; +import org.springframework.context.annotation.Configuration; +import org.springframework.stereotype.Component; + +/** + * Test for {@link SpringValueProcessor}. + * + * @author lingxiao.wlx + */ +public class SpringValueProcessorTest { + + @Test + public void springValueFiledProcessorTest() { + ApplicationContextRunner contextRunner = new ApplicationContextRunner() + .withConfiguration(AutoConfigurations.of(PolarisConfigBootstrapAutoConfiguration.class)) + .withConfiguration(AutoConfigurations.of(RefreshAutoConfiguration.class)) + .withConfiguration(AutoConfigurations.of(ValueTest.class)) + .withConfiguration(AutoConfigurations.of(PolarisConfigAutoConfiguration.class)) + .withPropertyValues("spring.application.name=" + "conditionalOnConfigReflectEnabledTest") + .withPropertyValues("spring.cloud.polaris.address=grpc://127.0.0.1:10081") + .withPropertyValues("spring.cloud.polaris.config.refresh-type=" + RefreshType.REFLECT) + .withPropertyValues("spring.cloud.polaris.config.enabled=true") + .withPropertyValues("timeout=10000"); + contextRunner.run(context -> { + SpringValueRegistry springValueRegistry = context.getBean(SpringValueRegistry.class); + PolarisConfigAutoConfiguration polarisConfigAutoConfiguration = context.getBean(PolarisConfigAutoConfiguration.class); + BeanFactory beanFactory = polarisConfigAutoConfiguration.beanFactory; + Collection timeout = springValueRegistry.get(beanFactory, "timeout"); + Assert.assertFalse(CollectionUtils.isEmpty(timeout)); + Optional springValueOptional = timeout.stream().findAny(); + Assert.assertTrue(springValueOptional.isPresent()); + + SpringValue springValue = springValueOptional.get(); + Assert.assertEquals("${timeout:1000}", springValue.getPlaceholder()); + Assert.assertTrue(springValue.isField()); + Assert.assertTrue(Objects.nonNull(springValue.getField())); + Assert.assertEquals("timeout", springValue.getField().getName()); + Assert.assertEquals(int.class, springValue.getTargetType()); + + ValueTest bean = context.getBean(ValueTest.class); + Assert.assertEquals(10000, bean.timeout); + }); + } + + @Test + public void springValueMethodProcessorTest() { + ApplicationContextRunner contextRunner = new ApplicationContextRunner() + .withConfiguration(AutoConfigurations.of(PolarisConfigBootstrapAutoConfiguration.class)) + .withConfiguration(AutoConfigurations.of(RefreshAutoConfiguration.class)) + .withConfiguration(AutoConfigurations.of(ValueTest.class)) + .withConfiguration(AutoConfigurations.of(PolarisConfigAutoConfiguration.class)) + .withPropertyValues("spring.application.name=" + "conditionalOnConfigReflectEnabledTest") + .withPropertyValues("spring.cloud.polaris.address=grpc://127.0.0.1:10081") + .withPropertyValues("spring.cloud.polaris.config.refresh-type=" + RefreshType.REFLECT) + .withPropertyValues("spring.cloud.polaris.config.enabled=true") + .withPropertyValues("name=test"); + contextRunner.run(context -> { + SpringValueRegistry springValueRegistry = context.getBean(SpringValueRegistry.class); + PolarisConfigAutoConfiguration polarisConfigAutoConfiguration = context.getBean(PolarisConfigAutoConfiguration.class); + BeanFactory beanFactory = polarisConfigAutoConfiguration.beanFactory; + Collection name = springValueRegistry.get(beanFactory, "name"); + Assert.assertFalse(CollectionUtils.isEmpty(name)); + Optional springValueOptional = name.stream().findAny(); + Assert.assertTrue(springValueOptional.isPresent()); + + SpringValue springValue = springValueOptional.get(); + Method method = springValue.getMethodParameter().getMethod(); + Assert.assertTrue(Objects.nonNull(method)); + Assert.assertEquals("setName", method.getName()); + Assert.assertEquals("${name:1000}", springValue.getPlaceholder()); + Assert.assertFalse(springValue.isField()); + Assert.assertEquals(String.class, springValue.getTargetType()); + + Assert.assertEquals("test", ValueTest.name); + }); + } + + @Configuration + @EnableAutoConfiguration + static class PolarisConfigAutoConfiguration { + + @Autowired + private BeanFactory beanFactory; + + public BeanFactory getBeanFactory() { + return beanFactory; + } + + public void setBeanFactory(BeanFactory beanFactory) { + this.beanFactory = beanFactory; + } + } + + @Component + private static class ValueTest { + @Value("${timeout:1000}") + private int timeout; + + private static String name; + + public int getTimeout() { + return timeout; + } + + public void setTimeout(int timeout) { + this.timeout = timeout; + } + + @Value("${name:1000}") + public void setName(String name) { + ValueTest.name = name; + } + } +} diff --git a/spring-cloud-starter-tencent-polaris-config/src/test/java/com/tencent/cloud/polaris/config/spring/property/Person.java b/spring-cloud-starter-tencent-polaris-config/src/test/java/com/tencent/cloud/polaris/config/spring/property/Person.java new file mode 100644 index 000000000..5a09fb880 --- /dev/null +++ b/spring-cloud-starter-tencent-polaris-config/src/test/java/com/tencent/cloud/polaris/config/spring/property/Person.java @@ -0,0 +1,67 @@ +/* + * Tencent is pleased to support the open source community by making Spring Cloud Tencent available. + * + * Copyright (C) 2019 THL A29 Limited, a Tencent company. All rights reserved. + * + * Licensed under the BSD 3-Clause License (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://opensource.org/licenses/BSD-3-Clause + * + * Unless required by applicable law or agreed to in writing, software distributed + * under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR + * CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + * + */ + +package com.tencent.cloud.polaris.config.spring.property; + +import org.springframework.beans.BeansException; +import org.springframework.beans.factory.BeanFactory; +import org.springframework.beans.factory.BeanFactoryAware; + +/** + * Test example. + * + * @author lingxiao.wlx + */ +public class Person implements BeanFactoryAware { + + private String name; + + private String age; + + private BeanFactory beanFactory; + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } + + public String getAge() { + return age; + } + + public void setAge(String age) { + this.age = age; + } + + public BeanFactory getBeanFactory() { + return beanFactory; + } + + @Override + public String toString() { + return "User{" + "name='" + name + '\'' + ", age=" + age + '}'; + } + + @Override + public void setBeanFactory(BeanFactory beanFactory) throws BeansException { + this.beanFactory = beanFactory; + } +} diff --git a/spring-cloud-starter-tencent-polaris-config/src/test/java/com/tencent/cloud/polaris/config/spring/property/PlaceholderHelperTest.java b/spring-cloud-starter-tencent-polaris-config/src/test/java/com/tencent/cloud/polaris/config/spring/property/PlaceholderHelperTest.java new file mode 100644 index 000000000..a605dda88 --- /dev/null +++ b/spring-cloud-starter-tencent-polaris-config/src/test/java/com/tencent/cloud/polaris/config/spring/property/PlaceholderHelperTest.java @@ -0,0 +1,88 @@ +/* + * Tencent is pleased to support the open source community by making Spring Cloud Tencent available. + * + * Copyright (C) 2019 THL A29 Limited, a Tencent company. All rights reserved. + * + * Licensed under the BSD 3-Clause License (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://opensource.org/licenses/BSD-3-Clause + * + * Unless required by applicable law or agreed to in writing, software distributed + * under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR + * CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + * + */ + +package com.tencent.cloud.polaris.config.spring.property; + +import java.util.Set; + +import com.tencent.polaris.api.utils.CollectionUtils; +import org.junit.Assert; +import org.junit.Test; + +/** + * Test for {@link PlaceholderHelper}. + * + * @author lingxiao.wlx + */ +public class PlaceholderHelperTest { + + private static final PlaceholderHelper PLACEHOLDER_HELPER = new PlaceholderHelper(); + + @Test + public void extractNormalPlaceholderKeysTest() { + final String placeholderCase = "${some.key}"; + final String placeholderCase1 = "${some.key:${some.other.key:100}}"; + final String placeholderCase2 = "${${some.key}}"; + final String placeholderCase3 = "${${some.key:other.key}}"; + final String placeholderCase4 = "${${some.key}:${another.key}}"; + final String placeholderCase5 = "#{new java.text.SimpleDateFormat('${some.key}').parse('${another.key}')}"; + + Set placeholderKeys = PLACEHOLDER_HELPER.extractPlaceholderKeys(placeholderCase); + Assert.assertEquals(1, placeholderKeys.size()); + Assert.assertTrue(placeholderKeys.contains("some.key")); + + Set placeholderKeys1 = PLACEHOLDER_HELPER.extractPlaceholderKeys(placeholderCase1); + Assert.assertEquals(2, placeholderKeys1.size()); + Assert.assertTrue(placeholderKeys1.contains("some.key")); + Assert.assertTrue(placeholderKeys1.contains("some.other.key")); + + Set placeholderKeys2 = PLACEHOLDER_HELPER.extractPlaceholderKeys(placeholderCase2); + Assert.assertEquals(1, placeholderKeys2.size()); + Assert.assertTrue(placeholderKeys2.contains("some.key")); + + Set placeholderKeys3 = PLACEHOLDER_HELPER.extractPlaceholderKeys(placeholderCase3); + Assert.assertEquals(1, placeholderKeys3.size()); + Assert.assertTrue(placeholderKeys3.contains("some.key")); + + Set placeholderKeys4 = PLACEHOLDER_HELPER.extractPlaceholderKeys(placeholderCase4); + Assert.assertEquals(2, placeholderKeys4.size()); + Assert.assertTrue(placeholderKeys4.contains("some.key")); + Assert.assertTrue(placeholderKeys4.contains("another.key")); + + Set placeholderKeys5 = PLACEHOLDER_HELPER.extractPlaceholderKeys(placeholderCase5); + Assert.assertEquals(2, placeholderKeys5.size()); + Assert.assertTrue(placeholderKeys5.contains("some.key")); + Assert.assertTrue(placeholderKeys5.contains("another.key")); + } + + @Test + public void extractIllegalPlaceholderKeysTest() { + final String placeholderCase = "${some.key"; + final String placeholderCase1 = "{some.key}"; + final String placeholderCase2 = "some.key"; + + Set placeholderKeys = PLACEHOLDER_HELPER.extractPlaceholderKeys(placeholderCase); + Assert.assertTrue(CollectionUtils.isEmpty(placeholderKeys)); + + Set placeholderKeys1 = PLACEHOLDER_HELPER.extractPlaceholderKeys(placeholderCase1); + Assert.assertTrue(CollectionUtils.isEmpty(placeholderKeys1)); + + Set placeholderKeys2 = PLACEHOLDER_HELPER.extractPlaceholderKeys(placeholderCase2); + Assert.assertTrue(CollectionUtils.isEmpty(placeholderKeys2)); + } +} diff --git a/spring-cloud-starter-tencent-polaris-config/src/test/java/com/tencent/cloud/polaris/config/spring/property/SpringValueDefinitionProcessorTest.java b/spring-cloud-starter-tencent-polaris-config/src/test/java/com/tencent/cloud/polaris/config/spring/property/SpringValueDefinitionProcessorTest.java new file mode 100644 index 000000000..c82980a41 --- /dev/null +++ b/spring-cloud-starter-tencent-polaris-config/src/test/java/com/tencent/cloud/polaris/config/spring/property/SpringValueDefinitionProcessorTest.java @@ -0,0 +1,75 @@ +/* + * Tencent is pleased to support the open source community by making Spring Cloud Tencent available. + * + * Copyright (C) 2019 THL A29 Limited, a Tencent company. All rights reserved. + * + * Licensed under the BSD 3-Clause License (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://opensource.org/licenses/BSD-3-Clause + * + * Unless required by applicable law or agreed to in writing, software distributed + * under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR + * CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + * + */ + +package com.tencent.cloud.polaris.config.spring.property; + +import java.lang.reflect.Method; +import java.util.Collection; +import java.util.Objects; +import java.util.Optional; + +import com.tencent.polaris.api.utils.CollectionUtils; +import org.junit.Assert; +import org.junit.Test; + +import org.springframework.beans.factory.BeanFactory; +import org.springframework.context.support.ClassPathXmlApplicationContext; + +/** + * Test for {@link SpringValueDefinitionProcessor}. + * + * @author lingxiao.wlx + */ +public class SpringValueDefinitionProcessorTest { + + @Test + public void springValueDefinitionProcessorTest() { + ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean.xml"); + Person person = context.getBean(Person.class); + + SpringValueRegistry springValueRegistry = context.getBean(SpringValueRegistry.class); + + BeanFactory beanFactory = person.getBeanFactory(); + Collection name = springValueRegistry.get(beanFactory, "name"); + Assert.assertFalse(CollectionUtils.isEmpty(name)); + Optional nameSpringValueOptional = name.stream().findAny(); + Assert.assertTrue(nameSpringValueOptional.isPresent()); + + SpringValue nameSpringValue = nameSpringValueOptional.get(); + Method method = nameSpringValue.getMethodParameter().getMethod(); + Assert.assertTrue(Objects.nonNull(method)); + Assert.assertEquals("setName", method.getName()); + Assert.assertEquals("${name:test}", nameSpringValue.getPlaceholder()); + Assert.assertFalse(nameSpringValue.isField()); + Assert.assertEquals(String.class, nameSpringValue.getTargetType()); + + + Collection age = springValueRegistry.get(beanFactory, "age"); + Assert.assertFalse(CollectionUtils.isEmpty(age)); + Optional ageSpringValueOptional = age.stream().findAny(); + Assert.assertTrue(ageSpringValueOptional.isPresent()); + + SpringValue ageSpringValue = ageSpringValueOptional.get(); + Method method1 = ageSpringValue.getMethodParameter().getMethod(); + Assert.assertTrue(Objects.nonNull(method1)); + Assert.assertEquals("setAge", method1.getName()); + Assert.assertEquals("${age:10}", ageSpringValue.getPlaceholder()); + Assert.assertFalse(ageSpringValue.isField()); + Assert.assertEquals(String.class, ageSpringValue.getTargetType()); + } +} diff --git a/spring-cloud-starter-tencent-polaris-config/src/test/resources/application-test.properties b/spring-cloud-starter-tencent-polaris-config/src/test/resources/application-test.properties new file mode 100644 index 000000000..613f52d5e --- /dev/null +++ b/spring-cloud-starter-tencent-polaris-config/src/test/resources/application-test.properties @@ -0,0 +1,2 @@ +name=test +age=10 diff --git a/spring-cloud-starter-tencent-polaris-config/src/test/resources/bean.xml b/spring-cloud-starter-tencent-polaris-config/src/test/resources/bean.xml new file mode 100644 index 000000000..e60613a5a --- /dev/null +++ b/spring-cloud-starter-tencent-polaris-config/src/test/resources/bean.xml @@ -0,0 +1,38 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/config/RpcEnhancementAutoConfiguration.java b/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/config/RpcEnhancementAutoConfiguration.java index d7cd05fa3..e337f6a6a 100644 --- a/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/config/RpcEnhancementAutoConfiguration.java +++ b/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/config/RpcEnhancementAutoConfiguration.java @@ -20,11 +20,12 @@ package com.tencent.cloud.rpc.enhancement.config; import java.util.List; import com.tencent.cloud.polaris.context.config.PolarisContextAutoConfiguration; +import com.tencent.cloud.rpc.enhancement.feign.DefaultEnhancedFeignPluginRunner; import com.tencent.cloud.rpc.enhancement.feign.EnhancedFeignBeanPostProcessor; +import com.tencent.cloud.rpc.enhancement.feign.EnhancedFeignPluginRunner; import com.tencent.cloud.rpc.enhancement.feign.plugin.EnhancedFeignPlugin; import com.tencent.cloud.rpc.enhancement.feign.plugin.reporter.ExceptionPolarisReporter; import com.tencent.cloud.rpc.enhancement.feign.plugin.reporter.SuccessPolarisReporter; -import com.tencent.cloud.rpc.enhancement.resttemplate.EnhancedRestTemplateModifier; import com.tencent.cloud.rpc.enhancement.resttemplate.EnhancedRestTemplateReporter; import com.tencent.polaris.api.core.ConsumerAPI; @@ -34,13 +35,11 @@ import org.springframework.boot.autoconfigure.AutoConfigureBefore; import org.springframework.boot.autoconfigure.condition.ConditionalOnClass; import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; import org.springframework.boot.context.properties.EnableConfigurationProperties; +import org.springframework.cloud.client.loadbalancer.RestTemplateCustomizer; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; -import org.springframework.core.annotation.Order; import org.springframework.web.client.RestTemplate; -import static org.springframework.core.Ordered.HIGHEST_PRECEDENCE; - /** * Auto Configuration for Polaris {@link feign.Feign} OR {@link RestTemplate} which can automatically bring in the call * results for reporting. @@ -65,10 +64,14 @@ public class RpcEnhancementAutoConfiguration { protected static class PolarisFeignClientAutoConfiguration { @Bean - @Order(HIGHEST_PRECEDENCE) - public EnhancedFeignBeanPostProcessor polarisFeignBeanPostProcessor( + public EnhancedFeignPluginRunner enhancedFeignPluginRunner( @Autowired(required = false) List enhancedFeignPlugins) { - return new EnhancedFeignBeanPostProcessor(enhancedFeignPlugins); + return new DefaultEnhancedFeignPluginRunner(enhancedFeignPlugins); + } + + @Bean + public EnhancedFeignBeanPostProcessor polarisFeignBeanPostProcessor(EnhancedFeignPluginRunner pluginRunner) { + return new EnhancedFeignBeanPostProcessor(pluginRunner); } @Configuration @@ -104,9 +107,8 @@ public class RpcEnhancementAutoConfiguration { } @Bean - public EnhancedRestTemplateModifier polarisRestTemplateBeanPostProcessor( - EnhancedRestTemplateReporter restTemplateResponseErrorHandler) { - return new EnhancedRestTemplateModifier(restTemplateResponseErrorHandler); + public RestTemplateCustomizer setErrorHandlerCustomizer(EnhancedRestTemplateReporter reporter) { + return restTemplate -> restTemplate.setErrorHandler(reporter); } } } diff --git a/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/feign/DefaultEnhancedFeignPluginRunner.java b/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/feign/DefaultEnhancedFeignPluginRunner.java new file mode 100644 index 000000000..5927a7526 --- /dev/null +++ b/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/feign/DefaultEnhancedFeignPluginRunner.java @@ -0,0 +1,66 @@ +/* + * Tencent is pleased to support the open source community by making Spring Cloud Tencent available. + * + * Copyright (C) 2019 THL A29 Limited, a Tencent company. All rights reserved. + * + * Licensed under the BSD 3-Clause License (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://opensource.org/licenses/BSD-3-Clause + * + * Unless required by applicable law or agreed to in writing, software distributed + * under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR + * CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + * + */ + +package com.tencent.cloud.rpc.enhancement.feign; + +import java.util.Comparator; +import java.util.List; + +import com.google.common.collect.ArrayListMultimap; +import com.google.common.collect.Multimap; +import com.tencent.cloud.rpc.enhancement.feign.plugin.EnhancedFeignContext; +import com.tencent.cloud.rpc.enhancement.feign.plugin.EnhancedFeignPlugin; +import com.tencent.cloud.rpc.enhancement.feign.plugin.EnhancedFeignPluginType; + +import org.springframework.util.CollectionUtils; + +/** + * Default plugin runner. + * + * @author Derek Yi 2022-08-16 + */ +public class DefaultEnhancedFeignPluginRunner implements EnhancedFeignPluginRunner { + + private Multimap pluginMap = ArrayListMultimap.create(); + + public DefaultEnhancedFeignPluginRunner(List enhancedFeignPlugins) { + if (!CollectionUtils.isEmpty(enhancedFeignPlugins)) { + enhancedFeignPlugins.stream() + .sorted(Comparator.comparing(EnhancedFeignPlugin::getOrder)) + .forEach(plugin -> pluginMap.put(plugin.getType().name(), plugin)); + } + } + + /** + * run the plugin. + * + * @param pluginType type of plugin + * @param context context in enhanced feign client. + */ + @Override + public void run(EnhancedFeignPluginType pluginType, EnhancedFeignContext context) { + for (EnhancedFeignPlugin plugin : pluginMap.get(pluginType.name())) { + try { + plugin.run(context); + } + catch (Throwable throwable) { + plugin.handlerThrowable(context, throwable); + } + } + } +} diff --git a/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/feign/EnhancedFeignBeanPostProcessor.java b/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/feign/EnhancedFeignBeanPostProcessor.java index a03a8eedf..b415172ad 100644 --- a/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/feign/EnhancedFeignBeanPostProcessor.java +++ b/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/feign/EnhancedFeignBeanPostProcessor.java @@ -17,9 +17,6 @@ package com.tencent.cloud.rpc.enhancement.feign; -import java.util.List; - -import com.tencent.cloud.rpc.enhancement.feign.plugin.EnhancedFeignPlugin; import feign.Client; import org.springframework.beans.BeansException; @@ -40,12 +37,12 @@ import org.springframework.lang.NonNull; */ public class EnhancedFeignBeanPostProcessor implements BeanPostProcessor, BeanFactoryAware { - private final List enhancedFeignPlugins; + private EnhancedFeignPluginRunner pluginRunner; private BeanFactory factory; - public EnhancedFeignBeanPostProcessor(List enhancedFeignPlugins) { - this.enhancedFeignPlugins = enhancedFeignPlugins; + public EnhancedFeignBeanPostProcessor(EnhancedFeignPluginRunner pluginRunner) { + this.pluginRunner = pluginRunner; } @Override @@ -80,7 +77,7 @@ public class EnhancedFeignBeanPostProcessor implements BeanPostProcessor, BeanFa } private EnhancedFeignClient createPolarisFeignClient(Client delegate) { - return new EnhancedFeignClient(delegate, enhancedFeignPlugins); + return new EnhancedFeignClient(delegate, pluginRunner); } @Override diff --git a/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/feign/EnhancedFeignClient.java b/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/feign/EnhancedFeignClient.java index 18b06c366..4bdf14eff 100644 --- a/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/feign/EnhancedFeignClient.java +++ b/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/feign/EnhancedFeignClient.java @@ -18,21 +18,17 @@ package com.tencent.cloud.rpc.enhancement.feign; import java.io.IOException; -import java.util.ArrayList; -import java.util.Comparator; -import java.util.List; -import java.util.stream.Collectors; import com.tencent.cloud.rpc.enhancement.feign.plugin.EnhancedFeignContext; -import com.tencent.cloud.rpc.enhancement.feign.plugin.EnhancedFeignPlugin; -import com.tencent.cloud.rpc.enhancement.feign.plugin.EnhancedFeignPluginType; import feign.Client; import feign.Request; import feign.Request.Options; import feign.Response; -import org.springframework.util.CollectionUtils; - +import static com.tencent.cloud.rpc.enhancement.feign.plugin.EnhancedFeignPluginType.EXCEPTION; +import static com.tencent.cloud.rpc.enhancement.feign.plugin.EnhancedFeignPluginType.FINALLY; +import static com.tencent.cloud.rpc.enhancement.feign.plugin.EnhancedFeignPluginType.POST; +import static com.tencent.cloud.rpc.enhancement.feign.plugin.EnhancedFeignPluginType.PRE; import static feign.Util.checkNotNull; /** @@ -44,43 +40,11 @@ public class EnhancedFeignClient implements Client { private final Client delegate; - private List preEnhancedFeignPlugins; - - private List postEnhancedFeignPlugins; - - private List exceptionEnhancedFeignPlugins; + private EnhancedFeignPluginRunner pluginRunner; - private List finallyEnhancedFeignPlugins; - - public EnhancedFeignClient(Client target, List enhancedFeignPlugins) { + public EnhancedFeignClient(Client target, EnhancedFeignPluginRunner pluginRunner) { this.delegate = checkNotNull(target, "target"); - - // Init the EnhancedFeignPlugins list. - this.preEnhancedFeignPlugins = new ArrayList<>(); - this.postEnhancedFeignPlugins = new ArrayList<>(); - this.exceptionEnhancedFeignPlugins = new ArrayList<>(); - this.finallyEnhancedFeignPlugins = new ArrayList<>(); - if (!CollectionUtils.isEmpty(enhancedFeignPlugins)) { - for (EnhancedFeignPlugin feignPlugin : enhancedFeignPlugins) { - if (feignPlugin.getType().equals(EnhancedFeignPluginType.PRE)) { - this.preEnhancedFeignPlugins.add(feignPlugin); - } - else if (feignPlugin.getType().equals(EnhancedFeignPluginType.POST)) { - this.postEnhancedFeignPlugins.add(feignPlugin); - } - else if (feignPlugin.getType().equals(EnhancedFeignPluginType.EXCEPTION)) { - this.exceptionEnhancedFeignPlugins.add(feignPlugin); - } - else if (feignPlugin.getType().equals(EnhancedFeignPluginType.FINALLY)) { - this.finallyEnhancedFeignPlugins.add(feignPlugin); - } - } - } - // Set the ordered enhanced feign plugins. - this.preEnhancedFeignPlugins = getSortedEnhancedFeignPlugin(this.preEnhancedFeignPlugins); - this.postEnhancedFeignPlugins = getSortedEnhancedFeignPlugin(this.postEnhancedFeignPlugins); - this.exceptionEnhancedFeignPlugins = getSortedEnhancedFeignPlugin(this.exceptionEnhancedFeignPlugins); - this.finallyEnhancedFeignPlugins = getSortedEnhancedFeignPlugin(this.finallyEnhancedFeignPlugins); + this.pluginRunner = pluginRunner; } @Override @@ -90,64 +54,24 @@ public class EnhancedFeignClient implements Client { enhancedFeignContext.setOptions(options); // Run pre enhanced feign plugins. - for (EnhancedFeignPlugin plugin : preEnhancedFeignPlugins) { - try { - plugin.run(enhancedFeignContext); - } - catch (Throwable throwable) { - plugin.handlerThrowable(enhancedFeignContext, throwable); - } - } + pluginRunner.run(PRE, enhancedFeignContext); try { Response response = delegate.execute(request, options); enhancedFeignContext.setResponse(response); // Run post enhanced feign plugins. - for (EnhancedFeignPlugin plugin : postEnhancedFeignPlugins) { - try { - plugin.run(enhancedFeignContext); - } - catch (Throwable throwable) { - plugin.handlerThrowable(enhancedFeignContext, throwable); - } - } + pluginRunner.run(POST, enhancedFeignContext); return response; } catch (IOException origin) { enhancedFeignContext.setException(origin); // Run exception enhanced feign plugins. - for (EnhancedFeignPlugin plugin : exceptionEnhancedFeignPlugins) { - try { - plugin.run(enhancedFeignContext); - } - catch (Throwable throwable) { - plugin.handlerThrowable(enhancedFeignContext, throwable); - } - } + pluginRunner.run(EXCEPTION, enhancedFeignContext); throw origin; } finally { // Run finally enhanced feign plugins. - for (EnhancedFeignPlugin plugin : finallyEnhancedFeignPlugins) { - try { - plugin.run(enhancedFeignContext); - } - catch (Throwable throwable) { - plugin.handlerThrowable(enhancedFeignContext, throwable); - } - } + pluginRunner.run(FINALLY, enhancedFeignContext); } } - - /** - * Ascending, which means the lower order number, the earlier executing enhanced feign plugin. - * - * @return sorted feign pre plugin list - */ - private List getSortedEnhancedFeignPlugin(List preEnhancedFeignPlugins) { - return new ArrayList<>(preEnhancedFeignPlugins) - .stream() - .sorted(Comparator.comparing(EnhancedFeignPlugin::getOrder)) - .collect(Collectors.toList()); - } } diff --git a/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/feign/EnhancedFeignPluginRunner.java b/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/feign/EnhancedFeignPluginRunner.java new file mode 100644 index 000000000..b821827b2 --- /dev/null +++ b/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/feign/EnhancedFeignPluginRunner.java @@ -0,0 +1,38 @@ +/* + * Tencent is pleased to support the open source community by making Spring Cloud Tencent available. + * + * Copyright (C) 2019 THL A29 Limited, a Tencent company. All rights reserved. + * + * Licensed under the BSD 3-Clause License (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://opensource.org/licenses/BSD-3-Clause + * + * Unless required by applicable law or agreed to in writing, software distributed + * under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR + * CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + * + */ + +package com.tencent.cloud.rpc.enhancement.feign; + +import com.tencent.cloud.rpc.enhancement.feign.plugin.EnhancedFeignContext; +import com.tencent.cloud.rpc.enhancement.feign.plugin.EnhancedFeignPluginType; + +/** + * Plugin runner. + * + * @author Derek Yi 2022-08-16 + */ +public interface EnhancedFeignPluginRunner { + + /** + * run the plugin. + * + * @param pluginType type of plugin + * @param context context in enhanced feign client. + */ + void run(EnhancedFeignPluginType pluginType, EnhancedFeignContext context); +} diff --git a/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/feign/plugin/EnhancedFeignPlugin.java b/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/feign/plugin/EnhancedFeignPlugin.java index bfe141d34..1ecc3d355 100644 --- a/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/feign/plugin/EnhancedFeignPlugin.java +++ b/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/feign/plugin/EnhancedFeignPlugin.java @@ -20,7 +20,7 @@ package com.tencent.cloud.rpc.enhancement.feign.plugin; import org.springframework.core.Ordered; /** - * Pre plugin used by EnhancedFeignClient. + * Plugin used by EnhancedFeignClient. * * @author Haotian Zhang */ diff --git a/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/feign/plugin/reporter/ExceptionPolarisReporter.java b/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/feign/plugin/reporter/ExceptionPolarisReporter.java index bfbec80c0..f5cb657ba 100644 --- a/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/feign/plugin/reporter/ExceptionPolarisReporter.java +++ b/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/feign/plugin/reporter/ExceptionPolarisReporter.java @@ -34,7 +34,7 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.core.Ordered; /** - * Polaris reporter when feign call is successful. + * Polaris reporter when feign call fails. * * @author Haotian Zhang */ diff --git a/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/resttemplate/EnhancedRestTemplateModifier.java b/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/resttemplate/EnhancedRestTemplateModifier.java deleted file mode 100644 index 0740e0ad7..000000000 --- a/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/resttemplate/EnhancedRestTemplateModifier.java +++ /dev/null @@ -1,66 +0,0 @@ -/* - * Tencent is pleased to support the open source community by making Spring Cloud Tencent available. - * - * Copyright (C) 2019 THL A29 Limited, a Tencent company. All rights reserved. - * - * Licensed under the BSD 3-Clause License (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * https://opensource.org/licenses/BSD-3-Clause - * - * Unless required by applicable law or agreed to in writing, software distributed - * under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR - * CONDITIONS OF ANY KIND, either express or implied. See the License for the - * specific language governing permissions and limitations under the License. - */ - -package com.tencent.cloud.rpc.enhancement.resttemplate; - -import java.util.Map; - -import org.springframework.beans.BeansException; -import org.springframework.beans.factory.SmartInitializingSingleton; -import org.springframework.cloud.client.loadbalancer.LoadBalanced; -import org.springframework.context.ApplicationContext; -import org.springframework.context.ApplicationContextAware; -import org.springframework.lang.NonNull; -import org.springframework.util.ObjectUtils; -import org.springframework.web.client.RestTemplate; - -/** - * Autoconfiguration RestTemplate, Find the RestTemplate bean annotated with {@link LoadBalanced}, - * then replace {@link org.springframework.web.client.ResponseErrorHandler} - * with {@link EnhancedRestTemplateReporter} . - * - * @author wh 2022/6/21 - */ -public class EnhancedRestTemplateModifier implements ApplicationContextAware, SmartInitializingSingleton { - - private final EnhancedRestTemplateReporter enhancedRestTemplateReporter; - private ApplicationContext applicationContext; - - public EnhancedRestTemplateModifier(EnhancedRestTemplateReporter enhancedRestTemplateReporter) { - this.enhancedRestTemplateReporter = enhancedRestTemplateReporter; - } - - @Override - public void afterSingletonsInstantiated() { - Map beans = this.applicationContext.getBeansWithAnnotation(LoadBalanced.class); - if (!ObjectUtils.isEmpty(beans)) { - beans.forEach(this::initRestTemplate); - } - } - - private void initRestTemplate(String beanName, Object bean) { - if (bean instanceof RestTemplate) { - RestTemplate restTemplate = (RestTemplate) bean; - restTemplate.setErrorHandler(enhancedRestTemplateReporter); - } - } - - @Override - public void setApplicationContext(@NonNull ApplicationContext applicationContext) throws BeansException { - this.applicationContext = applicationContext; - } -} diff --git a/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/stat/config/PolarisStatPropertiesAutoConfiguration.java b/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/stat/config/PolarisStatPropertiesAutoConfiguration.java index a080ff4e7..36c21680b 100644 --- a/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/stat/config/PolarisStatPropertiesAutoConfiguration.java +++ b/spring-cloud-tencent-rpc-enhancement/src/main/java/com/tencent/cloud/rpc/enhancement/stat/config/PolarisStatPropertiesAutoConfiguration.java @@ -20,9 +20,9 @@ package com.tencent.cloud.rpc.enhancement.stat.config; import com.tencent.cloud.polaris.context.ConditionalOnPolarisEnabled; import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean; +import org.springframework.boot.context.properties.EnableConfigurationProperties; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; -import org.springframework.context.annotation.Import; import org.springframework.core.env.Environment; /** @@ -32,7 +32,7 @@ import org.springframework.core.env.Environment; */ @Configuration(proxyBeanMethods = false) @ConditionalOnPolarisEnabled -@Import(PolarisStatProperties.class) +@EnableConfigurationProperties(PolarisStatProperties.class) public class PolarisStatPropertiesAutoConfiguration { @Bean diff --git a/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/config/RpcEnhancementAutoConfigurationTest.java b/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/config/RpcEnhancementAutoConfigurationTest.java index fd5afc187..1fa5f826c 100644 --- a/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/config/RpcEnhancementAutoConfigurationTest.java +++ b/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/config/RpcEnhancementAutoConfigurationTest.java @@ -17,11 +17,14 @@ package com.tencent.cloud.rpc.enhancement.config; +import java.io.IOException; +import java.net.URI; + import com.tencent.cloud.polaris.context.config.PolarisContextAutoConfiguration; import com.tencent.cloud.rpc.enhancement.feign.EnhancedFeignBeanPostProcessor; +import com.tencent.cloud.rpc.enhancement.feign.EnhancedFeignPluginRunner; import com.tencent.cloud.rpc.enhancement.feign.plugin.reporter.ExceptionPolarisReporter; import com.tencent.cloud.rpc.enhancement.feign.plugin.reporter.SuccessPolarisReporter; -import com.tencent.cloud.rpc.enhancement.resttemplate.EnhancedRestTemplateModifier; import com.tencent.cloud.rpc.enhancement.resttemplate.EnhancedRestTemplateReporter; import com.tencent.polaris.api.core.ConsumerAPI; import org.junit.Test; @@ -29,6 +32,11 @@ import org.junit.Test; import org.springframework.boot.autoconfigure.AutoConfigurations; import org.springframework.boot.autoconfigure.EnableAutoConfiguration; import org.springframework.boot.test.context.runner.WebApplicationContextRunner; +import org.springframework.cloud.client.ServiceInstance; +import org.springframework.cloud.client.loadbalancer.LoadBalanced; +import org.springframework.cloud.client.loadbalancer.LoadBalancerAutoConfiguration; +import org.springframework.cloud.client.loadbalancer.LoadBalancerClient; +import org.springframework.cloud.client.loadbalancer.LoadBalancerRequest; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.web.client.RestTemplate; @@ -46,18 +54,22 @@ public class RpcEnhancementAutoConfigurationTest { .withConfiguration(AutoConfigurations.of( PolarisContextAutoConfiguration.class, RpcEnhancementAutoConfiguration.class, - PolarisRestTemplateAutoConfigurationTester.class)) + PolarisRestTemplateAutoConfigurationTester.class, + LoadBalancerAutoConfiguration.class)) .withPropertyValues("spring.cloud.polaris.circuitbreaker.enabled=true"); @Test public void testDefaultInitialization() { this.contextRunner.run(context -> { assertThat(context).hasSingleBean(ConsumerAPI.class); + assertThat(context).hasSingleBean(EnhancedFeignPluginRunner.class); assertThat(context).hasSingleBean(EnhancedFeignBeanPostProcessor.class); assertThat(context).hasSingleBean(SuccessPolarisReporter.class); assertThat(context).hasSingleBean(ExceptionPolarisReporter.class); - assertThat(context).hasSingleBean(EnhancedRestTemplateModifier.class); assertThat(context).hasSingleBean(EnhancedRestTemplateReporter.class); + assertThat(context).hasSingleBean(RestTemplate.class); + RestTemplate restTemplate = context.getBean(RestTemplate.class); + assertThat(restTemplate.getErrorHandler() instanceof EnhancedRestTemplateReporter).isTrue(); }); } @@ -66,8 +78,34 @@ public class RpcEnhancementAutoConfigurationTest { static class PolarisRestTemplateAutoConfigurationTester { @Bean + @LoadBalanced RestTemplate restTemplate() { return new RestTemplate(); } + + @Bean + LoadBalancerClient loadBalancerClient() { + return new LoadBalancerClient() { + @Override + public ServiceInstance choose(String serviceId) { + return null; + } + + @Override + public T execute(String serviceId, LoadBalancerRequest request) throws IOException { + return null; + } + + @Override + public T execute(String serviceId, ServiceInstance serviceInstance, LoadBalancerRequest request) throws IOException { + return null; + } + + @Override + public URI reconstructURI(ServiceInstance instance, URI original) { + return null; + } + }; + } } } diff --git a/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/feign/EnhancedFeignClientTest.java b/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/feign/EnhancedFeignClientTest.java index 6f8067beb..1a0053c18 100644 --- a/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/feign/EnhancedFeignClientTest.java +++ b/spring-cloud-tencent-rpc-enhancement/src/test/java/com/tencent/cloud/rpc/enhancement/feign/EnhancedFeignClientTest.java @@ -74,7 +74,7 @@ public class EnhancedFeignClientTest { List enhancedFeignPlugins = getMockEnhancedFeignPlugins(); try { - new EnhancedFeignClient(mock(Client.class), enhancedFeignPlugins); + new EnhancedFeignClient(mock(Client.class), new DefaultEnhancedFeignPluginRunner(enhancedFeignPlugins)); } catch (Throwable e) { fail("Exception encountered.", e); @@ -103,7 +103,7 @@ public class EnhancedFeignClientTest { RequestTemplate requestTemplate = new RequestTemplate(); requestTemplate.feignTarget(target); - EnhancedFeignClient polarisFeignClient = new EnhancedFeignClient(delegate, getMockEnhancedFeignPlugins()); + EnhancedFeignClient polarisFeignClient = new EnhancedFeignClient(delegate, new DefaultEnhancedFeignPluginRunner(getMockEnhancedFeignPlugins())); // 200 Response response = polarisFeignClient.execute(Request.create(Request.HttpMethod.GET, "http://localhost:8080/test",