之前的博客专门分析了一个类到BeanDefinition的创建过程,现在分析BeanDefinition 到一个bean的创建过程:从refresh() 方法的---->finishBeanFactoryInitialization(beanFactory) 开始:
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) { // 像容器中设置一个类型转换器 if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) && beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) { beanFactory.setConversionService( beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)); } //设置一个占位符解析器 if (!beanFactory.hasEmbeddedValueResolver()) { beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal)); } // loadTimeWeaver是用于类加载阶段做切入使用的 String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false); for (String weaverAwareName : weaverAwareNames) { getBean(weaverAwareName); } // Stop using the temporary ClassLoader for type matching. beanFactory.setTempClassLoader(null); // 冻结beanDefinition信息,也就是下面要开始创建对象了,所以不允许再改变了 beanFactory.freezeConfiguration(); // Instantiate all remaining (non-lazy-init) singletons. //开始实例化所有的单例bean beanFactory.preInstantiateSingletons(); }
小结:该方法主要是在单例bean开始初始化前,对beanFactory设置一些初始化信息,最重要的还是: beanFactory.preInstantiateSingletons();
public void preInstantiateSingletons() throws BeansException { List<String> beanNames = new ArrayList<>(this.beanDefinitionNames); //获取所有的beanNams 然后遍历每个beanName,获取其BeanDefintion,然后一个个的创建实例 // Trigger initialization of all non-lazy singleton beans... for (String beanName : beanNames) { RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName); //这里为何是获取MergeBeanDefinition呢,原因是在xml时代,一个bean 可以通过继承一个抽象的bean,来获得初始化的属性 if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) { //在这里的beanDefinition必须不是抽象的,并且是单例,非懒加载的 if (isFactoryBean(beanName)) { //如果是FactoryBean,通过get(BeanName)方式获取的是里面的getObject()返回的对象,如果是get("&beanName")的方式,就是获取到FactoryBean本身 Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);//get("&beanName")方式,获取到FactoryBean本身 if (bean instanceof FactoryBean) { final FactoryBean<?> factory = (FactoryBean<?>) bean; boolean isEagerInit; if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) { isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit, getAccessControlContext()); } else { isEagerInit = (factory instanceof SmartFactoryBean && ((SmartFactoryBean<?>) factory).isEagerInit()); } if (isEagerInit) { //这里的意思是,是否要那么早初始化FactoryBean里面的getObject()对象,默认是用到时才会初始化 getBean(beanName);//这里调用的是FactoryBean里面的getObject() } } } else { getBean(beanName);//非factoryBean就开始创建对象,factoryBean 也是调用该方法创建对象,只是beanName不一样getBean(FACTORY_BEAN_PREFIX + beanName) } } } // Trigger post-initialization callback for all applicable beans... for (String beanName : beanNames) { //至此,所有的实例对象都创建完毕,对于实现SmartInitializingSingleton的bean,在这里会统一调用afterSingletonsInstantiated() Object singletonInstance = getSingleton(beanName); if (singletonInstance instanceof SmartInitializingSingleton) { final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance; if (System.getSecurityManager() != null) { AccessController.doPrivileged((PrivilegedAction<Object>) () -> { smartSingleton.afterSingletonsInstantiated(); return null; }, getAccessControlContext()); } else { smartSingleton.afterSingletonsInstantiated(); } } } }
小结:上面方法主要逻辑是:遍历所有的bean的定义信息,然后分别创建实例,这里区分了FactoryBean和普通Bean的创建过程,所有Bean都创建完毕后,会对实现SmartInitializingSingleton接口的bean,调用afterSingletonsInstantiated()
//接下来我们分析下单个bean的创建过程:getBean(beanName)
//下面参数的意思: name或者requiredType的意思是通过名称还是通过类型获取对象,args的意思是,如果是通过有参构造器去创建的bean,需要该实参,typeCheckOnly的意思是,我只是想获取返回的类型而不是对象,例如我想知道某个beanName的类型
//一般typeCheck是用于FactoryBean校验里面的getObject()返回的类型
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType, @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException { final String beanName = transformedBeanName(name);//这里的意思的,在xml时代,一个bean可以拥有多个别名,如果你是通过别名来创建对象的话,这里就会转成对应的BeanName,因为BeanName才是唯一的 Object bean; // Eagerly check singleton cache for manually registered singletons. Object sharedInstance = getSingleton(beanName);//校验实例对象是否已经存在了 if (sharedInstance != null && args == null) { if (logger.isTraceEnabled()) { if (isSingletonCurrentlyInCreation(beanName)) {//判断singletonsCurrentlyInCreation集合有没有该bean,有就代表正在创建中 logger.trace("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference"); } else { logger.trace("Returning cached instance of singleton bean '" + beanName + "'"); } } bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);//这里的意思是:既然bean已经创建了,如果是FactoryBean,那么这里就要返回FactoryBean里面的Object对象,其他的Bean直接返回 } else { //该方法只有非单例才会出现,这里是判断prototypesCurrentlyInCreation有没包含该BeanName,prototypesCurrentlyInCreation是一个ThreadLocal,所以存在代表创建了2次 // We're assumably within a circular reference. if (isPrototypeCurrentlyInCreation(beanName)) { throw new BeanCurrentlyInCreationException(beanName); } // Check if bean definition exists in this factory. BeanFactory parentBeanFactory = getParentBeanFactory(); if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { //这里面的逻辑是,如果BeanFactory并没有包含该Bean的定义信息,那么久去找其父类,看看父类有没该bean // Not found -> check parent. //查找父类看看有没该Bean String nameToLookup = originalBeanName(name); if (parentBeanFactory instanceof AbstractBeanFactory) { return ((AbstractBeanFactory) parentBeanFactory).doGetBean( nameToLookup, requiredType, args, typeCheckOnly); } else if (args != null) { // Delegation to parent with explicit args. //使用有参构造器去创建实例 return (T) parentBeanFactory.getBean(nameToLookup, args); } else if (requiredType != null) { // No args -> delegate to standard getBean method. return parentBeanFactory.getBean(nameToLookup, requiredType);//通过类型去创建实例 } else { return (T) parentBeanFactory.getBean(nameToLookup);//通过名称去创建实例 } } if (!typeCheckOnly) { markBeanAsCreated(beanName); //这里的意思是,本次调用方法,并非是要获取bean的类型,而是为了创建实例,将beanName存到alreadyCreated集合,代表该bean已经创建了,后面try。。catch有异常会清空该beanName } try { final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);//mergeBeanDefinition的作用是解决xml时代,bean继承一个抽象bean,获取其对应属性,类之间并非真的是继承关系 checkMergedBeanDefinition(mbd, beanName, args);//这里检查mbd是否是抽象的,抽象的话就不能创建 // Guarantee initialization of beans that the current bean depends on. String[] dependsOn = mbd.getDependsOn(); //这里是解决@DependsOn("xx")注解的作用,该注解的作用是,创建某个Bean前,必须先创建xx,xx可以是个数组 if (dependsOn != null) { for (String dep : dependsOn) { if (isDependent(beanName, dep)) { //判断是否相互之间有依赖关系,这个要结合下面代码registerDependentBean(dep, beanName);才好理解 throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'"); } registerDependentBean(dep, beanName); try { getBean(dep); //先创建依赖的Bean } catch (NoSuchBeanDefinitionException ex) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", ex); } } } // Create bean instance. if (mbd.isSingleton()) { //如果是单例,就通过调用该方法创建 sharedInstance = getSingleton(beanName, () -> { try { return createBean(beanName, mbd, args); } catch (BeansException ex) { // Explicitly remove instance from singleton cache: It might have been put there // eagerly by the creation process, to allow for circular reference resolution. // Also remove any beans that received a temporary reference to the bean. destroySingleton(beanName); throw ex; } }); bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);//这里的意思前面也分析过了,意思是,如果是FactroyBean,就调用其getObject()方法,返回对应的对象 } else if (mbd.isPrototype()) { //如果是非单例 // It's a prototype -> create a new instance. Object prototypeInstance = null; try { beforePrototypeCreation(beanName);//存到prototypesCurrentlyInCreation这个ThreadLocal中,代表正在创建 prototypeInstance = createBean(beanName, mbd, args);//该方法跟单例创建实例调用的逻辑是一样的,后续会分析 } finally { afterPrototypeCreation(beanName);//既然创建完毕,那么久可以从ThreadLocal中移除该bean了 } bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);//这里逻辑前面分析过了 } else { String scopeName = mbd.getScope(); //@Scope标注的bean 下面的逻辑跟创建非单例(原型protoType)bean一样 final 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, () -> { beforePrototypeCreation(beanName); try { return createBean(beanName, mbd, args); } finally { afterPrototypeCreation(beanName); } }); bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd); } catch (IllegalStateException ex) { 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", ex); } } } catch (BeansException ex) { cleanupAfterBeanCreationFailure(beanName);//前面做了markBeanAsCreated(beanName)代表该bean已经创建,失败后,这里就要删除 throw ex; } } // Check if required type matches the type of the actual bean instance. if (requiredType != null && !requiredType.isInstance(bean)) { //如果我们需要的类型跟获取的不一致,那么就要转换 try { T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType); if (convertedBean == null) { throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass()); } return convertedBean; } catch (TypeMismatchException ex) { if (logger.isTraceEnabled()) { logger.trace("Failed to convert bean '" + name + "' to required type '" + ClassUtils.getQualifiedName(requiredType) + "'", ex); } throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass()); } } return (T) bean; }
//小结:上面主要对不同的bean类型做了不同的操作,同时对依赖关系的bean也做了处理,主要方法:createBean(beanName, mbd, args)
后续有一个方法会经常用到,在这里提前分析:Object sharedInstance = getSingleton(beanName,true);
//该方法可以解决循环依赖,也就是A和B相互依赖,例如使用@autowried注解 protected Object getSingleton(String beanName, boolean allowEarlyReference) {//allowEarlyReference代表是否允许循环依赖 Object singletonObject = this.singletonObjects.get(beanName);//我们创建的单例bean都会存在该Map中,如果已经创建,那么久可以获取到,我们可以把它看作一级缓存 if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
//当一个Bean正在创建中此时已经new出来目标对象了,只是还没有经过后置处理器处理,所以此时它是正在创建中,A依赖B,然后创建B,发现B依赖A,那么久会创建A,创建A时,发现A已经正在创建了 synchronized (this.singletonObjects) { singletonObject = this.earlySingletonObjects.get(beanName); //先从二级缓存获取 if (singletonObject == null && allowEarlyReference) {//获取不到 ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName); //再从三级缓存获取,该缓存是一个单例工厂 if (singletonFactory != null) { singletonObject = singletonFactory.getObject();//工厂中获取对象 this.earlySingletonObjects.put(beanName, singletonObject);//存入二级缓存 this.singletonFactories.remove(beanName);//移除工厂 那么问题:为何要有二三级缓存?原因是工厂里面的方法可能会很复杂,所以工厂获取对象后,存到二级缓存中,下次再次获取就更高效率了 } } } } return singletonObject; }
//接下来,我们来分析bean的创建过程createBean(beanName, mbd, args),由于单例创建过程内容多点,我们从单例的代码入手:
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) { Assert.notNull(beanName, "Bean name must not be null"); synchronized (this.singletonObjects) { Object singletonObject = this.singletonObjects.get(beanName); //先从单例缓存中获取 if (singletonObject == null) { if (this.singletonsCurrentlyInDestruction) { //判断beanFactroy是否正在执行销毁操作 throw new BeanCreationNotAllowedException(beanName, "Singleton bean creation not allowed while singletons of this factory are in destruction " + "(Do not request a bean from a BeanFactory in a destroy method implementation!)"); } } beforeSingletonCreation(beanName);//存beanName到singletonsCurrentlyInCreation集合,代表单例bean正在创建 boolean newSingleton = false; boolean recordSuppressedExceptions = (this.suppressedExceptions == null);//用于记录异常用,不是我们关心的点 if (recordSuppressedExceptions) { this.suppressedExceptions = new LinkedHashSet<>(); } try { singletonObject = singletonFactory.getObject();//调用工厂方法,也就是我们说的createBean(beanName, mbd, args) newSingleton = true; } catch (IllegalStateException ex) { // Has the singleton object implicitly appeared in the meantime -> // if yes, proceed with it since the exception indicates that state. singletonObject = this.singletonObjects.get(beanName);//即使有异常,但目标对象已经创建了 if (singletonObject == null) { throw ex; } } catch (BeanCreationException ex) { if (recordSuppressedExceptions) { //记录下异常的操作 for (Exception suppressedException : this.suppressedExceptions) { ex.addRelatedCause(suppressedException); } } throw ex; } finally { if (recordSuppressedExceptions) { this.suppressedExceptions = null; } afterSingletonCreation(beanName); //从singletonsCurrentlyInCreation集合中移除该beanName,因为已经创建完毕了 } if (newSingleton) { addSingleton(beanName, singletonObject);//这里逻辑是将该单例bean添加到this.singletonObjects.put(beanName, singletonObject);和 this.registeredSingletons.add(beanName); } } return singletonObject; } }
//小结:上面方法的核心逻辑是:设置单例bean正在创建中,创建完毕后,存到缓存;接下来我们要分析的是:createBean(beanName, mbd, args)
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException { RootBeanDefinition mbdToUse = mbd; // Make sure bean class is actually resolved at this point, and // clone the bean definition in case of a dynamically resolved Class // which cannot be stored in the shared merged bean definition. Class<?> resolvedClass = resolveBeanClass(mbd, beanName);//获取真实的类型 if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) { mbdToUse = new RootBeanDefinition(mbd); //这里新创建一个mbd 防止被其他线程更改 mbdToUse.setBeanClass(resolvedClass); } // Prepare method overrides. try { mbdToUse.prepareMethodOverrides(); //用于校验@lookup注解相关的处理校验 } catch (BeanDefinitionValidationException ex) { throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed", ex); } try { // InstantiationAwareBeanPostProcessor 后置处理器执行postProcessBeforeInstantiation() 方法 Object bean = resolveBeforeInstantiation(beanName, mbdToUse); if (bean != null) { //如果后置处理器获得了代理对象就返回去 return bean; } } catch (Throwable ex) { throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", ex); } try { Object beanInstance = doCreateBean(beanName, mbdToUse, args); //这里是核心 if (logger.isTraceEnabled()) { logger.trace("Finished creating instance of bean '" + beanName + "'"); } return beanInstance; } catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) { // A previously detected exception with proper bean creation context already, // or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry. throw ex; } catch (Throwable ex) { throw new BeanCreationException( mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex); } }
小结:该方法主要是在bean实例化前对bean执行后置处理器InstantiationAwareBeanPostProcessor的postProcessBeforeInstantiation(beanClass, beanName);
下面跟进: Object beanInstance = doCreateBean(beanName, mbdToUse, args);
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args) throws BeanCreationException { // Instantiate the bean. BeanWrapper instanceWrapper = null; //对实例对象进行包装 if (mbd.isSingleton()) { instanceWrapper = this.factoryBeanInstanceCache.remove(beanName); //缓存中获取 } if (instanceWrapper == null) { instanceWrapper = createBeanInstance(beanName, mbd, args); //创建bean实例,后续会重点关注 } final Object bean = instanceWrapper.getWrappedInstance(); //获取目标bean Class<?> beanType = instanceWrapper.getWrappedClass(); //获取类型 if (beanType != NullBean.class) { mbd.resolvedTargetType = beanType;//修改beanDefinition的目标对象类型 } // Allow post-processors to modify the merged bean definition. synchronized (mbd.postProcessingLock) { if (!mbd.postProcessed) { try {//调用MergedBeanDefinitionPostProcessor 后置处理器的postProcessMergedBeanDefinition(mbd, beanType, beanName); 允许修改mbd applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName); } catch (Throwable ex) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", ex); } mbd.postProcessed = true; } } // Eagerly cache singletons to be able to resolve circular references // even when triggered by lifecycle interfaces like BeanFactoryAware. boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName)); //如果是单例同时允许循环依赖,同时该bean是正在创建的,很明显,符合要求 if (earlySingletonExposure) { if (logger.isTraceEnabled()) { logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references"); }
//工厂方法会调用SmartInstantiationAwareBeanPostProcessor的getEarlyBeanReference(Object bean, String beanName) addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean)); //设置单例的二级缓存this.singletonFactories.put(beanName, singletonFactory); } // Initialize the bean instance. Object exposedObject = bean; try { populateBean(beanName, mbd, instanceWrapper); //给属性赋值(后续会分析) exposedObject = initializeBean(beanName, exposedObject, mbd);//执行init 方法(后续会分析) } catch (Throwable ex) { if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) { throw (BeanCreationException) ex; } else { throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex); } } if (earlySingletonExposure) { Object earlySingletonReference = getSingleton(beanName, false);//当有循环依赖时,这里就会从二级缓存中获取到早期的bean,如果没有循环依赖,这里获取到的是null if (earlySingletonReference != null) { if (exposedObject == bean) { exposedObject = earlySingletonReference; } else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
//如果不相等,例如使用@Async注解标注的bean,调用initializeBean(beanName, exposedObject, mbd);获得的是一个代理对象,因此exposedObject是代理对象,而bean还是原生对象,通过二级缓存得到的是原生对象
//如果循环依赖的bean已经创建完了,说明他们依赖的是原生的Bean而不是代理的bean,这样就会报错 String[] dependentBeans = getDependentBeans(beanName); Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length); for (String dependentBean : dependentBeans) { if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) { actualDependentBeans.add(dependentBean); } } if (!actualDependentBeans.isEmpty()) { throw new BeanCurrentlyInCreationException(beanName, "Bean with name '" + beanName + "' has been injected into other beans [" + StringUtils.collectionToCommaDelimitedString(actualDependentBeans) + "] in its raw version as part of a circular reference, but has eventually been " + "wrapped. This means that said other beans do not use the final version of the " + "bean. This is often the result of over-eager type matching - consider using " + "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example."); } } } } // Register bean as disposable. try { registerDisposableBeanIfNecessary(beanName, bean, mbd); //有detroy方法的bean就会收集起来,当容器销毁时,就可以调用这些bean的destroy方法 } catch (BeanDefinitionValidationException ex) { throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex); } return exposedObject; }
小结:该方法的核心是:创建bean的实例(createBeanInstance(beanName, mbd, args); ),进行属性赋值( populateBean(beanName, mbd, instanceWrapper);),执行init方法(initializeBean(beanName, exposedObject, mbd);),注册有detroy方法的bean,下面分别分析这三个方法:
1.createBeanInstance(beanName, mbd, args);
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) { // Make sure bean class is actually resolved at this point. Class<?> beanClass = resolveBeanClass(mbd, beanName); //获取实际的类型 if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) { //如果不是public修饰的,代表不能访问 throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Bean class isn't public, and non-public access not allowed: " + beanClass.getName()); } Supplier<?> instanceSupplier = mbd.getInstanceSupplier(); if (instanceSupplier != null) { return obtainFromSupplier(instanceSupplier, beanName);//如果有实例工厂,直接调用工厂方法 } if (mbd.getFactoryMethodName() != null) { return instantiateUsingFactoryMethod(beanName, mbd, args);//如果是@bean修饰的方法,那么调用该方法即可(反射调用) } // Shortcut when re-creating the same bean... boolean resolved = false; boolean autowireNecessary = false; if (args == null) { synchronized (mbd.constructorArgumentLock) { if (mbd.resolvedConstructorOrFactoryMethod != null) { //如果是第二次创建相同bean,如原型对象,他们的beanDefinition对象已经知道用哪个构造器或者工厂方法了,此时就直接调用对应方法即可 resolved = true; autowireNecessary = mbd.constructorArgumentsResolved; } } } if (resolved) {//之前已经调用过了,这里直接调用对应方法,根据构造器参数是否已经解析了来处理 if (autowireNecessary) { return autowireConstructor(beanName, mbd, null, null); } else { return instantiateBean(beanName, mbd); } } // Candidate constructors for autowiring? Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName); //第一次解析,就要获取合适的构造器 if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR || mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) { return autowireConstructor(beanName, mbd, ctors, args); } // Preferred constructors for default construction? ctors = mbd.getPreferredConstructors();//如果有默认的合适构造器 if (ctors != null) { return autowireConstructor(beanName, mbd, ctors, null); } // No special handling: simply use no-arg constructor. return instantiateBean(beanName, mbd);//上面都不满足,那么只能调用无参构造器了 }
小结: 该方法的作用是通过工厂方法或者@bean注解标注的方法或者构造器来进行对象的实例化
2. populateBean(beanName, mbd, instanceWrapper); bean的属性赋值
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) { if (bw == null) { if (mbd.hasPropertyValues()) {//如果bean实例为空,但mbd有属性 throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance"); } else { // Skip property population phase for null instance. return; } } // Give any InstantiationAwareBeanPostProcessors the opportunity to modify the // state of the bean before properties are set. This can be used, for example, //实例化之后,属性赋值之前执行InstantiationAwareBeanPostProcessor // to support styles of field injection. boolean continueWithPropertyPopulation = true; if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) { for (BeanPostProcessor bp : getBeanPostProcessors()) { if (bp instanceof InstantiationAwareBeanPostProcessor) { InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp; if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) { continueWithPropertyPopulation = false; break; } } } } if (!continueWithPropertyPopulation) { //如果后置处理器返回为false后就不能走下去了 return; } PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null); if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) { //这里不看,这里是旧逻辑了,xml时代的 MutablePropertyValues newPvs = new MutablePropertyValues(pvs); // Add property values based on autowire by name if applicable. if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME) { autowireByName(beanName, mbd, bw, newPvs); } // Add property values based on autowire by type if applicable. if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) { autowireByType(beanName, mbd, bw, newPvs); } pvs = newPvs; } boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors(); boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE); PropertyDescriptor[] filteredPds = null; if (hasInstAwareBpps) { if (pvs == null) { pvs = mbd.getPropertyValues(); }
//这里才是核心,我们的@Autowired 和 @Value注解注入的属性就是在这里实现的,后置处理器是:AutowiredAnnotationBeanPostProcessor for (BeanPostProcessor bp : getBeanPostProcessors()) { if (bp instanceof InstantiationAwareBeanPostProcessor) { InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp; PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName); if (pvsToUse == null) { if (filteredPds == null) { filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching); } pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName); if (pvsToUse == null) { return; } } pvs = pvsToUse; } } } if (needsDepCheck) { if (filteredPds == null) { filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching); } checkDependencies(beanName, mbd, filteredPds, pvs); } if (pvs != null) { //这里不看,这里是旧逻辑了,xml时代的 复杂 applyPropertyValues(beanName, mbd, bw, pvs); } }
小结:上面方法主要的核心是:1.在bean的实例化之后,属性赋值之前执行了InstantiationAwareBeanPostProcessor后置处理器的postProcessAfterInstantiation(bw.getWrappedInstance(), beanName) 2.@autowried和@value的属性赋值实现逻辑是通过InstantiationAwareBeanPostProcessor的.postProcessProperties(pvs, bw.getWrappedInstance(), beanName)方法实现
3.exposedObject = initializeBean(beanName, exposedObject, mbd);
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) { if (System.getSecurityManager() != null) { AccessController.doPrivileged((PrivilegedAction<Object>) () -> { invokeAwareMethods(beanName, bean); return null; }, getAccessControlContext()); } else { invokeAwareMethods(beanName, bean); //调用aware接口的实现方法,例如ApplicationContextAware的setApplicationContext()方法 } Object wrappedBean = bean; if (mbd == null || !mbd.isSynthetic()) {//Synthetic 这个的意思是,类或者方法不是由开发人员自己定义的,而是jvm帮忙创建的 wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); //执行BeanPostProcessor的applyBeanPostProcessorsBeforeInitialization方法 } try { invokeInitMethods(beanName, wrappedBean, mbd);//执行init方法 } catch (Throwable ex) { throw new BeanCreationException( (mbd != null ? mbd.getResourceDescription() : null), beanName, "Invocation of init method failed", ex); } if (mbd == null || !mbd.isSynthetic()) { wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);//执行BeanPostProcessor的 } return wrappedBean; } private void invokeAwareMethods(final String beanName, final Object bean) { //aware方法的逻辑 if (bean instanceof Aware) { if (bean instanceof BeanNameAware) { ((BeanNameAware) bean).setBeanName(beanName); } if (bean instanceof BeanClassLoaderAware) { ClassLoader bcl = getBeanClassLoader(); if (bcl != null) { ((BeanClassLoaderAware) bean).setBeanClassLoader(bcl); } } if (bean instanceof BeanFactoryAware) { ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this); } } }
init方法的执行:
protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd) throws Throwable { boolean isInitializingBean = (bean instanceof InitializingBean); if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) { if (logger.isTraceEnabled()) { logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'"); } if (System.getSecurityManager() != null) { try { AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> { ((InitializingBean) bean).afterPropertiesSet(); return null; }, getAccessControlContext()); } catch (PrivilegedActionException pae) { throw pae.getException(); } } else { ((InitializingBean) bean).afterPropertiesSet(); //如果实现了InitializingBean 就调用该方法 } } if (mbd != null && bean.getClass() != NullBean.class) { String initMethodName = mbd.getInitMethodName(); if (StringUtils.hasLength(initMethodName) && !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) && !mbd.isExternallyManagedInitMethod(initMethodName)) { invokeCustomInitMethod(beanName, bean, mbd);//如果有自定义的init方法,例如@Bean(initMethod ="hello" ) } } }
至此,一个bean的创建过程分析完毕
最后一张图总结bean创建的过程: