Spring Bean实例化原理

亦凉 2023-06-06 10:53 27阅读 0赞

**以AnnotationConfigApplicationContext为例,AnnotationConfigApplicationContext的构造方法做了三件事：**

public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) { 
    		//调用父类构造方法初始化读取器和扫描器
            this();
            //注册构造方法中传入的注解类到context中
            this.register(annotatedClasses);
            //构造spring bean并交由ioc容器管理
            this.refresh();
        }

**1.this方法：**  
除了初始化Context并初始化读取器和扫描器，spring还注册了五个BeanFactoryPostProcessor用于处理不同类型的Bean（如2.图）  
**2.register方法：**

public void register(Class<?>... annotatedClasses) { 
            Assert.notEmpty(annotatedClasses, "At least one annotated class must be specified");
            //调用读取器的register方法注册注解类
            this.reader.register(annotatedClasses);
        }

读取器的register方法调用了registerBean空方法，这个空方法又调用了doRegisterBean方法，主要看这个方法：

<T> void doRegisterBean(Class<T> annotatedClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name, @Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) { 
       		//将注解类封装成BeanDefinition
            AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
            if (!this.conditionEvaluator.shouldSkip(abd.getMetadata())) { 
                abd.setInstanceSupplier(instanceSupplier);
                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));
                        }
                    }
                }
    
                BeanDefinitionCustomizer[] var13 = definitionCustomizers;
                var10 = definitionCustomizers.length;
    
                for(var11 = 0; var11 < var10; ++var11) { 
                    BeanDefinitionCustomizer customizer = var13[var11];
                    customizer.customize(abd);
                }
    
                BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
                definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
                //注册到context中
                BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
            }
        }

这个方法主要是封装注解类，并进行BeanDefinition的初始化，然后注册进context中![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjU0NDg0_size_16_color_FFFFFF_t_70][]  
**3.下面分析refresh方法**

public void refresh() throws BeansException, IllegalStateException { 
            synchronized(this.startupShutdownMonitor) { 
            	//初始化Bean之前的准备，比如：设置容器启动时间，设置容器使用状态等
                this.prepareRefresh();
                //刷新并获取当前BeanFactory
                ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
                //根据配置初始化BeanFactory
                this.prepareBeanFactory(beanFactory);
    			
                try { 
                    this.postProcessBeanFactory(beanFactory);
    			     //创建BeanFactoryProcessor组件并调用回调方法
    			     //创建BeanFactoryProcessorBeanDefinitionRegistryPostProcessor组件并调用回调方法 
    			    this.invokeBeanFactoryPostProcessors(beanFactory);
                    this.registerBeanPostProcessors(beanFactory);
                    this.initMessageSource();
                    this.initApplicationEventMulticaster();
                    this.onRefresh();
                    this.registerListeners();
    				//创建Bean对象并调用后置处理器的回调方法
    				//调用init，destory后置方法 
                    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();
                }
    
            }
        }

主要分析invokeBeanFactoryPostProcessors和finishBeanFactoryInitialization这两个方法：

*  invokeBeanFactoryPostProcessors是PostProcessorRegistrationDelegate的静态方法，该方法的作用是：通过PriorityOrdered和Ordered类判断BeanFactoryProcessor执行的先后顺序，然后进行通过getBean创建,最后进行排序，注册，执行。
 *  finishBeanFactoryInitialization这个方法负责创建Bean对象并调用后置处理器的回调方法，主要也是通过getBean方法进行创建并调用回调方法。

那么getBean到底做了什么呢？来看看getBean：

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 { 
        	//转化BeanName，将beanName转化为别名
            String beanName = this.transformedBeanName(name);
            //判断单例池中是否有该bean，如果有就将单例池中的bean设置为当前bean
            Object sharedInstance = this.getSingleton(beanName);
            Object bean;
            if (sharedInstance != null && args == null) { 
                if (this.logger.isTraceEnabled()) { 
                    if (this.isSingletonCurrentlyInCreation(beanName)) { 
                        this.logger.trace("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference");
                    } else { 
                        this.logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
                    }
                }
    
                bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);
            } else { 
            	//检查是否处于原型模式下的依赖
                if (this.isPrototypeCurrentlyInCreation(beanName)) { 
                    throw new BeanCurrentlyInCreationException(beanName);
                }
    
                BeanFactory parentBeanFactory = this.getParentBeanFactory();
                //如果BeanDefinition中没有这个bean，就尝试从parentBeanFactory中加载
                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);
                }
    			//从MergedLocalBeanDefinition中获取对应BeanName的RootBeanDefinintion，如果这个BeanDefinintion是子类，则合并其父类的属性
                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];
                            //检查依赖是否已注册给当前Bean
                            if (this.isDependent(beanName, dep)) { 
                                throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                            }
    						//注册到依赖Bean中
                            this.registerDependentBean(dep, beanName);
    
                            try { 
                            	//初始化依赖Bean
                                this.getBean(dep);
                            } catch (NoSuchBeanDefinitionException var24) { 
                                throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", var24);
                            }
                        }
                    }
    				
                    if (mbd.isSingleton()) { 、
                   		//实例化Bean
                        sharedInstance = this.getSingleton(beanName, () -> { 
                            try {                             return this.createBean(beanName, mbd, args);
                            } catch (BeansException var5) { 
                                this.destroySingleton(beanName);
                                throw var5;
                            }
                        });
                    //省略

getSingleton再次检查单例池中是否有该Bean，然后调用栈如下createBean()–>doCreateBean()–>createInstance()–>instantiateBean()–>instantiate()–>instantiate()，最后来看instantiate方法：

public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) { 
            if (!bd.hasMethodOverrides()) { 
                Constructor constructorToUse;
                synchronized(bd.constructorArgumentLock) { 
                    constructorToUse = (Constructor)bd.resolvedConstructorOrFactoryMethod;
                    if (constructorToUse == null) { 
                    	//反射获取Class对象
                        Class<?> clazz = bd.getBeanClass();
                        if (clazz.isInterface()) { 
                            throw new BeanInstantiationException(clazz, "Specified class is an interface");
                        }
    
                        try { 
                            if (System.getSecurityManager() != null) { 
                                clazz.getClass();
                                constructorToUse = (Constructor)AccessController.doPrivileged(() -> { 
                                    return clazz.getDeclaredConstructor();
                                });
                            } else { 
                            	//获取构造函数
                                constructorToUse = clazz.getDeclaredConstructor();
                            }
    
                            bd.resolvedConstructorOrFactoryMethod = constructorToUse;
                        } catch (Throwable var9) { 
                            throw new BeanInstantiationException(clazz, "No default constructor found", var9);
                        }
                    }
                }
    			//使用BeanUtils的instantiateClass方法实例化Bean
                return BeanUtils.instantiateClass(constructorToUse, new Object[0]);
            } else { 
                return this.instantiateWithMethodInjection(bd, beanName, owner);
            }
        }

到这里实例化一个Spring Bean的底层原理已经清晰了，但是Spring Bean的生命周期还没有结束，Spring Bean的生命周期后面再分析

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNjU0NDg0_size_16_color_FFFFFF_t_70]: /images/20230601/32e2d1a694614e1a9d52e92923214bab.png