SpringBoot源码分析

Java资料网推荐SpringBoot源码分析这篇文章给大家，欢迎收藏Java资料网享受知识的乐趣

Springboot源码分析

1、SpringApplication初始化

从run()方法进入，可以看到Springboot首先创建了SpringApplication，然后调用SpringApplication的run()方法。

public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
    return (new SpringApplication(primarySources)).run(args);
}

创建SpringApplication，首先要执行它的构造方法。

//SpringApplication.class
public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
    this.sources = new LinkedHashSet();
    this.bannerMode = Mode.CONSOLE;
    this.logStartupInfo = true;
    this.addCommandLineProperties = true;
    this.addConversionService = true;
    this.headless = true;
    this.registerShutdownHook = true;
    this.additionalProfiles = new HashSet();
    this.isCustomEnvironment = false;
    this.lazyInitialization = false;
    this.resourceLoader = resourceLoader;
    Assert.notNull(primarySources, "PrimarySources must not be null");
    this.primarySources = new LinkedHashSet(Arrays.asList(primarySources));
    //webApplication类型一般是servlet
    this.webApplicationType = WebApplicationType.deduceFromClasspath();
   //设置初始化器，加载spring.factories文件中的ApplicationContextInitializer
    this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class));
    //设置监听器，加载spring.factories文件中的ApplicationListener
    this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));
    //启动类的类型，我们的是com.example.demo.DemoApplication
    this.mainApplicationClass = this.deduceMainApplicationClass();
}

1.1 & 1.2 设置初始化器和监听器

上面的setInitializers和setListeners去初始化spring.factories文件中对应的类，然后放入ArrayList中。比如这些：

org.springframework.context.ApplicationContextInitializer=\
org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer,\
org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener

# Application Listeners
org.springframework.context.ApplicationListener=\
org.springframework.boot.autoconfigure.BackgroundPreinitializer

1.2.1 getSpringFactoriesInstances

在getSpringFactoriesInstances()方法中，springboot首先去所有spring.factories找到对应的类，然后通过反射创建类的实例。

//SpringApplication.class
private <T> Collection<T> getSpringFactoriesInstances(Class<T> type) {
    return this.getSpringFactoriesInstances(type, new Class[0]);
}

private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
    ClassLoader classLoader = this.getClassLoader();
    //获取spring.factories中对应类的类名，以ApplicationListenser为例，springboot会去文件中找到所有ApplicationListener对应的类，放入Set中。
    Set<String> names = new LinkedHashSet(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
    //反射创建类的实例对象，放到List中返回
    List<T> instances = this.createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
    AnnotationAwareOrderComparator.sort(instances);
    return instances;
}

private <T> List<T> createSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, ClassLoader classLoader, Object[] args, Set<String> names) {
    List<T> instances = new ArrayList(names.size());
    Iterator var7 = names.iterator();

    while(var7.hasNext()) {
        String name = (String)var7.next();

        try {
            //获取类信息
            Class<?> instanceClass = ClassUtils.forName(name, classLoader);
            Assert.isAssignable(type, instanceClass);
            //获取构造器
            Constructor<?> constructor = instanceClass.getDeclaredConstructor(parameterTypes);
            //创建实例
            T instance = BeanUtils.instantiateClass(constructor, args);
            instances.add(instance);
        } catch (Throwable var12) {
            throw new IllegalArgumentException("Cannot instantiate " + type + " : " + name, var12);
        }
    }

    return instances;
}

1.2.2 loadFactoryNames()

进入SpringFactoriesLoader.loadFactoryNames(type, classLoader)看一下，这里还是以ApplicationListener为例，这时的type是org.springframework.context.ApplicationListener，classLoader是AppClassLoader。

//SpringFactoriesLoader.class
public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
    String factoryTypeName = factoryType.getName();
    return (List)loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());
}

private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
    MultiValueMap<String, String> result = (MultiValueMap)cache.get(classLoader);
    if (result != null) {
        return result;
    } else {
        try {
            Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
            MultiValueMap<String, String> result = new LinkedMultiValueMap();

            while(urls.hasMoreElements()) {
                URL url = (URL)urls.nextElement();
                UrlResource resource = new UrlResource(url);
                Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                Iterator var6 = properties.entrySet().iterator();

                while(var6.hasNext()) {
                    Map.Entry<?, ?> entry = (Map.Entry)var6.next();
                    String factoryTypeName = ((String)entry.getKey()).trim();
                    String[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                    int var10 = var9.length;

                    for(int var11 = 0; var11 < var10; ++var11) {
                        String factoryImplementationName = var9[var11];
                        result.add(factoryTypeName, factoryImplementationName.trim());
                    }
                }
            }

            cache.put(classLoader, result);
            return result;
        } catch (IOException var13) {
            throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var13);
        }
    }
}

loadSpringFactories()方法会遍历所有的spring.factories文件，把所有的类的名字保存到map中，然后调用getOrDefault()方法就可以获取到所有的ApplicationListner对应的类名了。

SpringApplication初始化完了，接下来该执行run()方法了

2、SpringApplication执行run()方法

