Spring源码解读——启动流程refresh

Spring源码解读——启动流程

---

准备工作

maven依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.7</version>
</dependency>

一个普通类

public class TestBean {
}

自定义Spring组件

@Component
public class TestComponent {
	@bean
  public TestBean testBean(){
    return new TestBean();
  }
}

Spring启动方法

public static void main(String[] args) {
        final AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
  			//扫你的包名，这个时候会初始化bd
        applicationContext.scan("com.example.demo");
  			//这是我们主要关注的方法
        applicationContext.refresh();
}

refresh方法全貌

public void refresh() throws BeansException, IllegalStateException {
        synchronized(this.startupShutdownMonitor) {
            StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
          	//1、容器属性校验
            this.prepareRefresh();
          	//2、获取beanFactory
            ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
          	//3、初始化beanFactory，主要是将Spring内置的类或依赖填充到beanFactory中，包括设置类加载器、Spel、属性编辑器，忽略的内置接口、固定注册内置依赖，实例化、初始化内置bean
            this.prepareBeanFactory(beanFactory);

            try {
              	//模板方法不作处理
                this.postProcessBeanFactory(beanFactory);
                StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
              //4、对beanFactory进行后置处理，主要按PriorityOrdered、Ordered、普通三个顺序执行BeanDefinitionRegistryPostProcessor
              //其中会将bd合并成mbd，处理继承关系，并使用ConfigurationClassPostProcessor创建@bean方法返回对象的bd
                this.invokeBeanFactoryPostProcessors(beanFactory);
              //5、按顺序注册beanPostProcessor
                this.registerBeanPostProcessors(beanFactory);
                beanPostProcess.end();
              	//初始化资源文件
                this.initMessageSource();
              	//初始化时间多播器
                this.initApplicationEventMulticaster();
              	//末班方法不执行
                this.onRefresh();
              	//注册监听器
                this.registerListeners();
              	//6、实例化bean并放入beanFactory的一级缓存
              	//其中AutowiredAnnotationBeanPostProcessor处理处理依赖注入、循环依赖
                this.finishBeanFactoryInitialization(beanFactory);
              	//注册并执行LifeCyclePostProcessor
                this.finishRefresh();
            } catch (BeansException var10) {
                //doSth...
            } finally {
              	//清空一些没用的缓存
                this.resetCommonCaches();
                contextRefresh.end();
            }

        }

1、prepareRefresh

容器刷新前的预处理，主要做容器属性的初始化和环境属性的校验，在咱们现在的最简启动情况下所有的集合大小全是0，可以暂时跳过

protected void prepareRefresh() {
        this.startupDate = System.currentTimeMillis();
        this.closed.set(false);
        this.active.set(true);

        this.initPropertySources();
        this.getEnvironment().validateRequiredProperties();
        if (this.earlyApplicationListeners == null) {
            this.earlyApplicationListeners = new LinkedHashSet(this.applicationListeners);
        } else {
            this.applicationListeners.clear();
            this.applicationListeners.addAll(this.earlyApplicationListeners);
        }

        this.earlyApplicationEvents = new LinkedHashSet();
    }

2、obtainFreshBeanFactory

主要作用就是获取beanFactory

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
    this.refreshBeanFactory();
    return this.getBeanFactory();
}

2.1、refreshBeanFactory

调用GenericApplicationContext#refreshBeanFactory()方法

主要作用是防止并发刷新，并设置beanFactory的序列化id

protected final void refreshBeanFactory() throws IllegalStateException {
        if (!this.refreshed.compareAndSet(false, true)) {
            throw new IllegalStateException("GenericApplicationContext does not support multiple refresh attempts: just call 'refresh' once");
        } else {
            //这个id是ApplicationContext的hashCode，具体哪用到了没注意
          	//这个beanFactory是在new ApplicationContext()的时候创建的DefaultListableBeanFactory
            this.beanFactory.setSerializationId(this.getId());
        }
    }

2.2、getBeanFactory

就是获取beanFactory

public final ConfigurableListableBeanFactory getBeanFactory() {
    return this.beanFactory;
}

3、prepareBeanFactory

