Apollo与SpringBoot整合原理深度剖析

public abstract class AbstractEnvironment implements ConfigurableEnvironment {
    //Spring中并不是直接用一个List<PropertySource>管理多个属性源,而是用一个MutablePropertySources进行管理
	private final MutablePropertySources propertySources = new MutablePropertySources(this.logger); 
	...
}
//MutablePropertySources中本质还是使用一个List集合进行管理---组合模式的体现
public class MutablePropertySources implements PropertySources {
	//一个写时复制集合,考虑到了线程安全性,同时兼顾了性能,因为对于PropertySource而言,读大于写,一般属性源在Spring应用程序启动完毕后,基本就确定不动了
	private final List<PropertySource<?>> propertySourceList = new CopyOnWriteArrayList<>();
    ...
}

public abstract class AbstractEnvironment implements ConfigurableEnvironment {
    //管理激活配置文件的容器    
	private final Set<String> activeProfiles = new LinkedHashSet<>();
   //管理默认配置文件的容器
	private final Set<String> defaultProfiles = new LinkedHashSet<>(getReservedDefaultProfiles());
    //MutablePropertySources负责管理多个属性源---组合模式体现
	private final MutablePropertySources propertySources = new MutablePropertySources(this.logger);
    //负责${}占位符属性解析
	private final ConfigurablePropertyResolver propertyResolver =
			new PropertySourcesPropertyResolver(this.propertySources);
    
    public AbstractEnvironment() {
        //留给子类扩展其他属性源的钩子方法
		customizePropertySources(this.propertySources);
	}
    ...
}    

public class StandardEnvironment extends AbstractEnvironment {
	public static final String SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME = "systemEnvironment";
	public static final String SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME = "systemProperties";
    //StandardEnvironment只干了一件事,通过钩子接口customizePropertySources向属性源集合添加系统属性源和系统上下文属性源
	@Override
	protected void customizePropertySources(MutablePropertySources propertySources) {
		propertySources.addLast(
				new PropertiesPropertySource(SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME, getSystemProperties()));
		propertySources.addLast(
				new SystemEnvironmentPropertySource(SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME, getSystemEnvironment()));
	}
}

public class StandardServletEnvironment extends StandardEnvironment implements ConfigurableWebEnvironment {
	public static final String SERVLET_CONTEXT_PROPERTY_SOURCE_NAME = "servletContextInitParams";
	public static final String SERVLET_CONFIG_PROPERTY_SOURCE_NAME = "servletConfigInitParams";
	public static final String JNDI_PROPERTY_SOURCE_NAME = "jndiProperties";
    //StandardServletEnvironment同样是通过钩子接口,向属性源集合中添加上面三个属性源
	@Override
	protected void customizePropertySources(MutablePropertySources propertySources) {
	    //此处的Stub意思为桩,表示模拟属性源--在initPropertySources方法中会对Stub属性源进行实际替换操作
	    //之所以这里采用Stud模拟属性源,因为环境上下文模块初始化早于Servlet容器初始化和启动
		propertySources.addLast(new StubPropertySource(SERVLET_CONFIG_PROPERTY_SOURCE_NAME));
		propertySources.addLast(new StubPropertySource(SERVLET_CONTEXT_PROPERTY_SOURCE_NAME));
		if (JndiLocatorDelegate.isDefaultJndiEnvironmentAvailable()) {
			propertySources.addLast(new JndiPropertySource(JNDI_PROPERTY_SOURCE_NAME));
		}
		//调用父类钩子方法,添加系统属性源和系统上下文属性源
		super.customizePropertySources(propertySources);
	}
    
    //initPropertySources方法来源于ConfigurableWebEnvironment接口，当Servlet容器启动时,调用此方法完成上面两个stub属性源的替换
    //initPropertySources回调接口何时被调用,大家可以追踪一下SpringBoot环境下Servlet容器初始化过程
	@Override
	public void initPropertySources(@Nullable ServletContext servletContext, @Nullable ServletConfig servletConfig){
		WebApplicationContextUtils.initServletPropertySources(getPropertySources(), servletContext, servletConfig);
	}
}

