18.Spring创建Bean源码-创建bean,非常细!

最新推荐文章于 2024-08-05 23:51:30 发布

然而,然而

最新推荐文章于 2024-08-05 23:51:30 发布

阅读量241

点赞数

文章标签： spring 数学建模 java 后端开发语言

本文链接：https://blog.csdn.net/qq_30635523/article/details/131325602

版权

highlight: arduino-light

5.6registerBeanPostProcessors(beanFactory)

```java public static void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) { /** AutowiredAnnotationProcessor 实现了PriorityOrdered CommonAnnotationProcessor 实现了PriorityOrdered AnnotationAwareAspectJAutoProxyCreator 实现了ordered */ String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

/**
 ApplicationContextAwareProcessor
 ApplicationListenerDetector
 ConfigurationClassPostProcessor$ImportAwareBeanPostProcessor
*/

//上面3个+下面3个 + 1个 BeanPostProcessorChecker = 7
int beanProcessorTargetCount = beanFactory
                        .getBeanPostProcessorCount() + 1 + postProcessorNames.length;
beanFactory.addBeanPostProcessor
        (new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));


//实现了 PriorityOrdered, BeanPostProcessors
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
//实现了 PriorityOrdered 且是 MergedBeanDefinitionPostProcessor类型
//就是 internalPostProcessors
List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
//实现了 Ordered, BeanPostProcessors
List<String> orderedPostProcessorNames = new ArrayList<>();
//既没有实现PriorityOrdered也没有实现Ordered PriorityOrdered, BeanPostProcessors
List<String> nonOrderedPostProcessorNames = new ArrayList<>();

/**
 ApplicationContextAwareProcessor
 ApplicationListenerDetector
 ConfigurationClassPostProcessor$ImportAwareBeanPostProcessor
 */
//筛选类型放入对应集合
//首先创建并注册实现了PriorityOrdered的BeanPostProcessors
for (String ppName : postProcessorNames) {
        if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                /**
                 * doCreate 实例化BeanPostProcessor
                 * 放入beanFactory
                 */
                BeanPostProcessor pp = beanFactory.getBean
                                                        (ppName, BeanPostProcessor.class);
                priorityOrderedPostProcessors.add(pp);
                if (pp instanceof MergedBeanDefinitionPostProcessor) {
                        internalPostProcessors.add(pp);
                }
        }else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
                orderedPostProcessorNames.add(ppName);
        }else {
                nonOrderedPostProcessorNames.add(ppName);
        }
}

/***
 * 0 = {CommonAnnotationBeanPostProcessor@1739}
 * 1 = {AutowiredAnnotationBeanPostProcessor@1689}
 */
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
//上面是放入beanFactory
//这里是放入beanPostProcessors集合中
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

// 下一步创建并注册实现了Ordered的BeanPostProcessors
List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
for (String ppName : orderedPostProcessorNames) {
        /**
         * doCreate 实例化BeanPostProcessor
         * 放入beanFactory
         */
        BeanPostProcessor pp = beanFactory.getBean
                                                (ppName, BeanPostProcessor.class);
        orderedPostProcessors.add(pp);
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
                internalPostProcessors.add(pp);
        }
}

/**
AnnotationAwareAspectJAutoProxyCreator在这里加入的
*/
sortPostProcessors(orderedPostProcessors, beanFactory);
//上面是放入beanFactory
//这里是放入beanPostProcessors集合中
registerBeanPostProcessors(beanFactory, orderedPostProcessors);

// 创建并注册没有实现任何Ordered的BeanPostProcessors
List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
for (String ppName : nonOrderedPostProcessorNames) {
        /**
         * doCreate 实例化BeanPostProcessor
         * 放入beanFactory
         */
        BeanPostProcessor pp = beanFactory.getBean
                                                        (ppName, BeanPostProcessor.class);
        nonOrderedPostProcessors.add(pp);
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
                internalPostProcessors.add(pp);
        }
}

/***
 *空集合
 */
//上面是放入beanFactory
//这里是放入beanPostProcessors集合中
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

// 最后创建并注册内部BeanPostProcessors
//   MergedBeanDefinitionPostProcessor类型
/**
0 = {CommonAnnotationBeanPostProcessor@2252}
1 = {AutowiredAnnotationBeanPostProcessor@2253}
*/
sortPostProcessors(internalPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, internalPostProcessors);

// Re-register post-processor for detecting inner beans as ApplicationListeners,
// moving it to the end of the processor chain (for picking up proxies etc).
//注册了一个BeanPostProcessor?
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));

} ```

5.6.1getBeanNamesForType

5.6.1.1getMergedLocalBeanDefinition(beanName)

1.遍历所有的beanDefinitionNames
    
    2.首先从map缓存中获取 获取到直接返回
    
    3.获取不到首先根据beanDefinitionName获取对应 beanDefinition
    
    4.判断是否有父类,没有父类直接将当前BD包装返回一个RootBeanDefinition
    
    5.有父类,继续递归调用getMergedBeanDefinition(String name)
    
    先从缓存mergedBeanDefinitions中获取 如果获取不到判断是否有父类 没有父类 
    如果有父类 那么先合并父类的BD 如果父类还有父类 那么先合并爷爷类
    等父类的BD都合并完毕 基于父类去合并bean的BD
    具体做法是 基于父类 使用子类的属性覆盖父类的属性
    比如 父类有A方法 B属性 C属性
    子类有A方法 B属性 没有C属性
    那么在覆盖的时候 子类A方法会覆盖父类A方法
    那么在覆盖的时候 子类B属性会覆盖父类B属性
    那么在覆盖的时候 子类没有C属性 父类有C属性 因为是直接基于父类构建所以子类也有C属性
    
    6.判断类型是否匹配
    
    7.如果匹配加入返回的集合中

5.6.2遍历BPP集合对BPP进行分类