//SpringApplication.class
public ConfigurableApplicationContext run(String... args) {
    StopWatch stopWatch = new StopWatch();
    stopWatch.start();
    //这里是Spring的上下文
    ConfigurableApplicationContext context = null;
    Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList();
    this.configureHeadlessProperty();
    //获取运行监听器，获取到的是EventPublishingRunListener，这是springboot的启动监听器
    SpringApplicationRunListeners listeners = this.getRunListeners(args);
    //启动监听器
    listeners.starting();

    Collection exceptionReporters;
    try {
        ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
        //2.1 准备环境
        ConfigurableEnvironment environment = this.prepareEnvironment(listeners, applicationArguments);
        this.configureIgnoreBeanInfo(environment);
        //Banner打印类
        Banner printedBanner = this.printBanner(environment);
        //2.2 创建应用上下文
        context = this.createApplicationContext();
        exceptionReporters = this.getSpringFactoriesInstances(SpringBootExceptionReporter.class, new Class[]{ConfigurableApplicationContext.class}, context);
        //2.3 准备上下文
        this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);
        //2.4 刷新上下文
        this.refreshContext(context);
        //刷新上下文后置处理
        this.afterRefresh(context, applicationArguments);
        stopWatch.stop();
        if (this.logStartupInfo) {
            (new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), stopWatch);
        }
		//发布上下文启动完成事件
        listeners.started(context);
        this.callRunners(context, applicationArguments);
    } catch (Throwable var10) {
        this.handleRunFailure(context, var10, exceptionReporters, listeners);
        throw new IllegalStateException(var10);
    }

    try {
        listeners.running(context);
        return context;
    } catch (Throwable var9) {
        this.handleRunFailure(context, var9, exceptionReporters, (SpringApplicationRunListeners)null);
        throw new IllegalStateException(var9);
    }
}

2.1 prepareEnvironment()准备环境

//SpringApplication.class
private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments) {
    //根据前面推断的webApplicationType创建对应的环境，servlet对应的是StandardServletEnvironment()
    ConfigurableEnvironment environment = this.getOrCreateEnvironment();
    //根据参数配置环境，包括命令行参数，启动类传入的参数
    this.configureEnvironment((ConfigurableEnvironment)environment, applicationArguments.getSourceArgs());
    ConfigurationPropertySources.attach((Environment)environment);
    //执行完这个，配置文件中的配置进行就被加载到环境中了
    listeners.environmentPrepared((ConfigurableEnvironment)environment);
    //环境和SpringApplication绑定起来
    this.bindToSpringApplication((ConfigurableEnvironment)environment);
    if (!this.isCustomEnvironment) {
        environment = (new EnvironmentConverter(this.getClassLoader())).convertEnvironmentIfNecessary((ConfigurableEnvironment)environment, this.deduceEnvironmentClass());
    }

    ConfigurationPropertySources.attach((Environment)environment);
    return (ConfigurableEnvironment)environment;
}

2.1.1 根据参数配置环境configureEnvironment()

//SpringApplication.class
protected void configureEnvironment(ConfigurableEnvironment environment, String[] args) {
    if (this.addConversionService) {
        ConversionService conversionService = ApplicationConversionService.getSharedInstance();
        environment.setConversionService((ConfigurableConversionService)conversionService);
    }
	//配置命令行中的参数
    this.configurePropertySources(environment, args);
    //激活相应的配置文件，例如application.propertires或者application-dev.properties等
    this.configureProfiles(environment, args);
}

如果我启动的dev环境，执行完上面的代码后环境中是这样的

2.1.2 listeners.environmentPrepared()

执行完这句代码后，配置文件中的信息就被加载到环境中了，如下图。具体怎么做到的还没看懂

2.2 创建应用上下文createApplicationContext()

//SpringApplication.class
protected ConfigurableApplicationContext createApplicationContext() {
    Class<?> contextClass = this.applicationContextClass;
    if (contextClass == null) {
        try {
            switch (this.webApplicationType) {
                case SERVLET:
                    contextClass = Class.forName("org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext");
                    break;
                case REACTIVE:
                    contextClass = Class.forName("org.springframework.boot.web.reactive.context.AnnotationConfigReactiveWebServerApplicationContext");
                    break;
                default:
                    contextClass = Class.forName("org.springframework.context.annotation.AnnotationConfigApplicationContext");
            }
        } catch (ClassNotFoundException var3) {
            throw new IllegalStateException("Unable create a default ApplicationContext, please specify an ApplicationContextClass", var3);
        }
    }

    return (ConfigurableApplicationContext)BeanUtils.instantiateClass(contextClass);
}

这个函数也是根据前面的webApplicationType创建应用上下文，servlet对应的是AnnotationConfigServletWebServerApplicationContext，当初始化完这个类时，其实也会创建一个IOC容器beanFactory，如下图所示。这是因为AnnotationConfigServletWebServerApplicationContext会继承GenericApplicationContext，当执行完这个类的构造函数，会创建一个DefaultListableBeanFactory()的beanFactory，这个就是IOC容器。

2.3 准备上下文prepareContext()

//SpringApplication.class
private void prepareContext(ConfigurableApplicationContext context, ConfigurableEnvironment environment, SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) {
    //设置上下文环境
    context.setEnvironment(environment);
    this.postProcessApplicationContext(context);
    //初始化所有的ApplicationContextInitializer
    this.applyInitializers(context);
    //发布上下文准备完成事件
    listeners.contextPrepared(context);
    if (this.logStartupInfo) {
        this.logStartupInfo(context.getParent() == null);
        this.logStartupProfileInfo(context);
    }
    //获取IOC容器beanFactory
    ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
    //将springApplicationArguments和springBootBanner注册成单例
    beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
    if (printedBanner != null) {
        beanFactory.registerSingleton("springBootBanner", printedBanner);
    }

    if (beanFactory instanceof DefaultListableBeanFactory) {
        ((DefaultListableBeanFactory)beanFactory).setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
    }

    if (this.lazyInitialization) {
        context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
    }
	//2.3.1 获取资源，其中primarySources就是我们定义的启动类DemoApplication
    Set<Object> sources = this.getAllSources();
    Assert.notEmpty(sources, "Sources must not be empty");
    //2.3.2 加载启动类，注入IOC容器
    this.load(context, sources.toArray(new Object[0]));
    //发布完成加载事件
    listeners.contextLoaded(context);
}

2.3.1 & 2.3.2 获取启动类，注入IOC容器

当执行完getAllSources()，可以获取到启动类DemoApplication

重点看load()方法，进入load()。

