Spring ApplicationContext启动流程

最新推荐文章于 2023-03-19 20:55:22 发布
最新推荐文章于 2023-03-19 20:55:22 发布
阅读量1k 收藏 3
点赞数
文章标签： java
原文链接：https://juejin.im/post/5bc57f52f265da0aff1766a6
版权

ApplicationContext(AC)和BeanFacory(BF)两者都是用于加载Bean的，但是相比之下，AC提供了更多的扩张功能。

那么究竟AC和BF多出了哪些功能呢？我们一起来一探原理。

  • 使用BF方式加载XML XmlBeanFactory bf = new XmlBeanFactory(new ClassPathResource("iocbeans.xml"));

  • 使用AC方式加载XML ApplicationContext factory = new ClassPathXmlApplicationContext("beans.xml"); 我们进入代码 public ClassPathXmlApplicationContext(String configLocation) throws BeansException { this(new String[] {configLocation}, true, null); } public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent) { super(parent); setConfigLocations(configLocations); if (refresh) { refresh(); } }

    ClassPathXmlApplicationContext 中可以将配置文件路径以数组的方式传入，并对数组进行解析并进行加载。而对于解析及功能都在refresh()中实现。 1.设置路径 public void setConfigLocations(String... locations) { if (locations != null) { Assert.noNullElements(locations, "Config locations must not be null"); this.configLocations = new String[locations.length]; for (int i = 0; i < locations.length; i++) { //解析给定路径 this.configLocations[i] = resolvePath(locations[i]).trim(); } } else { this.configLocations = null; } }

此函数主要用于解析给定的路径数组，当然，如果数组中包含特殊符号，如${var}，那么在resolvePath中会搜寻匹配的系统变量并替换。

2.扩展功能

设置了路径之后，便可以根据路径做配置文件的解析以及各种功能的实现。可以说refresh函数包含了几乎AC中的全部功能，而且逻辑清晰。

public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
			// 1.准备刷新的上下文环境
			prepareRefresh();

			// 2.初始化BF,并进行XML文件读取。返回时，已经包含了所有解析好的配置
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// 3.对BF进行各种功能填充
			prepareBeanFactory(beanFactory);

			try {
				// 4.子类覆盖方法做额外的处理
				postProcessBeanFactory(beanFactory);

				//5. 激活各种BF处理器
				invokeBeanFactoryPostProcessors(beanFactory);

        //6.注册拦截Bean创建过程的处理器。这里只是注册，真正调用在getBean时候
				registerBeanPostProcessors(beanFactory);

				// 7.为上下文初始化Message源，即不同语言的消息体，国际化处理
				initMessageSource();

				// 8.初始化应用消息广播器.观察者模式(事件监听)
				initApplicationEventMulticaster();

				// 9.留给子类来初始化其他的bean
				onRefresh();

				// 10.在所有注册的bean中查找Listener bean，注册到消息广播器中
				registerListeners();

				// 11.完成BF初始化，包括ConversionService设置、配置冻结、初始化所有非惰性的单实例
				finishBeanFactoryInitialization(beanFactory);

				//12. 完成刷新过程，通知生命周期处理器lifecycleProcessor刷新过程，同时发出ContextRefreshEvent通知别人
				finishRefresh();
			}

			catch (BeansException ex) {
			
				// Destroy already created singletons to avoid dangling resources.
				destroyBeans();

				// Reset 'active' flag.
				cancelRefresh(ex);

				// Propagate exception to caller.
				throw ex;
			}

			finally {
				// Reset common introspection caches in Spring's core, since we
				// might not ever need metadata for singleton beans anymore...
				resetCommonCaches();
			}
		}
	}
复制代码

对上面的步骤的说明:

  • (1) 初始化前的准备工作，例如对系统属性或环境变量进行准备及验证。 如果有时我们需要读取某些系统变量，而这个变量很重要，就可以利用这个函数在容器启动前对变量做存在性验证。
  • （2）初始化BF，并进行XML文件读取。
  • （3）对BF进行各种功能填充。
    @Qulifier和@Autowired注解，是在这一步骤中增加的支持。
  • (4) 子类覆盖方法做额外处理
    空函数实现留给子类扩展
  • （5）激活各种BF处理器
  • …….直到12步

3.环境准备

prepareRefresh函数主要是做准备工作，对系统属性及环境变量的初始化及验证。

protected void prepareRefresh() {
		this.startupDate = System.currentTimeMillis();
		this.closed.set(false);
		this.active.set(true);
		// 空方法，留给子类覆盖
		initPropertySources();

		//  验证需要的属性文件是否都已放入环境中
		getEnvironment().validateRequiredProperties();
		this.earlyApplicationEvents = new LinkedHashSet<ApplicationEvent>();
	}
复制代码
  • initPropertySources符合Spring开放式设计，留给用户扩展。用户自己重写这个方法，进行个性化属性处理。
  • validateRequiredProperties对属性进行验证。 我们写个demo体会下。 public class MyClassPathXMLApplicationContext extends ClassPathXmlApplicationContext{ public MyClassPathXMLApplicationContext(String ...configs){ super(configs); } protected void initPropertySources(){ //添加验证要求.当验证程序走到getEnv.validateRequiredProperties()时，如果没检测到，则抛异常 getEnvironment().setRequiredProperties("var"); } } 当然，我们实际使用时要替换原有ClassPathXmlApplicationContext: public static void main(String[]args){ AC bf = new MyClassPathXMLApplicationContext("test/test.xml"); User user = (User)bf.getBean("testBean"); }

加载BeanFactory

obtainFreshBeanFactory方法获取BF。经过这个函数后AC就有了BF的全部功能。

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
//初始化 BF,并进行XML读取，并将得到的BF记录在当前实体的属性中
		refreshBeanFactory();
		//返回当前实体的BF属性
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
	
		return beanFactory;
	}
复制代码

方法中将核心实现委托给refreshBeanFactory:

	protected final void refreshBeanFactory() throws BeansException {
		if (hasBeanFactory()) {
			destroyBeans();
			closeBeanFactory();
		}
		try {
		//创建DefaultListableBeanFactory。它是容器的基础。必须首先实例化。
			DefaultListableBeanFactory beanFactory = createBeanFactory();
			//为了序列化指定id。如果需要的话，让这个BF从id反序列化到BF对象
			beanFactory.setSerializationId(getId());
			//定制BF。设置注解解析器
			customizeBeanFactory(beanFactory);
			//初始化DocmentReader，并进行XML文件读取
			loadBeanDefinitions(beanFactory);
			//使用全局变量记录BF.因为上面beanFactory是函数内局部变量，所以要全局变量记录结果。
			synchronized (this.beanFactoryMonitor) {
				this.beanFactory = beanFactory;
			}
		}
		catch (IOException ex) {
			throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
		}
	}
复制代码

  • 定制BF 思想同上，我们写个子类继承ClassPathXmlApplicationContext,覆盖customizeBeanFactory方法。然后用super调父类方法。

  • 加载BeanDefinition 我们需要一个reader来读取XML protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) { //为指定BF创建XmlBeanDefinitionReader XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory); // 对beanDefinitionReader进行环境变量设置 beanDefinitionReader.setEnvironment(this.getEnvironment()); beanDefinitionReader.setResourceLoader(this); beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

    		// 对beanDefinitionReader进行设置，可以覆盖
		initBeanDefinitionReader(beanDefinitionReader);
		loadBeanDefinitions(beanDefinitionReader);
	}
复制代码

现在可以读取配置文件了。

	protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
		Resource[] configResources = getConfigResources();
		if (configResources != null) {
			reader.loadBeanDefinitions(configResources);
		}
		String[] configLocations = getConfigLocations();
		if (configLocations != null) {
			reader.loadBeanDefinitions(configLocations);
		}
	}