主要作用就是初始化beanFactory

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
  	//设置类加载器
    beanFactory.setBeanClassLoader(this.getClassLoader());
    if (!shouldIgnoreSpel) {
      	//设置Spring spel表达式，默认不忽略（就是启用）
        beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
    }
		//添加一个属性编辑器，不知道是干啥用的，后面再看
    beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, this.getEnvironment()));
  	//实现BeanPostProcessor接口
    //针对Spring内置的bean，在这些bean初始化之前，使用applicationContext给这些bean设置一些属性
    beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
  	//忽略的内置接口，记录到ignoredDependencyInterfaces的hashSet中
    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);
  	//注册内置的可解析的依赖，放到一个叫resolvableDependencies的ConcurrentHashMap内
  	//比如Spring内有很多BeanFactory的实现类，容器无法确定自动注入的是哪个实例
    //那不如就在初始化时指定，如果谁想注入BeanFactory对象，就给他唯一的beanFactory对象
    beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
    beanFactory.registerResolvableDependency(ResourceLoader.class, this);
    beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
    beanFactory.registerResolvableDependency(ApplicationContext.class, this);
  	//实现BeanPostProcessor接口
  	//针对实现ApplicationListener的bean，将他们放到applicationContext的applicationListeners这个set中
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
  	//提供切面织入的支持，咱们是最简启动这里不进
    if (!NativeDetector.inNativeImage() && beanFactory.containsBean("loadTimeWeaver")) {
        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
        beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    }
		//注册一些Spring自己的对象，
    if (!beanFactory.containsLocalBean("environment")) {
        beanFactory.registerSingleton("environment", this.getEnvironment());
    }
    if (!beanFactory.containsLocalBean("systemProperties")) {
        beanFactory.registerSingleton("systemProperties", this.getEnvironment().getSystemProperties());
    }
    if (!beanFactory.containsLocalBean("systemEnvironment")) {
        beanFactory.registerSingleton("systemEnvironment", this.getEnvironment().getSystemEnvironment());
    }
    if (!beanFactory.containsLocalBean("applicationStartup")) {
        beanFactory.registerSingleton("applicationStartup", this.getApplicationStartup());
    }

}

4、postProcessBeanFactory

空的，不用管

protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
}

5、invokeBeanFactoryPostProcessors

对beanFactory执行所有后置处理

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, this.getBeanFactoryPostProcessors());

}

invokeBeanFactoryPostProcessors

开始对beanFactory执行后置处理

主要就是使用ConfigurationClassPostProcessor扫bean下的方法，并注册带有@bean注解的方法返回对象的beanDefinition

public static void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
        Set<String> processedBeans = new HashSet();
        ArrayList regularPostProcessors;
        ArrayList registryProcessors;
        int var9;
        ArrayList currentRegistryProcessors;
        String[] postProcessorNames;
        if (beanFactory instanceof BeanDefinitionRegistry) {
            BeanDefinitionRegistry registry = (BeanDefinitionRegistry)beanFactory;
            regularPostProcessors = new ArrayList();
            registryProcessors = new ArrayList();
            Iterator var6 = beanFactoryPostProcessors.iterator();
            //刚开始的时候，beanFactoryPostProcessors为空，这里跳过
            while(var6.hasNext()) {
                BeanFactoryPostProcessor postProcessor = (BeanFactoryPostProcessor)var6.next();
                if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                    BeanDefinitionRegistryPostProcessor registryProcessor = (BeanDefinitionRegistryPostProcessor)postProcessor;
                    registryProcessor.postProcessBeanDefinitionRegistry(registry);
                    registryProcessors.add(registryProcessor);
                } else {
                    regularPostProcessors.add(postProcessor);
                }
            }

            currentRegistryProcessors = new ArrayList();
          //获取实现了BeanDefinitionRegistryPostProcessor的类，这里只有ConfigurationClassPostProcessor，bean的name名字叫org.springframework.context.annotation.internalConfigurationAnnotationProcessor
          
          	//找的同时，针对用户自定义Bean的BeanDefinition，从beanDefinitionMap取出bd，再根据bd创建mbd放到mergedBeanDefinitions中
            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            String[] var16 = postProcessorNames;
            var9 = postProcessorNames.length;

            int var10;
            String ppName;
          	//从中找到实现了PriorityOrdered的类，也只有ConfigurationClassPostProcessor
            for(var10 = 0; var10 < var9; ++var10) {
                ppName = var16[var10];
                if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                    currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                    processedBeans.add(ppName);
                }
            }

            sortPostProcessors(currentRegistryProcessors, beanFactory);
            registryProcessors.addAll(currentRegistryProcessors);
          	//对beanFactory中的bean进行处理，这里也只执行ConfigurationClassPostProcessor
          	//主要是扫描每个bean中是否有@bean注解的方法，并注册方法返回的对应的beanDefinition
            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
            currentRegistryProcessors.clear();
            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            var16 = postProcessorNames;
            var9 = postProcessorNames.length;
						//先找实现了Ordered的BeanDefinitionRegistryPostProcessor执行，再执行剩下的BeanDefinitionRegistryPostProcessor
          	//DoSth...
        } else {
            //DoSth...
        }
        String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
       //和上面相同的套路，按照PriorityOrdered、Ordered、普通的顺序执行BeanFactoryPostProcessor
				//这里只有EventListenerMethodProcessor
        invokeBeanFactoryPostProcessors((Collection)nonOrderedPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
        beanFactory.clearMetadataCache();
    }