//SpringApplication.class
protected void load(ApplicationContext context, Object[] sources) {
    if (logger.isDebugEnabled()) {
        logger.debug("Loading source " + StringUtils.arrayToCommaDelimitedString(sources));
    }
	//创建BeanDefinitionLoader
    BeanDefinitionLoader loader = this.createBeanDefinitionLoader(this.getBeanDefinitionRegistry(context), sources);
    if (this.beanNameGenerator != null) {
        loader.setBeanNameGenerator(this.beanNameGenerator);
    }

    if (this.resourceLoader != null) {
        loader.setResourceLoader(this.resourceLoader);
    }

    if (this.environment != null) {
        loader.setEnvironment(this.environment);
    }
	//加载启动类
    loader.load();
}

其中getBeanDefinitionRegistry(context)方法会将之前的上下文context强转成BeanDefinitionRegistry，他们之间的继承关系很复杂，可以转换成不同的类完成不同的方法。createBeanDefinitionLoader()方法创建了一个BeanDefinitionLoader()，点进去看看。

//BeanDefinitionLoader.class
BeanDefinitionLoader(BeanDefinitionRegistry registry, Object... sources) {
    Assert.notNull(registry, "Registry must not be null");
    Assert.notEmpty(sources, "Sources must not be empty");
    this.sources = sources;
    //注解形式的Bean阅读器
    this.annotatedReader = new AnnotatedBeanDefinitionReader(registry);
    //xml形式的Bean阅读器
    this.xmlReader = new XmlBeanDefinitionReader(registry);
    if (this.isGroovyPresent()) {
        this.groovyReader = new GroovyBeanDefinitionReader(registry);
    }
	//类路径扫描器
    this.scanner = new ClassPathBeanDefinitionScanner(registry);
    this.scanner.addExcludeFilter(new ClassExcludeFilter(sources));
}

一直跟进load()。

//BeanDefinitionLoader.class
private int load(Class<?> source) {
    if (this.isGroovyPresent() && GroovyBeanDefinitionSource.class.isAssignableFrom(source)) {
        GroovyBeanDefinitionSource loader = (GroovyBeanDefinitionSource)BeanUtils.instantiateClass(source, GroovyBeanDefinitionSource.class);
        this.load(loader);
    }
	//启动类会走进这里
    if (this.isEligible(source)) {
        //将启动类注册进beanDefinitionMap
        this.annotatedReader.register(new Class[]{source});
        return 1;
    } else {
        return 0;
    }
}

进入register()方法。

//AnnotatedBeanDefinitionReader.class
public void register(Class<?>... componentClasses) {
    Class[] var2 = componentClasses;
    int var3 = componentClasses.length;

    for(int var4 = 0; var4 < var3; ++var4) {
        Class<?> componentClass = var2[var4];
        this.registerBean(componentClass);
    }

}

public void registerBean(Class<?> beanClass) {
    this.doRegisterBean(beanClass, (String)null, (Class[])null, (Supplier)null, (BeanDefinitionCustomizer[])null);
}

private <T> void doRegisterBean(Class<T> beanClass, @Nullable String name, @Nullable Class<? extends Annotation>[] qualifiers, @Nullable Supplier<T> supplier, @Nullable BeanDefinitionCustomizer[] customizers) {
    //将beanClass(这里是启动类DemoApplication)封装成AnnotatedGenericBeanDefinition
    AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);
    if (!this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
        abd.setInstanceSupplier(supplier);
        ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
        abd.setScope(scopeMetadata.getScopeName());
        String beanName = name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry);
        AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
        int var10;
        int var11;
        if (qualifiers != null) {
            Class[] var9 = qualifiers;
            var10 = qualifiers.length;

            for(var11 = 0; var11 < var10; ++var11) {
                Class<? extends Annotation> qualifier = var9[var11];
                if (Primary.class == qualifier) {
                    abd.setPrimary(true);
                } else if (Lazy.class == qualifier) {
                    abd.setLazyInit(true);
                } else {
                    abd.addQualifier(new AutowireCandidateQualifier(qualifier));
                }
            }
        }

        if (customizers != null) {
            BeanDefinitionCustomizer[] var13 = customizers;
            var10 = customizers.length;

            for(var11 = 0; var11 < var10; ++var11) {
                BeanDefinitionCustomizer customizer = var13[var11];
                customizer.customize(abd);
            }
        }
		//创建BeanDefinitionHolder，就是把BeanDefinition包装了一下，添加了一些属性和方法。
        BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
        definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
        //将启动类BeanDefinition注册到IOC容器的map中。
        BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
    }
}

registerBeanDefinition()方法实际会调用BeanDefinitionRegistry的registerBeanDefinition()方法，它在DefaultListableBeanFactory实现类里实现的，之前说过这个就是IOC容器。

