1.前言
2.spring源码外围办法refresh()介绍
3.总结
1.前言
github源码地址（带正文）：
https://github.com/su15967456...
在进入明天的spring外围办法介绍之前，咱们先来温习一下上次咱们学习的内容，Spring源码剖析——spring容器总览，如图所示：
大抵流程为：
1.IOC容器从xml，注解等中央获取类的信息。
2.将类的信息封装成BeanDefinition
3.beanFactoryPostProcessor前置解决
4.ioc容器获取类信息通过反射进行实例化
5.执行实例化
6.执行初始化逻辑（填充属性(populateBean)->执行aware接口办法->beanPostProcessor:before->init-method->beanPostProcessor:after）
以上，咱们只是将spring容器的执行流程大体介绍了一下，接下来，咱们要进入源码中，大抵（因为咱们当初是第一回看源码，心愿不要被卷入一细节，而是大抵走一遍就能够了，卷入细节的旋涡很容易劝退。）理解一下spring启动的程序代码。
spring源码中，最重要的外围办法，就是refresh()了，只有看懂了refresh()中的外围的13个办法，差不多就看懂spring了！
咱们在开始看源码前，能够看着执行过程图猜想一下，第一步会执行什么？
个别咱们都会感觉是读取配置文件
然而其实是————要把beanFactory创立好。因为只有把组件初始化结束之后，咱们才会有工具类去读配置文件，去实例化等操作。
2.spring源码外围办法refresh()介绍
2.1 debug的前置工作
在开始看spring源码之前，咱们先筹备一下前置工作。
咱们先写两个一般的类A和B（为了体现出实例化和循环依赖的成果,循环依赖咱们前期会讲），
类A：
public class A { private B b; public void init(){ System.out.println("执行init()"); } public void destroy(){ System.out.println("执行destroy()"); } public A(B b) { this.b = b; } public A() { System.out.println("A 创立了"); } public B getB() { return b; } public void setB(B b) { this.b = b; }}类B：
public class B { private A a; public B() { System.out.println("B 创立了"); } public A getA() { return a; } public void setA(A a) { this.a = a; }}再写一个配置文件：
applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?><beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> <bean id="a" class="slf.A" > <property name="b" ref="b"/> </bean> <bean id="b" class="slf.B"> <property name="a" ref="a"/> </bean></beans>最初写一个启动demo类，就算功败垂成了！
public static void main(String[] args) throws Exception { //启动容器 ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml"); A a = (A) classPathXmlApplicationContext.getBean(A.class); B b = classPathXmlApplicationContext.getBean(B.class); }咱们能够在启动容器那一行下面打上断点，而后debug启动！
读spring源码，如何debug很重要，这里我放上一张截图，咱们能够依据须要抉择哪个性能。
2.2spring源码外围办法refresh()介绍
好的，那咱们先进入这个办法，点击下面那张图的第二个箭头：
能够看出咱们进入了一个办法，然而不是ClassPathXmlApplicationContext的构造方法。
这里咱们能够不必理睬，点击步出按钮，再点步入按钮。
就会进入到咱们所心愿看到的办法了：
然而当初还看不出什么端倪，所以咱们能够持续步入：
好了，终于看到了咱们的外围refresh()办法了。
public ClassPathXmlApplicationContext( String[] configLocations, boolean refresh, @Nullable ApplicationContext parent) throws BeansException { //调用父类构造方法，进行相干的对象创立操作 super(parent); //设置配置文件门路，放入一个对象中，不便后续的读取和应用 setConfigLocations(configLocations); if (refresh) { refresh(); } }咱们能够看出，除了refresh()办法，还有一些其它的办法，咱们大抵地介绍一下：
2.2.1 super()办法介绍
super()次要用来调用父类构造方法，进行一些属性的对象创立，前期应用。
往super()外面点，点到最外面，咱们发现它调用了两个办法：
/** * Create a new AbstractApplicationContext with the given parent context. * @param parent the parent context */ public AbstractApplicationContext(@Nullable ApplicationContext parent) { this(); setParent(parent); }首先咱们看this()办法：
/** * Create a new AbstractApplicationContext with no parent. */ public AbstractApplicationContext() { //加载资源模式解析器 用来加载咱们零碎运行的时候须要的资源（xml） this.resourcePatternResolver = getResourcePatternResolver(); }通过getResourcePatternResolver办法的正文咱们能够看出，它创立了一个资源模式解析器，是前面用来加xml等载资源用的。上文提到过，咱们容器的初始化后面的阶段次要就是要将容器，组件进行实例化。
2.2.2 setParent(parent)办法介绍
接下来看咱们的setParent(parent)办法，往里面点咱们能够看出，如果父类环境属性不等于空，那么久把父类容器的环境和子类容器合并。
public void setParent(@Nullable ApplicationContext parent) { this.parent = parent; if (parent != null) { Environment parentEnvironment = parent.getEnvironment(); if (parentEnvironment instanceof ConfigurableEnvironment) { getEnvironment().merge((ConfigurableEnvironment) parentEnvironment); } } }咱们可能搞不清楚父子容器的概念，因为目前spring只有一个容器，能够临时先略过。
2.2.3 setConfigLocations(configLocations)办法介绍
这个办法比较简单，就是将传进来的 applicationContext.xml 这个字符串保留一下，不便后续读取xml,能够间接从数组中获取。
2.2.4 refresh()办法介绍
好了，接下来终于要到咱们的refresh()办法了，咱们间接进入这个办法。
@Override public void refresh() throws BeansException, IllegalStateException { synchronized (this.startupShutdownMonitor) { StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh"); // Prepare this context for refreshing. //容器刷新前的筹备工作 /* 1.设置容器的启动工夫 2.设置沉闷状态为true 3.设置敞开状态为false 4.获取Environment对象，并加载以后零碎的属性到Environment中 5.筹备监听器和事件的汇合对象，默认为空的对象汇合 */ prepareRefresh(); // Tell the subclass to refresh the internal bean factory. //创立容器对象，DefaultListableBeanFactory //加载xml配置文件的属性到以后工厂中，最重要的就是BeanDefinition ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); // Prepare the bean factory for use in this context. //筹备bean工厂，实现bean工厂属性的一些初始化操作 prepareBeanFactory(beanFactory); try { // Allows post-processing of the bean factory in context subclasses. //空办法 //子类笼罩做额定的解决，此处咱们个别不做任何扩大工作，这个办法具体能够做什么，能够进去看正文，springmvc/springboot里有具体的扩大实现 postProcessBeanFactory(beanFactory); StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process"); // Invoke factory processors registered as beans in the context. //执行beanFactoryPostProcessors，调用各种beanFactory处理器，比方替换工作 ${username} invokeBeanFactoryPostProcessors(beanFactory); // Register bean processors that intercept bean creation. //注册BeanPostProcessors registerBeanPostProcessors(beanFactory); beanPostProcess.end(); // Initialize message source for this context. //初始化音讯资源 国际化设置 initMessageSource(); // Initialize event multicaster for this context. //初始化利用的多播器 initApplicationEventMulticaster(); // Initialize other special beans in specific context subclasses. onRefresh(); // Check for listener beans and register them. //注册监听器到多播器外面 registerListeners(); // Instantiate all remaining (non-lazy-init) singletons. //实例化非懒加载的实例对象 finishBeanFactoryInitialization(beanFactory); // Last step: publish corresponding event. //事件公布 finishRefresh(); } catch (BeansException ex) { if (logger.isWarnEnabled()) { logger.warn("Exception encountered during context initialization - " + "cancelling refresh attempt: " + 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(); contextRefresh.end(); } } }能够看出，一共调用了13个办法，这13个办法就是咱们要了解的要害，我曾经相应地输入了一些注解，接下来咱们挨个进行解释：
2.2.4.1 prepareRefresh()办法介绍
protected void prepareRefresh() { // Switch to active. //创立一下开启工夫 this.startupDate = System.currentTimeMillis(); //敞开状态设置为false this.closed.set(false); //激活状态设置为true this.active.set(true); if (logger.isDebugEnabled()) { if (logger.isTraceEnabled()) { logger.trace("Refreshing " + this); } else { logger.debug("Refreshing " + getDisplayName()); } } // Initialize any placeholder property sources in the context environment. //留给子类笼罩，初始化属性资源 initPropertySources(); // Validate that all properties marked as required are resolvable: // see ConfigurablePropertyResolver#setRequiredProperties //获取环境对象并验证，验证所须要的属性文件是否曾经放入环境中 getEnvironment().validateRequiredProperties(); // Store pre-refresh ApplicationListeners... //创立一些根本的监听器 if (this.earlyApplicationListeners == null) { this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners); } else { // Reset local application listeners to pre-refresh state. this.applicationListeners.clear(); this.applicationListeners.addAll(this.earlyApplicationListeners); } // Allow for the collection of early ApplicationEvents, // to be published once the multicaster is available... //筹备监听器事件的汇合 this.earlyApplicationEvents = new LinkedHashSet<>(); }咱们能够看出prepareRefresh()办法次要还是做了一些筹备工作，比方：
1.创立一下开启的工夫
2.设置敞开状态
3.设置激活状态
4.打印日志
5.获取环境对象并验证，验证所须要的属性文件是否曾经放入环境中
6.创立一些根本的监听器，筹备监听器事件的汇合（监听器在前面的公布->订阅模式中有用到，这里只是初始化一下类。）
咱们能够看出，这个办法，次要还是做一些初始化上下文的工作，也就是刷新前的筹备工作！
2.2.4.2 obtainFreshBeanFactory()办法介绍
// Tell the subclass to refresh the internal bean factory. //创立容器对象，DefaultListableBeanFactory //加载xml配置文件的属性到以后工厂中，最重要的就是BeanDefinition ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();这个办法就比拟重要了，大略做了两步操作：
1.创立一个容器对象（DefaultListableBeanFactory）
2.读取xml的bean信息封装成beanDefinition的操作。
咱们能够点进去看一下：
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() { //初始化BeanFactory,并进行xml文件读取，并将失去的BeanFactory记录在以后实体的属性中 refreshBeanFactory(); return getBeanFactory();//返回以后实体的beanFactory属性 }咱们先对容器进行初始化操作（因为容器到当初还没进行过初始化呢），而后再读取xml中的bean并封装成BeanDefinition。
debug 步入 refreshBeanFactory();
@Override protected final void refreshBeanFactory() throws BeansException { //如果有bean工厂了，先销毁掉 if (hasBeanFactory()) { destroyBeans(); closeBeanFactory(); } try { //创立DefaultListableBeanFactory对象 DefaultListableBeanFactory beanFactory = createBeanFactory(); //每个容器都有本人的id，为了序列化指定id，能够从id反序列化到beanFactory对象 beanFactory.setSerializationId(getId()); //定制beanFactory，设置相干属性，包含是否容许笼罩同名称的不同定义的对象以及循环依赖,能够通过子类重写 customizeBeanFactory(beanFactory); //初始化documentReader，并进行对xml文件进行解析 loadBeanDefinitions(beanFactory); this.beanFactory = beanFactory; } catch (IOException ex) { throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex); } }1.如果有了容器的话，先销毁容器。
2.创立一个DefaultListableBeanFactory对象
3.接着进行相干属性设置
4.最重要的就是对xml文件进行解析的loadBeanDefinitions办法，把xml文件进行解析读取bean并封装。（解析过程比较复杂，所以这次先不点进去看了）
2.2.4.3 prepareBeanFactory()办法介绍
接下来是对bean工厂的属性进行一些初始化操作：
// Prepare the bean factory for use in this context. //筹备bean工厂，实现bean工厂属性的一些初始化操作 prepareBeanFactory(beanFactory);咱们能够点击进去看看：
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) { // Tell the internal bean factory to use the context's class loader etc. //设置beanFactory的类加载器为以后context的类加载器 beanFactory.setBeanClassLoader(getClassLoader()); if (!shouldIgnoreSpel) { //设置beanfactory的表达式语言处理器 解决类->解析类->配置类 beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader())); } //为beanFactory减少一个默认的PropertyEditor，这个次要是对bean的属性设置治理的一个工具类 属性编辑类，比方date的format beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment())); // Configure the bean factory with context callbacks. //增加beanPostProcessor 此类用来实现某些aware对象的注入 beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this)); //设置疏忽主动拆卸的接口，这些接口的实现是容器是须要 beanPostProcessor 注入的 //所以在应用@Autowired进行注入的时候须要对这些接口进行疏忽 beanFactory.ignoreDependencyInterface(EnvironmentAware.class); beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class); beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class); beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class); beanFactory.ignoreDependencyInterface(MessageSourceAware.class); beanFactory.ignoreDependencyInterface(ApplicationContextAware.class); beanFactory.ignoreDependencyInterface(ApplicationStartupAware.class); // BeanFactory interface not registered as resolvable type in a plain factory. // MessageSource registered (and found for autowiring) as a bean. //设置几个主动拆卸的非凡规定，当在进行IOC的时候，如果有多个实现，就按指定的对象注入 beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory); beanFactory.registerResolvableDependency(ResourceLoader.class, this); beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this); beanFactory.registerResolvableDependency(ApplicationContext.class, this); // Register early post-processor for detecting inner beans as ApplicationListeners. beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this)); // Detect a LoadTimeWeaver and prepare for weaving, if found. //减少aspectJ的反对，在java中织入有三种形式，别离为编译器织入，类加载器织入，运行时织入 //编译器织入指通过非凡的编译器，将切面织入到java中 //类加载器织入指通过非凡的类加载器，在类字节码加载入JVM的时候，织入切面，相似cglib //aspectj采纳了两种织入形式，非凡编译器和类加载器，类加载器就是上面的load_time_wave if (!NativeDetector.inNativeImage() && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) { beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory)); // Set a temporary ClassLoader for type matching. beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader())); } // Register default environment beans. // 注册默认的零碎环境bean到一级缓存中 if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) { beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment()); } if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) { beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties()); } if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) { beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment()); } if (!beanFactory.containsLocalBean(APPLICATION_STARTUP_BEAN_NAME)) { beanFactory.registerSingleton(APPLICATION_STARTUP_BEAN_NAME, getApplicationStartup()); } }这个看不懂没关系，就是对beanFactory的一些属性值进行了一些操作。咱们后续会进行解说。
2.2.4.4 postProcessBeanFactory()办法介绍
//空办法 //子类笼罩做额定的解决，此处咱们个别不做任何扩大工作，这个办法具体能够做什么，能够进去看正文，springmvc/springboot里有具体的扩大实现 postProcessBeanFactory(beanFactory);2.2.4.5 invokeBeanFactoryPostProcessors()办法介绍
// Invoke factory processors registered as beans in the context. //执行beanFactoryPostProcessors，调用各种beanFactory处理器，比方替换工作 ${username} invokeBeanFactoryPostProcessors(beanFactory);这个办法次要用来执行BeanFactoryPostProcessor对BeanDefinition进行解决。
咱们当前调用的时候再来解说。
2.2.4.6 registerBeanPostProcessors()办法介绍
//注册BeanPostProcessors registerBeanPostProcessors(beanFactory);这个步骤初始化了一下所有的beanPostProcessor，不便后续初始化的时候进行调用。
2.2.4.7 beanPostProcess.end()办法介绍
空办法，模板办法，在容器刷新的时候能够自定义逻辑，不同的Spring容器做不同的事件。
2.2.4.8 initMessageSource()办法介绍
// Initialize message source for this context. //初始化音讯资源 国际化设置 initMessageSource();为上下文初始化 Message 源，即对不同语言的音讯体进行国际化解决。
2.2.4.9 initApplicationEventMulticaster()办法介绍
// Initialize event multicaster for this context. //初始化利用的多播器 initApplicationEventMulticaster();初始化事件播送器，并放入 applicationEventMulticaster bean 中，用于前面的公布，订阅模式事件播送。
2.2.4.10 onRefresh()办法介绍
// Initialize other special beans in specific context subclasses. //模板办法，在容器刷新的时候能够自定义逻辑，不同的Spring容器做不同的事件。 onRefresh();2.2.4.11 registerListeners()办法介绍
// Check for listener beans and register them. //注册监听器到多播器外面 registerListeners();2.2.4.12 finishBeanFactoryInitialization()办法介绍
// Instantiate all remaining (non-lazy-init) singletons. //实例化非懒加载的实例对象 finishBeanFactoryInitialization(beanFactory);这个办法就是refresh()的外围办法，创立bean，解决循环依赖，AOP都在这外面。也是当前要重点解说的办法。
2.2.4.13 finishRefresh()办法介绍
// Last step: publish corresponding event. //事件公布 finishRefresh();后面的事件实现了，启动公布订阅模式，告诉另外一些类实现一些事件。
3.总结
明天咱们介绍了refresh()的外围十三个办法，十分重要，咱们能够debug跟一遍，而后打上正文。
执行的流程如下：
1.容器刷新前的筹备工作
2.创立bean工厂
3.加载xml配置文件到bean工厂中
4.对bean工厂进行赋值
5.执行beanFactoryPostProcessors
6.注册BeanPostProcessors
7.初始化音讯资源 国际化设置
8.初始化利用的多播器
9.注册监听器到多播器外面
10.实例化非懒加载的实例对象
11.事件公布