6、registerBeanPostProcessors

将BeanPostProcessor按照PriorityOrdered、Ordered、普通的顺序进行注册

protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}

public static void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
				//和执行beanFactoryPostProcessor时一样的套路，只不过现在是只注册beanPostProcessor
  			//按照PriorityOrdered、Ordered、普通的顺序将beanPostProcessor注册
  			//底层存储beanPostProcessor的地方叫beanPostProcessors，是个CopyOnWriteArrayList
    }

7、initMessageSource

初始化一个读取资源文件的对象

protected void initMessageSource() {
        ConfigurableListableBeanFactory beanFactory = this.getBeanFactory();
        if (beanFactory.containsLocalBean("messageSource")) {
            //doSth...
        } else {
          //如果你不自定义的话，会走下面创建一个默认的
            DelegatingMessageSource dms = new DelegatingMessageSource();
            dms.setParentMessageSource(this.getInternalParentMessageSource());
            this.messageSource = dms;
            beanFactory.registerSingleton("messageSource", this.messageSource);
            if (this.logger.isTraceEnabled()) {
                this.logger.trace("No 'messageSource' bean, using [" + this.messageSource + "]");
            }
        }

    }

8、initApplicationEventMulticaster

初始化事件多播器

protected void initApplicationEventMulticaster() {
        ConfigurableListableBeanFactory beanFactory = this.getBeanFactory();
        if (beanFactory.containsLocalBean("applicationEventMulticaster")) {
            //doSth...
        } else {
          //如果你不自定义的话，会走下面创建一个默认的
            this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
            beanFactory.registerSingleton("applicationEventMulticaster", this.applicationEventMulticaster);
            if (this.logger.isTraceEnabled()) {
                this.logger.trace("No 'applicationEventMulticaster' bean, using [" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");
            }
        }

    }

9、onRefresh

空的模板方法

10、registerListeners

注册监听器

protected void registerListeners() {
        Iterator var1 = this.getApplicationListeners().iterator();

        while(var1.hasNext()) {
            ApplicationListener<?> listener = (ApplicationListener)var1.next();
            this.getApplicationEventMulticaster().addApplicationListener(listener);
        }

        String[] listenerBeanNames = this.getBeanNamesForType(ApplicationListener.class, true, false);
        String[] var7 = listenerBeanNames;
        int var3 = listenerBeanNames.length;

        for(int var4 = 0; var4 < var3; ++var4) {
            String listenerBeanName = var7[var4];
            this.getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
        }

        Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
        this.earlyApplicationEvents = null;
        if (!CollectionUtils.isEmpty(earlyEventsToProcess)) {
            Iterator var9 = earlyEventsToProcess.iterator();

            while(var9.hasNext()) {
                ApplicationEvent earlyEvent = (ApplicationEvent)var9.next();
                this.getApplicationEventMulticaster().multicastEvent(earlyEvent);
            }
        }

    }

11、finishBeanFactoryInitialization

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
        if (beanFactory.containsBean("conversionService") && beanFactory.isTypeMatch("conversionService", ConversionService.class)) {
            beanFactory.setConversionService((ConversionService)beanFactory.getBean("conversionService", ConversionService.class));
        }
  
        if (!beanFactory.hasEmbeddedValueResolver()) {
          	//还不知道这是做什么的
            beanFactory.addEmbeddedValueResolver((strVal) -> {
                return this.getEnvironment().resolvePlaceholders(strVal);
            });
        }
				//空的
        String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
        String[] var3 = weaverAwareNames;
        int var4 = weaverAwareNames.length;

        for(int var5 = 0; var5 < var4; ++var5) {
            String weaverAwareName = var3[var5];
            this.getBean(weaverAwareName);
        }

        beanFactory.setTempClassLoader((ClassLoader)null);
  			//冻结配置
        beanFactory.freezeConfiguration();
  			//最主要的Spring实例化的逻辑
        beanFactory.preInstantiateSingletons();
    }

