Spring启动流程源码解析

Yunson.

已于 2022-09-03 16:57:56 修改

阅读量977

点赞数 2

分类专栏： Spring的那点事文章标签： spring java 后端

于 2022-09-03 16:57:41 首次发布

本文链接：https://blog.csdn.net/weixin_51743274/article/details/126675555

版权

Spring的那点事专栏收录该内容

2 篇文章 0 订阅

订阅专栏

Spring的启动流程

流程

1.Spring会将所有交由spring管理,扫描其class文件,将其解析成BeanDefinition,在BeanDefinition中会描述类的信息,例如:这个类是否是单例的,Bean的类型,是否是懒加载的,依赖哪些类.

2.Spring容器在本文可以简单理解为DefaultListableBeanFactory,它是BeanFactory的实现类，这个类有几个非常重要的属性：beanDefinitionMap是一个map，用来存放bean所对应的BeanDefinition；beanDefinitionNames是一个List集合，用来存放所有bean的name；singletonObjects是一个Map，用来存放所有创建好的单例Bean。

3.Spring中有很多后置处理器，但最终可以分为两种，一种是BeanFactoryPostProcessor，一种是BeanPostProcessor。前者的用途是用来干预BeanFactory的创建过程，后者是用来干预Bean的创建过程。后置处理器的作用十分重要，bean的创建以及AOP的实现全部依赖后置处理器。

启动接口

    public AnnotationConfigApplicationContext(DefaultListableBeanFactory beanFactory) {
        super(beanFactory);
        this.reader = new AnnotatedBeanDefinitionReader(this);
        this.scanner = new ClassPathBeanDefinitionScanner(this);
    }

    public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
        // 会初始化一个BeanFactory,为默认的DefaultListableBeanFactory
        // 会初始化一个beanDefinition的读取器，同时向容器中注册了7个spring的后置处理器(包括BeanPostProcessor和BeanFactoryPostProcessor)
        // 会初始化一个扫描器，后面似乎并没有用到这个扫描器，在refresh()中使用的是重新new的一个扫描器。
        this(); // 会先调用父类GenricApplicationContext的初始化方法 初始化一个DefaultListBeanfactory 
        this.register(componentClasses);
        this.refresh();
    }

    //在初始化reader时 加载7个类到beandefinitionMap中 包括一些后置处理器等
    public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(BeanDefinitionRegistry registry, @Nullable Object source) {
        DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
        Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet(8);
        RootBeanDefinition def;

        // 注册ConfigurationClassPostProcessor,这个类超级重要，它完成了对加了Configuration注解类的解析，@ComponentScan、@Import的解析。
        if (!registry.containsBeanDefinition("org.springframework.context.annotation.internalConfigurationAnnotationProcessor")) {
            def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, "org.springframework.context.annotation.internalConfigurationAnnotationProcessor"));
        }
        // 注册AutowiredAnnotationBeanPostProcessor,这个bean的后置处理器用来处理@Autowired的注入
        if (!registry.containsBeanDefinition("org.springframework.context.annotation.internalAutowiredAnnotationProcessor")) {
            def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, "org.springframework.context.annotation.internalAutowiredAnnotationProcessor"));
        }
        // 注册CommonAnnotationBeanPostProcessor，用来处理如@Resource，@PostConstruct等符合JSR-250规范的注解
        if (jsr250Present && !registry.containsBeanDefinition("org.springframework.context.annotation.internalCommonAnnotationProcessor")) {
            def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, "org.springframework.context.annotation.internalCommonAnnotationProcessor"));
        }
        // 注册PersistenceAnnotationBeanPostProcessor，来用支持JPA
        if (jpaPresent && !registry.containsBeanDefinition("org.springframework.context.annotation.internalPersistenceAnnotationProcessor")) {
            def = new RootBeanDefinition();

            try {
                def.setBeanClass(ClassUtils.forName("org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor", AnnotationConfigUtils.class.getClassLoader()));
            } catch (ClassNotFoundException var6) {
                throw new IllegalStateException("Cannot load optional framework class: org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor", var6);
            }

            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, "org.springframework.context.annotation.internalPersistenceAnnotationProcessor"));
        }
        // 注册EventListenerMethodProcessor，用来处理方法上加了@EventListener注解的方法
        if (!registry.containsBeanDefinition("org.springframework.context.event.internalEventListenerProcessor")) {
            def = new RootBeanDefinition(EventListenerMethodProcessor.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, "org.springframework.context.event.internalEventListenerProcessor"));
        }
        // 注册DefaultEventListenerFactory，暂时不知道干啥用的，从类名来看，是一个事件监听器的工厂
        if (!registry.containsBeanDefinition("org.springframework.context.event.internalEventListenerFactory")) {
            def = new RootBeanDefinition(DefaultEventListenerFactory.class);
            def.setSource(source);
            beanDefs.add(registerPostProcessor(registry, def, "org.springframework.context.event.internalEventListenerFactory"));
        }
        return beanDefs;
    }

