spring生成非懒加载的单例Bean

// 1、创建AnnotationConfigApplicationContext对象
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

// 2、他会调用refresh();刷新方法
public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
    .......
    refresh();
}

// 3、调用初始化bean工厂方法
public void refresh() throws BeansException, IllegalStateException {
    ......
    finishBeanFactoryInitialization(beanFactory);
    ......
}

// 4、调用实例化非懒加载的单例Bean方法
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    ......
    beanFactory.preInstantiateSingletons();
}

生成非懒加载的单例Bean源码分析

public void preInstantiateSingletons() throws BeansException {
    if (logger.isTraceEnabled()) {
        logger.trace("Pre-instantiating singletons in " + this);
    }

    // Iterate over a copy to allow for init methods which in turn register new bean definitions.
    // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
    // 得到所有的Bean名字
    List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

    // Trigger initialization of all non-lazy singleton beans...
    for (String beanName : beanNames) {
        // 获取合并（xml方式配置parent=另一个BeanName）后的BeanDefinition，并放入mergedBeanDefinitions这个Map中
        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);

        // 不是抽象的BeanDefinition（xml方式配置abstract=true），并且它是单例的，并且他不是懒加载的
        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
            // FactoryBean的逻辑
            if (isFactoryBean(beanName)) {
                // 获取FactoryBean对象（类对象）
                Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                // 他是FactoryBean
                if (bean instanceof FactoryBean) {
                    // 强转为FactoryBean
                    FactoryBean<?> factory = (FactoryBean<?>) bean;
                    // 是否要初始化的判断标志
                    boolean isEagerInit;
                    // 当他实现了SmartFactoryBean的时候，并且重写的isEagerInit为true才会吧isEagerInit设置为true，进行getObject()的Bean的创建
                    if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                        isEagerInit = AccessController.doPrivileged(
                                (PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
                                getAccessControlContext());
                    }
                    else {
                        isEagerInit = (factory instanceof SmartFactoryBean &&
                                ((SmartFactoryBean<?>) factory).isEagerInit());
                    }
                    if (isEagerInit) {
                        // 创建真正的Bean对象(getObject()返回的对象)
                        getBean(beanName);
                    }
                }
            }
            else {
                // 创建Bean对象
                getBean(beanName);
            }
        }
    }

    // 所有的非懒加载单例Bean都创建完了后
    // Trigger post-initialization callback for all applicable beans...
    for (String beanName : beanNames) {
        // 找到当前beanName对应的单例对象
        Object singletonInstance = getSingleton(beanName);
        // 所有的非懒加载单例Bean创建完成之后，调用当前Bean实现了SmartInitializingSingleton接口的方法。针对单个Bean
        if (singletonInstance instanceof SmartInitializingSingleton) {
            // 一个计时器开始位置
            StartupStep smartInitialize = this.getApplicationStartup().start("spring.beans.smart-initialize")
                    .tag("beanName", beanName);
            // 强转为我们的实现类
            SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
            // 通过JDK的安全处理器方式调用这个Bean重写的方法
            if (System.getSecurityManager() != null) {
                AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                    smartSingleton.afterSingletonsInstantiated();
                    return null;
                }, getAccessControlContext());
            }
            else {
                // 直接调用这个Bean重写的方法
                smartSingleton.afterSingletonsInstantiated();
            }
            // 一个计时器结束位置
            smartInitialize.end();
        }
    }
}

判断是否是FactoryBean源码分析

public boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException {
    String beanName = transformedBeanName(name);
    // 找到当前beanName对应的单例对象：
    Object beanInstance = getSingleton(beanName, false);
    // 不为空的时候，直接返回他是否属于FactoryBean
    if (beanInstance != null) {
        return (beanInstance instanceof FactoryBean);
    }
    // No singleton instance found -> check bean definition.
    // 走到这里说明没有拿到，只能根据BeanDefinition进行判断。
    // 当前容器beanDefinitionMap中没有当前Bean并且父BeanFactory是配置类
    if (!containsBeanDefinition(beanName) && getParentBeanFactory() instanceof ConfigurableBeanFactory) {
        // No bean definition found in this factory -> delegate to parent.
        // 返回父BeanFactory的isFactoryBean。
        return ((ConfigurableBeanFactory) getParentBeanFactory()).isFactoryBean(name);
    }
    // 当前容器中包含这个Bean，判断当前Bean是否是FactoryBean，走这个方法判断
    return isFactoryBean(beanName, getMergedLocalBeanDefinition(beanName));
}

/**
 * 当前容器中包含这个Bean，判断当前Bean是否是FactoryBean
 */
protected boolean isFactoryBean(String beanName, RootBeanDefinition mbd) {
    // 看这个BeanDefinition的isFactoryBean属性，是否是值
    Boolean result = mbd.isFactoryBean;
    if (result == null) {
        // 获取BeanDefinition的beanClass属性，没有就去加载这个具体的Bean（依赖注入的时候去深入分析这个方法）
        Class<?> beanType = predictBeanType(beanName, mbd, FactoryBean.class);
        // 判断是不是实现了FactoryBean接口
        result = (beanType != null && FactoryBean.class.isAssignableFrom(beanType));
        // 设置到当前BeanDefinition的isFactoryBean属性
        mbd.isFactoryBean = result;
    }
    // 拿到返回值
    return result;
}

注意：本文归作者所有，未经作者允许，不得转载