//DefaultListableBeanFactory.class
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException {
    Assert.hasText(beanName, "Bean name must not be empty");
    Assert.notNull(beanDefinition, "BeanDefinition must not be null");
    if (beanDefinition instanceof AbstractBeanDefinition) {
        try {
            ((AbstractBeanDefinition)beanDefinition).validate();
        } catch (BeanDefinitionValidationException var8) {
            throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName, "Validation of bean definition failed", var8);
        }
    }
	//IOC容器beanFactory的beanDefinitionMap
    BeanDefinition existingDefinition = (BeanDefinition)this.beanDefinitionMap.get(beanName);
    if (existingDefinition != null) {
        if (!this.isAllowBeanDefinitionOverriding()) {
            throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
        }

        if (existingDefinition.getRole() < beanDefinition.getRole()) {
            if (this.logger.isInfoEnabled()) {
                this.logger.info("Overriding user-defined bean definition for bean '" + beanName + "' with a framework-generated bean definition: replacing [" + existingDefinition + "] with [" + beanDefinition + "]");
            }
        } else if (!beanDefinition.equals(existingDefinition)) {
            if (this.logger.isDebugEnabled()) {
                this.logger.debug("Overriding bean definition for bean '" + beanName + "' with a different definition: replacing [" + existingDefinition + "] with [" + beanDefinition + "]");
            }
        } else if (this.logger.isTraceEnabled()) {
            this.logger.trace("Overriding bean definition for bean '" + beanName + "' with an equivalent definition: replacing [" + existingDefinition + "] with [" + beanDefinition + "]");
        }

        this.beanDefinitionMap.put(beanName, beanDefinition);
    } else {
        if (this.hasBeanCreationStarted()) {
            synchronized(this.beanDefinitionMap) {
                this.beanDefinitionMap.put(beanName, beanDefinition);
                List<String> updatedDefinitions = new ArrayList(this.beanDefinitionNames.size() + 1);
                updatedDefinitions.addAll(this.beanDefinitionNames);
                updatedDefinitions.add(beanName);
                this.beanDefinitionNames = updatedDefinitions;
                this.removeManualSingletonName(beanName);
            }
        } else {
            //启动阶段会走到这里，以beanName为key，beanDefinition为value存入beanDefinitionMap中
            this.beanDefinitionMap.put(beanName, beanDefinition);
            this.beanDefinitionNames.add(beanName);
            this.removeManualSingletonName(beanName);
        }

        this.frozenBeanDefinitionNames = null;
    }

    if (existingDefinition == null && !this.containsSingleton(beanName)) {
        if (this.isConfigurationFrozen()) {
            this.clearByTypeCache();
        }
    } else {
        this.resetBeanDefinition(beanName);
    }

}

注册完之后可以看到demoApplication已经被添加到beanFactory的beanDefinitionMap中了。

2.4、刷新上下文refreshContext()

Springboot最终在这里调用Spring的refresh()方法，从refreshContext()一直跟进去会到AbstractApplicationContext的refresh()方法。

//AbstractApplicationContext.class
public void refresh() throws BeansException, IllegalStateException {
    synchronized(this.startupShutdownMonitor) {
        this.prepareRefresh();
        //2.4.1 获取容器
        ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
        //准备beanFactory，这个方法就是为beanFactory添加一些组件和配置，比如后置处理器、类加载器、依赖处理器等等
        this.prepareBeanFactory(beanFactory);

        try {
            //在上下文添加一些BeanFactory后置处理器，处理器在beanDefinition加载完后，bean实例化之前执行
            this.postProcessBeanFactory(beanFactory);
            //2.4.2 调用BeanFactory后置处理器，这一步会进行IOC容器的初始化
            this.invokeBeanFactoryPostProcessors(beanFactory);
            //注册bean的后置处理器，上面是BeanFactory后置处理器
            this.registerBeanPostProcessors(beanFactory);
            this.initMessageSource();
            this.initApplicationEventMulticaster();
            this.onRefresh();
            this.registerListeners();
            //上面这些不看了，直接从这开始
            //2.4.3 完成所有单例bean的初始化
            this.finishBeanFactoryInitialization(beanFactory);
            //广播刷新完成事件
            this.finishRefresh();
        } catch (BeansException var9) {
            if (this.logger.isWarnEnabled()) {
                this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);
            }

            this.destroyBeans();
            this.cancelRefresh(var9);
            throw var9;
        } finally {
            this.resetCommonCaches();
        }

    }
}

2.4.1 obtainFreshBeanFactory()获取容器

之前说过Springboot在创建应用上下文时，触发了GenericApplicationContext的构造函数，创建了beanFactory，这个方法就是获取之前创建的beanFactory。

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

这两个方法都是模板方法，由子类GenericApplicationContext实现

//GenericApplicationContext.class
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 {
        this.beanFactory.setSerializationId(this.getId());
    }
}

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

2.4.2 invokeBeanFactoryPostProcessors()

public static void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
...
    	//默认的beanFactoryPostProcessors有三个，SharedMetadataReaferFactoryContextInitializer、ConfigurationWArningsApplicationContextInitializer、ConfigFileApplicationListener
        Iterator var6 = beanFactoryPostProcessors.iterator();
		//循环将它们注册到beanDefinitionMap中
        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();
    //这里postProcessorNames是org.springframework.context.annotation.internalConfigurationAnnotationProcessor，internalConfigurationAnnotationProcessor是专门用来处理Configuration注解的类。
        postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
        String[] var16 = postProcessorNames;
        var9 = postProcessorNames.length;

        int var10;
        String ppName;
        for(var10 = 0; var10 < var9; ++var10) {
            ppName = var16[var10];
            if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                //通过getBean,从实例化了ConfigurationClassPostProcessor到容器中
                currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                processedBeans.add(ppName);
            }
        }

        sortPostProcessors(currentRegistryProcessors, beanFactory);
        registryProcessors.addAll(currentRegistryProcessors);
    //对于使用基于@Configuration注解和@bean注入的对象, 此时的processor类型为ConfigurationClassPostprocessor, 且在此处执行
    //如果是@Autowired和@Value注解注入的对象，processor类型应该是AutowiredAnnotationBeanPostProcessor，这些东西是在AnnotationConfigUtils类下定义的
    //2.4.2.1 进去重点看看此时的processor类型为ConfigurationClassPostprocessor的postProcessBeanDefinitionRegistry()做了什么
    invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
       ...
}

2.4.2.1 invokeBeanDefinitionRegistryPostProcessors()

一直跟进这个方法，知道ConfigurationClassPostProcessor.class中的parser.parse(candidates)方法，看下面这张图，这时候的只有这个启动类，接下来继续跟进这个方法。

