详解Spring启动实例化非懒加载的单例Bean

古城微笑少年丶 2023-10-02 11:41 6阅读 0赞

### 一、实例化所有非懒加载的单例 ###

不论是基于注解的Spring容器，还是基于xml的Spring容器，在启动的过程中，都会调用AbstractApplicationContext的refresh()，在该方法中，通过调用finishBeanFactoryInitialization(beanFactory)来实例化所有非懒加载的单例Bean

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
        
        ……
        // Instantiate all remaining (non-lazy-init) singletons.
        // 实例化非懒加载的单例Bean
        beanFactory.preInstantiateSingletons();
    }

##### 1.1 实例化普通的单例Bean #####

Spring扫描注册类的BeanDefinition的时候，会将beanName也保存一份，存在beanDefinitionNames中，这是一个ArrayList，实例化非懒加载的单例Bean时，遍历beanNam的列表，获取对应的BeanDefinition

public void preInstantiateSingletons() throws BeansException {
        
    
        List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
    
        // Trigger initialization of all non-lazy singleton beans...
        for (String beanName : beanNames) {
        
            // 获取合并后的BeanDefinition
            RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
    
            if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
        
                if (isFactoryBean(beanName)) {
        
                    ……
                }
                else {
        
                    // 创建Bean对象
                    getBean(beanName);
                }
            }
        }

*  根据beanName获取合并后的BeanDefinition，什么是合并后的BeanDefinition呢？
    
    在Spring.xml中定义两个Bean，其中userService继承自user，因此如果userService不显示指定scope属性，那么它将继承user的scope属性，变成一个原型Bean。
    
        <bean id="user" class="com.lizhi.service.User" scope="prototype"/>
        
        <bean id="userService" class="com.lizhi.service.UserService" parent="user"/>
    
    Spring会为下面两个Bean都创建各自的BeanDefinition，但是再实例化的时候，如果为某个Bean指定了parent，则需要整合它所有上层Bean的属性，生成一个RootBeanDefinition，如果没有指定parent，也需要根据当前Bean的BeanDefinition生成一个RootBeanDefinition，然后放入到mergedBeanDefinitions中，正真实例化用的BeanDefinition其实是合并后的RootBeanDefinition
    
    getMergedLocalBeanDefinition(beanName)源码如下：
    
    先从mergedBeanDefinitions中根据beanName获取RootBeanDefinition，如果没有再生成
    
        protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
              
            // Quick check on the concurrent map first, with minimal locking.
            RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
            if (mbd != null && !mbd.stale) {
              
                return mbd;
            }
            return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
        }
    
    获取合并后的RootBeanDefinition，getParentName()判断是否指定parant属性，如果没有，则直接根据当前BeanDefinition生成RootBeanDefinition；如果指定了pareant属性，则通过pbd = getMergedBeanDefinition(parentBeanName);递归获取上级父BeanDefinition，然后根据父BeanDefinition生成一个新的RootBeanDefinition，再用当前BeanDefinition的属性去覆盖新生成的RootBeanDefinition，然后将新生成的RootBeanDefinition放入到mergedBeanDefinitions中
    
        protected RootBeanDefinition getMergedBeanDefinition(
            String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd)
            throws BeanDefinitionStoreException {
              
        
            synchronized (this.mergedBeanDefinitions) {
              
                RootBeanDefinition mbd = null;
                RootBeanDefinition previous = null;
        
                // Check with full lock now in order to enforce the same merged instance.
                if (containingBd == null) {
              
                    mbd = this.mergedBeanDefinitions.get(beanName);
                }
        
                if (mbd == null || mbd.stale) {
              
                    previous = mbd;
                    if (bd.getParentName() == null) {
              
                        // Use copy of given root bean definition.
                        if (bd instanceof RootBeanDefinition) {
              
                            mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
                        }
                        else {
              
                            mbd = new RootBeanDefinition(bd);
                        }
                    }
                    else {
              
                        // Child bean definition: needs to be merged with parent.
                        // pbd表示parentBeanDefinition
                        BeanDefinition pbd;
                        try {
              
                            String parentBeanName = transformedBeanName(bd.getParentName());
                            if (!beanName.equals(parentBeanName)) {
              
                                // 递归获取父BeanDefinition,当前BeanDefinition的父BeanDefinition可能
                                pbd = getMergedBeanDefinition(parentBeanName);
                            }
                            else {
              
                                BeanFactory parent = getParentBeanFactory();
                                if (parent instanceof ConfigurableBeanFactory) {
              
                                    pbd = ((ConfigurableBeanFactory) parent).getMergedBeanDefinition(parentBeanName);
                                }
                                ……
                            }
                            ……
                        }
        
                        // Deep copy with overridden values.
                        // 子BeanDefinition的属性覆盖父BeanDefinition的属性，这就是合并
                        mbd = new RootBeanDefinition(pbd);
                        mbd.overrideFrom(bd);
                    }
                    ……
                    //将新生成的RootBeanDefinition放入到mergedBeanDefinitions
                    if (containingBd == null && isCacheBeanMetadata()) {
              
                        this.mergedBeanDefinitions.put(beanName, mbd);
                    }
                }
                ……
        		return mbd;
            }
 *  判断是否应该实例化
    
    获取RootBeanDefinition，判断是否是单例，是否是非懒加载，isAbstract()则用与判断当前BeanDefinition是否为抽象的BeanDefinition
    
        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
        
        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
              
            if (isFactoryBean(beanName)) {
              
                // 获取FactoryBean对象
                Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                if (bean instanceof FactoryBean) {
              
                    // FactoryBean实例化
                    ……
                }
            }
            else {
              
                // 创建普通Bean对象
                getBean(beanName);
            }
        }
    
    通过Spring.xml方式配置Bean，可以通过**abstract**属性指定抽象的Beandefinition
    
        <bean id="user" class="com.lizhi.service.User" scope="prototype" abstract="true"/>
    
    符合上述条件，则调用getBean(beanName)来完成非懒加载单例Bean的实例化

