Spring Bean加载流程

一时失言乱红尘 2022-11-12 09:50 179阅读 0赞

public void preInstantiateSingletons() throws BeansException {
        
    		if (logger.isTraceEnabled()) {
        
    			logger.trace("Pre-instantiating singletons in " + this);
    		}
    
    		// Iterate over a copy to allow for init methods which in turn register new bean definitions.
    		// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
    		//将所有bean的名字创建一个集合
    		List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
    
    		// Trigger initialization of all non-lazy singleton beans...
    		//触发所有非延迟加载单例bean的初始化，遍历集合对象
    		for (String beanName : beanNames) {
        
    			//合并父类BeanDefinition
    			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
    			// 条件判断 抽象 、单例、非懒加载
    			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
        
    				// 判断是否实现了FactoryBean接口
    				if (isFactoryBean(beanName)) {
        
    					// 根据&+beanName来获取具体的对象
    					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
    					// 进行类型转换
    					if (bean instanceof FactoryBean) {
        
    						FactoryBean<?> factory = (FactoryBean<?>) bean;
    						// 判断这个FactoryBean是否希望急切的初始化
    						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());
    						}
    						// 如果希望急切的初始化，则通过beanName获取bean实例
    						if (isEagerInit) {
        
    							getBean(beanName);
    						}
    					}
    				}
    				else {
        
    					// 如果beanName对应的bean不是FactoryBean，只是普通的bean，通过beanName获取bean实例
    					getBean(beanName);
    				}
    			}
    		}
    
    		// Trigger post-initialization callback for all applicable beans...
    		for (String beanName : beanNames) {
        
    			Object singletonInstance = getSingleton(beanName);
    			if (singletonInstance instanceof SmartInitializingSingleton) {
        
    				StartupStep smartInitialize = this.getApplicationStartup().start("spring.beans.smart-initialize")
    						.tag("beanName", beanName);
    				SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
    				if (System.getSecurityManager() != null) {
        
    					AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
        
    						smartSingleton.afterSingletonsInstantiated();
    						return null;
    					}, getAccessControlContext());
    				}
    				else {
        
    					smartSingleton.afterSingletonsInstantiated();
    				}
    				smartInitialize.end();
    			}
    		}
    	}

### getBean() --> doGetBean() --> createBean() --> doCreateBean() ###

public Object getBean(String name) throws BeansException {
        
    	// 此方法是实际获取bean的方法，也是触发依赖注入的方法
    	return this.doGetBean(name, (Class)null, (Object[])null, false);
    }

protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {
        
            //提取beanName
            String beanName = this.transformedBeanName(name);
            // 提前检查单例缓存中是否有手动注册的单例对象，跟循环依赖有关联
            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 + "'");
                    }
                }
    
    			// 返回对象的实例，很多同学会不理解这句话存在的意义，当实现了FactoryBean接口的对象，需要获取具体对象的时候，就需要此方法进行获取了。
                bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);
            } else {
        
            	//当对象都是单例的时候会尝试解决循环依赖的问题，但是原型模式下如果存在循环依赖的情况，那么直接抛出异常
                if (this.isPrototypeCurrentlyInCreation(beanName)) {
        
                    throw new BeanCurrentlyInCreationException(beanName);
                }
    			// 获取父类容器
                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);
                }
    
                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 + "'");
                            }
    
                            this.registerDependentBean(dep, beanName);
    
                            try {
        
                                this.getBean(dep);
                            } catch (NoSuchBeanDefinitionException var24) {
        
                                throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", var24);
                            }
                        }
                    }
    
                    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();
                        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;
            }
        }

#### createBean ####

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
        
            if (this.logger.isTraceEnabled()) {
        
                this.logger.trace("Creating instance of bean '" + beanName + "'");
            }
    
            RootBeanDefinition mbdToUse = mbd;
            Class<?> resolvedClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
            if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
        
                mbdToUse = new RootBeanDefinition(mbd);
                mbdToUse.setBeanClass(resolvedClass);
            }
    
            try {
        
                mbdToUse.prepareMethodOverrides();
            } catch (BeanDefinitionValidationException var9) {
        
                throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed", var9);
            }
    
            Object beanInstance;
            try {
        
                beanInstance = this.resolveBeforeInstantiation(beanName, mbdToUse);
                if (beanInstance != null) {
        
                    return beanInstance;
                }
            } catch (Throwable var10) {
        
                throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", var10);
            }
    
            try {
        
            	// 实际创建bean的调用
                beanInstance = this.doCreateBean(beanName, mbdToUse, args);
                if (this.logger.isTraceEnabled()) {
        
                    this.logger.trace("Finished creating instance of bean '" + beanName + "'");
                }
    
                return beanInstance;
            } catch (ImplicitlyAppearedSingletonException | BeanCreationException var7) {
        
                throw var7;
            } catch (Throwable var8) {
        
                throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", var8);
            }
        }

#### doCreateBean ####

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
        
            BeanWrapper instanceWrapper = null;
            if (mbd.isSingleton()) {
        
            	// 如果是单例对象，从factoryBean实例缓存中移除当前bean的定义信息
                instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);
            }
    
            if (instanceWrapper == null) {
        
            	// 根据执行bean使用对应的策略创建新的实例，如，工厂方法，构造函数主动注入、简单初始化
                instanceWrapper = this.createBeanInstance(beanName, mbd, args);
            }
    
            Object bean = instanceWrapper.getWrappedInstance();
            Class<?> beanType = instanceWrapper.getWrappedClass();
            if (beanType != NullBean.class) {
        
                mbd.resolvedTargetType = beanType;
            }
    
            synchronized(mbd.postProcessingLock) {
        
                if (!mbd.postProcessed) {
        
                    try {
        
                    	// 应用MergedBeanDefinitionPostProcessor
                        this.applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
                    } catch (Throwable var17) {
        
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Post-processing of merged bean definition failed", var17);
                    }
    
                    mbd.postProcessed = true;
                }
            }
    
    		// 判断当前bean是否需要提前曝光：单例 & 允许循环依赖 & 当前bean正在创建中，检测循环依赖
            boolean earlySingletonExposure = mbd.isSingleton() && this.allowCircularReferences && this.isSingletonCurrentlyInCreation(beanName);
            if (earlySingletonExposure) {
        
                if (this.logger.isTraceEnabled()) {
        
                    this.logger.trace("Eagerly caching bean '" + beanName + "' to allow for resolving potential circular references");
                }
    			// 为避免后期循环依赖，可以在bean初始化完成前将创建实例的ObjectFactory加入工厂
                this.addSingletonFactory(beanName, () -> {
        
                    return this.getEarlyBeanReference(beanName, mbd, bean);
                });
            }
    
            Object exposedObject = bean;
    
            try {
        
            	// 	对bean的属性进行填充，将各个属性值注入，其中，可能存在依赖于其他bean的属性，则会递归初始化依赖的bean
                this.populateBean(beanName, mbd, instanceWrapper);
                // 执行初始化逻辑
                exposedObject = this.initializeBean(beanName, exposedObject, mbd);
            } catch (Throwable var18) {
        
                if (var18 instanceof BeanCreationException && beanName.equals(((BeanCreationException)var18).getBeanName())) {
        
                    throw (BeanCreationException)var18;
                }
    
                throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", var18);
            }
    
            if (earlySingletonExposure) {
        
                Object earlySingletonReference = this.getSingleton(beanName, false);
                // earlySingletonReference 只有被检测到有循环依赖的情况下才不会为空
                if (earlySingletonReference != null) {
        
                	// 如果exposedObject没有在初始化方法中被改变，也就是没有被增强
                    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);
                            }
                        }
    
                        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.");
                        }
                    }
                }
            }
    
            try {
        
            	// 根据scope注册bean
                this.registerDisposableBeanIfNecessary(beanName, bean, mbd);
                return exposedObject;
            } catch (BeanDefinitionValidationException var16) {
        
                throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", var16);
            }
        }

#### createBeanInstance ####

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
        
    		// 确认需要创建的bean实例的类可以实例化
            Class<?> beanClass = this.resolveBeanClass(mbd, beanName, new Class[0]);
            if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
        
                throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
            } 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 {
        
                    boolean resolved = false;
                    boolean autowireNecessary = false;
                    if (args == null) {
        
                        synchronized(mbd.constructorArgumentLock) {
        
                            // 	一个类中有多个构造函数，每个构造器都有不同的参数，所以调用钱需要先根据参数锁定构造函数或对应的工厂方法
                            if (mbd.resolvedConstructorOrFactoryMethod != null) {
        
                                resolved = true;
                                autowireNecessary = mbd.constructorArgumentsResolved;
                            }
                        }
                    }
    				// 如果已经解析过则使用解析好的构造函数方法，不需要再次锁定。
                    if (resolved) {
        
                        //autowireNecessary  构造函数自动注入 ； instantiateBean 默认构造函数自动注入
                        return autowireNecessary ? this.autowireConstructor(beanName, mbd, (Constructor[])null, (Object[])null) : this.instantiateBean(beanName, mbd);
                    } else {
        
                    	//需要根据参数解析构造函数
                        Constructor<?>[] ctors = this.determineConstructorsFromBeanPostProcessors(beanClass, beanName);
                        if (ctors == null && mbd.getResolvedAutowireMode() != 3 && !mbd.hasConstructorArgumentValues() && ObjectUtils.isEmpty(args)) {
        
                            ctors = mbd.getPreferredConstructors();
                            return ctors != null ? this.autowireConstructor(beanName, mbd, ctors, (Object[])null) : this.instantiateBean(beanName, mbd);
                        } else {
        
                            return this.autowireConstructor(beanName, mbd, ctors, args);
                        }
                    }
                }
            }
        }

