resolved embedded value in annotation @ApolloConfigChangeListener

apollo-client/src/main/java/com/ctrip/framework/apollo/spring/annotation/ApolloAnnotationProcessor.java

@@ -10,6 +10,10 @@
 import java.util.Set;
 
 import com.google.common.collect.Sets;
+import org.springframework.beans.BeansException;
+import org.springframework.beans.factory.BeanFactory;
+import org.springframework.beans.factory.BeanFactoryAware;
+import org.springframework.beans.factory.config.ConfigurableBeanFactory;
 import org.springframework.core.annotation.AnnotationUtils;
 import org.springframework.util.ReflectionUtils;
 
@@ -18,7 +22,12 @@
  *
  * @author Jason Song(song_s@ctrip.com)
  */
-public class ApolloAnnotationProcessor extends ApolloProcessor {
+public class ApolloAnnotationProcessor extends ApolloProcessor implements BeanFactoryAware {
+
+  /**
+   * resolve the expression.
+   */
+  private ConfigurableBeanFactory configurableBeanFactory;
 
   @Override
   protected void processField(Object bean, String beanName, Field field) {
@@ -30,15 +39,20 @@ protected void processField(Object bean, String beanName, Field field) {
     Preconditions.checkArgument(Config.class.isAssignableFrom(field.getType()),
         "Invalid type: %s for field: %s, should be Config", field.getType(), field);
 
-    String namespace = annotation.value();
-    Config config = ConfigService.getConfig(namespace);
+    final String namespace = annotation.value();
+    final String resolvedNamespace = this.configurableBeanFactory.resolveEmbeddedValue(namespace);
+    Config config = ConfigService.getConfig(resolvedNamespace);
 
     ReflectionUtils.makeAccessible(field);
     ReflectionUtils.setField(field, bean, config);
   }
 
   @Override
   protected void processMethod(final Object bean, String beanName, final Method method) {
+    this.processApolloConfigChangeListener(bean, method);
+  }
+
+  private void processApolloConfigChangeListener(final Object bean, final Method method) {
     ApolloConfigChangeListener annotation = AnnotationUtils
         .findAnnotation(method, ApolloConfigChangeListener.class);
     if (annotation == null) {
@@ -67,7 +81,7 @@ public void onChange(ConfigChangeEvent changeEvent) {
     Set<String> interestedKeyPrefixes = annotatedInterestedKeyPrefixes.length > 0 ? Sets.newHashSet(annotatedInterestedKeyPrefixes) : null;
 
     for (String namespace : namespaces) {
-      Config config = ConfigService.getConfig(namespace);
+      Config config = ConfigService.getConfig(this.configurableBeanFactory.resolveEmbeddedValue(namespace));
 
       if (interestedKeys == null && interestedKeyPrefixes == null) {
         config.addChangeListener(configChangeListener);
@@ -76,4 +90,9 @@ public void onChange(ConfigChangeEvent changeEvent) {
       }
     }
   }
+
+  @Override
+  public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
+    this.configurableBeanFactory = (ConfigurableBeanFactory) beanFactory;
+  }
 }

apollo-client/src/main/java/com/ctrip/framework/apollo/spring/annotation/ApolloConfigChangeListener.java

@@ -18,6 +18,12 @@
  *     //handle change event
  * }
  * <br />
+ * //Listener on namespace of "xxx" by default, or the namespace which value of key "redis.namespace" you specify.
+ * &#064;ApolloConfigChangeListener({"${redis.namespace:xxx}"})
+ * private void onChange(ConfigChangeEvent changeEvent) {
+ *     //handle change event
+ * }
+ * <br />
  * //Listener on namespaces of "someNamespace" and "anotherNamespace", will only be notified when "someKey" or "anotherKey" is changed
  * &#064;ApolloConfigChangeListener(value = {"someNamespace","anotherNamespace"}, interestedKeys = {"someKey", "anotherKey"})
  * private void onChange(ConfigChangeEvent changeEvent) {

apollo-client/src/main/java/com/ctrip/framework/apollo/spring/annotation/ApolloConfigRegistrar.java

@@ -2,19 +2,28 @@
 
 import com.ctrip.framework.apollo.spring.spi.ApolloConfigRegistrarHelper;
 import com.ctrip.framework.foundation.internals.ServiceBootstrap;
+import org.springframework.beans.BeansException;
+import org.springframework.beans.factory.BeanFactory;
+import org.springframework.beans.factory.BeanFactoryAware;
 import org.springframework.beans.factory.support.BeanDefinitionRegistry;
 import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
 import org.springframework.core.type.AnnotationMetadata;
 
 /**
  * @author Jason Song(song_s@ctrip.com)
  */
-public class ApolloConfigRegistrar implements ImportBeanDefinitionRegistrar {
+public class ApolloConfigRegistrar implements ImportBeanDefinitionRegistrar, BeanFactoryAware {
 
-  private ApolloConfigRegistrarHelper helper = ServiceBootstrap.loadPrimary(ApolloConfigRegistrarHelper.class);
+  private final ApolloConfigRegistrarHelper helper = ServiceBootstrap.loadPrimary(ApolloConfigRegistrarHelper.class);
 
   @Override
   public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
     helper.registerBeanDefinitions(importingClassMetadata, registry);
   }
+
+  @Override
+  public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
+    this.helper.setBeanFactory(beanFactory);
+  }
+
 }

apollo-client/src/main/java/com/ctrip/framework/apollo/spring/spi/ApolloConfigRegistrarHelper.java

@@ -1,10 +1,11 @@
 package com.ctrip.framework.apollo.spring.spi;
 
 import com.ctrip.framework.apollo.core.spi.Ordered;
+import org.springframework.beans.factory.BeanFactoryAware;
 import org.springframework.beans.factory.support.BeanDefinitionRegistry;
 import org.springframework.core.type.AnnotationMetadata;
 
-public interface ApolloConfigRegistrarHelper extends Ordered {
+public interface ApolloConfigRegistrarHelper extends Ordered, BeanFactoryAware {
 
   void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry);
 }

apollo-client/src/main/java/com/ctrip/framework/apollo/spring/spi/DefaultApolloConfigRegistrarHelper.java

@@ -11,20 +11,29 @@
 import com.google.common.collect.Lists;
 import java.util.HashMap;
 import java.util.Map;
+import org.springframework.beans.BeansException;
+import org.springframework.beans.factory.BeanFactory;
+import org.springframework.beans.factory.config.ConfigurableBeanFactory;
 import org.springframework.beans.factory.support.BeanDefinitionRegistry;
 import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;
 import org.springframework.core.annotation.AnnotationAttributes;
 import org.springframework.core.type.AnnotationMetadata;
 
 public class DefaultApolloConfigRegistrarHelper implements ApolloConfigRegistrarHelper {
 
+  /**
+   * resolve the expression.
+   */
+  private ConfigurableBeanFactory configurableBeanFactory;
+
   @Override
   public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
     AnnotationAttributes attributes = AnnotationAttributes
         .fromMap(importingClassMetadata.getAnnotationAttributes(EnableApolloConfig.class.getName()));
-    String[] namespaces = attributes.getStringArray("value");
-    int order = attributes.getNumber("order");
-    PropertySourcesProcessor.addNamespaces(Lists.newArrayList(namespaces), order);
+    final String[] namespaces = attributes.getStringArray("value");
+    final int order = attributes.getNumber("order");
+    final String[] resolvedNamespaces = this.resolveNamespaces(namespaces);
+    PropertySourcesProcessor.addNamespaces(Lists.newArrayList(resolvedNamespaces), order);
 
     Map<String, Object> propertySourcesPlaceholderPropertyValues = new HashMap<>();
     // to make sure the default PropertySourcesPlaceholderConfigurer's priority is higher than PropertyPlaceholderConfigurer
@@ -44,8 +53,22 @@ public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, B
         ApolloJsonValueProcessor.class);
   }
 
+  private String[] resolveNamespaces(String[] namespaces) {
+    String[] resolvedNamespaces = new String[namespaces.length];
+    for (int i = 0; i < namespaces.length; i++) {
+      resolvedNamespaces[i] = this.configurableBeanFactory.resolveEmbeddedValue(namespaces[i]);
+    }
+    return resolvedNamespaces;
+  }
+
   @Override
   public int getOrder() {
     return Ordered.LOWEST_PRECEDENCE;
   }
+
+  @Override
+  public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
+    this.configurableBeanFactory = (ConfigurableBeanFactory) beanFactory;
+  }
+
 }

