springboot接入apollo

添加pom依赖,建议使用1.3.0以上的版本

<!-- https://mvnrepository.com/artifact/com.ctrip.framework.apollo/apollo-client -->
<dependency>
    <groupId>com.ctrip.framework.apollo</groupId>
    <artifactId>apollo-client</artifactId>
    <version>1.4.0</version>
</dependency>

添加appid 通过Spring Boot的application.properties文件配置如下三个信息：

• 项目自定义应用id：appId
• Apollo配置中心地址：apollo.meta
• 配置文件命名空间：apollo.bootstrap.namespaces

app.id=iandundoctor1230
apollo.meta=http://192.168.100.80:8680  
application.yml,andundoctor-redis.yml,andundoctor-jdbc.yml,andundoctor-rabbitmq.yml,andundoctor-fdfs.yml,andundoctor-jpush

注意：该配置方式不适用于多个war包部署在同一个tomcat的使用场景

其他spring项目通过app.properties配置文件
可以在classpath:/META-INF/app.properties指定,这里不指定引入配置文件的默认命名空间，具体引用方式会在下面详细讲到。

app.id=andunapp1819  
apollo.meta=http://192.168.100.80:8680   

以上接入工作已完成，接下来看具体用法

• API方式灵活，功能完备，配置值实时更新（热发布），支持所有Java环境。
• Spring方式接入简单，结合Spring有N种酷炫的玩法，如
  • Placeholder方式：
    • 代码中直接使用，如：@Value("${someKeyFromApollo:someDefaultValue}")
    • 配置文件中使用替换placeholder，如：spring.datasource.url: ${someKeyFromApollo:someDefaultValue}
    • 直接托管spring的配置，如在apollo中直接配置spring.datasource.url=jdbc:mysql://localhost:3306/somedb?characterEncoding=utf8
  • Spring boot的@ConfigurationProperties方式
• Spring方式也可以结合API方式使用，如注入Apollo的Config对象，就可以照常通过API方式获取配置了：

@ApolloConfig
private Config config; //inject config for namespace application

API方式是最简单、高效使用Apollo配置的方式，不依赖Spring框架即可使用。

Config redisConfig=ConfigService.getConfig("andunapp-redis.properties");
String defaultValue = null;
redisConfig.getProperty("redis.host",defaultValue);
redisConfig.getProperty("redis.port", defaultValue);
redisConfig.getProperty("redis.timeout",defaultValue);
redisConfig.getProperty("redis.pass", defaultValue);

通过上述的config.getProperty可以获取到someKey对应的实时最新的配置值。

另外，配置值从内存中获取，所以不需要应用自己做缓存。

Apollo目前既支持比较传统的基于XML的配置，也支持目前比较流行的基于Java（推荐）的配置。

Spring的配置是有顺序的，如果多个property source都有同一个key，那么最终是顺序在前的配置生效。以下是注入多个namespace，并且指定顺序：

apollo:config如果不指定order，那么默认是最低优先级。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:apollo="http://www.ctrip.com/schema/apollo"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.ctrip.com/schema/apollo http://www.ctrip.com/schema/apollo.xsd">
    <!-- 这个是最简单的配置形式，一般应用用这种形式就可以了，用来指示Apollo注入application namespace的配置到Spring环境中 -->
    <apollo:config order="2"/>
    <!-- 这个是稍微复杂一些的配置形式，指示Apollo注入mail namespace的配置到Spring环境中 -->
    <apollo:config namespaces="andunapp-jdbc.properties" order="1"/>
    
    <!-- 数据源驱动类可不写，Druid默认会自动根据URL识别DriverClass -->
    <property name="driverClassName" value="${master.jdbc.driver}" />
    <!-- 基本属性 url、user、password -->
    <property name="url" value="${master.jdbc.url}" />
    <property name="username" value="${master.jdbc.username}" />
    <property name="password" value="${master.jdbc.password}" />
</beans>

相对于基于XML的配置，基于Java的配置是目前比较流行的方式。

注意@EnableApolloConfig要和@Configuration一起使用，不然不会生效。

//这个是最复杂的配置形式，指示Apollo注入FX.apollo和application.yml namespace的配置到Spring环境中，并且顺序在application前面
@Configuration
@EnableApolloConfig(order = 2)
public class SomeAppConfig {
  @Bean
  public TestJavaConfigBean javaConfigBean() {
    return new TestJavaConfigBean();
  }
}
@Configuration
@EnableApolloConfig(value = {"FX.apollo", "application.yml"}, order = 1)
public class AnotherAppConfig {}

