Environment preparation of Nacos configuration center

Nacos Environment preparation of the configuration center

Nacos What is the workflow of the configuration center ？ First start SpringBoot project , After starting the project , You need to load the configuration file of the remote server into Spring In the container

@SpringBootApplication
public class SpringCloudNacosConfigApplication {

 public static void main(String[] args) {
 ConfigurableApplicationContext context=
 SpringApplication.run(SpringCloudNacosConfigApplication.class, args);
 String info=context.getEnvironment().getProperty("info");
 System.out.println(info);
 }
}


The point is Environment Acquisition , So how to load the configuration from the remote server to Environment？

Let's see SpringBoot When it starts ,SpringApplication.run() What environmental preparations have been made for the method

public ConfigurableApplicationContext run(String... args) {
 StopWatch stopWatch = new StopWatch();
 stopWatch.start();
 ConfigurableApplicationContext context = null;
 Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
 configureHeadlessProperty();
 SpringApplicationRunListeners listeners = getRunListeners(args);
 listeners.starting();
 try {
 ApplicationArguments applicationArguments = new DefaultApplicationArguments(
 args);
 // Environmental preparation
 ConfigurableEnvironment environment = prepareEnvironment(listeners,
 applicationArguments);
 configureIgnoreBeanInfo(environment);
 Banner printedBanner = printBanner(environment);
 context = createApplicationContext();
 exceptionReporters = getSpringFactoriesInstances(
 SpringBootExceptionReporter.class,
 new Class[] { ConfigurableApplicationContext.class }, context);
 prepareContext(context, environment, listeners, applicationArguments,
 printedBanner);
 refreshContext(context);
 afterRefresh(context, applicationArguments);
 stopWatch.stop();
 if (this.logStartupInfo) {
 new StartupInfoLogger(this.mainApplicationClass)
 .logStarted(getApplicationLog(), stopWatch);
 }
 listeners.started(context);
 callRunners(context, applicationArguments);
 }
 catch (Throwable ex) {
 handleRunFailure(context, ex, exceptionReporters, listeners);
 throw new IllegalStateException(ex);
 }

 try {
 listeners.running(context);
 }
 catch (Throwable ex) {
 handleRunFailure(context, ex, exceptionReporters, null);
 throw new IllegalStateException(ex);
 }
 return context;
}


• Get monitoring and start monitoring

• Create according to the passed in parameters applicationArguments object

• call prepareEnvironment Method , Environmental preparation

• Print banner, Prepare context , Refresh context , Then perform the operation after refreshing, etc

• Return after rent context Context

Let's see. prepareEnvironment What does the method do

prepareEnvironment() Method

private ConfigurableEnvironment prepareEnvironment(
 SpringApplicationRunListeners listeners,
 ApplicationArguments applicationArguments) {
 // Create and configure the environment
 ConfigurableEnvironment environment = getOrCreateEnvironment();
 configureEnvironment(environment, applicationArguments.getSourceArgs());
 listeners.environmentPrepared(environment);
 bindToSpringApplication(environment);
 if (!this.isCustomEnvironment) {
 environment = new EnvironmentConverter(getClassLoader())
 .convertEnvironmentIfNecessary(environment, deduceEnvironmentClass());
 }
 ConfigurationPropertySources.attach(environment);
 return environment;
}


Get or create the environment , stay listeners.environmentPrepared(environment); Release a ApplicationEnvironmentPreparedEvent event , All that define this Listener Listeners will listen to this event .

BootstrapApplicationListener The event will be received and handled

@Override
public void onApplicationEvent(ApplicationEnvironmentPreparedEvent event) {
 ConfigurableEnvironment environment = event.getEnvironment();
 if (!environment.getProperty("spring.cloud.bootstrap.enabled", Boolean.class,
 true)) {
 return;
 }
 // don't listen to events in a bootstrap context
 if (environment.getPropertySources().contains(BOOTSTRAP_PROPERTY_SOURCE_NAME)) {
 return;
 }
 ConfigurableApplicationContext context = null;
 String configName = environment
 .resolvePlaceholders("${spring.cloud.bootstrap.name:bootstrap}");
 for (ApplicationContextInitializer<?> initializer : event.getSpringApplication()
 .getInitializers()) {
 if (initializer instanceof ParentContextApplicationContextInitializer) {
 context = findBootstrapContext(
 (ParentContextApplicationContextInitializer) initializer,
 configName);
 }
 }
 if (context == null) {
 context = bootstrapServiceContext(environment, event.getSpringApplication(),
 configName);
 event.getSpringApplication()
 .addListeners(new CloseContextOnFailureApplicationListener(context));
 }

 apply(context, event.getSpringApplication(), environment);
}