preInstantiateSingletons

public void preInstantiateSingletons() throws BeansException {
        if (this.logger.isTraceEnabled()) {
            this.logger.trace("Pre-instantiating singletons in " + this);
        }

        List<String> beanNames = new ArrayList(this.beanDefinitionNames);
        Iterator var2 = beanNames.iterator();

        while(true) {
            String beanName;
            Object bean;
            do {
                while(true) {
                    RootBeanDefinition bd;
                    do {
                        do {
                            do {
                                //doSth...

                                beanName = (String)var2.next();
                              	//这里的mbd是invokeBeanFactoryPostProcessors这步，执行BeanDefinitionRegistryPostProcessor时初始化的
                                bd = this.getMergedLocalBeanDefinition(beanName);
                            } while(bd.isAbstract());
                        } while(!bd.isSingleton());
                    } while(bd.isLazyInit());
										//校验是否为factoryBean
                    if (this.isFactoryBean(beanName)) {
                        bean = this.getBean("&" + beanName);
                        break;
                    }
										//获取或创建bean
                    this.getBean(beanName);
                }
            } while(!(bean instanceof FactoryBean));

            FactoryBean<?> factory = (FactoryBean)bean;
            boolean isEagerInit;
            if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                SmartFactoryBean var10000 = (SmartFactoryBean)factory;
                ((SmartFactoryBean)factory).getClass();
                isEagerInit = (Boolean)AccessController.doPrivileged(var10000::isEagerInit, this.getAccessControlContext());
            } else {
                isEagerInit = factory instanceof SmartFactoryBean && ((SmartFactoryBean)factory).isEagerInit();
            }

            if (isEagerInit) {
                this.getBean(beanName);
            }
        }
    }

getBean/doGetBean

public Object getBean(String name) throws BeansException {
        return this.doGetBean(name, (Class)null, (Object[])null, false);
    }

protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {
        String beanName = this.transformedBeanName(name);
  			//第一次实例化之前为空
        Object sharedInstance = this.getSingleton(beanName);
        Object beanInstance;
        if (sharedInstance != null && args == null) {
            //doSth...
        } else {
            //如果是第一次创建当前bean，那获取bean的单例肯定为空，直接进else
          
          	//spring默认单例创建bean，不会进
            if (this.isPrototypeCurrentlyInCreation(beanName)) {
                throw new BeanCurrentlyInCreationException(beanName);
            }

            BeanFactory parentBeanFactory = this.getParentBeanFactory();
						//标记bean已创建，并改变mbd的stale，让后面的操作能重新覆盖mbd
          	//标记创建的beanName会放到alreadyCreated这个ConcurrentHashMap中
            if (!typeCheckOnly) {
                this.markBeanAsCreated(beanName);
            }

            StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate").tag("beanName", name);

            try {
								//这里会重新创建并覆盖mbd List里的mbd
                RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
              	//校验不是抽象类
                this.checkMergedBeanDefinition(mbd, beanName, args);
                String[] dependsOn = mbd.getDependsOn();
                String[] var12;
                if (dependsOn != null) {
                  	//处理互相依赖的bean之间的关系
                    var12 = dependsOn;
                    int var13 = dependsOn.length;

                    for(int var14 = 0; var14 < var13; ++var14) {
                        String dep = var12[var14];
                      	//如果依赖当前bean的bean已经创建了，肯定有问题
                      	//具体逻辑是从mbd里拿出依赖当前bean的bean，然后循环检查dependentBeanMap中是否存在对应的bean，存在说明已经被实例化了，就有问题
                        if (this.isDependent(beanName, dep)) {
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                        }
												//注册依赖的bean，逻辑是把当前bean和被依赖的bean放到dependentBeanMap中
                        this.registerDependentBean(dep, beanName);

                        try {
                            this.getBean(dep);
                        } catch (NoSuchBeanDefinitionException var31) {
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", var31);
                        }
                    }
                }

                if (mbd.isSingleton()) {
                  //获取或创建单例bean
                    sharedInstance = this.getSingleton(beanName, () -> {
                        try {
                            return this.createBean(beanName, mbd, args);
                        } catch (BeansException var5) {
                            this.destroySingleton(beanName);
                            throw var5;
                        }
                    });
                    beanInstance = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                } else if (mbd.isPrototype()) {
                    var12 = null;

                    Object prototypeInstance;
                    try {
                        this.beforePrototypeCreation(beanName);
                        prototypeInstance = this.createBean(beanName, mbd, args);
                    } finally {
                        this.afterPrototypeCreation(beanName);
                    }

                    beanInstance = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
                } else {
                    String scopeName = mbd.getScope();
                    if (!StringUtils.hasLength(scopeName)) {
                        throw new IllegalStateException("No scope name defined for bean ��" + beanName + "'");
                    }

                    Scope scope = (Scope)this.scopes.get(scopeName);
                    if (scope == null) {
                        throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
                    }

                    try {
                        Object scopedInstance = scope.get(beanName, () -> {
                            this.beforePrototypeCreation(beanName);

                            Object var4;
                            try {
                                var4 = this.createBean(beanName, mbd, args);
                            } finally {
                                this.afterPrototypeCreation(beanName);
                            }

                            return var4;
                        });
                        beanInstance = this.getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                    } catch (IllegalStateException var30) {
                        throw new ScopeNotActiveException(beanName, scopeName, var30);
                    }
                }
            } catch (BeansException var32) {
                beanCreation.tag("exception", var32.getClass().toString());
                beanCreation.tag("message", String.valueOf(var32.getMessage()));
                this.cleanupAfterBeanCreationFailure(beanName);
                throw var32;
            } finally {
                beanCreation.end();
            }
        }

        return this.adaptBeanInstance(name, beanInstance, requiredType);
    }

getSingleton

bean实例化，放入

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
        Assert.notNull(beanName, "Bean name must not be null");
        synchronized(this.singletonObjects) {
          	//第一次初始化为空
            Object singletonObject = this.singletonObjects.get(beanName);
            if (singletonObject == null) {
                if (this.singletonsCurrentlyInDestruction) {
                    throw new BeanCreationNotAllowedException(beanName, "Singleton bean creation not allowed while singletons of this factory are in destruction (Do not request a bean from a BeanFactory in a destroy method implementation!)");
                }

                if (this.logger.isDebugEnabled()) {
                    this.logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
                }
								//实例化前的处理，如果inCreationCheckExclusions有bean就没问题
              	//如果没有就往singletonsCurrentlyInCreation添加bean，该缓存会在循环依赖时起作用
                this.beforeSingletonCreation(beanName);
                boolean newSingleton = false;
                boolean recordSuppressedExceptions = this.suppressedExceptions == null;
                if (recordSuppressedExceptions) {
                    this.suppressedExceptions = new LinkedHashSet();
                }

                try {
                  //从这里调用createBean方法创建bean实例
                    singletonObject = singletonFactory.getObject();
                    newSingleton = true;
                } catch (IllegalStateException var16) {
                    //doSth...
                } catch (BeanCreationException var17) {
                    //doSth...
                } finally {
                    if (recordSuppressedExceptions) {
                        this.suppressedExceptions = null;
                    }
										//创建完成再从singletonsCurrentlyInCreation移除bean
                    this.afterSingletonCreation(beanName);
                }

                if (newSingleton) {
                  	//实例化成功，将对象放入singletonObjects、registeredSingletons
                  	//并从singletonFactories、earlySingletonObjects移除
                    this.addSingleton(beanName, singletonObject);
                }
            }

            return singletonObject;
        }
    }