1.实现了PriorityOrdered接口
    2.实现了Ordered接口
    3.没有实现任何Order接口
    4.BPP类型是MergedBeanDefinitionPostProcessor

5.6.3创建&排序&注册BeanPostProcessor

使用doGetBean创建Bean,所谓的注册就是加入BeanFactory的集合中。

以实现了PriorityOrdered的BeanPostProcessors为例

java //筛选类型放入对应集合 // 首先创建并注册实现了PriorityOrdered的BeanPostProcessors for (String ppName : postProcessorNames) { if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) { /** * doCreate 实例化BeanPostProcessor */ BeanPostProcessor pp = beanFactory.getBean (ppName, BeanPostProcessor.class); priorityOrderedPostProcessors.add(pp); if (pp instanceof MergedBeanDefinitionPostProcessor) { internalPostProcessors.add(pp); } }else if (beanFactory.isTypeMatch(ppName, Ordered.class)) { orderedPostProcessorNames.add(ppName); }else { nonOrderedPostProcessorNames.add(ppName); } } /*** * 0 = {CommonAnnotationBeanPostProcessor@1739} * 1 = {AutowiredAnnotationBeanPostProcessor@1689} */ sortPostProcessors(priorityOrderedPostProcessors, beanFactory); registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

5.7initMessageSource

5.8onRefresh:扩展点

5.9finishBeanFactoryInitialization

实例化所有的非懒加载的单例bean

5.9.1preInstantiateSingletons

java @Override public void preInstantiateSingletons() throws BeansException { if (logger.isTraceEnabled()) { logger.trace("Pre-instantiating singletons in " + this); } /*** * 放置所有bean的name */ List<String> beanNames = new ArrayList<>(this.beanDefinitionNames); // Trigger initialization of all non-lazy singleton beans... /*** * 循环所有需要创建的beanName 依次创建bean */ for (String beanName : beanNames) { /*** 合并父BeanDefinition对象 GenericBeanDefinition源码实现非常的的简单，只增加了一个parentName的属性值其余的实现都在父类AbstractBeanDefinition里备注：若你是xml配置，最初被加载进来都是一个GenericBeanDefinition，之后再逐渐解析的。 ChildBeanDefinition：子Bean定义信息，依赖于父类RootBeanDefinition ChildBeanDefinition是一种bean definition 它可以继承父类的设置，即ChildBeanDefinition对RootBeanDefinition有一定的依赖关系。功能和GenericBeanDefinition差不多所以此处忽略~ 从spring 2.5 开始，提供了一个更好的注册bean definition类 GenericBeanDefinition，所以以后推荐使用它。 RootBeanDefinition：一个RootBeanDefinition定义表明它是一个可合并的bean definition：即在spring beanFactory运行期间，可以返回一个特定的bean 但在Spring2.5以后，我们绝大多数情况还是可以使用GenericBeanDefinition来做。我们非常熟悉的final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); 这句代码，就是去合并parent的属性进来，这样体现了继承的强大。属性也才完整。*/ RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName); /*** * 非抽象 && 单例 && 非懒加载 */ if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) { //判断是否实现了FactoryBean接口 //如果实现了FactoryBean接口那么需要先创建FactoryBean //在bean非懒加载情况下会立刻再创建FactoryBean生成的Bean if (isFactoryBean(beanName)) { Object bean = getBean(FACTORY_BEAN_PREFIX + beanName); if (bean instanceof FactoryBean) { FactoryBean<?> factory = (FactoryBean<?>) bean; boolean isEagerInit; if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) { isEagerInit = AccessController.doPrivileged( (PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit, getAccessControlContext()); }else { //如果是SmartFactoryBean类型 //且SmartFactoryBean的isEagerInit()返回的是true isEagerInit = (factory instanceof SmartFactoryBean && ((SmartFactoryBean<?>) factory).isEagerInit()); } /*** * 是否立即加载如果是立即加载那么开始创建bean */ if (isEagerInit) { /*** * 创建bean入口 */ getBean(beanName); } } }else { //懒加载 getBean(beanName); } } } // Trigger post-initialization callback for all applicable beans... for (String beanName : beanNames) { Object singletonInstance = getSingleton(beanName); if (singletonInstance instanceof SmartInitializingSingleton) { SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance; if (System.getSecurityManager() != null) { AccessController.doPrivileged((PrivilegedAction<Object>) () -> { smartSingleton.afterSingletonsInstantiated(); return null; }, getAccessControlContext()); } else { smartSingleton.afterSingletonsInstantiated(); } } } }

### 5.9.1.1遍历beanDefinitionNames

5.9.1.2合并beanDefinition

5.9.1.3判断非抽象&&单例&&饥渴加载

lazyInit默认是false即不采用懒加载,如果你希望自己配置的bean不要懒加载，而是在Spring容器初始化时就率先去加载它，那你完全可以为这个bean配置属性lazyInit的值为false。

java if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit())

5.9.1.4转换beanName,判断是否是FactoryBean

```java @Override public boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException { //转换beanName 去掉& //注意这里是去掉了& //所以不管是传入&userFactoryBean还是传入userFactory //最后返回的都是userFactory //userFactory对应的类型就是FactoryBean //最后具体返回的是FactoryBean还是FactoryBean创建的对象 //取决于传入的是&userFactoryBean还是userFactory //同时还做了别名转换 String beanName = transformedBeanName(name); //从缓存中获取beanInstance Object beanInstance = getSingleton(beanName, false); if (beanInstance != null) { //返回是否是 FactoryBean return (beanInstance instanceof FactoryBean); }

if (!containsBeanDefinition(beanName) && getParentBeanFactory() instanceof ConfigurableBeanFactory) { return ((ConfigurableBeanFactory) getParentBeanFactory()).isFactoryBean(name); } return isFactoryBean(beanName, getMergedLocalBeanDefinition(beanName)); } ```