stay bootstrapServiceContext Call in method builder.sources(BootstrapImportSelectorConfiguration.class), Automatic assembly , No specific code will be posted here , Let's see BootstrapImportSelectorConfiguration What does this class do

BootstrapImportSelectorConfiguration class

BootstrapImportSelectorConfiguration Configuration class

@Configuration
@Import(BootstrapImportSelector.class)
public class BootstrapImportSelectorConfiguration {

}


use @Import Import BootstrapImportSelector Automatic assembly

BootstrapImportSelector Of selectImports Method ：

@Override
public String[] selectImports(AnnotationMetadata annotationMetadata) {
 ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
 // Use names and ensure unique to protect against duplicates
 List<String> names = new ArrayList<>(SpringFactoriesLoader
 .loadFactoryNames(BootstrapConfiguration.class, classLoader));
 names.addAll(Arrays.asList(StringUtils.commaDelimitedListToStringArray(
 this.environment.getProperty(&quot;spring.cloud.bootstrap.sources&quot;, &quot;&quot;))));

 List<OrderedAnnotatedElement> elements = new ArrayList<>();
 for (String name : names) {
 try {
 elements.add(
 new OrderedAnnotatedElement(this.metadataReaderFactory, name));
 }
 catch (IOException e) {
 continue;
 }
 }
 AnnotationAwareOrderComparator.sort(elements);

 String[] classNames = elements.stream().map(e -> e.name).toArray(String[]::new);

 return classNames;
}


utilize Spring Of SPI Mechanism search META-INF/spring.factories The extension point

key yes BootstrapConfiguration

stay spring-cloud-context.jar Medium spring.factories：PropertySourceBootstrapConfiguration

# Bootstrap components
org.springframework.cloud.bootstrap.BootstrapConfiguration=\
org.springframework.cloud.bootstrap.config.PropertySourceBootstrapConfiguration,\
org.springframework.cloud.bootstrap.encrypt.EncryptionBootstrapConfiguration,\
org.springframework.cloud.autoconfigure.ConfigurationPropertiesRebinderAutoConfiguration,\
org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration


stay spring-cloud-context.jar Medium spring.factories：

NacosConfigBootstrapConfiguration

org.springframework.cloud.bootstrap.BootstrapConfiguration=\
com.alibaba.cloud.nacos.NacosConfigBootstrapConfiguration
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.alibaba.cloud.nacos.NacosConfigAutoConfiguration,\
com.alibaba.cloud.nacos.endpoint.NacosConfigEndpointAutoConfiguration
org.springframework.boot.diagnostics.FailureAnalyzer=\
com.alibaba.cloud.nacos.diagnostics.analyzer.NacosConnectionFailureAnalyzer


The truth came out , It is automatically assembled here NacosConfigBootstrapConfiguration Configuration class

summary

This is it. Nacos Environment preparation of the configuration center , from SpringBoot Start with the method of environmental preparation for project startup , adopt BootstrapApplicationListener Class listening method , Called builder.sources(BootstrapImportSelectorConfiguration.class) To load the BootstrapImportSelectorConfiguration class , its selectImports() Use in method Spring Of SPI The extension mechanism records key by BootstrapConfiguration Some of the definitions nacos Middle class , Thus to nacos The startup environment is ready .

Actually nacos The most important functions are registration center and configuration center , As nacos Users of , We should master nacos The process and working principle of , To locate the problem , And in the appropriate business scenarios nacos Optimize and make good use of the functions of the service nacos, This article is only right nacos As the end of the environment preparation of the configuration center function , Further analysis will follow nacos The process and working principle of the configuration file . If you think this article will help you , Welcome to leave me a message, like comments and forward ！