//ConfigurationClassParser.class
public void parse(Set<BeanDefinitionHolder> configCandidates) {
    Iterator var2 = configCandidates.iterator();

    while(var2.hasNext()) {
        BeanDefinitionHolder holder = (BeanDefinitionHolder)var2.next();
        BeanDefinition bd = holder.getBeanDefinition();

        try {
            //会走这里，之前看到过启动类是被封装成AnnotatedBeanDefinition的
            if (bd instanceof AnnotatedBeanDefinition) {
                this.parse(((AnnotatedBeanDefinition)bd).getMetadata(), holder.getBeanName());
            } else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition)bd).hasBeanClass()) {
                this.parse(((AbstractBeanDefinition)bd).getBeanClass(), holder.getBeanName());
            } else {
                this.parse(bd.getBeanClassName(), holder.getBeanName());
            }
        } catch (BeanDefinitionStoreException var6) {
            throw var6;
        } catch (Throwable var7) {
            throw new BeanDefinitionStoreException("Failed to parse configuration class [" + bd.getBeanClassName() + "]", var7);
        }
    }
	//springboot自动装配的入口
    this.deferredImportSelectorHandler.process();
}

继续跟进parse()方法直到ConfigurationClassParser.class的doProcessConfigurationClass()方法。

//ConfigurationClassParser.class
    protected void processConfigurationClass(ConfigurationClass configClass, Predicate<String> filter) throws IOException {
			...
            do {
                //主要就是这个方法进行处理
                sourceClass = this.doProcessConfigurationClass(configClass, sourceClass, filter);
            } while(sourceClass != null);

            this.configurationClasses.put(configClass, configClass);
        }
    }

    protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter) throws IOException {
        //递归处理内部类，启动类是没有内部类的，如果是启动类这里进去什么都不做
        if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
            this.processMemberClasses(configClass, sourceClass, filter);
        }

        //处理@PropertySource注解配置的属性，对于启动类来说，这里也没有
        Iterator var4 = AnnotationConfigUtils.attributesForRepeatable(sourceClass.getMetadata(), PropertySources.class, PropertySource.class).iterator();

        AnnotationAttributes importResource;
        while(var4.hasNext()) {
            importResource = (AnnotationAttributes)var4.next();
            if (this.environment instanceof ConfigurableEnvironment) {
                this.processPropertySource(importResource);
            } else {
                this.logger.info("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() + "]. Reason: Environment must implement ConfigurableEnvironment");
            }
        }

        //处理@ComponentScan注解，扫描项目中的bean，启动类上包含这个注解
        Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
        if (!componentScans.isEmpty() && !this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
            Iterator var14 = componentScans.iterator();

            while(var14.hasNext()) {
                AnnotationAttributes componentScan = (AnnotationAttributes)var14.next();
                //2.4.2.2 扫描项目中的bean
                Set<BeanDefinitionHolder> scannedBeanDefinitions = this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
                Iterator var8 = scannedBeanDefinitions.iterator();

                while(var8.hasNext()) {
                    BeanDefinitionHolder holder = (BeanDefinitionHolder)var8.next();
                    BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
                    if (bdCand == null) {
                        bdCand = holder.getBeanDefinition();
                    }

                    if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
                        //todo：解析扫描到的bean，这里又循环会去了，可能是再从它们所在的包继续向下扫描？
                        this.parse(bdCand.getBeanClassName(), holder.getBeanName());
                    }
                }
            }
        }
        //2.4.2.3 递归处理@Import注解，SpringBoot中经常用的各种@Enable***注解基本都是封装的@Import
        this.processImports(configClass, sourceClass, this.getImports(sourceClass), filter, true);
        ...
        return null;
    }

2.4.2.2 扫描bean

主要看看怎么从扫描bean的，这里会调用doScan()方法扫描bean，然后将beanDefinition注册到beanDefinitionMap中。

protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
	...
    for(int var5 = 0; var5 < var4; ++var5) {
        String basePackage = var3[var5];
        //从basePackage下找bean
        Set<BeanDefinition> candidates = this.findCandidateComponents(basePackage);
        Iterator var8 = candidates.iterator();

        while(var8.hasNext()) {
            BeanDefinition candidate = (BeanDefinition)var8.next();
            ...
            if (this.checkCandidate(beanName, candidate)) {
                BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
                definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
                beanDefinitions.add(definitionHolder);
                //注册beanDefinition
                this.registerBeanDefinition(definitionHolder, this.registry);
            }
        }
    }

    return beanDefinitions;
}

执行完上面代码，看看扫描到了那些bean，这两个bean是我们提前写好的。

@Configuration
public class Config {
    @Bean
    public MyService getMyService(MyService myService){
        return myService;
    }
}

回到2.4.2.1的doProcessConfigurationClass()，此时代码执行到processImports()方法了，这个方法是处理@Import注解的。

2.4.2.3 processImports()

这个方法会处理@Import注解，这里主要从SpringBoot自动配置的角度看看这个方法，因为springboot开启自动配置的注解@EnableAutoConfiguration封装了@Import注解。进入processImports()代码。

private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass, Collection<SourceClass> importCandidates, Predicate<String> exclusionFilter, boolean checkForCircularImports) {
    //先看下面那段话
    if (!importCandidates.isEmpty()) {
        if (checkForCircularImports && this.isChainedImportOnStack(configClass)) {
            this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
        } else {
            this.importStack.push(configClass);

            try {
                Iterator var6 = importCandidates.iterator();

                while(var6.hasNext()) {
                    SourceClass candidate = (SourceClass)var6.next();
                    Class candidateClass;
                    if (candidate.isAssignable(ImportSelector.class)) {
                        candidateClass = candidate.loadClass();
                        ImportSelector selector = (ImportSelector)ParserStrategyUtils.instantiateClass(candidateClass, ImportSelector.class, this.environment, this.resourceLoader, this.registry);
                        Predicate<String> selectorFilter = selector.getExclusionFilter();
                        if (selectorFilter != null) {
                            exclusionFilter = exclusionFilter.or(selectorFilter);
                        }
						//AutoConfigurationImportSelector会走这里
                        if (selector instanceof DeferredImportSelector) {
                            this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector)selector);
                        } else {
                            String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
                            Collection<SourceClass> importSourceClasses = this.asSourceClasses(importClassNames, exclusionFilter);
                            this.processImports(configClass, currentSourceClass, importSourceClasses, exclusionFilter, false);
                        }

                    } else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
                        //ImportBeanDefinitionRegistrar会
                        candidateClass = candidate.loadClass();
                        ImportBeanDefinitionRegistrar registrar = (ImportBeanDefinitionRegistrar)ParserStrategyUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class, this.environment, this.resourceLoader, this.registry);
                        configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
                    } else {
//当真正需要注册需要自动配置的类时会走这里，不过要走到这里的入口是在2.4.2.1中提到的  this.deferredImportSelectorHandler.process()这个方法                    
                        this.importStack.registerImport(currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
 //又回到了这个方法，在2.4.2.1介绍启动类注册的时候说过了，就是注册到把beanDefinition注册到Map中，那这里就是去注册那些自动配置类了。                      
                        this.processConfigurationClass(candidate.asConfigClass(configClass), exclusionFilter);
                    }
                }
            } catch (BeanDefinitionStoreException var17) {
                throw var17;
            } catch (Throwable var18) {
                throw new BeanDefinitionStoreException("Failed to process import candidates for configuration class [" + configClass.getMetadata().getClassName() + "]", var18);
            } finally {
                this.importStack.pop();
            }
        }

    }
}

