Introduction to Apollo

Apollo (Apollo) is a distributed configuration center developed by Ctrip framework department. It can centrally manage the configuration of different application environments and different clusters. After the configuration is modified, it can be pushed to the application end in real time. It also has standardized permissions, process governance and other characteristics. It is suitable for micro service configuration management scenarios.
For details, please refer to GitHub: https://github.com/ctripcorp/apollo (all in English)

Import dependency

	<!--Apollo configuration center dependency-->
        <dependency>
            <groupId>com.ctrip.framework.apollo</groupId>
            <artifactId>apollo-client</artifactId>
            <version>1.0.0</version>
        </dependency>
        <dependency>
            <groupId>com.ctrip.framework.apollo</groupId>
            <artifactId>apollo-core</artifactId>
            <version>1.0.0</version>
        </dependency>

Note that when importing, you should rely on both client and core, otherwise the following errors may appear:

Exception in thread "main" java.lang.NoClassDefFoundError: Could not initialize class com.ctrip.framework.apollo.tracer.Tracer
      at com.ctrip.framework.apollo.build.ApolloInjector.getInstance(ApolloInjector.java:37)
      at com.ctrip.framework.apollo.ConfigService.getManager(ConfigService.java:25)
      at com.ctrip.framework.apollo.ConfigService.getConfig(ConfigService.java:61)

The picture shows the details of Apollo page

to configure

When using java to connect to apollo, users need to create an app Properties is in the META-INF folder, and META-INF must be under resources. In addition, aopollo env properties.

app.properties

Appollo. Appollo is the unique ID of each item in the configuration center In properties, you need to determine which project configuration information you need to use


Because apollo also needs to remotely connect the data of apollo configuration information in java, it can be added to apollo Meta = {IP}: 8080, because the apollo port is generally 8070, but the port we obtain data is generally 8080. For this, we need to know their configuration with the operation and maintenance department. This method can also obtain the specific data of apollo. It seems that we can connect to apollo to obtain the data. It feels like the apollo env in the previous figure Properties doesn't seem to work, but in actual development, we can't have only one environment. There is a development environment for development, a test environment for testing, and a production environment for production. Therefore, we generally don't write apollo Meta, using the app in the figure above ID, different environments only have different servers, but we keep app ID is consistent.

apollo-env.properties

apollo-env.properties is used to configure different environments and access different Apollo configuration centers. Apollo allows users to configure four different environments: dev development environment, fat function test environment, uat user test environment and pro production environment.

server.properties

It seems that there is another problem. How does the server know what environment it is in? Therefore, it also needs a configuration to tell apollo what environment its computer is in

Therefore, developers need to configure server in the folder of C:\opt\settings properties.

On the server In properties, tell apollo what environment it is in:

env=DEV
/*
env=FAT Functional test environment
env=UAT User test environment
env=PRO production environment 
*/

There are four environments in apollo. If you are a developer, you can honestly configure the DEV environment

Get remote configuration

After the remote configuration can be obtained, it needs to be configured in spring before it can be used

public class AppPropertyPlaceholderConfigurer extends PropertyPlaceholderConfigurer {
@Override
protected void processProperties(ConfigurableListableBeanFactory beanFactoryToProcess, Properties props) throws BeansException {
try {
//Get all configuration information from apollo
Config config = ConfigService.getAppConfig(); //config instance is singleton for each namespace and is never null
Set<String> fieldnames = config.getPropertyNames();
//Traverse configuration information
for(String fieldname : fieldnames){
String attributeName=fieldname;
String attributeValue = config.getProperty(fieldname,"");
System.out.println("attributeName:"+attributeName + "; attributeValue:" + attributeValue );
props.put(attributeName,attributeValue);
}
} catch (Exception e) {
e.printStackTrace();
logger.info("obtain apollo Configuration failed");
}

super.processProperties(beanFactoryToProcess, props);
}
}

In this way, you can store all the configurations in the spring container, but don't forget to configure the xml file.
Follow up is learning...