createBean

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
        if (this.logger.isTraceEnabled()) {
            this.logger.trace("Creating instance of bean '" + beanName + "'");
        }

        RootBeanDefinition mbdToUse = mbd;
        Class<?> resolvedClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
        if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
            mbdToUse = new RootBeanDefinition(mbd);
            mbdToUse.setBeanClass(resolvedClass);
        }

        try {
          	//准备方法重写
            mbdToUse.prepareMethodOverrides();
        } catch (BeanDefinitionValidationException var9) {
            throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed", var9);
        }

        Object beanInstance;
        try {
          	//实例化前获取bean的名称并执行InstantiationAwareBeanPostProcessor
            beanInstance = this.resolveBeforeInstantiation(beanName, mbdToUse);
            if (beanInstance != null) {
                return beanInstance;
            }
        } catch (Throwable var10) {
            throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", var10);
        }

        try {
            beanInstance = this.doCreateBean(beanName, mbdToUse, args);
            if (this.logger.isTraceEnabled()) {
                this.logger.trace("Finished creating instance of bean '" + beanName + "'");
            }
						//返回getSingleton方法
            return beanInstance;
        } catch (ImplicitlyAppearedSingletonException | BeanCreationException var7) {
            throw var7;
        } catch (Throwable var8) {
            throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", var8);
        }
    }

doCreateBean

创建bean实例

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
        BeanWrapper instanceWrapper = null;
        if (mbd.isSingleton()) {
          //从factoryBeanInstanceCache中移除bean
            instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
        }

        if (instanceWrapper == null) {
          	//创建bean实例
          	//一般使用默认构造器，通过bean的class->Class#getDeclaredConstructor->Constructor#newInstance反射创建
          	//接着，将返回的bean实例封为beanWrapper并初始化，初始化过程会将wrapper注册到customEditors中，不太清楚用途
            instanceWrapper = this.createBeanInstance(beanName, mbd, args);
        }
  
  			//doSth...

        Object exposedObject = bean;

        try {
          	//使用BeanPostProcessor对bean进行处理
          	//其中最主要的就是AutowiredAnnotationBeanPostProcessor，自动注入
            this.populateBean(beanName, mbd, instanceWrapper);
            exposedObject = this.initializeBean(beanName, exposedObject, mbd);
        } catch (Throwable var18) {
            if (var18 instanceof BeanCreationException && beanName.equals(((BeanCreationException)var18).getBeanName())) {
                throw (BeanCreationException)var18;
            }

            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", var18);
        }
  
  			//doSth...

        try {
            this.registerDisposableBeanIfNecessary(beanName, bean, mbd);
            return exposedObject;
        } catch (BeanDefinitionValidationException var16) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", var16);
        }
    }

populateBean

对当前bean的属性进行依赖注入

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
        if (bw == null) {
            //doSth...
        } else {
						//doSth...
            boolean hasInstAwareBpps = this.hasInstantiationAwareBeanPostProcessors();
            boolean needsDepCheck = mbd.getDependencyCheck() != 0;
            PropertyDescriptor[] filteredPds = null;
            if (hasInstAwareBpps) {
                if (pvs == null) {
                    pvs = mbd.getPropertyValues();
                }
								//遍历BeanPostProcessor对bean处理
                PropertyValues pvsToUse;
                for(Iterator var9 = this.getBeanPostProcessorCache().instantiationAware.iterator(); var9.hasNext(); pvs = pvsToUse) {
                    InstantiationAwareBeanPostProcessor bp = (InstantiationAwareBeanPostProcessor)var9.next();
                  	//最主要的是AutowiredAnnotationBeanPostProcessor
                  	//后面我们单拎出来讲
                    pvsToUse = bp.postProcessProperties((PropertyValues)pvs, bw.getWrappedInstance(), beanName);					
                  	//doSth...
                }
            }

            //doSth...

        }
    }

12、finishRefresh

protected void finishRefresh() {
  			//清除资源缓存
        this.clearResourceCaches();
  			//注册lifecycleProcessor
        this.initLifecycleProcessor();
  			//对实现了LifeCycle的bean做处理
        this.getLifecycleProcessor().onRefresh();
  			//发布事件
        this.publishEvent((ApplicationEvent)(new ContextRefreshedEvent(this)));
        if (!NativeDetector.inNativeImage()) {
            LiveBeansView.registerApplicationContext(this);
        }

    }

13、resetCommonCaches

清空各种缓存缓存

14、依赖注入

逻辑在11、finishBeanFactoryInitialization中

createBean之前，会把beanName放到缓存中，表示这个bean正在创建，创建完成后，会把beanName从缓存中移除

populateBean