refresh方法

    public void refresh() throws BeansException, IllegalStateException {
        // 只有一个线程能加载bean 保证单例
        synchronized(this.startupShutdownMonitor) {
            // 初始化属性配置文件、检验必须属性以及监听器
            this.prepareRefresh();
            // 给beanfactory设置序列化id
            ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
            // 向beanFactory中注册了两个BeanPostProcessor,以及三个和环境相关的bean
            // 这两个后置处理器为ApplicationContextAwareProcessor和ApplicationListenerDetector
            // 前一个后置处理是为实现了ApplicationContextAware接口的类，回调setApplicationContext()方法，
            // 后一个处理器时用来检测ApplicationListener类的，当某个Bean实现了ApplicationListener接口的bean被创建好后，会被加入到监听器列表中
            this.prepareBeanFactory(beanFactory);

            try {
            	//这个交给子类实现 本身不实现
                this.postProcessBeanFactory(beanFactory);
                // 执行所有的BeanFactoryPostProcessor，包括自定义的，以及spring内置的。默认情况下，容器中只有一个BeanFactoryPostProcessor,即：Spring内置的，ConfigurationClassPostProcessor(这个类很重要)
	            // 会先执行实现了BeanDefinitionRegistryPostProcessor接口的类，然后执行BeanFactoryPostProcessor的类
	            // ConfigurationClassPostProcessor类的postProcessorBeanFactory()方法进行了@Configuration类的解析，@ComponentScan的扫描，以及@Import注解的处理
	            // 经过这一步以后,会将所有交由spring管理的bean所对应的BeanDefinition放入到beanFactory的beanDefinitionMap中
	            // 同时ConfigurationClassPostProcessor类的postProcessorBeanFactory()方法执行完后，向容器中添加了一个后置处理器————ImportAwareBeanPostProcessor
                this.invokeBeanFactoryPostProcessors(beanFactory);
                // 注册所有的BeanPostProcessor，因为在方法里面调用了getBean()方法，所以在这一步，实际上已经将所有的BeanPostProcessor实例化了
            	// 为什么要在这一步就将BeanPostProcessor实例化呢？因为后面要实例化bean，而BeanPostProcessor是用来干预bean的创建过程的，所以必须在bean实例化之前就实例化所有的BeanPostProcessor(包括开发人员自己定义的)
            	// 最后再重新注册了ApplicationListenerDetector，这样做的目的是为了将ApplicationListenerDetector放入到后置处理器的最末端
                this.registerBeanPostProcessors(beanFactory);
                this.initMessageSource();
                this.initApplicationEventMulticaster();
                this.onRefresh();
                this.registerListeners();
                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();
            }

        }
    }

1.1 refresh方法中的invokeBeanFactoryPostProcessors(beanFactory)

对于invokeBeanFactoryPostProcessors(beanFactory)会干两件事情
1.首先将BeanFactoryPostProcess注册到beanFactory中，按照PriorityOrdered -> Ordered将具体的BeanFactoryPostProcess注册

			//截取部分代码
			currentRegistryProcessors = new ArrayList();
            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)) {
                    currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                    processedBeans.add(ppName);
                }
            }

            sortPostProcessors(currentRegistryProcessors, beanFactory);
            registryProcessors.addAll(currentRegistryProcessors);
            // 实现注册的函数
            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
            currentRegistryProcessors.clear();
            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            var16 = postProcessorNames;
            var9 = postProcessorNames.length;

            for(var10 = 0; var10 < var9; ++var10) {
                ppName = var16[var10];
                if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
                    currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                    processedBeans.add(ppName);
                }
            }

            sortPostProcessors(currentRegistryProcessors, beanFactory);
            registryProcessors.addAll(currentRegistryProcessors);
            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
            currentRegistryProcessors.clear();
            boolean reiterate = true;

2.仍然按照PriorityOrdered -> Ordered -> other的顺序,调用postProcessor.postProcessBeanFactory，因为默认的容器中存在ConfigurationClassPostProcessor(这是reader初始化时注入的)，我们以ConfigurationClassPostProcessor为例子查看源码。

    private static void invokeBeanFactoryPostProcessors(Collection<? extends BeanFactoryPostProcessor> postProcessors, ConfigurableListableBeanFactory beanFactory) {
        Iterator var2 = postProcessors.iterator();

        while(var2.hasNext()) {
        	//遍历PostProcessor调用 postProcessBeanFactory方法
            BeanFactoryPostProcessor postProcessor = (BeanFactoryPostProcessor)var2.next();
            postProcessor.postProcessBeanFactory(beanFactory);
        }
    }

	//以ConfigurationClassPostProcessor为例子
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    	//首先判断是否处理过，只能处理一次
        int factoryId = System.identityHashCode(beanFactory);
        if (this.factoriesPostProcessed.contains(factoryId)) {
            throw new IllegalStateException("postProcessBeanFactory already called on this post-processor against " + beanFactory);
        } else {
            this.factoriesPostProcessed.add(factoryId);
            //进行了@Configuration类的解析，@ComponentScan的扫描，以及@Import注解的处理
            if (!this.registriesPostProcessed.contains(factoryId)) {
                this.processConfigBeanDefinitions((BeanDefinitionRegistry)beanFactory);
            }
			
            this.enhanceConfigurationClasses(beanFactory);
            beanFactory.addBeanPostProcessor(new ConfigurationClassPostProcessor.ImportAwareBeanPostProcessor(beanFactory));
        }
    }

1.2 refresh中的registerBeanPostProcessors(beanFactory);

该方法的作用时找到所有的BeanPostProcessors，然后将这些BeanPostProcessors按照 priorityOrdered -> ordered -> nonOrdered -> internal的顺序进行注册到BeanFactory中。

如何找到所有的BeanPostProcessors，上面所说invokeBeanFactoryPostProcessor()中的ConfigurationClassPostProcessor会把所有的bean信息转化为BeanDefinition存在于ioc容器中

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

public static void registerBeanPostProcessors(
         ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
 
     // 从BeanDefinitionMap中找出所有的BeanPostProcessor
     String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
     //省略部分代码
 
     for (String ppName : postProcessorNames) {
        if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            // 此处调用了getBean()方法，因此在此处就会实例化出BeanPostProcessor
            BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
            priorityOrderedPostProcessors.add(pp);
            if (pp instanceof MergedBeanDefinitionPostProcessor) {
                internalPostProcessors.add(pp);
            }
        }
        else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
            orderedPostProcessorNames.add(ppName);
        }
        else {
            nonOrderedPostProcessorNames.add(ppName);
        }
    }

   // First, register the BeanPostProcessors that implement PriorityOrdered.
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    // 将实现了PriorityOrdered接口的BeanPostProcessor添加到BeanFactory的beanPostProcessors集合中
    registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

    // 下面这部分代码与上面的代码逻辑一致，是将实现了Ordered接口以及普通的BeanPostProcessor实例化以及添加到beanPostProcessors结合中，逻辑与处理PriorityOrdered的后置处理器一样
    List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
    for (String ppName : orderedPostProcessorNames) {
       BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
        orderedPostProcessors.add(pp);
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
            internalPostProcessors.add(pp);
        }
    }
    sortPostProcessors(orderedPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, orderedPostProcessors);

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

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

    // Re-register post-processor for detecting inner beans as ApplicationListeners,
    // moving it to the end of the processor chain (for picking up proxies etc).
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));

    // 最后将ApplicationListenerDetector这个后置处理器一样重新放入到beanPostProcessor中，这样做的目的是为了将其放入到后置处理器的最末端
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

1.3 refresh中的initMessageSource()

用来支持消息国际化，目前很少使用

1.4 refresh中的initApplicationEventMulticaster()

该方法初始化了一个事件传播器

    protected void initApplicationEventMulticaster() {
        ConfigurableListableBeanFactory beanFactory = this.getBeanFactory();
        if (beanFactory.containsLocalBean("applicationEventMulticaster")) {
            this.applicationEventMulticaster = (ApplicationEventMulticaster)beanFactory.getBean("applicationEventMulticaster", ApplicationEventMulticaster.class);
            if (this.logger.isTraceEnabled()) {
                this.logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
            }
        } 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() + "]");
            }
        }
    }

1.5 refresh中的onRefresh()

方法实现为空应该是Spring与其他框架整合时，需要初始化一些其他bean用的。

1.6 refresh中的registerListeners()

将自定义配置的listener的bean名称放入到事件广播器中,同时还会将早期的ApplicationEvent发布

    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);
            }
        }
    }

1.7 refresh中的finishBeanFactoryInitialization()

该方法十分重要，它完成了所有非懒加载的单例Bean的实例化和初始化，属性的填充以及解决了循环依赖等问题。

    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();
        // 实例化剩下所有的非懒加载的单例
        beanFactory.preInstantiateSingletons();
    }

1.7.1 refresh中的finishBeanFactoryInitialization()下的preInstantiateSingletons()方法

 public void preInstantiateSingletons() throws BeansException {

        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 {
                                if (!var2.hasNext()) {
                                    var2 = beanNames.iterator();
                                    while(var2.hasNext()) {
                                        beanName = (String)var2.next();
                                        Object singletonInstance = this.getSingleton(beanName);
                                        if (singletonInstance instanceof SmartInitializingSingleton) {
                                            SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton)singletonInstance;
                                            if (System.getSecurityManager() != null) {
                                                AccessController.doPrivileged(() -> {
                                                    smartSingleton.afterSingletonsInstantiated();
                                                    return null;
                                                }, this.getAccessControlContext());
                                            } else {
                                                smartSingleton.afterSingletonsInstantiated();
                                            }
                                        }
                                    }
                                    return;
                                }

                                beanName = (String)var2.next();
                                bd = this.getMergedLocalBeanDefinition(beanName);
                            } while(bd.isAbstract());
                        } while(!bd.isSingleton());
                    } while(bd.isLazyInit());

                    if (this.isFactoryBean(beanName)) {
                        bean = this.getBean("&" + beanName);
                        break;
                    }

                    this.getBean(beanName);
                }
            } while(!(bean instanceof FactoryBean));

			//如果时FactoryBean 就判断是否立刻加载 isEagerInit的话就立刻实例化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);
            }
        }
    }

1.7.1 refresh中的finishBeanFactoryInitialization()下的preInstantiateSingletons()方法下的getBean(beanName)

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

doGetBean

    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) {
        //省略日志信息
            bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);
        } 
        //缓存中拿不到就要去创建
        else {
        	// 判断是否正在创建
            if (this.isPrototypeCurrentlyInCreation(beanName)) {
                throw new BeanCurrentlyInCreationException(beanName);
            }
			// 交给父类的beanFactory进行创建？
            BeanFactory parentBeanFactory = this.getParentBeanFactory();
            if (parentBeanFactory != null && !this.containsBeanDefinition(beanName)) {
                String nameToLookup = this.originalBeanName(name);
                if (parentBeanFactory instanceof AbstractBeanFactory) {
                    return ((AbstractBeanFactory)parentBeanFactory).doGetBean(nameToLookup, requiredType, args, typeCheckOnly);
                }

                if (args != null) {
                    return parentBeanFactory.getBean(nameToLookup, args);
                }

                if (requiredType != null) {
                    return parentBeanFactory.getBean(nameToLookup, requiredType);
                }

                return parentBeanFactory.getBean(nameToLookup);
            }

            if (!typeCheckOnly) {
                this.markBeanAsCreated(beanName);
            }
			
			// 拿到Bean的元信息
            try {
                RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
                this.checkMergedBeanDefinition(mbd, beanName, args);
                // 解决依赖
                String[] dependsOn = mbd.getDependsOn();
                String[] var11;
                if (dependsOn != null) {
                    var11 = dependsOn;
                    int var12 = dependsOn.length;

                    for(int var13 = 0; var13 < var12; ++var13) {
                        String dep = var11[var13];
                        if (this.isDependent(beanName, dep)) {
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                        }
						// 注册当前beanName的依赖表
                        this.registerDependentBean(dep, beanName);
						// 创建依赖bean
                        try {
                            this.getBean(dep);
                        } catch (NoSuchBeanDefinitionException var24) {
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", var24);
                        }
                    }
                }
				// 真正创建bean的方法
                if (mbd.isSingleton()) {
                    sharedInstance = this.getSingleton(beanName, () -> {
                        try {
                            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()) {
                    var11 = null;

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

                    bean = 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;
                        });
                        bean = this.getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                    } catch (IllegalStateException var23) {
                        throw new BeanCreationException(beanName, "Scope '" + scopeName + "' is not active for the current thread; consider defining a scoped proxy for this bean if you intend to refer to it from a singleton", var23);
                    }
                }
            } catch (BeansException var26) {
                this.cleanupAfterBeanCreationFailure(beanName);
                throw var26;
            }
        }

        if (requiredType != null && !requiredType.isInstance(bean)) {
            try {
                T convertedBean = this.getTypeConverter().convertIfNecessary(bean, requiredType);
                if (convertedBean == null) {
                    throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
                } else {
                    return convertedBean;
                }
            } catch (TypeMismatchException var25) {
                if (this.logger.isTraceEnabled()) {
                    this.logger.trace("Failed to convert bean '" + name + "' to required type '" + ClassUtils.getQualifiedName(requiredType) + "'", var25);
                }

                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
            }
        } else {
            return bean;
        }
    }

getObjectForBeanInstance()方法的作用是为了根据beanName来判断是返回FactoryBean原生对象还是getObject()方法所返回的对象.若beanName以&符号开头，则表示返回FactoryBean原生对象，否则返回getObject()方法所返回的对象。

1protected Object getObjectForBeanInstance(
 2        Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
 3    if (BeanFactoryUtils.isFactoryDereference(name)) {
 4        if (beanInstance instanceof NullBean) {
 5            return beanInstance;
 6        }
 7        if (!(beanInstance instanceof FactoryBean)) {
 8            throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
 9        }
10    }
11
12    // 如果不是一个FactoryBean对象或者是获取FactoryBean的原生对象(原生对象指的是beanName是以&开头)
13    // 此时可以直接返回bean
14    if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
15        return beanInstance;
16    }
17
18    // 如果是获取FactoryBean的getObject()方法返回的类型对象，则需要进入到如下逻辑
19    // 对于getObject()方法，它返回的对象是在在第一次调用getObject方法时进行实例化的，实例化完成以后，会将结果缓存在factoryBeanObjectCache中
20    Object object = null;
21    if (mbd == null) {
22        object = getCachedObjectForFactoryBean(beanName);
23    }
24    if (object == null) {
25        // Return bean instance from factory.
26        FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
27        // Caches object obtained from FactoryBean if it is a singleton.
28        if (mbd == null && containsBeanDefinition(beanName)) {
29            mbd = getMergedLocalBeanDefinition(beanName);
30        }
31        boolean synthetic = (mbd != null && mbd.isSynthetic());
32        // 获取FactoryBean返回的对象
33        object = getObjectFromFactoryBean(factory, beanName, !synthetic);
34    }
35    return object;
36}

1.7.1 refresh中的finishBeanFactoryInitialization()下的preInstantiateSingletons()方法下的createBean()

 1protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
 2        throws BeanCreationException {
 3    RootBeanDefinition mbdToUse = mbd;
 4    // Make sure bean class is actually resolved at this point, and
 5    // clone the bean definition in case of a dynamically resolved Class
 6    // which cannot be stored in the shared merged bean definition.
 7    Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
 8    if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
 9        mbdToUse = new RootBeanDefinition(mbd);
10        mbdToUse.setBeanClass(resolvedClass);
11    }
12    // Prepare method overrides.
13    try {
14        mbdToUse.prepareMethodOverrides();
15    }
16    catch (BeanDefinitionValidationException ex) {
17        throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
18                beanName, "Validation of method overrides failed", ex);
19    }
20    try {
21        // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
22        // 第一次调用后置处理器(执行所有InstantiationAwareBeanPostProcessor的子类)
23        // 如果InstantiationAwareBeanPostProcessor的子类的postProcessBeforeInstantiation()方法返回值不为空，表示bean需要被增强，
24        // 此时将不会执行后面的逻辑，AOP的实际应用就是在这儿实现的
25        Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
26        if (bean != null) {
27            return bean;
28        }
29    }
30    catch (Throwable ex) {
31        throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
32                "BeanPostProcessor before instantiation of bean failed", ex);
33    }
34
35    try {
36        // 第二次执行后置处理器的入口
37        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
38        if (logger.isDebugEnabled()) {
39            logger.debug("Finished creating instance of bean '" + beanName + "'");
40        }
41        return beanInstance;
42    }
43    catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
44        throw ex;
45    }
46    catch (Throwable ex) {
47        throw new BeanCreationException(
48                mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
49    }
50}

doCreateBean()方法的代码(删减了部分代码)如下:

1protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
 2        throws BeanCreationException {
 3    // Instantiate the bean.
 4    BeanWrapper instanceWrapper = null;
 5    if (mbd.isSingleton()) {
 6        instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
 7    }
 8    if (instanceWrapper == null) {
 9        // 实例化bean(第二次执行后置处理器的入口),第二次执行后置处理器，主要是为了推断出实例化Bean所需要的构造器
10        instanceWrapper = createBeanInstance(beanName, mbd, args);
11    }
12    final Object bean = instanceWrapper.getWrappedInstance();
13    Class<?> beanType = instanceWrapper.getWrappedClass();
14    if (beanType != NullBean.class) {
15        mbd.resolvedTargetType = beanType;
16    }
17    // 此时bean对象已经创建成功，但是没有设置属性和经过其他后置处理器处理
18    // Allow post-processors to modify the merged bean definition.
19    synchronized (mbd.postProcessingLock) {
20        if (!mbd.postProcessed) {
21            try {
22                // 第三次执行后置处理器，缓存bean的注解元数据信息(用于后面在进行属性填充时使用)
23                // 这一步对于CommonAnnotationBeanPostProcessor、AutowiredAnnotationBeanPostProcessor、RequiredAnnotationBeanPostProcessor这一类处理器
24                // 主要是将bean的注解信息解析出来，然后缓存到后置处理器中的injectionMetadataCache属性中
25                // 而对于ApplicationListenerDetector处理器，而是将bean是否是单例的标识存于singletonNames这个Map类型的属性中
26                applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
27            }
28            mbd.postProcessed = true;
29        }
30    }
31    // 判断一个bean是否放入到singletonFactories中(提前暴露出来，可以解决循环依赖的问题)
32    boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
33            isSingletonCurrentlyInCreation(beanName));
34    if (earlySingletonExposure) {
35        // 第四次出现后置处理器
36        // 获取提前暴露的对象，可以解决循环引用的问题，实际上提前暴露出来的bean是放入到了singletonFactories中，key是beanName,value是一个lambda表达式
37        addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
38    }
39    // Initialize the bean instance.
40    Object exposedObject = bean;
41    try {
42        // 填充属性，第五次、第六次后置处理器入口
43        populateBean(beanName, mbd, instanceWrapper);
44        // 第七次、第八次执行后置处理器入口
45        exposedObject = initializeBean(beanName, exposedObject, mbd);
46    }
47    catch (Throwable ex) {
48    }
49    return exposedObject;
50}

createBeanInstance()会通过反射创建对象时，会先执行后置处理器，通过调用后置处理器的deternineCondidateConstructors()方法来推断出使用哪一个构造器来创建Bean，典型的代表类有AutowiredAnnotationBeanPostProcessor。
bean被通过反射创建完成后，会再次调用后置处理器MergedBeanDefinitionPostProcessor.postProcessMargedBeanDefinition()方法，这一步执行后置处理器的目的是为了找出加了@Autowired、@Resource等注解的属性和方法，然后将这些注解信息缓存到injectionMetadataCache属性中，便于后面在bean初始化阶段(属性赋值阶段)，根据@Autowired等注解实现自动装配。这一步的代表后置处理器有AutowiredAnnotationBeanPostProcessor、CommonAnnotationBeanPostProcessor
接下来会将半成品的bean(因为此时还未给bean的属性赋值，未完成自动装配，因此称之为半成品)放入到DefaultSingletonBeanRegistry类的singletonFactories的属性中，singletonFactories属性是一个Map，key为beanName,值为ObjectFactory类型(实际上就是一个lambda表达式)，当调用ObjectFactory的getObject()方法时，会执行lambda表达式的方法体，在当前场景下，lambda表达式的代码如下，实际上就是执行了一次Bean的后置处理器。这一步的目的是为了解决bean之间的循环依赖，究竟是如何解决循环依赖的。

 1protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
 2    Object exposedObject = bean;
 3    if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
 4        for (BeanPostProcessor bp : getBeanPostProcessors()) {
 5            if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
 6                SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
 7                // 调用后置处理的方法获取bean早期暴露出来的bean对象(半成品)
 8                exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
 9            }
10        }
11    }
12    return exposedObject;
13}

然后会执行到populateBean()方法，在该方法中又会执行两次Bean后置处理器，第一次执行后置处理器是为了判断Bean是否需要继续填充属性，如果InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation()方法返回的false，则表示不进行属性填充，bean就不会进行@Autowired等自动装配过程，populateBean()方法会直接结束。若返回true，则会进行接下来的属性填充，即会执行第二次后置处理器，InstantiationAwareBeanPostProcessor.postProcessPropertyValue()方法，这一步的主角就是AutowiredAnnotationBeanPostProcessor和CommonAnnotationBeanPostBeanPostProcessor了，它们会根据前面缓存在injectionMetadataCache中的注解信息来进行自动装配。

1.7 refresh中的finishRefresh()

执行到这一步，Spring容器的启动基本结束了，此时Bean已经被实例化完成，且完成了自动装配。执行finishRefresh()方法，是为了在容器refresh()结束时，做一些其他的操作，例如：发布ContextRefreshedEvent事件，这样当我们想在容器refresh完成后执行一些特殊的逻辑，就可以通过监听ContextRefreshedEvent事件来实现。Spring内置了四个和应用上下文(ApplicationContextEvent)有关的事件：ContextRefreshedEvent、ContextStartedEvent、ContextStopedEvent、ContextClosedEvent。

1protected void finishRefresh() {
2    clearResourceCaches();
3    initLifecycleProcessor();
4    getLifecycleProcessor().onRefresh();
5    // 发布ContextRefreshedEvent
6    publishEvent(new ContextRefreshedEvent(this));
7    LiveBeansView.registerApplicationContext(this˛);
8}

1.8 refresh中的resetCommonCaches()

请求单例bean的元数据信息

1protected void resetCommonCaches() {
2    ReflectionUtils.clearCache();
3    AnnotationUtils.clearCache();
4    ResolvableType.clearCache();
5    CachedIntrospectionResults.clearClassLoader(getClassLoader());
6}

1.9 Bean生命周期

经过多重的BeanPostProcessed后置处理器在Bean的生命周期中
容器启动 -> 通过BeanFactoryPostProcessor后置处理器将class解析成BeanDefinition(其实是reader初始化引入的ConfigurationClassPostProcessor) -> 通过调用getBean()，开始创建Bean -> 实例化前进行后置处理器 InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()处理依赖 -> 实例化SmartInstantiationAwareBeanPostProcessor.determineCandidateConstructor()推断出构造器，进行反射实例化 -> 通过后置处理器，缓存bean的注解等信息，便于后面自动装配MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition() -> 判断是否填充属性 -> 填充属性 -> 初始化前的后置处理 -> 初始化bean ，初始化方法的接口回调 -> bean初始化后的后置处理器 -> 正常使用 -> 销毁

Yunson.

关注

2
点赞
踩
3

收藏

觉得还不错? 一键收藏
打赏
0
评论
Spring启动流程源码解析

1.Spring会将所有交由spring管理,扫描其class文件,将其解析成BeanDefinition,在BeanDefinition中会描述类的信息,例如:这个类是否是单例的,Bean的类型,是否是懒加载的,依赖哪些类.2.Spring容器在本文可以简单理解为DefaultListableBeanFactory,它是BeanFactory的实现类，这个类有几个非常重要的属性：beanDefinitionMap是一个map，用来存放bean所对应的BeanDefinition；beanDefinitio
复制链接

扫一扫