java protected String transformedBeanName(String name) { //在BeanFactoryUtils的方法transformedBeanName中其实就干了一件事 //如果发现name以一个或多个符号“&”为前缀 //那就剔除掉name前缀中的“&”，直到name前缀中的符号“&”都剔除干净了才返回name。 return canonicalName(BeanFactoryUtils.transformedBeanName(name)); }

java public String canonicalName(String name) { String canonicalName = name; // Handle aliasing... String resolvedName; do { resolvedName = this.aliasMap.get(canonicalName); if (resolvedName != null) { canonicalName = resolvedName; } } while (resolvedName != null); return canonicalName; }

可以看到，在方法canonicalName中，其实就是通过参数传进来的name，到别名缓存alilasMap中获取bean的实际名称，之前我们在BeanDefinition注册到Spring容器之后，也看到了别名的注册逻辑。

canonicalName方法的处理也比较好理解，因为我们是通过getBean方法，让Spring来实例化name对应的bean，那Spring肯定要确保你传进来的bean名称name，得要尽最大的可能获取到Spring容器中的BeanDefinition。

当然，如果用户调用getBean方法时传进来一些错误的name，Spring是无可奈何的，肯定是获取不到相应的BeanDefinition来实例化bean的，但是，如果你传进来的name是bean的别名，那Spring还是有一定的纠错能力的，而方法canonicalName就是Spring将别名转换为bean实际名称的一个方法。

比如当bean在注册BeanDefinition时，BeanDefinition相应注册的名称为student，但是，如果这个bean的别名同时又被设置为student1，这个时候如果你通过student1这个别名，去Spring容器中获取BeanDefinition当然就获取不到了。

因为在别名缓存aliasMap中，存放了bean的别名student1到bean的实际名称student的映射，所以，在方法canonicalName中，就可以通过别名缓存aliasMap，根据别名student1获取bean的实际名称student，这样Spring再拿着bean的实际名称student，就可以从Spring容器中获取到bean的BeanDefinition了。

java protected boolean isFactoryBean(String beanName, RootBeanDefinition mbd) { Class<?> beanType = predictBeanType(beanName, mbd, FactoryBean.class); //判断是否是FactoryBean类型 return (beanType != null && FactoryBean.class.isAssignableFrom(beanType)); } @Nullable protected Class<?> predictBeanType(String beanName, RootBeanDefinition mbd, Class<?>... typesToMatch) { Class<?> targetType = mbd.getTargetType(); if (targetType != null) { return targetType; } if (mbd.getFactoryMethodName() != null) { return null; } //resolveBeanClass //获取mbd配置的bean类名将bean类名解析为Class对象 //并将解析后的Class对象缓存在mdb中以备将来使用 return resolveBeanClass(mbd, beanName, typesToMatch); }

5.9.1.4.1doGetBean获取FactoryBean实例

具体的看5.9.1.6.1

如果是实现了FactoryBean接口类型那么调用doGetBean加载FactoryBean

注意这里获取的是FactoryBean实例

java //使用&+beanName 去获取Bean Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);

获取到bean以后继续往下看。

然后会判断bean instanceof FactoryBean,如果是true。

那么调用doGetBean加载FactoryBean创建的bean。

java if (bean instanceof FactoryBean) { FactoryBean<?> factory = (FactoryBean<?>) bean; boolean isEagerInit; if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) { isEagerInit = AccessController .doPrivileged((PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory) ::isEagerInit,getAccessControlContext()); }else { //对于FactoryBean isEagerInit 默认是true //对于SmartFactoryBean,因为可以重写isEagerInit() 所以这里需要特殊处理 //如果是SmartFactoryBean类型需要获取SmartFactoryBean的isEagerInit()返回值 isEagerInit = (factory instanceof SmartFactoryBean && ((SmartFactoryBean<?>) factory).isEagerInit()); } //是否立即加载如果是立即加载那么创建Factory创建的bean if (isEagerInit) { //创建bean入口 getBean(beanName); } }

当我们调用

java context.getBean("&userFactoryBean");

java protected <T> T doGetBean( String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException { //解析bean 如果以&开头去掉& 如果是别名获取真正的名字 String beanName = transformedBeanName(name); Object bean; //获取到UserFactoryBean Object sharedInstance = getSingleton(beanName); //进入判断直接根据名称返回对应的类型 if (sharedInstance != null && args == null) { bean = getObjectForBeanInstance(sharedInstance, name, beanName, null); } else { //省略部分代码 } return (T) bean; }

5.9.1.5判断不是FactoryBean

5.9.1.5.1doGetBean获取实例

调用doGetBean直接去加载bean,具体的看5.9.1.6.1

java @Override public Object getBean(String name) throws BeansException { assertBeanFactoryActive(); return getBeanFactory().getBean(name); }

java @Override public Object getBean(String name) throws BeansException { //对应 getBean("orange") return doGetBean(name, null, null, false); }

由5.9.1.4和5.9.1.5可以看出来最后走的都是doGetBean。

但是getBean(beanName)中的参数beanName不一样!

getBean(FACTORYBEANPREFIX + beanName);

getBean(beanName);

5.9.1.6.1doGetBean(name, null, null, false);

```java @SuppressWarnings("unchecked") protected T doGetBean( String name, @Nullable Class requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException { //解析bean 如果以&开头去掉& 如果是别名获取真正的名字 String beanName = transformedBeanName(name); Object bean;

/***
     * 从缓存中获取如果一级缓存不在 则从二级缓存获取 如果二级缓存不在 则从三级缓存获取
     * 如果三级缓存存在则从三级缓存拿出ObjectFactory调用getObject获取bean
     //最后将bean从三级缓存移除 放到二级缓存
     * singletonObjects 一级缓存池
     * earlySingletonObjects 二级缓存池
     * singletonFactories 三级缓存池
     */
    Object sharedInstance = getSingleton(beanName);

if (sharedInstance != null && args == null) { /* * 如果实现了FactoryBean接口需要获取具体对象要使用下面的方法进行获取 * 如果没有实现FactoryBean接口会直接返回传递进来的beanInstance / bean = getObjectForBeanInstance(sharedInstance, name, beanName, null); } else { //当对象都是单例的时候会尝试解决循环依赖的问题 //但是原型模式下如果存在循环依赖的情况，那么直接抛出异常 if (isPrototypeCurrentlyInCreation(beanName)) { throw new BeanCurrentlyInCreationException(beanName); } // 检查父工厂是否存在该对象 spring mvc父子容器 BeanFactory parentBeanFactory = getParentBeanFactory(); // 如果beanDefinitionMap中也就是在所有已经加载的类中不包含beanName // 那么就尝试从父容器中获取 //即先从子容器获取子容器不存在再从父容器获取 if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { 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); } } // 如果不是做类型检查，那么表示要创建bean，此处在集合中做一个记录 if (!typeCheckOnly) { // 为beanName标记为已经创建(或将要创建) markBeanAsCreated(beanName); } try { // 此处要做类型转换，如果是子类bean的话，会合并父类的相关属性 RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); // 检查mbd的合法性，不合格会引发验证异常 checkMergedBeanDefinition(mbd, beanName, args); / 处理depends on属性即处理创建先后顺序的依赖关系如A依赖B则B先创建才能创建A 如果存在依赖的bean的话，那么则优先实例化依赖的bean 使用Spring @DependsOn控制bean加载顺序我们可以在bean A上使用@DependsOn注解，告诉容器bean B应该先被初始化。 */ String[] dependsOn = mbd.getDependsOn(); if (dependsOn != null) { for (String dep : dependsOn) { if (isDependent(beanName, dep)) { throw new BeanCreationException(); } registerDependentBean(dep, beanName); try { //继续doGetBean getBean(dep); } catch (NoSuchBeanDefinitionException ex) { throw new BeanCreationException(); } } } // Create bean instance. // 创建bean的实例对象 if (mbd.isSingleton()) { / * 从一级缓存singletonObjects获取bean对象 * 获取到了就直接返回 * 获取不到那么将传入的 createBean(beanName, mbd, args); / sharedInstance = getSingleton(beanName, () -> { try { //创建Bean return createBean(beanName, mbd, args); } catch (BeansException ex) { destroySingleton(beanName); throw ex; } }); / * 如果实现了FactoryBean接口需要获取具体对象要使用下面的方法进行获取 * 如果没有实现FactoryBean接口会直接返回传递进来的beanInstance */ bean = getObjectForBeanInstance (sharedInstance, name, beanName, mbd); } else if (mbd.isPrototype()) { Object prototypeInstance = null; try { beforePrototypeCreation(beanName); prototypeInstance = createBean(beanName, mbd, args); } finally { afterPrototypeCreation(beanName); } bean = getObjectForBeanInstance (prototypeInstance, name, beanName, mbd); } else { String scopeName = mbd.getScope(); if (!StringUtils.hasLength(scopeName)) { throw new IllegalStateException(); } Scope scope = this.scopes.get(scopeName); if (scope == null) { throw new IllegalStateException(); } 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(); } } } catch (BeansException ex) { cleanupAfterBeanCreationFailure(beanName); throw ex; } }

if (requiredType != null && !requiredType.isInstance(bean)) { try { T convertedBean = getTypeConverter() .convertIfNecessary(bean, requiredType); if (convertedBean == null) { throw new BeanNotOfRequiredTypeException(); } return convertedBean; } catch (TypeMismatchException ex) { throw new BeanNotOfRequiredTypeException (name, requiredType, bean.getClass()); } } return (T) bean; } ```

5.9.1.6.1.1从缓存中获取

从缓存中获取 Object sharedInstance = getSingleton(beanName)

java @Nullable protected Object getSingleton(String beanName, boolean allowEarlyReference) { //是否应创建早期引用 allowEarlyReference is true Object singletonObject = this.singletonObjects.get(beanName); //一级缓存中该bean为空且当前 bean 正在创建才能去2级缓存拿 if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) { //2级缓存中获取 singletonObject = this.earlySingletonObjects.get(beanName); if (singletonObject == null && allowEarlyReference) { synchronized (this.singletonObjects) { singletonObject = this.singletonObjects.get(beanName); if (singletonObject == null) { singletonObject = this.earlySingletonObjects.get(beanName); if (singletonObject == null) { //3级缓存中获取 ObjectFactory<?> singletonFactory =this.singletonFactories.get(beanName); if (singletonFactory != null) { singletonObject = singletonFactory.getObject(); this.earlySingletonObjects .put(beanName, singletonObject); this.singletonFactories.remove(beanName); } } } } } } return singletonObject; }

5.9.1.6.1.1.1如果缓存中存在

调用getObjectForBeanInstance

如果实现了FactoryBean接口需要获取具体对象要使用下面的方法进行获取

如果没有实现FactoryBean接口会直接返回传递进来的beanInstance

java /*** * 如果实现了FactoryBean接口需要根据具体的beanName返回具体的bean * 如果没有实现FactoryBean接口会直接返回传递进来的beanInstance */ bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);

java protected Object getObjectForBeanInstance(Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) { /*** * 如果实现了FactoryBean接口需要获取具体对象要使用下面的方法进行获取 * 如果没有实现FactoryBean接口会直接返回传递进来的beanInstance */ //name原始的名称&开头的 //beanName是去掉了&的名称 //判断name是否以&开头 if (BeanFactoryUtils.isFactoryDereference(name)) { if (beanInstance instanceof NullBean) { return beanInstance; } //进了这个方法beanInstance必须是实现了FactoryBean接口 if (!(beanInstance instanceof FactoryBean)) { throw new BeanIsNotAFactoryException (beanName, 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. if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) { //如果没有实现FactoryBean接口 return beanInstance; } Object object = null; if (mbd == null) { //缓存中获取 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. if (mbd == null && containsBeanDefinition(beanName)) { mbd = getMergedLocalBeanDefinition(beanName); } boolean synthetic = (mbd != null && mbd.isSynthetic()); //从FactoryBean中获取 //调用FactoryBean的getObject方法 //object = factory.getObject(); object = getObjectFromFactoryBean(factory, beanName, !synthetic); } return object; }

5.9.1.6.1.1.2如果缓存中不存在

一般第一次进来的时候在缓存中就是不存在的。

```java //没有从缓存中获取到 else { //当对象都是单例的时候会尝试解决循环依赖的问题 //但是原型模式下如果存在循环依赖的情况，那么直接抛出异常 if (isPrototypeCurrentlyInCreation(beanName)) { throw new BeanCurrentlyInCreationException(beanName); } // 检查父工厂是否存在该对象 spring mvc父子容器 BeanFactory parentBeanFactory = getParentBeanFactory(); // 如果beanDefinitionMap中也就是在所有已经加载的类中不包含beanName // 那么就尝试从父容器中获取 //即先从子容器获取子容器不存在再从父容器获取 if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { 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); } } // 如果不是做类型检查，那么表示要创建bean，此处在集合中做一个记录 if (!typeCheckOnly) { // 为beanName标记为已经创建(或将要创建) markBeanAsCreated(beanName); } try { // 此处要做类型转换，如果是子类bean的话，会合并父类的相关属性 RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); // 检查mbd的合法性，不合格会引发验证异常 checkMergedBeanDefinition(mbd, beanName, args); /** 处理depends on属性即处理创建先后顺序的依赖关系如A依赖B则B先创建才能创建A 如果存在依赖的bean的话，那么则优先实例化依赖的bean 使用Spring @DependsOn控制bean加载顺序我们可以在bean A上使用@DependsOn注解，告诉容器bean B应该先被初始化。 */ String[] dependsOn = mbd.getDependsOn(); if (dependsOn != null) { for (String dep : dependsOn) { if (isDependent(beanName, dep)) { throw new BeanCreationException(); } registerDependentBean(dep, beanName); try { //继续doGetBean getBean(dep); } catch (NoSuchBeanDefinitionException ex) { throw new BeanCreationException(); } } }

// 创建bean的实例对象 if (mbd.isSingleton()) { /* getSingleton (String beanName, ObjectFactory> singletonFactory) 区别于上面的getSingleton(String beanName) 从一级缓存singletonObjects获取bean对象获取到了就直接返回获取不到那么执行:createBean(beanName, mbd, args); / sharedInstance = getSingleton(beanName, () -> { try { //创建Bean return createBean(beanName, mbd, args); } catch (BeansException ex) { destroySingleton(beanName); throw ex; } }); / * 如果实现了FactoryBean接口需要获取具体对象要使用下面的方法进行获取 * 如果没有实现FactoryBean接口会直接返回传递进来的beanInstance */ bean = getObjectForBeanInstance (sharedInstance, name, beanName, mbd); } else if (mbd.isPrototype()) { Object prototypeInstance = null; try { beforePrototypeCreation(beanName); prototypeInstance = createBean(beanName, mbd, args); } finally { afterPrototypeCreation(beanName); } bean = getObjectForBeanInstance (prototypeInstance, name, beanName, mbd); } else { String scopeName = mbd.getScope(); if (!StringUtils.hasLength(scopeName)) { throw new IllegalStateException(); } Scope scope = this.scopes.get(scopeName); if (scope == null) { throw new IllegalStateException(); } 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(); } } } catch (BeansException ex) { cleanupAfterBeanCreationFailure(beanName); throw ex; } }

关键代码

java /*** * 从一级缓存singletonObjects获取bean对象 * 获取到了就直接返回 * 获取不到那么将传入的 createBean(beanName, mbd, args); */ sharedInstance = getSingleton(beanName, () -> { try { /*** * 創建bean對象 */ return createBean(beanName, mbd, args); } catch (BeansException ex) { destroySingleton(beanName); throw ex; } }); /*** * 如果实现了FactoryBean接口需要获取具体对象要使用下面的方法进行获取 * 如果没有实现FactoryBean接口会直接返回传递进来的beanInstance */ bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);

getSingleton(String n, ObjectFactory f)

```java 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) { throw new BeanCreationNotAllowedException(); }

/* * 验证完要真正开始创建对象先标识该bean正在被创建因为bean创建过程复杂步骤很多需要标识 / beforeSingletonCreation(beanName); / * 是否在singletonObjects里存在存在就不再put / boolean newSingleton = false; boolean recordSuppressedExceptions = (this.suppressedExceptions == null); if (recordSuppressedExceptions) { this.suppressedExceptions = new LinkedHashSet<>(); } try { /** * singletonFactory 即 AbstractBeanFactory * singletonFactory是函数式接口 * 注意是在这里创建的bean * 具体创建过程看 * AbstractAutowireCapableBeanFactory#createBean */ singletonObject = singletonFactory.getObject(); newSingleton = true; } catch (IllegalStateException ex) { 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); } if (newSingleton) { //加入一级缓存注意此时放入的是singletonObject 从二三级缓存移除 addSingleton(beanName, singletonObject); } } return singletonObject; } } ```

sharedInstance = getSingleton(beanName, () -> {return createBean(beanName, mbd, args);});

() -> {return createBean(beanName, mbd, args);是一个函数式接口ObjectFactory的匿名实现类。

真正的代码在AbstractAutowireCapableBeanFactory#createBean()

createBean

```java @Override protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)throws BeanCreationException {

RootBeanDefinition mbdToUse = mbd;

/* * 从RootBeanDefinition中获取类信息 * * 锁定class，根据设置的class属性或者根据className来解析class * beanName 参数只是为了抛出异常哈哈哈 / Class> resolvedClass = resolveBeanClass(mbd, beanName); if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) { mbdToUse = new RootBeanDefinition(mbd); mbdToUse.setBeanClass(resolvedClass); } // Prepare method overrides. try { // 验证及准备覆盖的方法,lookup-method replace-method // 当需要创建的bean对象中包含了lookup-method和replace-method标签的时候 // 会产生覆盖操作 /Spring的方法注入可分为两种查找方法注入：用于注入方法返回结果，也就是说能通过配置方式替换方法返回结果。即我们通常所说的lookup-method注入。替换方法注入：可以实现方法主体或返回结果的替换。即我们通常所说的replaced-method注入。 1. lookup-method注入单例模式的bean只会被创建一次，IoC容器会缓存该bean实例以供下次使用原型模式的bean每次都会创建一个全新的bean，IoC容器不会缓存该bean的实例。那么如果现在有一个单例模式的bean引用了一个原型模式的bean呢？如果无特殊处理，则被引用的原型模式的bean也会被缓存，这就违背了原型模式的初衷，这时使用lookup-method注入可以解决该问题。 2. replaced-method注入主要作用就是替换方法体及其返回值，其实现也比较简单 https://blog.csdn.net/lycliyanchao/article/details/82901216 https://blog.csdn.net/qq36882793/article/details/106176923 / mbdToUse.prepareMethodOverrides(); } catch (BeanDefinitionValidationException ex) { throw new BeanDefinitionStoreException(); } try { // postProcessBeforeInstantiation // 给BeanPostProcessors一个机会来返回代理来替代真正的实例 // 应用实例化前的前置处理器,用户自定义动态代理的方式 // 针对于当前的被代理类需要经过标准的代理流程来创建对象 //https://www.cnblogs.com/zhuxiaopijingjing/p/12617712.html //InstantiationAwareBeanPostProcessor 可用于创建自定义代理对象 // 意思是如果我们自己实例化了对象就不需要spring帮我们实例化了 //扩展点如果想返回自定义的对象可以使用实现该接口返回自定义对象 //创建代理的第一个时机:让BeanPostProcessors 有机会返回一个目标bean的代理对象 //创建代理的第一个时机:让BeanPostProcessors 有机会返回一个目标bean的代理对象 //创建代理的第一个时机:让BeanPostProcessors 有机会返回一个目标bean的代理对象 //只有指定targetSource，才会创建代理此时这里返回为null Object bean = resolveBeforeInstantiation(beanName, mbdToUse); if (bean != null) { //注意如果有 InstantiationAwareBeanPostProcessor类型的接口 //并返回了自定义对象这里会直接返回 return bean; } } catch (Throwable ex) { throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", ex); } try { / * 如果上面直接返回了bean 下面的doCreateBean就不会执行 */ Object beanInstance = doCreateBean(beanName, mbdToUse, args); return beanInstance; } catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) { throw ex; } catch (Throwable ex) { throw new BeanCreationException( mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex); } } ```

doCreateBean

```java protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException { // Instantiate the bean. BeanWrapper instanceWrapper = null; if (mbd.isSingleton()) { instanceWrapper = this.factoryBeanInstanceCache.remove(beanName); } if (instanceWrapper == null) { /* * 创建bean实例仅仅是创建bean实例 * instanceWrapper实现了 ConfigurablePropertyAccessor * 是一个包装类该类的属性可以编辑 */ instanceWrapper = createBeanInstance(beanName, mbd, args); } Object bean = instanceWrapper.getWrappedInstance(); Class> beanType = instanceWrapper.getWrappedClass(); if (beanType != NullBean.class) { mbd.resolvedTargetType = beanType; } //允许 post-processors 修改 beanDefinition synchronized (mbd.postProcessingLock) { if (!mbd.postProcessed) { try { //调用 MergedBeanDefinitionPostProcessor //查找出满足条件的属性、方法, 将他们封装起来 //以便后面在填充属性的时候可以直接使用 //https://juejin.cn/post/6844904167945797640 applyMergedBeanDefinitionPostProcessors (mbd, beanType, beanName); } catch (Throwable ex) { throw new BeanCreationException(); } mbd.postProcessed = true; } }

/* * 是否需要提前暴露 * 判断条件: * 1.是单例 * 2.允许循环依赖 * 3.bean正在被创建 / boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName)); //需要提前暴露加入3级缓存 if (earlySingletonExposure) { / * singletonObjects 一级缓存池 * earlySingletonObjects 二级缓存池 * singletonFactories 三级缓存池 * 将ObjectFactory> singletonFactory 加入三级缓存 singletonFactories * 并从二级缓存移除 * 放进去的是getEarlyBeanReference方法 / / getEarlyBeanReference放入了提前实例化但是未初始化的对象可以看到，在方法getEarlyBeanReference中主要就是执行后处理器SmartInstantiationAwareBeanPostProcessor的方法，默认情况下是没有注册相应SmartInstantiationAwareBeanPostProcessor 那如果注册了SmartInstantiationAwareBeanPostProcessor类型的后处理器默认会做些什么事呢？ Spring默认就把我们刚创建好的bean实例直接返回了。说到底，这里同样是Spring留给我们的一个扩展点的，希望我们自定义实现接口 SmartInstantiationAwareBeanPostProcessor 然后重写方法getEarlyBeanReference 自定义早期单例的bean应该需要哪些东西好让其他bean实例化时，得到符合需求的早期单例bean。 **/ addSingletonFactory( beanName, //如果有循环依赖 bean的代理对象就是在这里被创建的 //如果有循环依赖 bean的代理对象就是在这里被创建的 //如果有循环依赖 bean的代理对象就是在这里被创建的 () -> getEarlyBeanReference(beanName, mbd, bean) ); }

//此时这个bean已经放入了 getEarlyBeanReference(beanName, mbd, bean) Object exposedObject = bean; try { /* * 1.属性填充 * 2.处理属性依赖 / populateBean(beanName, mbd, instanceWrapper); / * 初始化bean * 如果bean实现了以下接口 * BeanNameAware, BeanFactoryAware, ApplicationContextAware * 则调用对应接口的方法 * 如果没有循环依赖 bean的代理对象就是在这里被创建的 * 如果没有循环依赖 bean的代理对象就是在这里被创建的 * 如果没有循环依赖 bean的代理对象就是在这里被创建的 / exposedObject = initializeBean(beanName, exposedObject, mbd); } catch (Throwable ex) { if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) { throw (BeanCreationException) ex; } else { throw new BeanCreationException(); } } /** * 是否需要提前暴露 earlySingletonExposure = true * 判断条件: * 1.是单例 * 2.允许循环依赖 * 3.bean正在被创建 */ if (earlySingletonExposure) { //从1级缓存和2级缓存获取 //因为allowEarlyReference=false 所以不会从3级缓存获取 //如果没有循环依赖这里返回的是空 //虽然A会被加入3级缓存,但是并没有从3级缓存中取也没有放入二级缓存 //最终会直接返回 exposedObject; //然后放入1即缓存 //如果有循环依赖 A 和 B 循环依赖 // 对于A来说 // 1.A在创建完实例后会被阻塞在填充属性的方法栈populateBean。 // 2.在B填充属性A对象时,会在填充属性方法中调用getSingleton(beanName,true); // 3.会把从3级缓存取出A的ObjectFactory并调用getObject方法获取A对象 // 4.其实调用的就是A对应的getEarlyBeanReference方法 // 5.因为allowEarlyReference是true 所以会到三级缓存拿并放入二级缓存 // 6.当B实例化完成后,A继续往下走 // 然后在这里获取的就是A在二级缓存中的对象 // 最后判断代理的对象和提前暴露的对象是不是还是一个 Object earlySingletonReference = getSingleton(beanName, false); if (earlySingletonReference != null) { if (exposedObject == bean) { //判断代理的对象和提前暴露的对象是不是还是一个 exposedObject = earlySingletonReference; //如果不是一个判断是否有依赖该bean的对象 }else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) { String[] dependentBeans = getDependentBeans(beanName); Set actualDependentBeans = new LinkedHashSet<>(dependentBeans.length); for (String dependentBean : dependentBeans) { if (!removeSingletonIfCreatedForTypeCheckOnly (dependentBean)) { actualDependentBeans.add(dependentBean); } } if (!actualDependentBeans.isEmpty()) { throw new BeanCurrentlyInCreationException(); } } } } try { registerDisposableBeanIfNecessary(beanName, bean, mbd); } catch (BeanDefinitionValidationException ex) { throw new BeanCreationException(); } return exposedObject; } ```

java protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) { Assert.notNull(singletonFactory, "Singleton factory must not be null"); synchronized (this.singletonObjects) { if (!this.singletonObjects.containsKey(beanName)) { /*** * 加入三级缓存 */ this.singletonFactories.put(beanName, singletonFactory); /*** * 从2级缓存移除 */ this.earlySingletonObjects.remove(beanName); /**** * 将beanName加入已注册实例 */ this.registeredSingletons.add(beanName); } } }

java //bean是早期暴露的引用 protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) { Object exposedObject = bean; //1.不是合成的 //2.存在InstantiationAwareBeanPostProcessor if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) { for (BeanPostProcessor bp : getBeanPostProcessors()) { if (bp instanceof SmartInstantiationAwareBeanPostProcessor) { //org.springframework.aop.framework.autoproxy. //AbstractAutoProxyCreator.getEarlyBeanReference SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp; exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName); } } } return exposedObject;

1.选择构造方法,创建实例bean

2.() -> getEarlyBeanReference(beanName, mbd, bean)加入三级缓存,这里也是ObjectFactory的一个匿名实现类。其中getEarlyBeanReference(beanName, mbd, bean)中已经将创建好的提前暴露的对象bean传递给了getEarlyBeanReference方法中作为参数。

3.填充属性

4.初始化并生成代理对象

5.没有循环依赖,从1 2 级缓存中获取bean,获取不到,返回的是一个空

md //没有循环依赖 protected Object getSingleton(String beanName, boolean allowEarlyReference) { // 是否应创建早期引用 allowEarlyReference is false // 一级缓存中该bean为空 Object singletonObject = this.singletonObjects.get(beanName); //singletonObject 且当前 bean 正在创建才能去2级缓存拿 //2级缓存中该bean也是空 if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) { singletonObject = this.earlySingletonObjects.get(beanName); } return singletonObject; }

md //这里有循环依赖和没有循环依赖稍微不同。 //如果没有循环依赖从1级缓存和2级缓存返回的都是空 //虽然A会被加入3级缓存,但是并没有从3级缓存中取也没有放入二级缓存 //虽然放入了三级缓存，但是不会调用A的ObjectFactory方法。 //也就是说在二级缓存中A是没有的。也不会去二级缓存拿。 //最终会直接返回 exposedObject; //然后放入1即缓存 //如果有循环依赖 A 和 B 循环依赖 // 对于A来说 // 1.A在创建完实例后会被阻塞在填充属性的方法栈populateBean。 // 2.在B填充属性A对象时,会在填充属性方法中调用getSingleton(beanName,true); // 3.会把从3级缓存取出A的ObjectFactory并调用getObject方法获取A对象 // 4.其实调用的就是A对应的getEarlyBeanReference方法 // 5.因为allowEarlyReference是true 所以会到三级缓存拿并放入二级缓存 // 6.当B实例化完成后,A继续往下走 // 然后在这里获取的就是A在二级缓存中的对象 // 最后判断代理的对象和提前暴露的对象是不是还是一个

感觉这里和有循环依赖稍微不同。这里只创建A。虽然放入了三级缓存，但是不会调用A的ObjectFactory方法也就是说在二级缓存中A是没有的。也不会去二级缓存拿。

如果是循环依赖,B在填充属性时会将A在三级缓存中的ObjectFactory拿出来调用获取一个半成品。放入二级缓存。

```java //有循环依赖 protected Object getSingleton(String beanName, boolean allowEarlyReference) { //是否应创建早期引用 allowEarlyReference is false //一级缓存中该bean为空 Object singletonObject = this.singletonObjects.get(beanName);

//singletonObject 且 当前 bean 正在创建才能去2级缓存拿
//2级缓存中该bean不是空  
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
     singletonObject = this.earlySingletonObjects.get(beanName);
}
return singletonObject;

} ```

6.判断二级缓存中对象是不是不等于null。

7.如果不是null 那么判断代理的对象和提前暴露的对象是不是还是一个

8.如果不是一个就报错,在判断是否有其他的bean依赖A,如果有那么报错

9.最后将正在创建中的状态修改掉,放入一级缓存。

# 5.10finishRefresh

``` protected void finishRefresh() { clearResourceCaches();

initLifecycleProcessor();

// Propagate refresh to lifecycle processor first. getLifecycleProcessor().onRefresh(); // Publish the final event. publishEvent(new ContextRefreshedEvent(this)); // Participate in LiveBeansView MBean, if active. LiveBeansView.registerApplicationContext(this); } ```

initLifecycleProcessor

``` protected void initLifecycleProcessor() { ConfigurableListableBeanFactory beanFactory = getBeanFactory(); if (beanFactory.containsLocalBean(LIFECYCLEPROCESSORBEANNAME)) { this.lifecycleProcessor = beanFactory.getBean(LIFECYCLEPROCESSORBEANNAME, LifecycleProcessor.class); if (logger.isTraceEnabled()) { logger.trace("Using LifecycleProcessor [" + this.lifecycleProcessor + "]"); } } else { DefaultLifecycleProcessor defaultProcessor = new DefaultLifecycleProcessor(); defaultProcessor.setBeanFactory(beanFactory); this.lifecycleProcessor = defaultProcessor; beanFactory.registerSingleton(LIFECYCLEPROCESSORBEAN_NAME, this.lifecycleProcessor);

}
}

```

可以看到，在方法initLifecycleProcessor中，首先就是到Spring容器中看下是否存在名称为lifecycleProcessor的bean。

如果存在的话，直接从Spring容器中获取出来，并赋值给成员变量lifecycleProcessor，如果不存在的话默认会创建一个DefaultLifecycleProcessor类型的对象，并赋值给成员变量lifecycleProcessor，最后再注入到Spring容器中，那DefaultLifecycleProcessor又是什么呢？

其实DefaultLifecycleProcessor是Spring中，处理Spring生命周期相关的一个组件，Spring提供生命周期的接口Lifecycle。

可以看到，DefaultLifecycleProcessor最终也是实现接口Lifecycle的，而LifecycleProcessor接口也只不过是Lifecycle接口的一个扩展接口而已，我们可以看下这两个接口中的方法：

在Spring中如果bean实现了接口Lifecycle，Spring会保证在容器启动时，就会调用这些bean中的start方法开启它们的生命周期，当然，在Spring关闭的时候也会调用stop方法来结束它们的生命周期。

而LifecycleProcessor在Lifecycle的基础上，又添加了两个方法onRefresh和onClose，主要就是对相应的bean做状态更新，关于onRefresh方法的逻辑，我们可以来看下。

可以看到，接下来会调用LifecycleProcessor中的onRefresh方法，我们到onRefresh方法中看下：

@Override public void onRefresh() { startBeans(true); this.running = true; }

private void startBeans(boolean autoStartupOnly) { Map<String, Lifecycle> lifecycleBeans = getLifecycleBeans(); Map<Integer, LifecycleGroup> phases = new HashMap<>(); lifecycleBeans.forEach((beanName, bean) -> { if (!autoStartupOnly || (bean instanceof SmartLifecycle && ((SmartLifecycle) bean).isAutoStartup())) { int phase = getPhase(bean); LifecycleGroup group = phases.get(phase); if (group == null) { group = new LifecycleGroup (phase, this.timeoutPerShutdownPhase, lifecycleBeans, autoStartupOnly); phases.put(phase, group); } group.add(beanName, bean); } }); if (!phases.isEmpty()) { List<Integer> keys = new ArrayList<>(phases.keySet()); Collections.sort(keys); for (Integer key : keys) { phases.get(key).start(); } } }

可以看到在onRefresh方法中，像我们刚才分析的一样，就会从Spring容器中获取所有实现了Lifecycle接口的bean，然后调用start方法来开启它们的生命周期，也就是开启Spring的生命周期了。

publishEvent

publishEvent(new ContextRefreshedEvent(this));

可以看到，其实就是发布了一个刷新上下文的事件ContextRefreshedEvent。

根据我们前面的源码分析，事件ContextRefreshedEvent将会注册到广播器中，广播器会把该事件广播器相应的监听器去处理，这个事件相当于告诉Spring整个容器已经刷新了，也就说Spring容器ApplicationContext已经初始化完毕了。

applyMergedBeanDefinitionPostProcessor

调用 MergedBeanDefinitionPostProcessor查找出满足条件的属性、方法, 将他们封装起来, 以便后面在填充属性的时候可以直接使用

具体参考:https://juejin.cn/post/6844904167945797640

```

然而,然而

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
18.Spring创建Bean源码-创建bean,非常细!

highlight: arduino-light5.6registerBeanPostProcessors(beanFactory)```javapublic static void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext ap...
复制链接

扫一扫