复制代码

因为在XmlBeanDefinitionReader中已经将之前初始化的DefaultListableBeanFactory注册进去了，所以XmlBeanDefinitionReader中所读取的BeanDefinitionHolder都会注册到DefaultListableBeanFactory。即经过此步骤，BF已经包含了所有解析好的配置。

功能扩展

进入prepareBeanFactory前，spring已经完成了对配置的解析，而AC在功能上的扩展从此展开。

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		// 设置bf的ClassLoader为当前context的classLoader
		beanFactory.setBeanClassLoader(getClassLoader());
  //设置表达式语言处理器
		beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
  //添加属性编辑器
		beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

		// 添加BeanPostProcessor
		beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
  //设置几个忽略自动装配的接口
		beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
		beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
		beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
		beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
		beanFactory.ignoreDependencyInterface(EnvironmentAware.class);

		// 设置几个自动装配的特殊规则
		beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
		beanFactory.registerResolvableDependency(ResourceLoader.class, this);
		beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
		beanFactory.registerResolvableDependency(ApplicationContext.class, this);

		// 增加对AspectJ的支持
		if (beanFactory.containsBean("loadTimeWeaver")) {
			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
		}

		// 添加默认的系统环境bean
		if (!beanFactory.containsLocalBean("environment")) {
			beanFactory.registerSingleton("environment", getEnvironment());
		}
		if (!beanFactory.containsLocalBean("systemProperties")) {
			beanFactory.registerSingleton("systemProperties", getEnvironment().getSystemProperties());
		}
		if (!beanFactory.containsLocalBean("systemEnvironment")) {
			beanFactory.registerSingleton("systemEnvironment", getEnvironment().getSystemEnvironment());
		}
	}