看这张图，传入的两个importCandidates一个是ImportBeanDefinitionRegistrar类，一个是ImportSelector类，对于AutoConfigurationImportSelector，更准确的说他是一个DeferredImportSelector。从名字也能看出他是延迟执行的，所以这时并不会将自动配置的类注入近来，在2.4.2.1中说过，springboot自动配置的入口是在 this.deferredImportSelectorHandler.process()这个方法下。在看上面的代码，两个不同的类会走不同的if或else。

一直跟进代码，直到走到this.deferredImportSelectorHandler.process()。这个方法在ConfigurationClassParser.class的parse()方法下。

//ConfigurationClassParser.class
public void process() {
    List<DeferredImportSelectorHolder> deferredImports = this.deferredImportSelectors;
    this.deferredImportSelectors = null;

    try {
        if (deferredImports != null) {
            DeferredImportSelectorGroupingHandler handler = ConfigurationClassParser.this.new DeferredImportSelectorGroupingHandler();
            deferredImports.sort(ConfigurationClassParser.DEFERRED_IMPORT_COMPARATOR);
            deferredImports.forEach(handler::register);
            //重点是这个
            handler.processGroupImports();
        }
    } finally {
        this.deferredImportSelectors = new ArrayList();
    }

}

在跟进processGroupImports()方法。

//ConfigurationClassParser.class
public void processGroupImports() {
    Iterator var1 = this.groupings.values().iterator();

    while(var1.hasNext()) {
		...
        //调用getImport()方法去找spring.factories文件中的自动配置类
        grouping.getImports().forEach((entry) -> {
            ConfigurationClass configurationClass = (ConfigurationClass)this.configurationClasses.get(entry.getMetadata());

            try {
                //又到了这个方法了，之前也提过，会走processImports()的最后一个else
                ConfigurationClassParser.this.processImports(configurationClass, ConfigurationClassParser.this.asSourceClass(configurationClass, exclusionFilter), Collections.singleton(ConfigurationClassParser.this.asSourceClass(entry.getImportClassName(), exclusionFilter)), exclusionFilter, false);
            } 
            ...
        });
    }

}

进入getImport()方法：

////ConfigurationClassParser.class
public Iterable<DeferredImportSelector.Group.Entry> getImports() {
    Iterator var1 = this.deferredImports.iterator();

    while(var1.hasNext()) {
        DeferredImportSelectorHolder deferredImport = (DeferredImportSelectorHolder)var1.next();
        //这里会调用Group接口的实现类AutoConfigurationImportSelector，执行process()方法将需要自动配置的类放到一个map中
        this.group.process(deferredImport.getConfigurationClass().getMetadata(), deferredImport.getImportSelector());
    }
	//调用AutoConfigurationImportSelector的selectImports()封装map然后返回需要自动配置的类
    return this.group.selectImports();
}

DeferredImportSelector下定义了一个Group接口，AutoConfigurationImportSelector实现了这个接口，当程序运行到this.group.process()，会去调用AutoConfigurationImportSelector实现的process()。

public void process(AnnotationMetadata annotationMetadata, DeferredImportSelector deferredImportSelector) {
    Assert.state(deferredImportSelector instanceof AutoConfigurationImportSelector, () -> {
        return String.format("Only %s implementations are supported, got %s", AutoConfigurationImportSelector.class.getSimpleName(), deferredImportSelector.getClass().getName());
    });
    //getAutoConfigurationEntry()最终会调用SpringFactoriesLoader.loadFactoryNames()方法去加载spring.factories文件中的类
    AutoConfigurationEntry autoConfigurationEntry = ((AutoConfigurationImportSelector)deferredImportSelector).getAutoConfigurationEntry(annotationMetadata);
    
    this.autoConfigurationEntries.add(autoConfigurationEntry);
    Iterator var4 = autoConfigurationEntry.getConfigurations().iterator();

    while(var4.hasNext()) {
        String importClassName = (String)var4.next();
        //将这些需要自动配置的类放到一个名为entries的map中
        this.entries.putIfAbsent(importClassName, annotationMetadata);
    }

}

然后调用AutoConfigurationImportSelector的selectImports()封装map然后返回需要自动配置的类

之后再回到ConfigurationClassParser的processGroupImports()方法执行后面的processImports()方法，这时才真正开始注册自动配置类的beanDefinition，这时的processImports()会进入processImports()的最后一个else，processConfigurationClass()这个方法前面说过了，将beanDefinition注册到Map中。

//ConfigurationClassParser.class   
private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass, Collection<SourceClass> importCandidates, Predicate<String> exclusionFilter, boolean checkForCircularImports) {
				...
                try {
                    Iterator var6 = importCandidates.iterator();

                    while(var6.hasNext()) {
					...
                        } else {
                            this.importStack.registerImport(currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
                            this.processConfigurationClass(candidate.asConfigClass(configClass), exclusionFilter);
                        }
                    }
                } 
            ...
    }

