1. Springcloud 启动

Springcloud 环境启动过个中有一个重要的listener。BootstrapApplicationListener. 这个listener 在Spring-cloud-context-xxx.jar 中，且在spring.factories 文件自动配置。

# Application Listeners
org.springframework.context.ApplicationListener=\
org.springframework.cloud.bootstrap.BootstrapApplicationListener,\

查看org.springframework.cloud.bootstrap.BootstrapApplicationListener#onApplicationEvent 调用时机

将断点下到org.springframework.cloud.bootstrap.BootstrapApplicationListener#onApplicationEvent 方法，查看其调用时机如下：

核心过程如下：

(1).org.springframework.boot.SpringApplication#prepareEnvironment boot启动过程中准备环境

(2).org.springframework.boot.context.event.EventPublishingRunListener#environmentPrepared 广播环境准备事件

(3).org.springframework.context.event.SimpleApplicationEventMulticaster#multicastEvent(org.springframework.context.ApplicationEvent, org.springframework.core.ResolvableType) 获取到所有的ApplicationListener，开始广播

(4) 调用到org.springframework.cloud.bootstrap.BootstrapApplicationListener#onApplicationEvent

org.springframework.cloud.bootstrap.BootstrapApplicationListener#onApplicationEvent 调用
准备一系列的Sprinigcloud 环境，注册一些PropertySource, 处理SpringApplication、environment 对象等。

核心代码如下：org.springframework.cloud.bootstrap.BootstrapApplicationListener#bootstrapServiceContext

	private ConfigurableApplicationContext bootstrapServiceContext(
			ConfigurableEnvironment environment, final SpringApplication application,
			String configName) {
    // 重置environment
		StandardEnvironment bootstrapEnvironment = new StandardEnvironment();
		MutablePropertySources bootstrapProperties = bootstrapEnvironment
				.getPropertySources();
		for (PropertySource<?> source : bootstrapProperties) {
			bootstrapProperties.remove(source.getName());
		}
		String configLocation = environment
				.resolvePlaceholders("${spring.cloud.bootstrap.location:}");
		Map<String, Object> bootstrapMap = new HashMap<>();
		bootstrapMap.put("spring.config.name", configName);
		// if an app (or test) uses spring.main.web-application-type=reactive, bootstrap
		// will fail
		// force the environment to use none, because if though it is set below in the
		// builder
		// the environment overrides it
		bootstrapMap.put("spring.main.web-application-type", "none");
		if (StringUtils.hasText(configLocation)) {
			bootstrapMap.put("spring.config.location", configLocation);
		}
    // 添加一个boostrap的MapPropertySource，后面解析bootstrap.yml 会用到
		bootstrapProperties.addFirst(
				new MapPropertySource(BOOTSTRAP_PROPERTY_SOURCE_NAME, bootstrapMap));
		for (PropertySource<?> source : environment.getPropertySources()) {
			if (source instanceof StubPropertySource) {
				continue;
			}
			bootstrapProperties.addLast(source);
		}
		
    // 重建一个builder
		SpringApplicationBuilder builder = new SpringApplicationBuilder()
				.profiles(environment.getActiveProfiles()).bannerMode(Mode.OFF)
				.environment(bootstrapEnvironment)
				// Don't use the default properties in this builder
				.registerShutdownHook(false).logStartupInfo(false)
				.web(WebApplicationType.NONE);
		final SpringApplication builderApplication = builder.application();
		if (builderApplication.getMainApplicationClass() == null) {
			// gh_425:
			// SpringApplication cannot deduce the MainApplicationClass here
			// if it is booted from SpringBootServletInitializer due to the
			// absense of the "main" method in stackTraces.
			// But luckily this method's second parameter "application" here
			// carries the real MainApplicationClass which has been explicitly
			// set by SpringBootServletInitializer itself already.
			builder.main(application.getMainApplicationClass());
		}
		if (environment.getPropertySources().contains("refreshArgs")) {
			// If we are doing a context refresh, really we only want to refresh the
			// Environment, and there are some toxic listeners (like the
			// LoggingApplicationListener) that affect global static state, so we need a
			// way to switch those off.
			builderApplication
					.setListeners(filterListeners(builderApplication.getListeners()));
		}
		builder.sources(BootstrapImportSelectorConfiguration.class);
    
    // builder.run() 相当于会重亲启动ApplicationContext （这一步会启动Springboot环境，加载配置也是在这一步骤进行加载的）
		final ConfigurableApplicationContext context = builder.run();
		// gh-214 using spring.application.name=bootstrap to set the context id via
		// `ContextIdApplicationContextInitializer` prevents apps from getting the actual
		// spring.application.name
		// during the bootstrap phase.
		context.setId("bootstrap");
		// Make the bootstrap context a parent of the app context
		addAncestorInitializer(application, context);
		// It only has properties in it now that we don't want in the parent so remove
		// it (and it will be added back later)
		bootstrapProperties.remove(BOOTSTRAP_PROPERTY_SOURCE_NAME);
    // 合并propertySource
		mergeDefaultProperties(environment.getPropertySources(), bootstrapProperties);
    // 返回Context，相当于替换Context
		return context;
	}

