dispatcherServlet 图片

AbstractApplicationContext

//初始化所有剩余的单例Bean
// 当工厂初始化完成的时候，
finishBeanFactoryInitialization(beanFactory);

它在判断它是不是“延时加载”，如果不是“延时加载”才给它注入

DefaultListableBeanFactory 加载。

//对配置lazy-init属性单态Bean的预实例化
@Override
public void preInstantiateSingletons() throws BeansException {
    if (this.logger.isDebugEnabled()) {
        this.logger.debug("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.
    List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

    // Trigger initialization of all non-lazy singleton beans...
    for (String beanName : beanNames) {
        //获取指定名称的Bean定义
        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
        //Bean不是抽象的，是单态模式的，且lazy-init属性配置为false
        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
            //如果指定名称的bean是创建容器的Bean
            if (isFactoryBean(beanName)) {
                //FACTORY_BEAN_PREFIX=”&”，当Bean名称前面加”&”符号
                //时，获取的是产生容器对象本身，而不是容器产生的Bean.
                //调用getBean方法，触发容器对Bean实例化和依赖注入过程
                final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
                //标识是否需要预实例化
                boolean isEagerInit;
                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) {
                    //调用getBean方法，触发容器对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) {
            final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
            if (System.getSecurityManager() != null) {
                AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                    smartSingleton.afterSingletonsInstantiated();
                    return null;
                }, getAccessControlContext());
            }
            else {
                smartSingleton.afterSingletonsInstantiated();
            }
        }
    }
}

BeanFactory：主语是 Factory（顶层接口）

​ 具体的工厂会通过 策略模式 去实现，不同的工厂生产不同的产品

FactoryBean：主语是 Bean，所有工厂生产的产品都要实现此接口

​ 简言之：BeanFactory 生产出来的产品都是 FactoryBean 。

​ 大部分情况下，BeanFactory 本身也是通过 BeanFactory 创建的，也就是说 BeanFactory 也是一个 FactoryBean。

​ 策略模式是我们预设好的创建者模型，我们选用什么样的策略是由用户来决定，这个工厂本身我是不知道调用什么方法去创建对象的。我要根据用户的配置去把这个配置搞出来，这个工厂本身是一个单例，所以 BeanFactory 也是要由 BeanFactory 来创建的。

BeanFactory 和 FactoryBean

"&" 区别 BeanFactory。

Beanname 和 Instance。

key 和 value。

Java在中 所有东西都是对象，Spring 中所有都是 FactoryBean。 异曲同工 。

Spring 中的 Bean 初始化之前和之后，都会有一个处理。

它有一个配置文件，来决定它用哪个工厂。

来源于: https://javaguide.net

微信公众号：不止极客