public class AutowiredAnnotationBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter
		implements MergedBeanDefinitionPostProcessor, PriorityOrdered, BeanFactoryAware {
	private final Set<Class<? extends Annotation>> autowiredAnnotationTypes = new LinkedHashSet<>(4);
	private String requiredParameterName = "required";
	private boolean requiredParameterValue = true;
	private ConfigurableListableBeanFactory beanFactory;
	private final Map<String, InjectionMetadata> injectionMetadataCache = new ConcurrentHashMap<>(256);

	public AutowiredAnnotationBeanPostProcessor() {
	    //当前Bean后置处理器负责处理Autowired,Value,Inject注解
		this.autowiredAnnotationTypes.add(Autowired.class);
		this.autowiredAnnotationTypes.add(Value.class);
		try {
			this.autowiredAnnotationTypes.add((Class<? extends Annotation>)
					ClassUtils.forName("javax.inject.Inject", AutowiredAnnotationBeanPostProcessor.class.getClassLoader()));
			logger.info("JSR-330 'javax.inject.Inject' annotation found and supported for autowiring");
		}
		catch (ClassNotFoundException ex) {
		}
	}
    
    //处理注解指定的依赖注入
	@Override
	public PropertyValues postProcessPropertyValues(
			PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeanCreationException{
        //寻找当前bean属性和方法上所有标注了相关注解的地方,如果找到了,则封装为一个InjectedElement对象实例
        //表示待注入元素,这里待注入元素可以是字段,或者方法
        //InjectionMetadata内部管理从当前bean上找到的所有InjectedElement
		InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
		try {
		    //进行注解标注的依赖注入---遍历InjectionMetadata内部管理的InjectedElement集合
		    //依次调用每个InjectedElement的inject方法
			metadata.inject(bean, beanName, pvs);
		}
		...
		//
		return pvs;
	}
    ...

	private InjectionMetadata findAutowiringMetadata(String beanName, Class<?> clazz, @Nullable PropertyValues pvs){
		// InjectionMetadata会被缓存起来--key为beanName
		String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
		InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
		//双重锁机制,确保单例
		if (InjectionMetadata.needsRefresh(metadata, clazz)) {
			synchronized (this.injectionMetadataCache) {
				metadata = this.injectionMetadataCache.get(cacheKey);
				if (InjectionMetadata.needsRefresh(metadata, clazz)) {
					if (metadata != null) {
						metadata.clear(pvs);
					}
					//为当前bean构建InjectionMetadata
					metadata = buildAutowiringMetadata(clazz);
					this.injectionMetadataCache.put(cacheKey, metadata);
				}
			}
		}
		return metadata;
	}
   
	private InjectionMetadata buildAutowiringMetadata(final Class<?> clazz) {
		List<InjectionMetadata.InjectedElement> elements = new ArrayList<>();
		Class<?> targetClass = clazz;
		do {
			final List<InjectionMetadata.InjectedElement> currElements = new ArrayList<>();
			//遍历当前类上所有属性,寻找到存在相关注解的属性
			ReflectionUtils.doWithLocalFields(targetClass, field -> {
				AnnotationAttributes ann = findAutowiredAnnotation(field);
				//排除静态属性的注入
				if (ann != null) {
					if (Modifier.isStatic(field.getModifiers())) {
						if (logger.isWarnEnabled()) {
							logger.warn("Autowired annotation is not supported on static fields: " + field);
						}
						return;
					}
					//从注解中取出required属性--表明是否必须注入成功
					boolean required = determineRequiredStatus(ann);
					//封装为AutowiredFieldElement后返回
					currElements.add(new AutowiredFieldElement(field, required));
				}
			});
            //遍历当前bean所有方法,寻找存在相关注解的方法,并且方法不是静态的,封装为AutowiredMethodElement后返回
			ReflectionUtils.doWithLocalMethods(targetClass, method -> {
				...
				AnnotationAttributes ann = findAutowiredAnnotation(bridgedMethod);
				if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
					if (Modifier.isStatic(method.getModifiers())) {
						...
						return;
					}
					...
					boolean required = determineRequiredStatus(ann);
					PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
					currElements.add(new AutowiredMethodElement(method, required, pd));
				}
			});
			elements.addAll(0, currElements);
			//注入依赖注入一并处理当前父类上标注的相关依赖注入点
			targetClass = targetClass.getSuperclass();
		}
		while (targetClass != null && targetClass != Object.class);
        //创建一个InjectionMetadata返回,InjectionMetadata管理当前bean中所有依赖注入点
		return new InjectionMetadata(clazz, elements);
	}	    
}

	public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
		    ...
		    //遍历所有InjectedElement，调用其inject方法完成依赖注入
			for (InjectedElement element : elementsToIterate) {
				...
				element.inject(target, beanName, pvs);
			}
		}
	}

	private class AutowiredFieldElement extends InjectionMetadata.InjectedElement {

		private final boolean required;

		private volatile boolean cached = false;

		@Nullable
		private volatile Object cachedFieldValue;
        ...
		@Override
		protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
			Field field = (Field) this.member;
			Object value;
			 ...
            //构建依赖描述符
		    DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
			  ...
             //类型转换器
		     TypeConverter typeConverter = beanFactory.getTypeConverter();
             //调用beanFactory的resolveDependency方法,根据依赖描述符完成依赖查找
			 value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
				...
            //反射注入        
			if (value != null) {
				ReflectionUtils.makeAccessible(field);
				field.set(bean, value);
			}
		}
	}

	public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
			@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
        //初始化方法参数名解析器
		descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
		...
		//如果当前依赖注入点上存在@Lazy注解,则创建一个代理对象返回,为的是实现依赖延迟注入---这块逻辑很简单,不展开,自己看源码
		Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(descriptor, requestingBeanName);
	     //正常情况下进入依赖查找逻辑
	    if (result == null) {
				result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
		 }
		return result;
	}
}

	public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
			@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
        
		InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
		try {
		    //描述符解析过了,直接返回--相当于缓存 
			Object shortcut = descriptor.resolveShortcut(this);
			if (shortcut != null) {
				return shortcut;
			}
            //获取要查找的bean类型---当然这里可能是bean类型(@Autowired注解),也可能需要查找的是String字符串(@Value注解)
			Class<?> type = descriptor.getDependencyType();
			//当前依赖注入点上是否存在@Value注解--如果存在返回注解中value属性值,否则返回null
			Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
			//如果value不为null,说明当前依赖查找需要解析value注解中的value属性值,然后返回作为依赖查找结果
			if (value != null) {
				if (value instanceof String) {
				     //解析${}占位符
					String strVal = resolveEmbeddedValue((String) value);
					BeanDefinition bd = (beanName != null && containsBean(beanName) ? getMergedBeanDefinition(beanName) : null);
					//解析EL表达式
					value = evaluateBeanDefinitionString(strVal, bd);
				}
				//获取类型转换器
				TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
				//@Value注解可以标注在Resource资源对象上,因为value字符串经过${}占位符解析和EL表达式解析后
				//可能得到的是一个资源路径或者url字符串表示形式,可以使用类型转换器将字符串形式表示的资源路径转换为
				//实际的资源类型对象
				return (descriptor.getField() != null ?
						converter.convertIfNecessary(value, type, descriptor.getField()) :
						converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));
			}
			//下面是@Autowired等注解的依赖查找过程,非本文重点,这里不进行讲解
            ...
		}
		finally {
			ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);
		}
	}

	public String resolveEmbeddedValue(@Nullable String value) {
		if (value == null) {
			return null;
		}
		String result = value;
		for (StringValueResolver resolver : this.embeddedValueResolvers) {
			result = resolver.resolveStringValue(result);
			if (result == null) {
				return null;
			}
		}
		return result;
	}