简单理解过程如下：springboot启动-》准备环境-》springcloudlistener操作(1. 设置springcloud环境-》2.builder.run启动springcloud环境(大体类似boot启动)-》3.清理环境中springcloud相关信息-》合并environment，重置context)-》boot其他listener-》boot其他启动逻辑

这里return 之前的environment 如下，如图：

2. bootstrap.yml加载过程

断点查看Springcloud 环境完全启动的environment的相关source ：

过程解释：

上面说了org.springframework.cloud.bootstrap.BootstrapApplicationListener#bootstrapServiceContext 方法builder.run(); 会使用上面springcloud 初始化之后的一些环境进行启动，相当于原来springboot环境的启动。启动完成之后替换Springboot的context和environment 对象。

builder.run(); 重新启动

调用到：org.springframework.boot.SpringApplication#run(java.lang.String...)
然后继续调用到：org.springframework.boot.SpringApplication#prepareEnvironment 方法
org.springframework.boot.context.config.ConfigFileApplicationListener#onApplicationEnvironmentPreparedEvent

    private void onApplicationEnvironmentPreparedEvent(ApplicationEnvironmentPreparedEvent event) {
        List<EnvironmentPostProcessor> postProcessors = this.loadPostProcessors();
        postProcessors.add(this);
        AnnotationAwareOrderComparator.sort(postProcessors);
        Iterator var3 = postProcessors.iterator();

        while(var3.hasNext()) {
            EnvironmentPostProcessor postProcessor = (EnvironmentPostProcessor)var3.next();
            postProcessor.postProcessEnvironment(event.getEnvironment(), event.getSpringApplication());
        }

    }

获取所有的环境后置处理器，进行后置处理。这里包括：

继续调用到org.springframework.boot.context.config.ConfigFileApplicationListener

这个里面加载重要的配置信息并且进行加载配置。

    private static final String DEFAULT_PROPERTIES = "defaultProperties";
    private static final String DEFAULT_SEARCH_LOCATIONS = "classpath:/,classpath:/config/,file:./,file:./config/";
    private static final String DEFAULT_NAMES = "application";
    private static final Set<String> NO_SEARCH_NAMES = Collections.singleton((Object)null);
    private static final Bindable<String[]> STRING_ARRAY = Bindable.of(String[].class);
    private static final Bindable<List<String>> STRING_LIST = Bindable.listOf(String.class);
    private static final Set<String> LOAD_FILTERED_PROPERTY;
    public static final String ACTIVE_PROFILES_PROPERTY = "spring.profiles.active";
    public static final String INCLUDE_PROFILES_PROPERTY = "spring.profiles.include";
    public static final String CONFIG_NAME_PROPERTY = "spring.config.name";
    public static final String CONFIG_LOCATION_PROPERTY = "spring.config.location";
    public static final String CONFIG_ADDITIONAL_LOCATION_PROPERTY = "spring.config.additional-location";
    public static final int DEFAULT_ORDER = -2147483638;      

        private void load(Profile profile, DocumentFilterFactory filterFactory, DocumentConsumer consumer) {
            this.getSearchLocations().forEach((location) -> {
                boolean isFolder = location.endsWith("/");
                Set<String> names = isFolder ? this.getSearchNames() : ConfigFileApplicationListener.NO_SEARCH_NAMES;
                names.forEach((name) -> {
                    this.load(location, name, profile, filterFactory, consumer);
                });
            });
        }

        private void load(String location, String name, Profile profile, DocumentFilterFactory filterFactory, DocumentConsumer consumer) {
            if (!StringUtils.hasText(name)) {
                Iterator var13 = this.propertySourceLoaders.iterator();

                PropertySourceLoader loader;
                do {
                    if (!var13.hasNext()) {
                        throw new IllegalStateException("File extension of config file location '" + location + "' is not known to any PropertySourceLoader. If the location is meant to reference a directory, it must end in '/'");
                    }

                    loader = (PropertySourceLoader)var13.next();
                } while(!this.canLoadFileExtension(loader, location));

                this.load(loader, location, profile, filterFactory.getDocumentFilter(profile), consumer);
            } else {
                Set<String> processed = new HashSet();
                Iterator var7 = this.propertySourceLoaders.iterator();

                while(var7.hasNext()) {
                    PropertySourceLoader loaderx = (PropertySourceLoader)var7.next();
                    String[] var9 = loaderx.getFileExtensions();
                    int var10 = var9.length;

                    for(int var11 = 0; var11 < var10; ++var11) {
                        String fileExtension = var9[var11];
                        if (processed.add(fileExtension)) {
                            this.loadForFileExtension(loaderx, location + name, "." + fileExtension, profile, filterFactory, consumer);
                        }
                    }
                }

            }
        }

        private Set<String> getSearchNames() {
            if (this.environment.containsProperty("spring.config.name")) {
                String property = this.environment.getProperty("spring.config.name");
                return this.asResolvedSet(property, (String)null);
            } else {
                return this.asResolvedSet(ConfigFileApplicationListener.this.names, "application");
            }
        }

org.springframework.boot.context.config.ConfigFileApplicationListener.Loader#load传入的参数如下：name = bootstrap, location=classpath:/

这里的核心逻辑是

(1). 获取搜索目录searchLocations，成员变量设置的默认值；

(2). 获取搜索的name; 如果包含spring.config.name ( 就获取cloud启动设置的bootstrap)；如果不包含就获取application.xxx (这里也就是为什么bootstrap.yml 优先获取)。

当springcloud 环境启动完成builder.run()执行完之后，有一个remove bootstrap 的操作。所以springcloud 环境启动完成之后相当于删除掉标记，然后合并context和environment 之后继续springboot 的启动。

(3). 然后遍历当前的loaders(也就是property和yml加载器)，然后获取当前loader 支持的后缀(property)，最后拼接传递参数让loader 去依次到指定位置获取。支持的后缀如下：（简单理解就是调用方给一个文件的basename和location，比如bootstrap，这里会分别调用两个loader 两次，然后传递不同的后缀去指定路径找文件加载。这也是为什么properties\yml\yaml都支持的原因。）

org.springframework.boot.env.PropertiesPropertySourceLoader#getFileExtensions
    public String[] getFileExtensions() {
        return new String[]{"properties", "xml"};
    }

org.springframework.boot.env.YamlPropertySourceLoader#getFileExtensions
    public String[] getFileExtensions() {
        return new String[]{"yml", "yaml"};
    }

继续调用到：org.springframework.boot.context.config.ConfigFileApplicationListener.Loader#loadDocuments
继续调用到： org.springframework.boot.env.YamlPropertySourceLoader#load 解析classpath:./bootstrap.yml

创建一个OriginTrackedMapPropertySource然后加入到

    public OriginTrackedMapPropertySource(String name, Map source, boolean immutable) {
        super(name, source);
        this.immutable = immutable;
    }

这里传入的参数如下：

这里就完成了加载bootstrap.yaml。

可能不通的Springboot 加载的类以及后置处理器不一样，但大体思路都是这样。

springoot 启动-》environment准备-》广播事件-》获取EnvironmentPostProcessor 环境后置处理器-》执行org.springframework.boot.env.EnvironmentPostProcessor#postProcessEnvironment 方法进行初始化配置加载(可能不同的版本采用不通的后置处理器处理)。

标签：String,Springcloud,bootstrap,springframework,environment,context,org,yml
From： https://www.cnblogs.com/qlqwjy/p/17135908.html

Springcloud环境中bootstrap.yml加载原理

1. Springcloud 启动

2. bootstrap.yml加载过程

相关文章

赞助商

阅读排行