Spring bean的加载
Spring的bean加载
- Spring的容器架构
[Spring容器架构]
finishBeanFactoryInitialization()，正文下面写着 **Instantiate all remaining (non-lazy-init) singletons**，意味着非提早加载的类，将在这一步实例化，实现类的加载。
加载流程：
从开始的getbean入口进行剖析
ApplicationContext context = new ClassPathXmlApplicationContext("配置文件xml"); context.getBean("bean名字");1、先获取bean，调用AbstractBeanFactory的doGetBean
doGetBean有四个参数：name：bean的名称
requiredType： 返回的类型
args： 传递的结构参数
typeCheckOnly： 查看类型protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType, @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException { //获取beanName，这边有三种模式，一个是原始的beanName，一个是加了&的，一个是别名 final String beanName = transformedBeanName(name); Object bean; // Eagerly check singleton cache for manually registered singletons. // 是否曾经创立了 Object sharedInstance = getSingleton(beanName); //曾经创立了，且没有结构参数，进入这个办法，如果有结构参数，往else走，也就是说不从获取bean，而间接创立bean if (sharedInstance != null && args == null) { if (logger.isTraceEnabled()) { if (isSingletonCurrentlyInCreation(beanName)) { 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，间接返回，是FactoryBean，返回他的getObject bean = getObjectForBeanInstance(sharedInstance, name, beanName, null); } else { // Fail if we're already creating this bean instance: // We're assumably within a circular reference. // 没创立过bean或者是多例的状况或者有参数的状况 // 创立过Prototype的bean，会循环援用，抛出异样，单例才尝试解决循环依赖的问题 if (isPrototypeCurrentlyInCreation(beanName)) { throw new BeanCurrentlyInCreationException(beanName); } // Check if bean definition exists in this factory. BeanFactory parentBeanFactory = getParentBeanFactory(); // 父容器存在，本地没有以后beanName，从父容器取 if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { // Not found -> check parent. // 解决后，如果是加&，就补上& 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) { // typeCheckOnly为false，将beanName放入alreadyCreated中 markBeanAsCreated(beanName); } try { // 获取BeanDefinition final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); // 抽象类查看 checkMergedBeanDefinition(mbd, beanName, args); // Guarantee initialization of beans that the current bean depends on. // 如果有依赖的状况，先初始化依赖的bean String[] dependsOn = mbd.getDependsOn(); if (dependsOn != null) { for (String dep : dependsOn) { // 查看是否循环依赖，a依赖b，b依赖a。包含传递的依赖，比方a依赖b，b依赖c，c依赖a if (isDependent(beanName, dep)) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'"); } // 注册依赖关系 registerDependentBean(dep, beanName); try { // 初始化依赖的bean getBean(dep); } 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 { // 创立bean 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，间接返回，是FactoryBean，返回他的getObject bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd); } else if (mbd.isPrototype()) { // It's a prototype -> create a new instance. Object prototypeInstance = null; try { // 退出prototypesCurrentlyInCreation，阐明正在创立 beforePrototypeCreation(beanName); //创立bean prototypeInstance = createBean(beanName, mbd, args); } finally { // 移除prototypesCurrentlyInCreation，阐明曾经创立完结 afterPrototypeCreation(beanName); } // 如果是一般bean，间接返回，是FactoryBean，返回他的getObject bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd); } else { String scopeName = mbd.getScope(); 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); 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;}2、获取beanName而后转换名称
解析完配置后创立的 Map，应用的是 beanName 作为 key。见 DefaultListableBeanFactory：/** Map of bean definition objects, keyed by bean name */private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>(256);BeanFactory.getBean中传入的那么，有可能是这几种状况：
1.bean name，能够间接获取到定义 BeanDefinition。
//转化beanprotected <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; .......2.alias name，别名，须要转化。
如果是 alias name，在解析阶段，alias name 和 bean name 的映射关系被注册到 SimpleAliasRegistry 中。从该注册器中取到 beanName。见 SimpleAliasRegistry.canonicalName：public String canonicalName(String name) { String canonicalName = name; String resolvedName; do { resolvedName = (String)this.aliasMap.get(canonicalName); if (resolvedName != null) { canonicalName = resolvedName; } } while(resolvedName != null); return canonicalName; }3.factorybean name, 带 & 前缀，通过它获取 BeanDefinition 的时候须要去除 & 前缀。
如果是 factorybean name，示意这是个工厂 bean，有携带前缀修饰符&的，间接把前缀去掉。见BeanFactoryUtils.transformedBeanName:public static String transformedBeanName(String name) { Assert.notNull(name, "'name' must not be null"); return !name.startsWith("&") ? name : (String)transformedBeanNameCache.computeIfAbsent(name, (beanName) -> { do { beanName = beanName.substring("&".length()); } while(beanName.startsWith("&")); return beanName; }); }
3、合并RootBeanDefinition（合并本地的bean）
从配置文件读取的BeanDefinition是 GenericBeanDefinition它的记录了一些以后类申明的属性或结构参数，然而对于父类只用了一个 parentName 来记录。public class GenericBeanDefinition extends AbstractBeanDefinition { ... private String parentName; ...}实例化 Bean 的时候，应用的 BeanDefinition 是 RootBeanDefinition 类型而非 GenericBeanDefinition。
GenericBeanDefinition 在有继承关系的状况下，定义的信息有余：
如果不存在继承关系，GenericBeanDefinition 存储的信息是残缺的，能够间接转化为 RootBeanDefinition。
如果存在继承关系，GenericBeanDefinition 存储的是 增量信息 而不是 全量信息。实际上干活的还是AbstractBeanFactory.doGetBean
protected <T> T doGetBean ... { ... // 合并父类定义 final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); ... // 应用合并后的定义进行实例化 bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd); ...}在判断 parentName 存在的状况下，阐明存在父类定义，启动合并。如果父类还有父类，递归调用，持续合并。
protected RootBeanDefinition getMergedBeanDefinition( String beanName, BeanDefinition bd, BeanDefinition containingBd) throws BeanDefinitionStoreException { ... String parentBeanName = transformedBeanName(bd.getParentName()); ... // 递归调用，持续合并父类定义 pbd = getMergedBeanDefinition(parentBeanName); ... // 应用合并后的残缺定义，创立 RootBeanDefinition mbd = new RootBeanDefinition(pbd); // 应用以后定义，对 RootBeanDefinition 进行笼罩 mbd.overrideFrom(bd); ... return mbd; }每次合并完父类定义后，都会调用 RootBeanDefinition.overrideFrom 对父类的定义进行笼罩，获取到以后类可能正确实例化的 全量信息。
解决循环依赖的问题（临时说一下，当前详细分析）
假如TestA中须要注入TestB，TestB中须要注入TestA。
对象创立胜利后，会在singletonFactories中保留一个对象工厂ObjectFactory，调用这个ObjectFactory的getObject()就能够在任何中央获取刚创立的对象。
这样当TestB在获取TestA的时候，发现singletonFactories中有个工厂能够获取到TestA，那么就间接调用他，最初会进入上面这个办法protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) { Object exposedObject = bean; if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) { List<SmartInstantiationAwareBeanPostProcessor> smartInstantiationAware = getBeanPostProcessorCache().smartInstantiationAware; for (SmartInstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().smartInstantiationAware) { exposedObject = bp.getEarlyBeanReference(exposedObject, beanName); } } return exposedObject;}所有实现了SmartInstantiationAwareBeanPostProcessor接口类的getEarlyBeanReference()尝试做最初的批改，这个办法返回的只是传递过去的对象。
这样依赖循环就解决了。
4、创立实例
获取到残缺的 RootBeanDefintion 后，就能够拿这份定义信息来实例具体的 Bean。（创立实例由AbstractAutowireCapableBeanFactory接手，在spring容器架构外面有具体内容）
源码解析：具体实例创立见 AbstractAutowireCapableBeanFactory.createBeanInstance//调用解析办法解析转进来的BeanClass<?> 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 {//是否有其余的类将本地bean实例了 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; // 为false阐明无参，true有参 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); } // 依据bean的定义解析参数 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); } } } } }返回 Bean 的包装类 BeanWrapper，一共有三种策略：
应用工厂办法创立，instantiateUsingFactoryMethod 。
应用工厂办法创立，会先应用 getBean 获取工厂类，而后通过参数找到匹配的工厂办法，调用实例化办法实现实例化，具体见ConstructorResolver.instantiateUsingFactoryMethod ：public BeanWrapper instantiateUsingFactoryMethod ... ( ... String factoryBeanName = mbd.getFactoryBeanName(); ... factoryBean = this.beanFactory.getBean(factoryBeanName); ... // 匹配正确的工厂办法 ... beanInstance = this.beanFactory.getInstantiationStrategy().instantiate(...); ... bw.setBeanInstance(beanInstance); return bw;}应用无参构造函数创立，instantiateBean。
应用无参构造函数创立是最简略的形式，见 AbstractAutowireCapableBeanFactory.instantiateBean:protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) { try { Object beanInstance; final BeanFactory parent = this; if (System.getSecurityManager() != null) { beanInstance = AccessController.doPrivileged((PrivilegedAction<Object>) () -> getInstantiationStrategy().instantiate(mbd, beanName, parent), getAccessControlContext()); } else { // 创立一个bean beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent); } // 初始化BeanWrapper并返回 BeanWrapper bw = new BeanWrapperImpl(beanInstance); initBeanWrapper(bw); return bw; } catch (Throwable ex) { throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex); }}应用有参构造函数创立，autowireConstructor。
应用有参构造函数创立，整个过程比较复杂，波及到参数和结构器的匹配。为了找到匹配的结构器，Spring 花了大量的工作，见 ConstructorResolver.autowireConstructor ：public BeanWrapper autowireConstructor ... { ... Constructor<?> constructorToUse = null; ... // 匹配构造函数的过程 ... beanInstance = this.beanFactory.getInstantiationStrategy().instantiate(...); ... bw.setBeanInstance(beanInstance); return bw;}
拿到了构造函数，并没有立刻实例化。因为用户应用了 replace 和 lookup 的配置办法，用到了动静代理退出对应的逻辑。如果没有的话，间接应用反射来创立实例。创立实例后，就能够开始注入属性和初始化等操作。如果是 FactoryBean 的话须要应用 getObject 办法来创立实例。见 AbstractBeanFactory.getObjectForBeanInstance ，会执行到 FactoryBeanRegistrySupport.doGetObjectFromFactoryBean 。- getObjectForBeanInstance 源码： ```Java protected Object getObjectForBeanInstance( Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) { // Don't let calling code try to dereference the factory if the bean isn't a factory. // 如果beanname是&结尾的，这个bean必须是FactoryBean类型 if (BeanFactoryUtils.isFactoryDereference(name)) { if (beanInstance instanceof NullBean) { return beanInstance; } if (!(beanInstance instanceof FactoryBean)) { throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass()); } } // Now we have the bean instance, which may be a normal bean or a FactoryBean. // If it's a FactoryBean, we use it to create a bean instance, unless the // caller actually wants a reference to the factory. // 一般bean或者beanname是&结尾的，返回beanInstance if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) { return beanInstance; } // 是FactoryBean然而没有&结尾的 Object object = null; if (mbd == null) { // bean的定义信息是空的，从缓存中拿 object = getCachedObjectForFactoryBean(beanName); } if (object == null) { //缓存不存在 // Return bean instance from factory. FactoryBean<?> factory = (FactoryBean<?>) beanInstance; // Caches object obtained from FactoryBean if it is a singleton. // mdb为空，并且曾经实例化过 if (mbd == null && containsBeanDefinition(beanName)) { mbd = getMergedLocalBeanDefinition(beanName); } // 是否是用户定义的，而不是程序自身定义的 boolean synthetic = (mbd != null && mbd.isSynthetic()); object = getObjectFromFactoryBean(factory, beanName, !synthetic);//返回factory的getObject办法 } return object; } ```- doGetObjectFromFactoryBean源码： ```Java //调用factoryBean的getObjectType办法返回对象 private Object doGetObjectFromFactoryBean(final FactoryBean<?> factory, final String beanName) throws BeanCreationException { Object object; try { if (System.getSecurityManager() != null) { AccessControlContext acc = getAccessControlContext(); try { object = AccessController.doPrivileged((PrivilegedExceptionAction<Object>) factory::getObject, acc); } catch (PrivilegedActionException pae) { throw pae.getException(); } } else { object = factory.getObject();//调用factoryBean的getObjectType办法返回对象 } } catch (FactoryBeanNotInitializedException ex) { throw new BeanCurrentlyInCreationException(beanName, ex.toString()); } catch (Throwable ex) { throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex); } // Do not accept a null value for a FactoryBean that's not fully // initialized yet: Many FactoryBeans just return null then. if (object == null) { if (isSingletonCurrentlyInCreation(beanName)) { throw new BeanCurrentlyInCreationException( beanName, "FactoryBean which is currently in creation returned null from getObject"); } //没获取到对象，返回NullBean object = new NullBean(); } return object; } ```5、注入属性
实例创立完后开始进行属性的注入，如果波及到内部依赖的实例，会自动检索并关联到该以后实例。入口办法在AbstractAutowireCapableBeanFactory.populateBean。
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) { if (bw == null) { // 如果BeanWrapper为空，然而有属性值，就跑异样 if (mbd.hasPropertyValues()) { 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, // to support styles of field injection. // 看看InstantiationAwareBeanPostProcessors是否有注入值，如果有注入，就不持续注入，间接返回 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) { return; } PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null); if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) { // 拷贝配置信息 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; } // r容器是否有InstantiationAwareBeanPostProcessors boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors(); // 是否进行依赖查看 boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE); PropertyDescriptor[] filteredPds = null; if (hasInstAwareBpps) { if (pvs == null) { pvs = mbd.getPropertyValues(); } // 后置解决 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) { // 此时才开始赋值 applyPropertyValues(beanName, mbd, bw, pvs); }}利用 InstantiationAwareBeanPostProcessor 处理器，在属性注入前后进行解决。假如咱们应用了 @Autowire 注解，这里会调用到 AutowiredAnnotationBeanPostProcessor 来对依赖的实例进行检索和注入的，它是 InstantiationAwareBeanPostProcessor 的子类。
依据名称或者类型进行主动注入，存储后果到 PropertyValues 中。
利用 PropertyValues，填充到 BeanWrapper。这里在检索依赖实例的援用的时候，会递归调用 BeanFactory.getBean 来取得。
6、初始化
1、触发Aware，Spring 在初始化阶段，如果判断 Bean 实现了这几个接口之一，就会往 Bean 中注入它关怀的资源。见 AbstractAutowireCapableBeanFactory.invokeAwareMethos :
protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd) throws Throwable { boolean isInitializingBean = (bean instanceof InitializingBean); // 如果是InitializingBean并且有afterPropertiesSet，调用afterPropertiesSet办法 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，但没有afterPropertiesSet，调用自定义的办法 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); } }}2、触发 BeanPostProcessor，Spring 框架提供了 BeanPostProcessor 来达成这个指标。
/** BeanPostProcessors to apply in createBean */private final List<BeanPostProcessor> beanPostProcessors = new ArrayList<BeanPostProcessor>();Bean 实例化前后，Spring 会去调用咱们曾经注册的 beanPostProcessors 把处理器都执行一遍。
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName) throws BeansException { Object result = existingBean; // 获取BeanPostProcessor解决 for (BeanPostProcessor processor : getBeanPostProcessors()) { Object current = processor.postProcessBeforeInitialization(result, beanName); if (current == null) { return result; } result = current; } return result;}public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeansException { Object result = existingBean; // 获取BeanPostProcessor解决 for (BeanPostProcessor processor : getBeanPostProcessors()) { Object current = processor.postProcessAfterInitialization(result, beanName); if (current == null) { return result; } result = current; } return result;}这里应用了责任链模式，Bean 会在处理器链中进行传递和解决。当咱们调用 BeanFactory.getBean 的后，执行到 Bean 的初始化办法 AbstractAutowireCapableBeanFactory.initializeBean 会启动这些处理器。
public Object initializeBean(Object existingBean, String beanName) { return initializeBean(beanName, existingBean, null);}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 { // 调用BeanNameAware、BeanClassLoaderAware、BeanFactoryAware invokeAwareMethods(beanName, bean); } Object wrappedBean = bean; if (mbd == null || !mbd.isSynthetic()) { // 前置处理器 wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); } try { // 初始化办法 invokeInitMethods(beanName, wrappedBean, mbd); } 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); } return wrappedBean;}3、触发自定义init
自定义初始化有两种形式能够抉择：
实现 InitializingBean。提供了一个很好的机会，在属性设置实现后再退出本人的初始化逻辑。 定义 init 办法。自定义的初始化逻辑。 见 AbstractAutowireCapableBeanFactory.invokeInitMethods ：protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd) throws Throwable { boolean isInitializingBean = (bean instanceof InitializingBean); // 如果是InitializingBean并且有afterPropertiesSet，调用afterPropertiesSet办法 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，但没有afterPropertiesSet，调用自定义的办法 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); } }}
7、类型转换
Bean 曾经加载结束，属性也填充好了，初始化也实现了。
在返回给调用者之前，还留有一个机会对 Bean 实例进行类型的转换。见 AbstractBeanFactory.doGetBean ：//调用dogetBean办法//以下办法根本都是对dogetbean参数的判断 protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException { // 获取bean后将转换后的bean赋值给beanName String beanName = this.transformedBeanName(name); Object bean; // 获取上方单例bean Object sharedInstance = this.getSingleton(beanName); //判断是否有单例BEAN，如果有BEAN并且没有args参数进入此办法 if (sharedInstance != null && args == null) { // 判断是否启用日志追踪 if (this.logger.isTraceEnabled()) { // 判断获取的单例bean是否曾经加载了 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"); // 如果获取的单例bean没有加载就纪录这条 } else { this.logger.trace("Returning cached instance of singleton bean '" + beanName + "'"); } } // 一般的bean间接返回FactoryBean，返回他的getObject bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null); // 如果没有单例BEAN，或者有BEAN并且有args参数进入此办法 } else { //没创立过bean或者是多例的状况或者有参数的状况 //创立过Prototype的bean，会循环援用，抛出异样，单例才尝试解决循环依赖的问题 if (this.isPrototypeCurrentlyInCreation(beanName)) { // 就抛出异样 Bean 以后正在创立异样 throw new BeanCurrentlyInCreationException(beanName); } // 获取父类工厂 BeanFactory parentBeanFactory = this.getParentBeanFactory(); //如果父类工厂不为空，beanName不存在也就是没有拿到本地的bean if (parentBeanFactory != null && !this.containsBeanDefinition(beanName)) { // 给调用者原始bean String nameToLookup = this.originalBeanName(name); //如果父类工厂实例形象bean工厂 if (parentBeanFactory instanceof AbstractBeanFactory) { //返回形象形象bean工厂的父类工厂，调用dogetbean办法 return ((AbstractBeanFactory)parentBeanFactory).doGetBean(nameToLookup, requiredType, args, typeCheckOnly); } // 如果参数不为空 if (args != null) { return parentBeanFactory.getBean(nameToLookup, args); } // requiredType： 返回的类型 if (requiredType != null) { return parentBeanFactory.getBean(nameToLookup, requiredType); } // nameToLookup要查找的名称 return parentBeanFactory.getBean(nameToLookup); } // 如果查看类型不为空 if (!typeCheckOnly) { // markBeanAsCreated将 Bean 标记为已创立 this.markBeanAsCreated(beanName); } try { //获取本地的BeanDefinition（获取合并的本地 Bean 定义也即是BeanDefinition） RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName); //查看合并BeanDefinition this.checkMergedBeanDefinition(mbd, beanName, args); //通过本地的BeanDefinition获取他的依赖 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]; // 查看是否循环依赖，a依赖b，b依赖a。包含传递的依赖，比方a依赖b，b依赖c，c依赖a 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); bean的定义异样 } catch (NoSuchBeanDefinitionException var24) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", var24); } } } // 如果本地的BeanDefinition是单例 if (mbd.isSingleton()) { // 给调用者创立一个BeanDefinition sharedInstance = this.getSingleton(beanName, () -> { try { //创立bean return this.createBean(beanName, mbd, args); // bean异样，销毁 } catch (BeansException var5) { this.destroySingleton(beanName); throw var5; } }); // 如果是一般bean，间接返回，是FactoryBean，返回他的getObject bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd); // 本地BeanDefinition是最后的bean（就是原型bean） } else if (mbd.isPrototype()) { var11 = null; // 定义一个原型bean Object prototypeInstance; try { // 退出一个prototypesCurrentlyInCreation this.beforePrototypeCreation(beanName); //在创立原型bean前创立一个beanBeanDefinition prototypeInstance = this.createBean(beanName, mbd, args); // 最终移除prototypesCurrentlyInCreation } finally { this.afterPrototypeCreation(beanName); } // 如果是一般bean，间接返回，是FactoryBean，返回他的getObject bean = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd); } else { //获取本地的BeanDefinition的作用域 String scopeName = mbd.getScope(); // 通过全局作用域获取以后bean Scope scope = (Scope)this.scopes.get(scopeName); // 如果作用域为空则bean不存在 if (scope == null) { // 抛出异样，bean状态异样 throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'"); } try { //退出一个prototypesCurrentlyInCreation Object scopedInstance = scope.get(beanName, () -> { // 在创立原型bean前创立一个beanBeanDefinition this.beforePrototypeCreation(beanName); Object var4; try { var4 = this.createBean(beanName, mbd, args); //最终移除prototypesCurrentlyInCreation } finally { this.afterPrototypeCreation(beanName); } return var4; }); // 如果是一般bean，间接返回，是FactoryBean，返回他的getObject 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; } } // 如果类型不为空，beanName不存在也就是没有拿到本地的bean if (requiredType != null && !requiredType.isInstance(bean)) { try { //调用类型转换器进行bean的转换 T convertedBean = this.getTypeConverter().convertIfNecessary(bean, requiredType); 如果转换后的bean还是为空 if (convertedBean == null) { //抛出bean类型异样 throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass()); // 间接返回转换后的bean } 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; } }