public abstract class AbstractApplicationContext extends DefaultResourceLoader implements ConfigurableApplicationContext, DisposableBean {

	protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
		...
		// 若没有指定EmbeddedValueResolver
		if (!beanFactory.hasEmbeddedValueResolver()) {
		    //创建一个匿名内部类的实现,核心交给环境上下文对象完成
			beanFactory.addEmbeddedValueResolver(new StringValueResolver() {
				@Override
				public String resolveStringValue(String strVal) {
					return getEnvironment().resolvePlaceholders(strVal);
				}
			});
		}
		...
	}
}

	@Override
	public String resolvePlaceholders(String text) {
	    //这里的strict表示是否忽略无法被解析的${}占位符,如果不忽略,则会抛出异常
		if (this.nonStrictHelper == null) {
			this.nonStrictHelper = createPlaceholderHelper(true);
		}
		// 真正进行占位符解析
		return doResolvePlaceholders(text, this.nonStrictHelper);
	}
   
	private String doResolvePlaceholders(String text, PropertyPlaceholderHelper helper) {
		//借助PropertyPlaceholderHelper完成占位符解析
		return helper.replacePlaceholders(text, this::getPropertyAsRawString);
	}	
    
    //子类实现根据PropertyPlaceholderHelper取出${server.port}占位符中的server.port
    //去属性源集合中根据取出的server.port作为key,进行查找
	protected abstract String getPropertyAsRawString(String key);	

    //传入的是value注解中的value属性值,如: ${server.port}
    public String replacePlaceholders(String value, PlaceholderResolver placeholderResolver) {
		Assert.notNull(value, "'value' must not be null");
		return parseStringValue(value, placeholderResolver, new HashSet<>());
	}
     
	protected String parseStringValue(
			String value, PlaceholderResolver placeholderResolver, Set<String> visitedPlaceholders) {
		StringBuilder result = new StringBuilder(value);
		//定位 ${ 出现的位置
		int startIndex = value.indexOf(this.placeholderPrefix);
		while (startIndex != -1) {
		    //定位 } 出现的位置 
			int endIndex = findPlaceholderEndIndex(result, startIndex);
			if (endIndex != -1) {
			    //截取${server.post}占位符之间的值--> server.port
				String placeholder = result.substring(startIndex + this.placeholderPrefix.length(), endIndex);
				//拿到传入的占位符解析器
				String originalPlaceholder = placeholder;
				...
				// 递归解析${}占位符,因为可能会存在${${config.key}.value}的情况
				placeholder = parseStringValue(placeholder, placeholderResolver, visitedPlaceholders);
				// 调用传入的占位符解析器的resolvePlaceholder方法解析占位符
				String propVal = placeholderResolver.resolvePlaceholder(placeholder);
				//valueSeparator默认为":",表示默认值
				//如果val值为null,那么尝试查找默认值
				if (propVal == null && this.valueSeparator != null) {
				   //如: ${server.port:8079}---如果存在默认值设置,那么将默认值作为结果
					int separatorIndex = placeholder.indexOf(this.valueSeparator);
					if (separatorIndex != -1) {
						String actualPlaceholder = placeholder.substring(0, separatorIndex);
						String defaultValue = placeholder.substring(separatorIndex + this.valueSeparator.length());
						propVal = placeholderResolver.resolvePlaceholder(actualPlaceholder);
						if (propVal == null) {
							propVal = defaultValue;
						}
					}
				}
				//如果解析结果不为null
				if (propVal != null) {
					//考虑到根据${dhy.name}中的dhy.name查找属性源得到的值可能是${xpy.name}这种形式
					//因此需要继续递归解析
					propVal = parseStringValue(propVal, placeholderResolver, visitedPlaceholders);
					result.replace(startIndex, endIndex + this.placeholderSuffix.length(), propVal);
					...
					startIndex = result.indexOf(this.placeholderPrefix, startIndex + propVal.length());
				}
				else if (this.ignoreUnresolvablePlaceholders) {
					// Proceed with unprocessed value.
					startIndex = result.indexOf(this.placeholderPrefix, endIndex + this.placeholderSuffix.length());
				}
				//ignoreUnresolvablePlaceholders为false的情况下,抛出解析失败异常
				else {
					throw new IllegalArgumentException("Could not resolve placeholder '" +
							placeholder + "'" + " in value \"" + value + "\"");
				}
				visitedPlaceholders.remove(originalPlaceholder);
			}
			else {
				startIndex = -1;
			}
		}
		return result.toString();
	}

	protected String resolvePlaceholder(String placeholder) {
		if (this.sources != null) {
		   //挨个遍历每个属性源,哪个先找到,就直接返回---这里引出了配置优先级问题 
			for (PropertySource<?> source : this.sources) {
				Object value = source.getProperty(placeholder);
				if (value != null) {
					return String.valueOf(value);
				}
			}
		}
		return null;
	}

	public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
		this.resourceLoader = resourceLoader;
		Assert.notNull(primarySources, "PrimarySources must not be null");
		this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
		this.webApplicationType = WebApplicationType.deduceFromClasspath();
		setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
		setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
		this.mainApplicationClass = deduceMainApplicationClass();
	}

	public ConfigurableApplicationContext run(String... args) {
		..
		ConfigurableApplicationContext context = null;
		...
		//SPI加载SpringApplicationRunListener实现类,然后交给SpringApplicationRunListeners管理---组合模式
		SpringApplicationRunListeners listeners = getRunListeners(args);
		...
		return context;
	}

	public EventPublishingRunListener(SpringApplication application, String[] args) {
		this.application = application;
		this.args = args;
        //事件派发器
		this.initialMulticaster = new SimpleApplicationEventMulticaster();
		//从SpringApplication拿到通过SPI加载得到的ApplicationListener集合
        for (ApplicationListener<?> listener : application.getListeners()) {
			this.initialMulticaster.addApplicationListener(listener);
		}
	}

	public ConfigurableApplicationContext run(String... args) {
		..
		ConfigurableApplicationContext context = null;
		...
		//SPI加载SpringApplicationRunListener实现类,然后交给SpringApplicationRunListeners管理---组合模式
		SpringApplicationRunListeners listeners = getRunListeners(args);
		//发布SpringBoot应用程序启动事件
		listeners.starting();
		try {
		    //封装命令行参数
			ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
			//环境上下文准备--配置类加载的地方
			ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
			...
			context = createApplicationContext();
			...
			//这里我们需要关注一点: 此处会调用经过SPI加载得到的ApplicationContextInitializer的initialize方法
			prepareContext(context, environment, listeners, applicationArguments, printedBanner);
			refreshContext(context);
			afterRefresh(context, applicationArguments);
			...
			listeners.started(context);
			callRunners(context, applicationArguments);
		}
		...
		listeners.running(context);
		return context;
	}

	private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
			ApplicationArguments applicationArguments) {
		ConfigurableEnvironment environment = getOrCreateEnvironment();
		//主要干的事情: 封装命令行参数为propertySource,加入环境上下文管理的属性源集合中
		configureEnvironment(environment, applicationArguments.getSourceArgs());
		//发布环境上下文准备好的事件
		listeners.environmentPrepared(environment);
		bindToSpringApplication(environment);
		...
		ConfigurationPropertySources.attach(environment);
		return environment;
	}
     
    //根据当前应用程序类型的不同,创建不同的环境上下文实现类
	private ConfigurableEnvironment getOrCreateEnvironment() {
		if (this.environment != null) {
			return this.environment;
		}
		switch (this.webApplicationType) {
		case SERVLET:
			return new StandardServletEnvironment();
		case REACTIVE:
			return new StandardReactiveWebEnvironment();
		default:
			return new StandardEnvironment();
		}
	}

	protected void configureEnvironment(ConfigurableEnvironment environment, String[] args) {
	    //封装命令行参数为propertySource,加入环境上下文管理的属性源集合中
		configurePropertySources(environment, args);
		// 从已有的属性源集合中更新激活profile的配置
		configureProfiles(environment, args);
	}		

	@Override
	public void onApplicationEvent(ApplicationEvent event) {
	     //重点关注监听应用程序环境上下文准备好的这个事件处理逻辑
		if (event instanceof ApplicationEnvironmentPreparedEvent) {
			onApplicationEnvironmentPreparedEvent((ApplicationEnvironmentPreparedEvent) event);
		}
		//一句话: 将SpringApplication中的defaultProperties对应的propertysource移动到属性源集合末尾
		//即: 具有最低优先级 --- 上面一开始添加过
		if (event instanceof ApplicationPreparedEvent) {
			onApplicationPreparedEvent(event);
		}
	}

	private void onApplicationEnvironmentPreparedEvent(ApplicationEnvironmentPreparedEvent event) {
	    //SPI机制加载所有EnvironmentPostProcessor
		List<EnvironmentPostProcessor> postProcessors = loadPostProcessors();
		//ConfigFileApplicationListener自己本身也是一个EnvironmentPostProcessor
		postProcessors.add(this);
		AnnotationAwareOrderComparator.sort(postProcessors);
		for (EnvironmentPostProcessor postProcessor : postProcessors) {
			postProcessor.postProcessEnvironment(event.getEnvironment(), event.getSpringApplication());
		}
	}

	@Override
	public void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application) {
		addPropertySources(environment, application.getResourceLoader());
	}
    //addPropertySources方法中,会首先向环境上下中添加一个随机数属性源
	protected void addPropertySources(ConfigurableEnvironment environment, ResourceLoader resourceLoader) {
		RandomValuePropertySource.addToEnvironment(environment);
		//创建一个Loader,调用其load方法,完成配置文件的加载
		new Loader(environment, resourceLoader).load();
	}

		Loader(ConfigurableEnvironment environment, ResourceLoader resourceLoader) {
			this.environment = environment;
			//search and parse==> environment内部的propertySources集合的delegate
            this.placeholdersResolver = new PropertySourcesPlaceholdersResolver(this.environment);
            //加载配置的资源加载器
			this.resourceLoader = (resourceLoader != null) ? resourceLoader : new DefaultResourceLoader(null);
            //通过SPI机制加载PropertySourceLoader
			this.propertySourceLoaders = SpringFactoriesLoader.loadFactories(PropertySourceLoader.class,
					getClass().getClassLoader());
		}