#### instantiateBean 使用默认构造函数进行实例化 ####

protected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mbd) {
        
            try {
        
                Object beanInstance;
                if (System.getSecurityManager() != null) {
        
                    beanInstance = AccessController.doPrivileged(() -> {
        
                        return thisx.getInstantiationStrategy().instantiate(mbd, beanName, this);
                    }, this.getAccessControlContext());
                } else {
        
                    beanInstance = this.getInstantiationStrategy().instantiate(mbd, beanName, this);
                }
                BeanWrapper bw = new BeanWrapperImpl(beanInstance);
                this.initBeanWrapper(bw);
                return bw;
            } catch (Throwable var6) {
        
                throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Instantiation of bean failed", var6);
            }
        }

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 {
        
            	// 对特殊的bean处理Aware接口
                this.invokeAwareMethods(beanName, bean);
            }
    
            Object wrappedBean = bean;
            if (mbd == null || !mbd.isSynthetic()) {
        
            	// BeanPostProcessors - Before
                wrappedBean = this.applyBeanPostProcessorsBeforeInitialization(bean, beanName);
            }
    
            try {
        
            	// 调用用户自定义的Init方法
                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()) {
        
            	// BeanPostProcessors - After
                wrappedBean = this.applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
            }
    
            return wrappedBean;
        }

#### invokeAwareMethods ####

private void invokeAwareMethods(String beanName, Object bean) {
        
            if (bean instanceof Aware) {
        
                if (bean instanceof BeanNameAware) {
        
                    ((BeanNameAware)bean).setBeanName(beanName);
                }
    
                if (bean instanceof BeanClassLoaderAware) {
        
                    ClassLoader bcl = this.getBeanClassLoader();
                    if (bcl != null) {
        
                        ((BeanClassLoaderAware)bean).setBeanClassLoader(bcl);
                    }
                }
    
                if (bean instanceof BeanFactoryAware) {
        
                    ((BeanFactoryAware)bean).setBeanFactory(this);
                }
            }
    
        }

#### instantiate ####

public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
        
            //如果有需要覆盖或者动态替换的方法，则使用cglib进行动态代理，因为可以在创建代理的同时将动态方法植入类中，但是如果没有需要动态改变的方法，为了方便直接反射就可以了。
            if (!bd.hasMethodOverrides()) {
        
                Constructor constructorToUse;
                synchronized(bd.constructorArgumentLock) {
        
                    constructorToUse = (Constructor)bd.resolvedConstructorOrFactoryMethod;
                    if (constructorToUse == null) {
        
                        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);
                        }
                    }
                }
    
    			// 实例化
                return BeanUtils.instantiateClass(constructorToUse, new Object[0]);
            } else {
        
                return this.instantiateWithMethodInjection(bd, beanName, owner);
            }
        }

####  ####

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()) && !mbd.isNonPublicAccessAllowed()) {
        
                throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
            } 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 {
        
                    boolean resolved = false;
                    boolean autowireNecessary = false;
                    if (args == null) {
        
                        synchronized(mbd.constructorArgumentLock) {
        
                            if (mbd.resolvedConstructorOrFactoryMethod != null) {
        
                                resolved = true;
                                autowireNecessary = mbd.constructorArgumentsResolved;
                            }
                        }
                    }
    
                    if (resolved) {
        
                        return autowireNecessary ? this.autowireConstructor(beanName, mbd, (Constructor[])null, (Object[])null) : this.instantiateBean(beanName, mbd);
                    } else {
        
                        Constructor<?>[] ctors = this.determineConstructorsFromBeanPostProcessors(beanClass, beanName);
                        if (ctors == null && mbd.getResolvedAutowireMode() != 3 && !mbd.hasConstructorArgumentValues() && ObjectUtils.isEmpty(args)) {
        
                            ctors = mbd.getPreferredConstructors();
                            return ctors != null ? this.autowireConstructor(beanName, mbd, ctors, (Object[])null) : this.instantiateBean(beanName, mbd);
                        } else {
        
                            return this.autowireConstructor(beanName, mbd, ctors, args);
                        }
                    }
                }
            }
        }