复制代码

// 添加BeanPostProcessor

beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this))的主要目的是注册个BeanPostProcessor，而真正的逻辑在ApplicationContextAwareProcessor中。它实现BeanPostProcessor接口。里面有两个重要的方法,它们是在调用自己定义的初始化函数(1.initializingBean 2.init-method)的前后调用。

public Object postProcessBeforeInitialization(final Object bean, String beanName) throws BeansException {
		AccessControlContext acc = null;

		if (System.getSecurityManager() != null &&
				(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
						bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
						bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)) {
			acc = this.applicationContext.getBeanFactory().getAccessControlContext();
		}

		if (acc != null) {
			AccessController.doPrivileged(new PrivilegedAction<Object>() {
				@Override
				public Object run() {
				//<1>
					invokeAwareInterfaces(bean);
					return null;
				}
			}, acc);
		}
		else {<2>
			invokeAwareInterfaces(bean);
		}

		return bean;
	}
	
	//这个方法没做什么
		public Object postProcessAfterInitialization(Object bean, String beanName) {
		return bean;
	}


	private void invokeAwareInterfaces(Object bean) {
		if (bean instanceof Aware) {
			if (bean instanceof EnvironmentAware) {
				((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
			}
			if (bean instanceof EmbeddedValueResolverAware) {
				((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(
						new EmbeddedValueResolver(this.applicationContext.getBeanFactory()));
			}
			if (bean instanceof ResourceLoaderAware) {
				((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
			}
			if (bean instanceof ApplicationEventPublisherAware) {
				((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
			}
			if (bean instanceof MessageSourceAware) {
				((MessageSourceAware) bean).setMessageSource(this.applicationContext);
			}
			if (bean instanceof ApplicationContextAware) {
				((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
			}
		}
	}
复制代码

在postProcessBeforeInitialization方法中主要调用invokeAwareInterfaces方法，目的是为该bean里set了aware需要的东西。

BF的后处理

  • 激活注册的BeanFacotyPostProcessor BeanFacotyPostProcessor可以对bean的定义进行处理。也就是说，IoC容器允许BeanFacotyPostProcessor在容器实际实例化任何其他bean之前读取配元数据，并可以修改它。还可以利用"order"接口来设置多个BeanFacotyPostProcessor的顺序。 public static void invokeBeanFactoryPostProcessors( ConfigurableListableBeanFactory beanFactory, List beanFactoryPostProcessors) { Set processedBeans = new HashSet(); //对于BeanDefinitionRegistry类型的处理 if (beanFactory instanceof BeanDefinitionRegistry) { BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;

    					//<1>硬编码方式注册的BeanFactoryPostProcessor类型BF
			List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<>();
				//<2>硬编码方式注册的BeanDefinitionRegistryPostProcessor类型BF
			List<BeanDefinitionRegistryPostProcessor> registryPostProcessors =new LinkedList<>();
				//遍历所有BF
			for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
				if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
					BeanDefinitionRegistryPostProcessor registryPostProcessor =
							(BeanDefinitionRegistryPostProcessor) postProcessor;
							
					registryPostProcessor.postProcessBeanDefinitionRegistry(registry);
					registryPostProcessors.add(registryPostProcessor);//放入<2>中
				}
				else {
					regularPostProcessors.add(postProcessor);//放入<1>中
				}
			}

			// Do not initialize FactoryBeans here: We need to leave all regular beans
			// uninitialized to let the bean factory post-processors apply to them!
			// Separate between BeanDefinitionRegistryPostProcessors that implement
			// PriorityOrdered, Ordered, and the rest.
			String[] postProcessorNames =
					beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);

			// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
			List<BeanDefinitionRegistryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();
			for (String ppName : postProcessorNames) {
				if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
					priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					processedBeans.add(ppName);
				}
			}
			sortPostProcessors(beanFactory, priorityOrderedPostProcessors);
			registryPostProcessors.addAll(priorityOrderedPostProcessors);
			invokeBeanDefinitionRegistryPostProcessors(priorityOrderedPostProcessors, registry);

			// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
			postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			List<BeanDefinitionRegistryPostProcessor> orderedPostProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();
			for (String ppName : postProcessorNames) {
				if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
					orderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					processedBeans.add(ppName);
				}
			}
			sortPostProcessors(beanFactory, orderedPostProcessors);
			registryPostProcessors.addAll(orderedPostProcessors);
			invokeBeanDefinitionRegistryPostProcessors(orderedPostProcessors, registry);

			// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
			boolean reiterate = true;
			while (reiterate) {
				reiterate = false;
				postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
				for (String ppName : postProcessorNames) {
					if (!processedBeans.contains(ppName)) {
						BeanDefinitionRegistryPostProcessor pp = beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class);
						registryPostProcessors.add(pp);
						processedBeans.add(ppName);
						pp.postProcessBeanDefinitionRegistry(registry);
						reiterate = true;
					}
				}
			}

			// Now, invoke the postProcessBeanFactory callback of all processors handled so far.
			invokeBeanFactoryPostProcessors(registryPostProcessors, beanFactory);
			invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
		}

		else {
			// Invoke factory processors registered with the context instance.
			invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
		}

		// Do not initialize FactoryBeans here: We need to leave all regular beans
		// uninitialized to let the bean factory post-processors apply to them!
		String[] postProcessorNames =
				beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

		// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
		// Ordered, and the rest.
		List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
		List<String> orderedPostProcessorNames = new ArrayList<String>();
		List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
		for (String ppName : postProcessorNames) {
			if (processedBeans.contains(ppName)) {
				// skip - already processed in first phase above
			}
			else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
			}
			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);
			}
			else {
				nonOrderedPostProcessorNames.add(ppName);
			}
		}

		// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
		sortPostProcessors(beanFactory, priorityOrderedPostProcessors);
		invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

		// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
		List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
		for (String postProcessorName : orderedPostProcessorNames) {
			orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		sortPostProcessors(beanFactory, orderedPostProcessors);
		invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

		// Finally, invoke all other BeanFactoryPostProcessors.
		List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
		for (String postProcessorName : nonOrderedPostProcessorNames) {
			nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
		}
		invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

		// Clear cached merged bean definitions since the post-processors might have
		// modified the original metadata, e.g. replacing placeholders in values...
		beanFactory.clearMetadataCache();
	}

	public static void registerBeanPostProcessors(
			ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {

		String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

		// Register BeanPostProcessorChecker that logs an info message when
		// a bean is created during BeanPostProcessor instantiation, i.e. when
		// a bean is not eligible for getting processed by all BeanPostProcessors.
		int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
		beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

		// Separate between BeanPostProcessors that implement PriorityOrdered,
		// Ordered, and the rest.
		List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
		List<BeanPostProcessor> internalPostProcessors = new ArrayList<BeanPostProcessor>();
		List<String> orderedPostProcessorNames = new ArrayList<String>();
		List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
		for (String ppName : postProcessorNames) {
			if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
				priorityOrderedPostProcessors.add(pp);
				if (pp instanceof MergedBeanDefinitionPostProcessor) {
					internalPostProcessors.add(pp);
				}
			}
			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);
			}
			else {
				nonOrderedPostProcessorNames.add(ppName);
			}
		}

		// First, register the BeanPostProcessors that implement PriorityOrdered.
		sortPostProcessors(beanFactory, priorityOrderedPostProcessors);
		registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

		// Next, register the BeanPostProcessors that implement Ordered.
		List<BeanPostProcessor> orderedPostProcessors = new ArrayList<BeanPostProcessor>();
		for (String ppName : orderedPostProcessorNames) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			orderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		sortPostProcessors(beanFactory, orderedPostProcessors);
		registerBeanPostProcessors(beanFactory, orderedPostProcessors);

		// Now, register all regular BeanPostProcessors.
		List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
		for (String ppName : nonOrderedPostProcessorNames) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			nonOrderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

		// Finally, re-register all internal BeanPostProcessors.
		sortPostProcessors(beanFactory, internalPostProcessors);
		registerBeanPostProcessors(beanFactory, internalPostProcessors);

		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
	}
复制代码

    • 注册BeanPostProcessor public static void registerBeanPostProcessors( ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {

      		String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

	
		int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
		beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

	//<1> priorityOrdered类型的处理器
		List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
		
		List<BeanPostProcessor> internalPostProcessors = new ArrayList<BeanPostProcessor>();
		//<2>ordered保证顺序
		List<String> orderedPostProcessorNames = new ArrayList<String>();
		//<3>无序处理器
		List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
		
		for (String ppName : postProcessorNames) {
			if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
				priorityOrderedPostProcessors.add(pp);//加入1
				
				if (pp instanceof MergedBeanDefinitionPostProcessor) {
					internalPostProcessors.add(pp);//加入2
				}
			}
			else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
				orderedPostProcessorNames.add(ppName);//加入3
			}
			else {
				nonOrderedPostProcessorNames.add(ppName);//加入4
			}
		}

		// 注册所有实现 priorityOrdered的处理器
		sortPostProcessors(beanFactory, priorityOrderedPostProcessors);
		registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

			// 注册所有实现 Ordered的处理器
		List<BeanPostProcessor> orderedPostProcessors = new ArrayList<BeanPostProcessor>();
		for (String ppName : orderedPostProcessorNames) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			orderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		sortPostProcessors(beanFactory, orderedPostProcessors);
		registerBeanPostProcessors(beanFactory, orderedPostProcessors);

		// 注册无序的处理器
		List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
		for (String ppName : nonOrderedPostProcessorNames) {
			BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
			nonOrderedPostProcessors.add(pp);
			if (pp instanceof MergedBeanDefinitionPostProcessor) {
				internalPostProcessors.add(pp);
			}
		}
		registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

		// 注册MergedBeanDefinitionPostProcessor类型的处理器。并非重复注册，会先移除
		sortPostProcessors(beanFactory, internalPostProcessors);
		registerBeanPostProcessors(beanFactory, internalPostProcessors);