Spring Boot除了支持上述两种集成方式以外，还支持通过application.properties/bootstrap.properties来配置，该方式能使配置在更早的阶段注入，比如使用@ConditionalOnProperty的场景或者是有一些spring-boot-starter在启动阶段就需要读取配置做一些事情（如dubbo-spring-boot-project），所以对于Spring Boot环境建议通过以下方式来接入Apollo(需要0.10.0及以上版本）。

使用方式很简单，只需要在application.properties/bootstrap.properties中按照如下样例配置即可。

1. 注入默认application namespace的配置示例

    # will inject 'application' namespace in bootstrap phase
     apollo.bootstrap.enabled = true

2. 注入非默认application namespace或多个namespace的配置示例

     # will inject 'application', 'FX.apollo' and 'application.yml' namespaces in bootstrap phase
     apollo.bootstrap.namespaces = application,FX.apollo,application.yml

3. 将Apollo配置加载提到初始化日志系统之前(1.2.0+)
   从1.2.0版本开始，如果希望把日志相关的配置（如logging.level.root=info或logback-spring.xml中的参数）也放在Apollo管理，那么可以额外配置apollo.bootstrap.eagerLoad.enabled=true来使Apollo的加载顺序放到日志系统加载之前，不过这会导致Apollo的启动过程无法通过日志的方式输出(因为执行Apollo加载的时候，日志系统压根没有准备好呢！所以在Apollo代码中使用Slf4j的日志输出便没有任何内容)

     # put apollo initialization before logging system initialization
     apollo.bootstrap.eagerLoad.enabled=true

假设我有一个TestJavaConfigBean，通过Java Config的方式还可以使用@Value的方式注入：

public class TestJavaConfigBean {
  @Value("${timeout:100}")
  private int timeout;
  private int batch;
 
  @Value("${batch:200}")
  public void setBatch(int batch) {
    this.batch = batch;
  }
 
  public int getTimeout() {
    return timeout;
  }
 
  public int getBatch() {
    return batch;
  }
}

Spring Boot提供了@ConfigurationProperties把配置注入到bean对象中。

Apollo也支持这种方式，下面的例子会把redis.cache.expireSeconds和redis.cache.commandTimeout分别注入到SampleRedisConfig的expireSeconds和commandTimeout字段中。

@ConfigurationProperties(prefix = "redis.cache")
public class SampleRedisConfig {
  private int expireSeconds;
  private int commandTimeout;

  public void setExpireSeconds(int expireSeconds) {
    this.expireSeconds = expireSeconds;
  }

  public void setCommandTimeout(int commandTimeout) {
    this.commandTimeout = commandTimeout;
  }
}

Apollo同时还增加了几个新的Annotation来简化在Spring环境中的使用。

1. @ApolloConfig
   • 用来自动注入Config对象
2. @ApolloConfigChangeListener
   • 用来自动注册ConfigChangeListener
3. @ApolloJsonValue
   • 用来把配置的json字符串自动注入为对象

使用样例如下：

public class TestApolloAnnotationBean {
  @ApolloConfig
  private Config config; //inject config for namespace application
  @ApolloConfig("application")
  private Config anotherConfig; //inject config for namespace application
  @ApolloConfig("FX.apollo")
  private Config yetAnotherConfig; //inject config for namespace FX.apollo
  @ApolloConfig("application.yml")
  private Config ymlConfig; //inject config for namespace application.yml
 
  /**
   * ApolloJsonValue annotated on fields example, the default value is specified as empty list - []
   * <br />
   * jsonBeanProperty=[{"someString":"hello","someInt":100},{"someString":"world!","someInt":200}]
   */
  @ApolloJsonValue("${jsonBeanProperty:[]}")
  private List<JsonBean> anotherJsonBeans;

  @Value("${batch:100}")
  private int batch;
  
  //config change listener for namespace application
  @ApolloConfigChangeListener
  private void someOnChange(ConfigChangeEvent changeEvent) {
    //update injected value of batch if it is changed in Apollo
    if (changeEvent.isChanged("batch")) {
      batch = config.getIntProperty("batch", 100);
    }
  }
 
  //config change listener for namespace application
  @ApolloConfigChangeListener("application")
  private void anotherOnChange(ConfigChangeEvent changeEvent) {
    //do something
  }
 
  //config change listener for namespaces application, FX.apollo and application.yml
  @ApolloConfigChangeListener({"application", "FX.apollo", "application.yml"})
  private void yetAnotherOnChange(ConfigChangeEvent changeEvent) {
    //do something
  }

  //example of getting config from Apollo directly
  //this will always return the latest value of timeout
  public int getTimeout() {
    return config.getIntProperty("timeout", 200);
  }

  //example of getting config from injected value
  //the program needs to update the injected value when batch is changed in Apollo using @ApolloConfigChangeListener shown above
  public int getBatch() {
    return this.batch;
  }

  private static class JsonBean{
    private String someString;
    private int someInt;
  }
}

在Configuration类中按照下面的方式使用：

@Configuration
@EnableApolloConfig
public class AppConfig {
  @Bean
  public TestApolloAnnotationBean testApolloAnnotationBean() {
    return new TestApolloAnnotationBean();
  }
}