这部分就到这里了，回到2.4。

2.4.3 finishBeanFactoryInitialization()初始化bean

之前只是将bean的beanDefinition注册到IOC容器中，但是还没有初始化，bean的完整生命周期是在这个方法中完成的。我们以自定义的bean为例来看看bean的初始化。跟进代码，到AbstractBeanFactory.class的doGetBean时在断点上添加条件，这个条件就是beanName=myController时才会进去。

//AbstractBeanFactory.class
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 bean;
    if (sharedInstance != null && args == null) {
	//...
    } else {
		//...
        try {
            //获取bean的beanDefinition
            RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
            this.checkMergedBeanDefinition(mbd, beanName, args);
			//...
            //如果是单例bean
            if (mbd.isSingleton()) {
                //获取bean，这里是从缓冲池里拿，在初始化bean的过程中会把他们放到缓冲池
                sharedInstance = this.getSingleton(beanName, () -> {
                    try {
                        //bean的初始化过程是在这里完成的
                        return this.createBean(beanName, mbd, args);
                    } catch (BeansException var5) {
                        this.destroySingleton(beanName);
                        throw var5;
                    }
                });
                bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
            } else if (mbd.isPrototype()) {
				//...
            } else {
				//...
            }
        } catch (BeansException var26) {
            this.cleanupAfterBeanCreationFailure(beanName);
            throw var26;
        }
    }
	//...
}

然后一直跟进代码createBean()方法，直到AbstractAutowireCapableBeanFactory.class的doCreateBean()方法，这里完成了bean的初始化，主要包括三个步骤：1、创建bean实例。2、为bean实例进行属性注入。3、调用bean的初始化方法。

//AbstractAutowireCapableBeanFactory.class
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
    BeanWrapper instanceWrapper = null;
    if (mbd.isSingleton()) {
        instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
    }
    if (instanceWrapper == null) {
        //2.4.3.1 创建bean实例
        instanceWrapper = this.createBeanInstance(beanName, mbd, args);
    }

    Object bean = instanceWrapper.getWrappedInstance();
    //...
    
    //如果bean是单例且允许循环引用且正在创建，暴露一个bean的早期对象工厂，放到三级缓存
    boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);
    if (earlySingletonExposure) {
		//...
        this.addSingletonFactory(beanName, () -> {
            return this.getEarlyBeanReference(beanName, mbd, bean);
        });
    }

    Object exposedObject = bean;

    try {
        //2.4.3.2 属性注入
        this.populateBean(beanName, mbd, instanceWrapper);
        //2.4.3.3 调用初始化方法
        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);
    }

    if (earlySingletonExposure) {
        Object earlySingletonReference = this.getSingleton(beanName, false);
        if (earlySingletonReference != null) {
            if (exposedObject == bean) {
                exposedObject = earlySingletonReference;
            } else if (!this.allowRawInjectionDespiteWrapping && this.hasDependentBean(beanName)) {
                String[] dependentBeans = this.getDependentBeans(beanName);
                Set<String> actualDependentBeans = new LinkedHashSet(dependentBeans.length);
                String[] var12 = dependentBeans;
                int var13 = dependentBeans.length;

                for(int var14 = 0; var14 < var13; ++var14) {
                    String dependentBean = var12[var14];
                    if (!this.removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                        actualDependentBeans.add(dependentBean);
                    }
                }
                //...
            }
        }
    }

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

2.4.3.1 createBeanInstance()创建bean实例

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
    Class<?> beanClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
    if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && 
        //...
    } else {
        Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
        if (instanceSupplier != null) {
            return this.obtainFromSupplier(instanceSupplier, beanName);
        } else if (mbd.getFactoryMethodName() != null) {
            return this.instantiateUsingFactoryMethod(beanName, mbd, args);
        } else {
            //...
            if (resolved) {
				//...
            } else {
                Constructor<?>[] ctors = this.determineConstructorsFromBeanPostProcessors(beanClass, beanName);
                if (ctors == null && mbd.getResolvedAutowireMode() != 3 && !mbd.hasConstructorArgumentValues() && ObjectUtils.isEmpty(args)) {
                    ctors = mbd.getPreferredConstructors();
                    //对于myController这个我们自定义的bean，会进入instantiateBean()方法，通过BeanUtils创建bean实例
                    return ctors != null ? this.autowireConstructor(beanName, mbd, ctors, (Object[])null) : this.instantiateBean(beanName, mbd);
                } else {
                    return this.autowireConstructor(beanName, mbd, ctors, args);
                }
            }
        }
    }
}

2.4.3.2 populateBean()属性注入

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
    if (bw == null) {
        //...
    } else {
        //...
        boolean hasInstAwareBpps = this.hasInstantiationAwareBeanPostProcessors();
        //...
        if (hasInstAwareBpps) {
            if (pvs == null) {
                pvs = mbd.getPropertyValues();
            }

            Iterator var9 = this.getBeanPostProcessors().iterator();
			//使用后置处理器进行属性注入，对于通过@Autowired注入的属性，使用ImportAwareBeanPostProcessor这个处理器，用它完成属性注入，它是InstantiationAwareBeanPostProcessor的一个实现类。
            while(var9.hasNext()) {
                BeanPostProcessor bp = (BeanPostProcessor)var9.next();
                if (bp instanceof InstantiationAwareBeanPostProcessor) {
                    InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor)bp;
                    //假如MyController中注入了MyService,在这里会先去初始化MyService,流程和MyController一样，之后再回到MyController的生命周期进行属性注入。
                    PropertyValues pvsToUse = ibp.postProcessProperties((PropertyValues)pvs, bw.getWrappedInstance(), beanName);
                    //...
                }
            }
        }
		//...
    }
}

进入postProcessProperties()看看注入逻辑。

//AutowriedAnnotationBeanPostProcessor.class
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);
    }
}

findAutowiringMetadata()可以找到要注入的属性，看下面的图，找到了要注入到MyController中的MyService。

然后执行inject()方法进行注入，注入MyService时会先去初始化MyService，流程是一样的。

2.4.3.3 initializeBean()调用初始化方法

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
    if (System.getSecurityManager() != null) {
        AccessController.doPrivileged(() -> {
            this.invokeAwareMethods(beanName, bean);
            return null;
        }, this.getAccessControlContext());
    } else {
        //调用Aware接口的实现，设置相关的beanName、beanClassLoader、BeanFactory等，自己定义的bean好像不会走这。
        this.invokeAwareMethods(beanName, bean);
    }

    Object wrappedBean = bean;
    if (mbd == null || !mbd.isSynthetic()) {
        //在初始化之前调用BeanPostProcessor，为了方便扩展吧
        wrappedBean = this.applyBeanPostProcessorsBeforeInitialization(bean, beanName);
    }

    try {
        //调用初始化方法
        this.invokeInitMethods(beanName, wrappedBean, mbd);
    } catch (Throwable var6) {
        throw new BeanCreationException(mbd != null ? mbd.getResourceDescription() : null, beanName, "Invocation of init method failed", var6);
    }

    if (mbd == null || !mbd.isSynthetic()) {
        //初始化之后调用BeanPostProcessor
        wrappedBean = this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }

    return wrappedBean;
}

接下来看一下invokeInitMethods()方法，有两个初始化方法，第一个是实现InitializingBean接口并重写afterPropertiesSet()方法，第二种方法是设置init-method方法。springboot会判断我们有没有定义这些方法，如果有就按顺序执行就好了。

protected void invokeInitMethods(String beanName, Object bean, @Nullable RootBeanDefinition mbd) throws Throwable {
    //判断bean有没有实现InitializingBean接口并重写afterPropertiesSet()方法，如果判断为ture，那就调用afterPropertiesSet()方法进行初始化。
    boolean isInitializingBean = bean instanceof InitializingBean;
    if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
        if (this.logger.isTraceEnabled()) {
            this.logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
        }

        if (System.getSecurityManager() != null) {
            try {
                AccessController.doPrivileged(() -> {
                    ((InitializingBean)bean).afterPropertiesSet();
                    return null;
                }, this.getAccessControlContext());
            } catch (PrivilegedActionException var6) {
                throw var6.getException();
            }
        } else {
            //调用afterPropertiesSet()进行初始化
            ((InitializingBean)bean).afterPropertiesSet();
        }
    }
	
    //判断bean是否配置了init-method方法，如果判断为true，通过反射得到method对象，然后调用init-method，完成最后的初始化。
    if (mbd != null && bean.getClass() != NullBean.class) {
        String initMethodName = mbd.getInitMethodName();
        if (StringUtils.hasLength(initMethodName) && (!isInitializingBean || !"afterPropertiesSet".equals(initMethodName)) && !mbd.isExternallyManagedInitMethod(initMethodName)) {
            this.invokeCustomInitMethod(beanName, bean, mbd);
        }
    }

}

自定义这两种方法也很简单，如下：

//实现InitializingBean接口并重写afterPropertiesSet()方法
@Controller
public class MyController implements InitializingBean {
    @Autowired
    private MyService myService;

    public void testController(){
        return;
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("method 1");
    }
}

//配置了init-method方法
@Configuration
public class Config {

    @Bean(initMethod = "test")
    public MyService getMyService(MyService myService){
        return myService;
    }
}
@Service
public class MyService {
    public void test(){
        System.out.println("haha");
    }
}

到这里单例bean就初始化完了，结束。

3、补充：循环依赖

Spring解决循环依赖的流程如下图所示。

没有AOP的情况下：

Spring通过三级缓存解决循环依赖问题，假设A和B发生了循环依赖，在A的生命周期中，在A创建了实例之后，会生成一个A的对象工厂并将其放入三级缓存，在A进行属性注入时，发生A依赖了B，这时Spring会先去创建B，和A的流程一样，当B进行属性注入时发现依赖了A，这时Spring又会调用doGetBean()想去创建A，但是在创建A之前，会先调用getSingleton()方法从缓存中取，这时Spring从三级缓存中调用A的对象工厂来生成一个A的早期对象，然后把它放到二级缓存。将A注入B之后，B会走完剩下的生命周期，然后通过getSingleton()方法将B放入一级缓存。接下来，A会走完剩下的生命周期，并且会把A放入一级缓存。就这样，A和B就都初始化完了。

有AOP的情况下：

AOP动态代理的处理一般是发生在bean初始化之后的，也就是initializeBean()方法中的最后执行applyBeanPostProcessorsAfterInitialization()时生成代理对象，但是当出现循环依赖时，可以发现bean的AOP代理提前发生了。我觉得将AOP代理提前才是为什么需要第三级缓存的原因把。

还是看上面这个例子，当A经过实例化createInstance之后，会生成一个早期bean工厂放入三级缓存，代码是这样的，可以看到它传入了一个lambda表达时，当三级缓存中的早期bean工厂执行getObject()时会触发这个lambda表达式调用getEarlyBeanReference()，也就是当B需要注入A时，需要走到这一步。如果A被AOP代理了，这个这个方法会去调wrapIfNecessary()方法生成A的代理对象。如果没有三级缓存，那么就无法提前生成bean的代理对象，那么B中就会注入A的原始对象，但是当A经过初始化之后再去生成AOP代理对象，就会出现多个A，这不符合单例模式。

this.addSingletonFactory(beanName, () -> {
    return this.getEarlyBeanReference(beanName, mbd, bean);
});

文章来源:https://www.cnblogs.com/Linwei33/p/18409960
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系邮箱：jacktools123@163.com进行投诉反馈，一经查实，立即删除！