apollo-client/src/test/java/com/ctrip/framework/apollo/spring/JavaConfigAnnotationApolloConfigChangeListenerTest.java

@@ -0,0 +1,92 @@
+package com.ctrip.framework.apollo.spring;
+
+import static org.mockito.Mockito.mock;
+
+import com.ctrip.framework.apollo.Config;
+import com.ctrip.framework.apollo.core.ConfigConsts;
+import com.ctrip.framework.apollo.model.ConfigChangeEvent;
+import com.ctrip.framework.apollo.spring.annotation.ApolloConfigChangeListener;
+import com.ctrip.framework.apollo.spring.annotation.EnableApolloConfig;
+import java.util.Properties;
+import org.junit.Test;
+import org.springframework.context.annotation.AnnotationConfigApplicationContext;
+import org.springframework.context.annotation.Configuration;
+
+public class JavaConfigAnnotationApolloConfigChangeListenerTest extends
+    AbstractSpringIntegrationTest {
+
+  @Test
+  public void testResolveExpressionSimple() {
+    Config applicationConfig = mock(Config.class);
+    mockConfig("application", applicationConfig);
+    new AnnotationConfigApplicationContext(TestResolveExpressionSimpleConfiguration.class);
+  }
+
+  /**
+   * resolve namespace's name from system property.
+   */
+  @Test
+  public void testResolveExpressionFromSystemProperty() {
+    Config applicationConfig = mock(Config.class);
+    mockConfig(ConfigConsts.NAMESPACE_APPLICATION, applicationConfig);
+
+    final String namespaceName = "magicRedis";
+    System.setProperty("redis.namespace", namespaceName);
+    Config redisConfig = mock(Config.class);
+    mockConfig(namespaceName, redisConfig);
+    new AnnotationConfigApplicationContext(
+        TestResolveExpressionFromSystemPropertyConfiguration.class);
+  }
+
+  /**
+   * resolve namespace from config. ${mysql.namespace} will be resolved by config from namespace
+   * application.
+   */
+  @Test
+  public void testResolveExpressionFromApplicationNamespace() {
+    Config applicationConfig = mock(Config.class);
+    mockConfig(ConfigConsts.NAMESPACE_APPLICATION, applicationConfig);
+
+    final String namespaceKey = "mysql.namespace";
+    final String namespaceName = "magicMysqlNamespaceApplication";
+
+    Properties properties = new Properties();
+    properties.setProperty(namespaceKey, namespaceName);
+    this.prepareConfig(ConfigConsts.NAMESPACE_APPLICATION, properties);
+
+    Config mysqlConfig = mock(Config.class);
+    mockConfig(namespaceName, mysqlConfig);
+
+    new AnnotationConfigApplicationContext(
+        TestResolveExpressionFromApplicationNamespaceConfiguration.class);
+  }
+
+  @Configuration
+  @EnableApolloConfig
+  static class TestResolveExpressionSimpleConfiguration {
+
+    @ApolloConfigChangeListener("${simple.application:application}")
+    private void onChange(ConfigChangeEvent event) {
+    }
+  }
+
+  @Configuration
+  @EnableApolloConfig
+  static class TestResolveExpressionFromSystemPropertyConfiguration {
+
+    @ApolloConfigChangeListener(value = {ConfigConsts.NAMESPACE_APPLICATION,
+        "${redis.namespace}"})
+    private void onChange(ConfigChangeEvent event) {
+    }
+  }
+
+  @Configuration
+  @EnableApolloConfig
+  static class TestResolveExpressionFromApplicationNamespaceConfiguration {
+
+    @ApolloConfigChangeListener(value = {ConfigConsts.NAMESPACE_APPLICATION,
+        "${mysql.namespace}"})
+    private void onChange(ConfigChangeEvent event) {
+    }
+  }
+}