support http-exchange configuration dynamic refresh (#17)

Author: DanielLiu1123

build.gradle

@@ -17,10 +17,15 @@ repositories {
 dependencies {
     api(platform("org.springframework.boot:spring-boot-dependencies:${springBootVersion}"))
     annotationProcessor(platform("org.springframework.boot:spring-boot-dependencies:${springBootVersion}"))
+    compileOnly(platform("org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"))
+    testImplementation(platform("org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"))
 
     api("org.springframework.boot:spring-boot-starter")
     api("org.springframework:spring-webflux")
 
+    // dynamic refresh configuration for exchange clients
+    compileOnly("org.springframework.cloud:spring-cloud-context")
+
     compileOnly("org.projectlombok:lombok")
     annotationProcessor("org.projectlombok:lombok")
     annotationProcessor("org.springframework.boot:spring-boot-configuration-processor")
@@ -31,6 +36,7 @@ dependencies {
     testCompileOnly("org.springframework.boot:spring-boot-starter-web")
     testCompileOnly("org.springframework.boot:spring-boot-starter-webflux")
     testCompileOnly("org.springframework.boot:spring-boot-starter-validation")
+    testImplementation("org.springframework.cloud:spring-cloud-context")
 }
 
 compileJava {

gradle.properties

@@ -3,6 +3,7 @@ artifact=httpexchange-spring-boot-starter
 version=3.1.2-SNAPSHOT
 
 springBootVersion=3.1.1
+springCloudVersion=2022.0.3
 spotlessVersion=6.19.0
 spotbugsVersion=5.0.14
 

src/main/java/com/freemanan/starter/httpexchange/Cache.java

@@ -1,25 +1,42 @@
 package com.freemanan.starter.httpexchange;
 
-import java.util.Set;
+import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 import lombok.experimental.UtilityClass;
+import org.springframework.aop.framework.AopProxyUtils;
 
 /**
  * @author Freeman
  */
 @UtilityClass
 class Cache {
-    private static final Set<Class<?>> clientClasses = ConcurrentHashMap.newKeySet();
+    /**
+     * Cache all clients.
+     */
+    private static final Map<Class<?>, Object> classToInstance = new ConcurrentHashMap<>();
 
-    public static void addClientClass(Class<?> type) {
-        clientClasses.add(type);
+    /**
+     * Add client to cache.
+     *
+     * @param client client
+     */
+    public static void addClient(Object client) {
+        classToInstance.put(AopProxyUtils.ultimateTargetClass(client), client);
     }
 
-    public static Set<Class<?>> getClientClasses() {
-        return Set.copyOf(clientClasses);
+    /**
+     * Get clients.
+     *
+     * @return unmodifiable map
+     */
+    public static Map<Class<?>, Object> getClients() {
+        return Map.copyOf(classToInstance);
     }
 
+    /**
+     * Clear cache.
+     */
     public static void clear() {
-        clientClasses.clear();
+        classToInstance.clear();
     }
 }

src/main/java/com/freemanan/starter/httpexchange/ExchangeClientCreator.java

@@ -5,6 +5,7 @@
 import com.freemanan.starter.httpexchange.shaded.ShadedHttpServiceProxyFactory;
 import java.time.Duration;
 import java.util.Optional;
+import java.util.concurrent.atomic.AtomicReference;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.config.ConfigurableBeanFactory;
@@ -29,21 +30,15 @@ class ExchangeClientCreator {
     private final ConfigurableBeanFactory beanFactory;
     private final Environment environment;
     private final Class<?> clientType;
-    private final HttpClientsProperties.Channel channelConfig;
     private final boolean usingClientSideAnnotation;
+    private final AtomicReference<HttpClientsProperties> properties = new AtomicReference<>();
 
-    ExchangeClientCreator(
-            ConfigurableBeanFactory beanFactory,
-            HttpClientsProperties properties,
-            Class<?> clientType,
-            boolean usingClientSideAnnotation) {
+    ExchangeClientCreator(ConfigurableBeanFactory beanFactory, Class<?> clientType, boolean usingClientSideAnnotation) {
         Assert.notNull(beanFactory, "beanFactory must not be null");
-        Assert.notNull(properties, "properties must not be null");
         Assert.notNull(clientType, "clientType must not be null");
         this.beanFactory = beanFactory;
         this.environment = beanFactory.getBean(Environment.class);
         this.clientType = clientType;
-        this.channelConfig = findMatchedConfig(clientType, properties).orElseGet(properties::defaultClient);
         this.usingClientSideAnnotation = usingClientSideAnnotation;
     }
 
@@ -55,33 +50,45 @@ class ExchangeClientCreator {
      */
     @SuppressWarnings("unchecked")
     public <T> T create() {
+        HttpClientsProperties httpClientsProperties = beanFactory
+                .getBeanProvider(HttpClientsProperties.class)
+                .getIfUnique(() -> {
+                    HttpClientsProperties prop = properties.get();
+                    if (prop == null) {
+                        properties.set(Util.getProperties(environment));
+                    }
+                    return properties.get();
+                });
+        HttpClientsProperties.Channel chan =
+                findMatchedConfig(clientType, httpClientsProperties).orElseGet(httpClientsProperties::defaultClient);
         if (usingClientSideAnnotation) {
-            HttpServiceProxyFactory cachedFactory = buildServiceProxyFactory();
+            HttpServiceProxyFactory cachedFactory = buildServiceProxyFactory(chan);
             T result = (T) cachedFactory.createClient(clientType);
-            Cache.addClientClass(clientType);
+            Cache.addClient(result);
             return result;
         }
-        ShadedHttpServiceProxyFactory cachedFactory = buildShadedServiceProxyFactory();
+        ShadedHttpServiceProxyFactory cachedFactory = buildShadedServiceProxyFactory(chan);
         T result = (T) cachedFactory.createClient(clientType);
-        Cache.addClientClass(clientType);
+        Cache.addClient(result);
         return result;
     }
 
-    private HttpServiceProxyFactory buildServiceProxyFactory() {
-        HttpServiceProxyFactory.Builder builder = proxyFactoryBuilder();
+    private HttpServiceProxyFactory buildServiceProxyFactory(HttpClientsProperties.Channel channelConfig) {
+        HttpServiceProxyFactory.Builder builder = proxyFactoryBuilder(channelConfig);
         return builder.build();
     }
 
-    private ShadedHttpServiceProxyFactory buildShadedServiceProxyFactory() {
-        ShadedHttpServiceProxyFactory.Builder builder = ShadedHttpServiceProxyFactory.builder(proxyFactoryBuilder());
+    private ShadedHttpServiceProxyFactory buildShadedServiceProxyFactory(HttpClientsProperties.Channel channelConfig) {
+        ShadedHttpServiceProxyFactory.Builder builder =
+                ShadedHttpServiceProxyFactory.builder(proxyFactoryBuilder(channelConfig));
         return builder.build();
     }
 
-    private HttpServiceProxyFactory.Builder proxyFactoryBuilder() {
+    private HttpServiceProxyFactory.Builder proxyFactoryBuilder(HttpClientsProperties.Channel channelConfig) {
         HttpServiceProxyFactory.Builder builder = beanFactory
                 .getBeanProvider(HttpServiceProxyFactory.Builder.class)
                 .getIfUnique(HttpServiceProxyFactory::builder)
-                .clientAdapter(WebClientAdapter.forClient(buildWebClient()));
+                .clientAdapter(WebClientAdapter.forClient(buildWebClient(channelConfig)));
 
         // Customized argument resolvers
         beanFactory
@@ -102,7 +109,7 @@ private HttpServiceProxyFactory.Builder proxyFactoryBuilder() {
         return builder;
     }
 
-    private WebClient buildWebClient() {
+    private WebClient buildWebClient(HttpClientsProperties.Channel channelConfig) {
         WebClient.Builder builder =
                 beanFactory.getBeanProvider(WebClient.Builder.class).getIfUnique(WebClient::builder);
         if (StringUtils.hasText(channelConfig.getBaseUrl())) {

src/main/java/com/freemanan/starter/httpexchange/HttpClientBeanRegistrar.java

@@ -7,19 +7,23 @@
 import java.util.concurrent.ConcurrentHashMap;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.aop.scope.ScopedProxyUtils;
 import org.springframework.beans.factory.annotation.AnnotatedBeanDefinition;
 import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.beans.factory.config.BeanDefinitionHolder;
 import org.springframework.beans.factory.config.ConfigurableBeanFactory;
 import org.springframework.beans.factory.support.AbstractBeanDefinition;
 import org.springframework.beans.factory.support.BeanDefinitionBuilder;
 import org.springframework.beans.factory.support.BeanDefinitionOverrideException;
+import org.springframework.beans.factory.support.BeanDefinitionReaderUtils;
 import org.springframework.beans.factory.support.BeanDefinitionRegistry;
 import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider;
 import org.springframework.core.annotation.AnnotationUtils;
 import org.springframework.core.type.AnnotationMetadata;
 import org.springframework.core.type.ClassMetadata;
 import org.springframework.core.type.classreading.MetadataReader;
 import org.springframework.util.Assert;
+import org.springframework.util.ClassUtils;
 import org.springframework.util.ObjectUtils;
 import org.springframework.util.ReflectionUtils;
 import org.springframework.web.bind.annotation.RequestMapping;
@@ -32,6 +36,8 @@ class HttpClientBeanRegistrar {
     private static final Logger log = LoggerFactory.getLogger(HttpClientBeanRegistrar.class);
 
     private static final Set<BeanDefinitionRegistry> registries = ConcurrentHashMap.newKeySet();
+    private static final boolean SPRING_CLOUD_CONTEXT_PRESENT =
+            ClassUtils.isPresent("org.springframework.cloud.context.scope.refresh.RefreshScope", null);
 
     private final ClassPathScanningCandidateComponentProvider scanner;
     private final HttpClientsProperties properties;
@@ -89,7 +95,7 @@ public void registerHttpClientBean(BeanDefinitionRegistry registry, String class
         Assert.isInstanceOf(ConfigurableBeanFactory.class, registry);
 
         ExchangeClientCreator creator =
-                new ExchangeClientCreator((ConfigurableBeanFactory) registry, properties, clz, hasClientSideAnnotation);
+                new ExchangeClientCreator((ConfigurableBeanFactory) registry, clz, hasClientSideAnnotation);
 
         AbstractBeanDefinition abd = BeanDefinitionBuilder.genericBeanDefinition(clz, creator::create)
                 .getBeanDefinition();
@@ -99,7 +105,14 @@ public void registerHttpClientBean(BeanDefinitionRegistry registry, String class
         abd.setLazyInit(true);
 
         try {
-            registry.registerBeanDefinition(className, abd);
+            if (SPRING_CLOUD_CONTEXT_PRESENT) {
+                abd.setScope("refresh");
+                BeanDefinitionHolder scopedProxy =
+                        ScopedProxyUtils.createScopedProxy(new BeanDefinitionHolder(abd, className), registry, false);
+                BeanDefinitionReaderUtils.registerBeanDefinition(scopedProxy, registry);
+            } else {
+                registry.registerBeanDefinition(className, abd);
+            }
         } catch (BeanDefinitionOverrideException ignore) {
             // clients are included in base packages
             log.warn(

src/main/java/com/freemanan/starter/httpexchange/HttpClientsAutoConfiguration.java

@@ -57,7 +57,7 @@ public void destroy() {
 
     private void warningUnusedConfiguration() {
         // Identify the configuration items that are not taking effect and print warning messages.
-        Set<Class<?>> classes = Cache.getClientClasses();
+        Set<Class<?>> classes = Cache.getClients().keySet();
 
         List<HttpClientsProperties.Channel> channels = properties.getChannels();
 

src/test/java/com/freemanan/starter/httpexchange/DynamicRefreshTests.java

@@ -0,0 +1,69 @@
+package com.freemanan.starter.httpexchange;
+
+import static com.freemanan.starter.Dependencies.springBootVersion;
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.freemanan.cr.core.anno.Action;
+import com.freemanan.cr.core.anno.ClasspathReplacer;
+import com.freemanan.starter.PortFinder;
+import org.junit.jupiter.api.Test;
+import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
+import org.springframework.boot.builder.SpringApplicationBuilder;
+import org.springframework.cloud.endpoint.event.RefreshEvent;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.core.env.ConfigurableEnvironment;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.service.annotation.GetExchange;
+
+/**
+ * @author Freeman
+ */
+class DynamicRefreshTests {
+
+    @Test
+    @ClasspathReplacer({@Action("org.springframework.boot:spring-boot-starter-webflux:" + springBootVersion)})
+    void testDynamicRefresh() {
+        int port = PortFinder.availablePort();
+        var ctx = new SpringApplicationBuilder(Cfg.class)
+                .properties("server.port=" + port)
+                .properties("http-exchange.base-url=http://localhost:" + port)
+                .run();
+        ConfigurableEnvironment env = ctx.getEnvironment();
+
+        FooApi api = ctx.getBean(FooApi.class);
+        assertThat(api.get()).isEqualTo("OK");
+
+        env.getSystemProperties().put("http-exchange.base-url", "http://localhost:" + port + "/v2");
+        ctx.publishEvent(new RefreshEvent(ctx, null, null));
+
+        // base-url changed
+        assertThat(api.get()).isEqualTo("OK v2");
+
+        ctx.close();
+    }
+
+    @Configuration(proxyBeanMethods = false)
+    @EnableAutoConfiguration
+    @EnableExchangeClients(clients = FooApi.class)
+    @RestController
+    static class Cfg implements FooApi {
+
+        @Override
+        @GetMapping("/get")
+        public String get() {
+            return "OK";
+        }
+
+        @GetMapping("/v2/get")
+        public String getV2() {
+            return "OK v2";
+        }
+    }
+
+    interface FooApi {
+
+        @GetExchange("/get")
+        String get();
+    }
+}