##### 1.2 实例化FactoryBean #####

获取RootBeanDefinition，首先需要判断判断是否是一个FactoryBean，开发人员可以通过实现FactoryBean接口自定义Bean的创建

// 获取合并后的BeanDefinition
    RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
    
    if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
        
        if (isFactoryBean(beanName)) {
        
            // 获取FactoryBean对象
            Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
            if (bean instanceof FactoryBean) {
        
                FactoryBean<?> factory = (FactoryBean<?>) bean;
                boolean isEagerInit;
                ……
                isEagerInit = (factory instanceof SmartFactoryBean &&
                                   ((SmartFactoryBean<?>) factory).isEagerInit());
                if (isEagerInit) {
        
                    // 创建真正的Bean对象(getObject()返回的对象)
                    getBean(beanName);
                }
            }
            // 实例化普通Bean
            ……
        }
    }

*  根据beanName判断是否是FactoryBean
    
    首先去从单例池中获取Bean，判断Bean是否实现了FactoryBean接口，因为现在处于实例化单例Bean的过程，所以当前单例池是没有的
    
    单例池如果没有的话，则判断当前BeanDefinitionMap中是否有该BeanName，如果当前BeanFactory的BeanDefinitionMap中没有，则去ParentBeanFactory的BeanDefinitionMap中查找
    
    `什么是ParentBeanFactory?`
    
    如下代码所示，AppConfig1和AppConfig配置类指定扫描不同的包，生成了两个Spring容器，context容器将parent设置为自己的父容器，当从context容器中找不到资源时就会去parent找
    
        AnnotationConfigApplicationContext parent = new AnnotationConfigApplicationContext(AppConfig1.class);
        
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        context.setParent(parent);
    
    父容器的单例池中也没有Bean，就需要根据beanName和RootBeanDefinition去推断Bean类型
    
        public boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException {
              
            String beanName = transformedBeanName(name);
            Object beanInstance = getSingleton(beanName, false);
            if (beanInstance != null) {
              
                return (beanInstance instanceof FactoryBean);
            }
            // No singleton instance found -> check bean definition.
            if (!containsBeanDefinition(beanName) && getParentBeanFactory() instanceof ConfigurableBeanFactory) {
              
                // No bean definition found in this factory -> delegate to parent.
                return ((ConfigurableBeanFactory) getParentBeanFactory()).isFactoryBean(name);
            }
            return isFactoryBean(beanName, getMergedLocalBeanDefinition(beanName));
        }
    
    推断beanName是否是FactoryBean，然后将推断结果进行缓存，下次就可以直接使用了，BeanDefinition中的很多属性都是作为缓存使用的
    
        protected boolean isFactoryBean(String beanName, RootBeanDefinition mbd) {
              
            Boolean result = mbd.isFactoryBean;
            if (result == null) {
              
                // 根据BeanDefinition推测Bean类型（获取BeanDefinition的beanClass属性）
                Class<?> beanType = predictBeanType(beanName, mbd, FactoryBean.class);
                // 判断是不是实现了FactoryBean接口
                result = (beanType != null && FactoryBean.class.isAssignableFrom(beanType));
                // 缓存当前Bean是否为FactoryBean
                mbd.isFactoryBean = result;
            }
            return result;
        }
 *  获取FactoryBean对象
    
    `如果getBean()中的beanName不是以&开头,则返回的是FactoryBean的getObject()返回的对象;如果beanName是以&开头的,则返回的是FactoryBean对象`
    
    想要获取FactoryBean对象，需要在beanName前加上“&”，表示这是FactoryBean的beanName
    
        if (isFactoryBean(beanName)) {
              
            // 获取FactoryBean对象
            Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
            ……
        }
    
    根据转换后的beanName从单例池中找Bean，转化后的beanName是没有"&"前缀的，如果能从单例池中取出单例Bean，再调用getObjectForBeanInstance()
    
        protected <T> T doGetBean(
            String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
            throws BeansException {
              
        
            // name有可能是 &xxx 或者 xxx，如果name是&xxx，那么beanName就是xxx
            // name有可能传入进来的是别名，那么beanName就是id
            String beanName = transformedBeanName(name);
            Object beanInstance;
            Object sharedInstance = getSingleton(beanName);
            if (sharedInstance != null && args == null) {
              
                // 如果sharedInstance是FactoryBean，那么就调用getObject()返回对象
                beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
            }
            // 创建FactoryBean或普通Bean
            ……
    
    如果需要获取FactoryBean对象，同时传进来的beanInstance就是FactoryBean则直接返回
    
        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.
            // 如果&xxx，那么就直接返回单例池中的对象
            if (BeanFactoryUtils.isFactoryDereference(name)) {
              
                if (beanInstance instanceof NullBean) {
              
                    return beanInstance;
                }
                if (!(beanInstance instanceof FactoryBean)) {
              
                    throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
                }
                if (mbd != null) {
              
                    mbd.isFactoryBean = true;
                }
                return beanInstance;
            }
            ……
    
    transformedBeanName()就是将传进来带&的beanName，去掉前面的&作为beanName，单例池中的Key是对应的beanName是xxx格式
    
        // FACTORY_BEAN_PREFIX = "&"
        public static String transformedBeanName(String name) {
              
            Assert.notNull(name, "'name' must not be null");
            // 如果不是FactoryBean格式的beanName就直接返回
            if (!name.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {
              
                return name;
            }
            return transformedBeanNameCache.computeIfAbsent(name, beanName -> {
              
                do {
              
                    // beanName前面可能有多个&前缀,去掉所有的&前缀
                    beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());
                }
                while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX));
                return beanName;
            });
        }
 *  判断获取的Bean对象是否为FactoryBean
    
    如果获取到是FactoryBean对象，接着判断该FactoryBean对象是否实现了SmartFactoryBean接口，如果实现了该接口，并且接口中isEagerInit()返回的是true，意味着Spring容器启动的过程中，就会调用FactoryBean对象的getObject()创建对应的Bean对象，如果没有实现SmartFactoryBean接口或isEagerInit()返回的是false，则在调用getBean()时才会调用getObject()创建对应的Bean对象
    
        if (bean instanceof FactoryBean) {
              
            FactoryBean<?> factory = (FactoryBean<?>) bean;
            boolean isEagerInit;
            ……
            isEagerInit = (factory instanceof SmartFactoryBean &&
                           ((SmartFactoryBean<?>) factory).isEagerInit());
            if (isEagerInit) {
              
                // 创建真正的Bean对象(getObject()返回的对象)
                getBean(beanName);
            }
        }
    
    `FactoryBean的实现类,在Spring加载的时候,只会生成该实现类类的BeanDifiniton,而getObject()中的类是没有BeanDifiniton的,并且这种方式创建的Bean没有完整的生命周期,只是经历了初始化后`

##### 1.3 实例化后方法调用 #####

当所有非懒加载的单例Bean创建完成之后，遍历所有的单例Bean，判断是否实现了SmartInitializingSingleton接口，如果某个单例Bean实现了该接口，则会去调用该接口的afterSingletonsInstantiated()

public void preInstantiateSingletons() throws BeansException {
        
        // 所有的非懒加载单例Bean都创建完了后
        // Trigger post-initialization callback for all applicable beans...
        for (String beanName : beanNames) {
        
            Object singletonInstance = getSingleton(beanName);
            if (singletonInstance instanceof SmartInitializingSingleton) {
        
                // JFR(Java Flight Record) 技术,用于监控记录以下代码的执行
                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();
            }
        }
    }