//添加ApplicationListener探测器
		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
	}
复制代码

      • finishBeanFactoryInitialization

        protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) { //ConversionService设置 if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) && beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) { beanFactory.setConversionService( beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)); }

          // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
  String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
  for (String weaverAwareName : weaverAwareNames) {
  	getBean(weaverAwareName);
  }

  // Stop using the temporary ClassLoader for type matching.
  beanFactory.setTempClassLoader(null);

  // 配置冻结
  beanFactory.freezeConfiguration();

  //初始化所有非惰性的单实例
  beanFactory.preInstantiateSingletons();
复制代码

        }

转载于:https://juejin.im/post/5bc57f52f265da0aff1766a6

weixin_34351321
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
深入探索SpringApplication执行流程
云南小伙闯深圳
05-01 1864
SpringApplication的run方法的实现是我们本次旅程的主要线路，该方法的主要流程大体可以归纳如下： 1） 如果我们使用的是SpringApplication的静态run方法，那么，这个方法里面首先要创建一个SpringApplication对象实例，然后调用这个创建好的SpringApplication的实例方法。在SpringApplication实例初始化的时候，它会提前做
Spring Boot启动流程断点过程解析
08-25
Spring Boot启动流程断点过程解析 Spring Boot是当前最流行的Java框架之一，它提供了许多功能强大的特性来帮助开发者快速构建企业级应用程序。然而，对于Spring Boot的启动流程断点过程的理解是至关重要的。只有当...
spring容器的触发事件 ClassPathXmlApplicationContext的start()方法的用法
02-10
spring容器的触发事件 ClassPathXmlApplicationContext的start()方法的用法
Spring——ApplicationContext启动过程
cheya3213的博客
03-24 335
大致会经过以下步骤，（图片来自https://www.jianshu.com/p/2692bf784976） 转载于:https://my.oschina.net/u/33009...
SpringApplication启动流程
myStyle的博客
12-06 2427
SpringApplication启动流程 1.SpringApplication的构造过程 推断应用类型（是web,不是web,SpringBoot2.0支持响应式编程） 加载初始化构造器ApplicationContextInitializer （[ɪ'nɪʃəlaɪzə]） 创建应用监听器 设置应用main()方法所在的类 2.SpringApplication的run()方法 Headless模式设置 加载SpringApplicationRunListeners监听器 封装Application
ApplicationContext启动过程
02-17 309
applicationContext 容器启动流程
Spring Boot启动流程分析
08-29
Spring Boot启动流程分析是指Spring Boot应用程序从启动到运行的整个过程。该过程可以分为两个部分：SpringApplication的实例化和调用该实例的run方法。 首先，让我们来看看SpringApplication的实例化过程。在这个...
详解Spring IOC 容器启动流程分析
08-25
Spring IOC 容器的启动流程是一个复杂的过程，它涉及到许多步骤和组件。AbstractApplicationContext 的 refresh 方法是 IOC 容器的核心所在，它实现了容器的启动逻辑。ClassPathXmlApplicationContext 和 ...
Spring MVC 启动过程源码分析详解
08-27
Spring MVC 启动过程源码分析详解 Spring MVC 启动过程的源码分析详解是 Spring MVC 框架中一个非常重要的部分，对于了解 Spring MVC 的工作原理和内部机制非常重要。在这篇文章中，我们将从源码层面上对 Spring ...
Spring启动流程refresh()源码深入解析
09-07
Spring框架的启动流程是其核心功能之一，其中`refresh()`方法起到了至关重要的作用。当我们调用`ApplicationContext`的`refresh()`方法时，Spring容器开始初始化并加载配置，为应用程序提供服务。下面我们将深入分析...
spring源码解析（三） applicationContext启动过程
全场梦游c的博客
11-16 625
applicationContext启动过程 首先去准备容器，也就是 new一个applicationcontext，Config.class为@ComponentScan注解标记的类。 AnnotationConfigApplicationContext applicationContext=new AnnotationConfigApplicationContext(Config.class); 调用它自己的构造方法。 public AnnotationConfigApplication.
ApplicationContext启动流程详解
qq_39588606的博客
07-29 170
spring ApplicationContext启动过程
ac_dao_di的专栏
03-31 1518
本文对spring ApplicationContext启动过程进行详细解析，介绍刷新过程中的10个阶段的作用，包括ConfigurationClassPostProcessor处理java config注入beanDefinition，注册BeanPostProcessor对所有bean的构建进行初始化，创建内嵌tomcat容器注册servlet
SpringApplication启动过程和AutoConfiguration实现
简单，坚持
08-23 1404
本文讲解了SpringApplication启动的全过程，并讲了SpringBootApplication中使用SpringFactoriesLoader来加载配置类的实现；通过本文的讲解读者能够明白spring-boot-configure中配置类的加载时机 和 过程。
Spring Boot 2.2.6 源码之旅六SpringApplication启动流程六
王伟王胖胖的博客
04-10 567
Spring Boot 2.2.6 源码之旅六SpringApplication启动流程六SpringApplication的prepareEnvironment准备环境SpringApplication的getOrCreateEnvironment创建环境configureEnvironment配置环境ApplicationConversionService的getSharedInstance配...
Spring探秘2：ApplicationContext启动流程
我叫李铁柱
03-29 433
     ApplicationContext是Spring框架中最基础的接口之一，可以认为其实现类就是一个Spring的环境（容器），而一个简单的Spring应用的启动过程就是一个ApplicationContext的实现类的实例化过程，是研究Spring源码的很好的切入点。这里研究的实现类是AnnotationConfigApplicationConte...
SpringApplication 启动流程及各类事件生命周期那点事
woshiyizhiyu0的博客
05-07 1450
SpringApplication run 方法启动那点事，看完绝对哇塞
Spring 启动流程
liucs669的博客
03-19 183
入口 @SpringBootApplication方法：SpringApplication.run() 方法。
Spring IOC容器启动流程 AbstractApplicationContext#refresh()方法源码分析
会走的桃子的博客
05-28 425
文章目录Spring Bean声明周期流程图AbstractApplicationContext#refresh()AbstractApplicationContext#prepareRefresh()AbstractApplicationContext#getEnvironment() refresh()方法是Spring容器启动的核心中的核心，逻辑也是异常的复杂，因为准备分两篇文章来叙述他的过...
简单描述spring boot启动流程
最新发布
06-07
当Spring Boot应用程序启动时，它会首先加载SpringApplication类。SpringApplication类提供了便捷的静态方法来启动Spring Boot应用程序。在启动时，SpringApplication类会执行以下操作： 1. 加载主配置类：...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值