在doCreateBean方法中被调用

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
        if (bw == null) {
            //doSth...
        } else {
          	//doSth...
            if (hasInstAwareBpps) {
                if (pvs == null) {
                    pvs = mbd.getPropertyValues();
                }
								//对当前bean遍历执行beanPostProcessor
                PropertyValues pvsToUse;
                for(Iterator var9 = this.getBeanPostProcessorCache().instantiationAware.iterator(); var9.hasNext(); pvs = pvsToUse) {
                    InstantiationAwareBeanPostProcessor bp = (InstantiationAwareBeanPostProcessor)var9.next();
                  	//当执行到AutowiredAnnotationBeanPostProcessor时，会开始处理依赖注入的field
                    pvsToUse = bp.postProcessProperties((PropertyValues)pvs, bw.getWrappedInstance(), beanName);
                }
            }

        }
    }

AutowiredAnnotationBeanPostProcessor#postProcessProperties

public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
        InjectionMetadata metadata = this.findAutowiringMetadata(beanName, bean.getClass(), pvs);

        try {
          	//依赖注入
            metadata.inject(bean, beanName, pvs);
            return pvs;
        } catch (BeanCreationException var6) {
            throw var6;
        } catch (Throwable var7) {
            throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", var7);
        }
    }

private Object resolveFieldValue(Field field, Object bean, @Nullable String beanName) {
            //doSth...

            Object value;
            try {
              	//解决依赖
                value = AutowiredAnnotationBeanPostProcessor.this.beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
            } catch (BeansException var12) {
                throw new UnsatisfiedDependencyException((String)null, beanName, new InjectionPoint(field), var12);
            }
  					//doSth...
        }
    }

doResolveDependency

public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName, @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
        InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);

        Object var7;
        try {
            Object shortcut = descriptor.resolveShortcut(this);
            if (shortcut == null) {
                //doSth...
								//处理集合依赖
                Object multipleBeans = this.resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
                if (multipleBeans != null) {
                    var23 = multipleBeans;
                    return var23;
                }
								//寻找自动注入的依赖
                Map<String, Object> matchingBeans = this.findAutowireCandidates(beanName, type, descriptor);
                String autowiredBeanName;
                if (matchingBeans.isEmpty()) {
                    if (this.isRequired(descriptor)) {
                        this.raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
                    }

                    autowiredBeanName = null;
                    return autowiredBeanName;
                }

                if (instanceCandidate instanceof Class) {
                  	//从这里开始解决依赖问题，如果有循环依赖会触发对应bean的实例化
                    instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
                }
              
              	//doSth...
            }

            var7 = shortcut;
        } finally {
            ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);
        }

        return var7;
    }

getSingleton

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null && this.isSingletonCurrentlyInCreation(beanName)) 
            //一级缓存singletonObjects没bean，而且这个bean当前正在创建中，说明创建流程还没走完
            singletonObject = this.earlySingletonObjects.get(beanName);
  					//第一次创建的时候allowEarlyReference是false，不允许获取早期bean
  					//这样就能直接跳出逻辑，返回空对象，告诉程序这个bean还没创建
            if (singletonObject == null && allowEarlyReference) {
              	//当处理下一个bean自动注入的依赖时，allowEarlyReference为true，会进来
                synchronized(this.singletonObjects) {
                    singletonObject = this.singletonObjects.get(beanName);
                    if (singletonObject == null) {
                        singletonObject = this.earlySingletonObjects.get(beanName);
                        if (singletonObject == null) {
                          //将三级缓存的bean挪到二级缓存，来告诉程序这些bean现在可以被发现，但还没初始化完成
                            ObjectFactory<?> singletonFactory = (ObjectFactory)this.singletonFactories.get(beanName);
                            if (singletonFactory != null) {
                                singletonObject = singletonFactory.getObject();
                                this.earlySingletonObjects.put(beanName, singletonObject);
                                this.singletonFactories.remove(beanName);
                            }
                        }
                    }
                }
            }
        }

        return singletonObject;
    }

依赖注入总结

1. A、B两个对象互相依赖
2. 先初始化A，发现A依赖B，就跑去初始化B，此时A在三级缓存
3. B初始化时发现依赖A，就把A从三级缓存挪到二级，然后给依赖的字段注入，此时B在一级缓存
4. B初始化完之后，回到A初始化，A从一级缓存拿B注入
5. 依赖注入完成