org.springframework.boot.env.PropertySourceLoader=\
org.springframework.boot.env.PropertiesPropertySourceLoader,\
org.springframework.boot.env.YamlPropertySourceLoader

		void load() {
			FilteredPropertySource.apply(this.environment, DEFAULT_PROPERTIES, LOAD_FILTERED_PROPERTY,
					(defaultProperties) -> {
						this.profiles = new LinkedList<>();
						this.processedProfiles = new LinkedList<>();
						this.activatedProfiles = false;
						this.loaded = new LinkedHashMap<>();
                        //初始化profiles--从已有的propertySource集合中解析得到激活的profile
						initializeProfiles();
						while (!this.profiles.isEmpty()) {
							Profile profile = this.profiles.poll();
                            //如果当前Profile是默认的,那么加入Environment的ActiveProfile集合
							if (isDefaultProfile(profile)) {
								addProfileToEnvironment(profile.getName());
							}
                           //加载配置文件,并通过getNegativeProfileFilter过滤进行过滤
                           //过滤规则: 
                           //1.如果传入的profile为null,那么过滤掉document的profiles不为空
                           //2.如果传入的profile不为null,那么过滤掉document的profile不等于传入的profile的
							load(profile, this::getPositiveProfileFilter,
                                    //将配置文件加载完毕后,回调此方法,用于将配置文件对应的PropertySource和Profile关系记录到loaded集合中
									addToLoaded(MutablePropertySources::addLast, false));
							//标记当前profile处理完毕
                            this.processedProfiles.add(profile);
						}
                        //加载配置文件,并通过getNegativeProfileFilter过滤进行过滤
                        //过滤规则: 1.如果传入的profile为null,那么过滤掉document的profiles不为空
                        //2.如果传入的profile不为null,那么过滤掉document的profile不等于传入的profile的
						load(null, this::getNegativeProfileFilter, addToLoaded(MutablePropertySources::addFirst, true));
                        //将Loaded集合中记录的propertySource加入environment的propertySources集合中去
						addLoadedPropertySources();
                        //向environment中添加通过解析配置文件得到的activeProfiles
						applyActiveProfiles(defaultProperties);
					});
		}

		private void initializeProfiles() {
			// The default profile for these purposes is represented as null. We add it
			// first so that it is processed first and has lowest priority.
			this.profiles.add(null);
			Binder binder = Binder.get(this.environment);
            //获取spring.profiles.active和spring.profiles.include
			Set<Profile> activatedViaProperty = getProfiles(binder, ACTIVE_PROFILES_PROPERTY);
			Set<Profile> includedViaProperty = getProfiles(binder, INCLUDE_PROFILES_PROPERTY);
            //获取Environment中已经存在的profile的，过滤掉了和上面两个重复的profile
			List<Profile> otherActiveProfiles = getOtherActiveProfiles(activatedViaProperty, includedViaProperty);
            //合并三个集合
			this.profiles.addAll(otherActiveProfiles);
			// Any pre-existing active profiles set via property sources (e.g.
			// System properties) take precedence over those added in config files.
			this.profiles.addAll(includedViaProperty);
			addActiveProfiles(activatedViaProperty);
            //如果我们没有通过命令行或者系统参数的形式配置spring.profiles.active
            //那么添加defaultProflie到profiles集合中
			if (this.profiles.size() == 1) { // only has null profile
				for (String defaultProfileName : this.environment.getDefaultProfiles()) {
					Profile defaultProfile = new Profile(defaultProfileName, true);
					this.profiles.add(defaultProfile);
				}
			}
		}

		private void load(Profile profile, DocumentFilterFactory filterFactory, DocumentConsumer consumer) {
			//默认springboot会去这几个路径下寻找配置文件
            //classpath:/,classpath:/config/,file:./,file:./config/*/,file:./config/
            getSearchLocations()
                .forEach((location) -> {
                //getSearchNames获取配置文件的前缀名，默认只有一个,为application
				boolean isDirectory = location.endsWith("/");
				Set<String> names = isDirectory ? getSearchNames() : NO_SEARCH_NAMES;
				names.forEach((name) -> 
                              //location目录路径有了,配置文件名有了,还差个后缀名
                              //load方法拼接上后缀，然后去定位配置文件
                              load(location, name, profile, filterFactory, consumer));
			});
		}

 //location目录路径有了,配置文件名有了,还差个后缀名
//load方法拼接上后缀，然后去定位配置文件
private void load(String location, String name, Profile profile, DocumentFilterFactory filterFactory,
				DocumentConsumer consumer) {
			...
			Set<String> processed = new HashSet<>();
            //默认情况下能够处理.properties后缀,.yml后缀或者是.yaml后缀
			for (PropertySourceLoader loader : this.propertySourceLoaders) {
				for (String fileExtension : loader.getFileExtensions()) {
					if (processed.add(fileExtension)) {
                        //配置文件完整路径=目录名+文件名+后缀名
						loadForFileExtension(loader, location + name, "." + fileExtension, profile, filterFactory,
								consumer);
					}
				}
			}
		}

		private void loadForFileExtension(PropertySourceLoader loader, String prefix, String fileExtension,
				Profile profile, DocumentFilterFactory filterFactory, DocumentConsumer consumer) {
            //DocumentFilterFactory负责进行过滤
			DocumentFilter defaultFilter = filterFactory.getDocumentFilter(null);
			DocumentFilter profileFilter = filterFactory.getDocumentFilter(profile);
            //如果说profile不为null,那么还会尝试根据:目录名+文件名+"-"+profile+后缀去定位配置文件
			if (profile != null) {
				String profileSpecificFile = prefix + "-" + profile + fileExtension;
				load(loader, profileSpecificFile, profile, defaultFilter, consumer);
				load(loader, profileSpecificFile, profile, profileFilter, consumer);
				// Try profile specific sections in files we've already processed
				for (Profile processedProfile : this.processedProfiles) {
					if (processedProfile != null) {
						String previouslyLoaded = prefix + "-" + processedProfile + fileExtension;
						load(loader, previouslyLoaded, profile, profileFilter, consumer);
					}
				}
			}
			//根据 目录名+文件名+后缀去定位配置文件
			load(loader, prefix + fileExtension, profile, profileFilter, consumer);
		}

		private void load(PropertySourceLoader loader, String location, Profile profile, DocumentFilter filter,
				DocumentConsumer consumer) {
            //利用resourceLoader加载配置文件
			Resource[] resources = getResources(location);
			for (Resource resource : resources) {
				try {
                    //如果配置文件不存在则continue--省略配置文件不存在或者不符合要求的几种情况判断
                    ...
                    //配置文件存在--name作为propertySource的名字
					String name = "applicationConfig: [" + getLocationName(location, resource) + "]";
                    //加载配置文件信息
					List<Document> documents = loadDocuments(loader, name, resource);
					//如果集合为空,则continue
                    ...
                    // DocumentFilter进行过滤    
					List<Document> loaded = new ArrayList<>();
					for (Document document : documents) {
						if (filter.match(document)) {
                            //如果配置文件中指定了spring.profiles.active则进行记录
							addActiveProfiles(document.getActiveProfiles());
                            //如果配置文件中指定了spring.profiles.include则进行记录
							addIncludedProfiles(document.getIncludeProfiles());
							loaded.add(document);
						}
					}
					Collections.reverse(loaded);
					if (!loaded.isEmpty()) {
                        //调用回调接口,进行propertySource合并处理
                        //加入ConfigFileApplicationListener的Map<Profile, MutablePropertySources> loaded
                        //集合中
						loaded.forEach((document) -> consumer.accept(profile, document));
						...
					}
				}
				...
			}
		}

  /**
   * 为了能够尽可能早的在spring加载日志系统之前加载apollo配置,ApolloApplicationContextInitializer的postProcessEnvironment可以在ConfigFileApplicationListener被成功调用后执行
   *
   * 此时的处理顺序会如下所示:
   * Load Bootstrap properties and application properties -----> load Apollo configuration properties ----> Initialize Logging systems
   */
  @Override
  public void postProcessEnvironment(ConfigurableEnvironment configurableEnvironment, SpringApplication springApplication) {

    //应始终首先初始化系统属性，例如 app.id --> 先从environment中取出app.id,apollo.meta等值
    //设置进System系统属性集合中 
    initializeSystemProperty(configurableEnvironment);
    //apollo.bootstrap.eagerLoad.enabled是否被设置为true
    Boolean eagerLoadEnabled = configurableEnvironment.getProperty(PropertySourcesConstants.APOLLO_BOOTSTRAP_EAGER_LOAD_ENABLED, Boolean.class, false);

    //EnvironmentPostProcessor should not be triggered if you don't want Apollo Loading before Logging System Initialization
    if (!eagerLoadEnabled) {
      return;
    }
     //apollo.bootstrap.enabled属性为true才会启用apollo
    Boolean bootstrapEnabled = configurableEnvironment.getProperty(PropertySourcesConstants.APOLLO_BOOTSTRAP_ENABLED, Boolean.class, false);

    if (bootstrapEnabled) {
      initialize(configurableEnvironment);
    }

  }

protected void initialize(ConfigurableEnvironment environment) {
//apollo会向environment中新增一个名为ApolloBootstrapPropertySources的propertysource
if(environment.getPropertySources().contains(PropertySourcesConstants.APOLLO_BOOTSTRAP_PROPERTY_SOURCE_NAME)) {
      //already initialized
      return;
    }
    //获取我们配置文件中配置的apollo.bootstrap.namespaces配置,如果没配置,默认加载的命名空间为application
    String namespaces = environment.getProperty(PropertySourcesConstants.APOLLO_BOOTSTRAP_NAMESPACES, ConfigConsts.NAMESPACE_APPLICATION);
    logger.debug("Apollo bootstrap namespaces: {}", namespaces);
    List<String> namespaceList = NAMESPACE_SPLITTER.splitToList(namespaces);
    //创建一个名为ApolloBootstrapPropertySources的CompositePropertySource
    CompositePropertySource composite = new CompositePropertySource(PropertySourcesConstants.APOLLO_BOOTSTRAP_PROPERTY_SOURCE_NAME);
    //依次拉取各个命名空间下的配置
    for (String namespace : namespaceList) {
      Config config = ConfigService.getConfig(namespace);
      //每个命名空间下的配置创建一个ConfigPropertySource接收
      composite.addPropertySource(configPropertySourceFactory.getConfigPropertySource(namespace, config));
    }
   //将apollo对应的CompositePropertySource放在environment中PropertySources列表头部
    //说明具有最高优先级
    environment.getPropertySources().addFirst(composite);
  }

  public void update(Object newVal) throws IllegalAccessException, InvocationTargetException {
    if (isField()) {
      injectField(newVal);
    } else {
      injectMethod(newVal);
    }
  }

  private void injectField(Object newVal) throws IllegalAccessException {
    Object bean = beanRef.get();
    if (bean == null) {
      return;
    }
    boolean accessible = field.isAccessible();
    field.setAccessible(true);
    field.set(bean, newVal);
    field.setAccessible(accessible);
  }

  private void injectMethod(Object newVal)
      throws InvocationTargetException, IllegalAccessException {
    Object bean = beanRef.get();
    if (bean == null) {
      return;
    }
    methodParameter.getMethod().invoke(bean, newVal);
  }