protectedObjectcreateBean(String beanName,RootBeanDefinition mbd,@NullableObject[] args)throwsBeanCreationException{// 日志打印if(logger.isTraceEnabled()){
logger.trace("Creating instance of bean '"+ beanName +"'");}// 使用的BeanDefinitionRootBeanDefinition 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.// 马上就要实例化Bean了,确保beanClass被加载了Class<?> resolvedClass =resolveBeanClass(mbd, beanName);// Bean被加载,并且当前BeanDefinition的beanClass属性不是class类型,并且对应的BeanNam不是Nullif(resolvedClass !=null&&!mbd.hasBeanClass()&& mbd.getBeanClassName()!=null){// 重新定义一个BeanDefinition。这里之前的BeanClass属性是字符串!
mbdToUse =newRootBeanDefinition(mbd);// 把上面实例化的Bean设置进去
mbdToUse.setBeanClass(resolvedClass);}// Prepare method overrides.// 这里主要处理@Lookup注解,进行方法的替代!try{
mbdToUse.prepareMethodOverrides();}catch(BeanDefinitionValidationException ex){thrownewBeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName,"Validation of method overrides failed", ex);}try{// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.// 实例化前Object bean =resolveBeforeInstantiation(beanName, mbdToUse);// 自己创建成功了,直接放回if(bean !=null){return bean;}}catch(Throwable ex){thrownewBeanCreationException(mbdToUse.getResourceDescription(), beanName,"BeanPostProcessor before instantiation of bean failed", ex);}try{// spring本身的实例化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){thrownewBeanCreationException(
mbdToUse.getResourceDescription(), beanName,"Unexpected exception during bean creation", ex);}}
privateClass<?>doResolveBeanClass(RootBeanDefinition mbd,Class<?>... typesToMatch)throwsClassNotFoundException{// 得到当前Bean的类加载器ClassLoader beanClassLoader =getBeanClassLoader();// 定义一个动态的类加载器。有临时类加载器用临时类加载器,没有临时类加载器用现在这个ClassLoader dynamicLoader = beanClassLoader;// 表示RootBeanDefinition的配置的bean类名需要重新被dynameicLoader加载的标记,默认不需要boolean freshResolve =false;// 进行类型匹配if(!ObjectUtils.isEmpty(typesToMatch)){// When just doing type checks (i.e. not creating an actual instance yet),// use the specified temporary class loader (e.g. in a weaving scenario).// 一个临时的类加载器,用于类型的匹配校验ClassLoader tempClassLoader =getTempClassLoader();// 解析的值不一样,走下面的逻辑if(tempClassLoader !=null){// 吧当前的类加载器赋值给动态类加载器
dynamicLoader = tempClassLoader;// 标记当前的RootBeanDefinition需要被dynamicLoader解析
freshResolve =true;// 他是spring自定义的DecoratingClassLoader类加载器if(tempClassLoader instanceofDecoratingClassLoader){// 类加载器强转DecoratingClassLoader dcl =(DecoratingClassLoader) tempClassLoader;// 类型匹配!for(Class<?> typeToMatch : typesToMatch){
dcl.excludeClass(typeToMatch.getName());}}}}// 获取className:beanClass是名称直接返回,是class返回class对应的NameString className = mbd.getBeanClassName();if(className !=null){// 解析Spring表达式,有可能直接返回了一个Class对象Object evaluated =evaluateBeanDefinitionString(className, mbd);// 表达式解析的类型不一致if(!className.equals(evaluated)){// A dynamically resolved expression, supported as of 4.2...// 4.2支持动态的类型。能得到class类型直接返回if(evaluated instanceofClass){return(Class<?>) evaluated;}// 得到的是字符串elseif(evaluated instanceofString){// BeanName赋值
className =(String) evaluated;// 标记当前的RootBeanDefinition需要被dynamicLoader解析
freshResolve =true;}else{// 除了class类型和字符串,其他的直接抛异常thrownewIllegalStateException("Invalid class name expression result: "+ evaluated);}}// 类没有被加载的时候,进行加载if(freshResolve){// When resolving against a temporary class loader, exit early in order// to avoid storing the resolved Class in the bean definition.// 类加载器不能为空!if(dynamicLoader !=null){try{// 返回用dynamicLoader具体的类加载器加载类,得到class对象return dynamicLoader.loadClass(className);}catch(ClassNotFoundException ex){if(logger.isTraceEnabled()){
logger.trace("Could not load class ["+ className +"] from "+ dynamicLoader +": "+ ex);}}}// 加载数组,String,基本类型returnClassUtils.forName(className, dynamicLoader);}}// Resolve regularly, caching the result in the BeanDefinition...// 定期解析,将结果缓存在BeanDefinition中。可以通过AbstractBeanDefinition#getBeanClass来获取缓存return mbd.resolveBeanClass(beanClassLoader);}
创建Bean使用的类加载器信息
/**
* 获取类加载器信息的方法
*/publicClassLoadergetBeanClassLoader(){returnthis.beanClassLoader;}// 使用的类加载器信息privateClassLoader beanClassLoader =ClassUtils.getDefaultClassLoader();/**
* 初始化类加载器的方法
*/publicstaticClassLoadergetDefaultClassLoader(){ClassLoader cl =null;// 优先获取线程中的类加载器。通过Thread.currentThread().setContextClassLoader(cl)进行设置try{
cl =Thread.currentThread().getContextClassLoader();}catch(Throwable ex){// Cannot access thread context ClassLoader - falling back...}// 线程中类加载器为null的情况下,获取加载ClassUtils类的类加载器if(cl ==null){// No thread context class loader -> use class loader of this class.// 使用和ClassUtils相同的类加载器。简单理解就是和spring-core包放的位置有关系
cl =ClassUtils.class.getClassLoader();if(cl ==null){// getClassLoader() returning null indicates the bootstrap ClassLoader// 加入ClassUtils是被Bootstrap类加载器加载的,则获取系统类加载器。(jre/lib目录下)try{
cl =ClassLoader.getSystemClassLoader();}catch(Throwable ex){// Cannot access system ClassLoader - oh well, maybe the caller can live with null...}}}return cl;}
实例化前:resolveBeforeInstantiation源码分析
protectedObjectresolveBeforeInstantiation(String beanName,RootBeanDefinition mbd){Object bean =null;// 如果当前还没有进行实例化钱的操作if(!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)){// Make sure bean class is actually resolved at this point.// synthetic表示合成,如果某些Bean式合成的,那么则不会经过BeanPostProcessor的处理。并且他有实例化前的实现:。并且把所有的InstantiationAwareBeanPostProcessor、SmartInstantiationAwareBeanPostProcessor、DestructionAwareBeanPostProcessor、MergedBeanDefinitionPostProcessor加入到BeanPostProcessorCache,判断加入后有没有InstantiationAwareBeanPostProcessor。if(!mbd.isSynthetic()&&hasInstantiationAwareBeanPostProcessors()){// 得到class类型Class<?> targetType =determineTargetType(beanName, mbd);// 得到的class类型不为nullif(targetType !=null){// 循环调用每个postProcessBeforeInstantiation方法,直到有返回值(自己去实例化),或者执行完返回null(让spring去实例化)
bean =applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);// 如果其中一个有返回值,循环调用每个postProcessAfterInitialization方法,直到有一个返回值为null(没有实例化成功)。否则返回具体的值(自己实例化成功)。这里主要是为了Bean的AOPif(bean !=null){
bean =applyBeanPostProcessorsAfterInitialization(bean, beanName);}}}// bean有值说明实例化成功,下次的这个判断不会进来,否则会继续执行
mbd.beforeInstantiationResolved =(bean !=null);}// 返回当前的处理过的Beanreturn bean;}
spring本身的实例化方法
protectedObjectdoCreateBean(String beanName,RootBeanDefinition mbd,@NullableObject[] args)throwsBeanCreationException{// 实例化bean// Instantiate the bean.BeanWrapper instanceWrapper =null;// 这个Bean是单例的if(mbd.isSingleton()){// 有可能在本Bean创建之前,就有其他Bean把当前Bean给创建出来了(比如依赖注入过程中)。factoryBean需要重新创建
instanceWrapper =this.factoryBeanInstanceCache.remove(beanName);}if(instanceWrapper ==null){// 创建Bean实例:推断构造方法,@Bean的处理
instanceWrapper =createBeanInstance(beanName, mbd, args);}// 得到Bean对象Object bean = instanceWrapper.getWrappedInstance();// 得到Bean的类型Class<?> beanType = instanceWrapper.getWrappedClass();if(beanType !=NullBean.class){
mbd.resolvedTargetType = beanType;}// 后置处理合并后的BeanDefinition(MergedBeanDefinitionPostProcessor):比如可以进行初始化方法的设置,比如添加属性值。spring友谊个默认的实现去寻找注入点。// Allow post-processors to modify the merged bean definition.synchronized(mbd.postProcessingLock){if(!mbd.postProcessed){try{applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);}catch(Throwable ex){thrownewBeanCreationException(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));// 第一次处理循环依赖if(earlySingletonExposure){if(logger.isTraceEnabled()){
logger.trace("Eagerly caching bean '"+ beanName +"' to allow for resolving potential circular references");}// 循环依赖-添加到三级缓存addSingletonFactory(beanName,()->getEarlyBeanReference(beanName, mbd, bean));}// Initialize the bean instance.Object exposedObject = bean;try{// 属性填充populateBean(beanName, mbd, instanceWrapper);//getBean()// 初始化:包括三个回调以及初始化前中后
exposedObject =initializeBean(beanName, exposedObject, mbd);}catch(Throwable ex){if(ex instanceofBeanCreationException&& beanName.equals(((BeanCreationException) ex).getBeanName())){throw(BeanCreationException) ex;}else{thrownewBeanCreationException(
mbd.getResourceDescription(), beanName,"Initialization of bean failed", ex);}}// 第二次处理循环依赖问题if(earlySingletonExposure){// 从一级、二级缓存中获取BeanObject earlySingletonReference =getSingleton(beanName,false);// 获取到了if(earlySingletonReference !=null){// 是当前Bean,放入二级缓存if(exposedObject == bean){
exposedObject = earlySingletonReference;}elseif(!this.allowRawInjectionDespiteWrapping &&hasDependentBean(beanName)){// beanName被哪些bean依赖了,现在发现beanName所对应的bean对象发生了改变,那么则会报错String[] dependentBeans =getDependentBeans(beanName);Set<String> actualDependentBeans =newLinkedHashSet<>(dependentBeans.length);for(String dependentBean : dependentBeans){if(!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)){
actualDependentBeans.add(dependentBean);}}if(!actualDependentBeans.isEmpty()){thrownewBeanCurrentlyInCreationException(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 "+"'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");}}}}// Register bean as disposable.// 处理Bean销毁前要执行的方法try{registerDisposableBeanIfNecessary(beanName, bean, mbd);}catch(BeanDefinitionValidationException ex){thrownewBeanCreationException(
mbd.getResourceDescription(), beanName,"Invalid destruction signature", ex);}return exposedObject;}
属性填充:populateBean源码分析
protectedvoidpopulateBean(String beanName,RootBeanDefinition mbd,@NullableBeanWrapper bw){// Bean不存在的时候,直接返回或者抛异常if(bw ==null){// 有依赖的属性,抛异常if(mbd.hasPropertyValues()){thrownewBeanCreationException(
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,// to support styles of field injection.// 实例化后,属性设置之前。循环调用每个实现postProcessAfterInstantiation的方法if(!mbd.isSynthetic()&&hasInstantiationAwareBeanPostProcessors()){for(InstantiationAwareBeanPostProcessor bp :getBeanPostProcessorCache().instantiationAware){if(!bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)){return;}}}// 得到所有的属性值PropertyValues pvs =(mbd.hasPropertyValues()? mbd.getPropertyValues():null);// 依赖注入的逻辑int resolvedAutowireMode = mbd.getResolvedAutowireMode();// 这个判断是spring自带的依赖注入逻辑。可以在@Bean上配置autowire属性配置ByName或者ByType(已过期)if(resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE){// MutablePropertyValues是PropertyValues具体的实现类MutablePropertyValues newPvs =newMutablePropertyValues(pvs);// Add property values based on autowire by name if applicable.// ByName找的是set方法,比如setXxxxx就会找xxxx,setName就会找Nameif(resolvedAutowireMode == AUTOWIRE_BY_NAME){autowireByName(beanName, mbd, bw, newPvs);}// Add property values based on autowire by type if applicable.// ByType找的是set方法,从Bean中找到当前类型的入参,进行传入if(resolvedAutowireMode == AUTOWIRE_BY_TYPE){autowireByType(beanName, mbd, bw, newPvs);}
pvs = newPvs;}// 获取是否有实现InstantiationAwareBeanPostProcessor的方法,这里主要使用postProcessProperties方法。boolean hasInstAwareBpps =hasInstantiationAwareBeanPostProcessors();// 获取是否需要进行依赖注入boolean needsDepCheck =(mbd.getDependencyCheck()!=AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);PropertyDescriptor[] filteredPds =null;if(hasInstAwareBpps){// 属性为空,获取需要注入的信息if(pvs ==null){
pvs = mbd.getPropertyValues();}for(InstantiationAwareBeanPostProcessor bp :getBeanPostProcessorCache().instantiationAware){// 这里会调用AutowiredAnnotationBeanPostProcessor的postProcessProperties()方法,会直接给对象中的属性赋值。真正的处理@Autowired、@Resource、@Value注解// AutowiredAnnotationBeanPostProcessor内部并不会处理pvs。直接返回自己设置的PropertyValues对象(可以在实例化前设置)。PropertyValues pvsToUse = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);// 这里的含义是程序员自己已经给属性赋值了,就不需要Spring给他赋值。这里是程序员没有赋值,所以需要Spring进行赋值if(pvsToUse ==null){// 第一次进来一般为空if(filteredPds ==null){
filteredPds =filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);}// 和postProcessProperties类似,但是已经过期了
pvsToUse = bp.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);}// 如果当前Bean中的BeanDefinition中设置了PropertyValues,那么最终将是PropertyValues中的值,覆盖@Autowiredif(pvs !=null){applyPropertyValues(beanName, mbd, bw, pvs);}}