乐趣区

关于spring:Spring源码分析spring源码之prepareBeanFactorybeanFactory介绍

1. 前言

2.spring 源码 prepareBeanFactory(beanFactory)介绍

3. 总结

1. 前言

github 源码地址(带正文):
https://github.com/su15967456…

spring 源码执行流程图:

明天咱们要介绍的 prepareBeanFactory(beanFactory)办法,其次要性能就是:
// 筹备 bean 工厂,实现 bean 工厂属性的一些初始化操作
其实这个办法挺简略的,就是前面 bean 工厂须要用到的一些类,要在这个办法里进行初始化,所以咱们在这里可能会看到这里在初始化一些没见过的类,没有关系,前面碰到了再点到这里看就行了。

2.spring 源码 prepareBeanFactory(beanFactory)介绍

话不多说,咱们往这个办法里 debug:

    /**
     * Configure the factory's standard context characteristics,
     * such as the context's ClassLoader and post-processors.
     * @param beanFactory the BeanFactory to configure
     */
    protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        // Tell the internal bean factory to use the context's class loader etc.
        // 设置 beanFactory 的类加载器为以后 context 的类加载器
        beanFactory.setBeanClassLoader(getClassLoader());
        if (!shouldIgnoreSpel) {
            // 设置 beanfactory 的表达式语言处理器
            // 解决类 -> 解析类 -> 配置类
            beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
        }
        // 为 beanFactory 减少一个默认的 PropertyEditor
        // 这个次要是对 bean 的属性设置治理的一个工具类 属性编辑类,比方 date 的 format
        beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

        // Configure the bean factory with context callbacks.
        // 增加 beanPostProcessor 此类用来实现某些 aware 对象的注入
        beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
        // 设置疏忽主动拆卸的接口,这些接口的实现是容器是须要 beanPostProcessor 注入的
        // 在前面进行对立解决
        // 所以在应用 @Autowired 进行注入的时候须要对这些接口进行疏忽
        beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
        beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
        beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
        beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
        beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
        beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
        beanFactory.ignoreDependencyInterface(ApplicationStartupAware.class);

        // BeanFactory interface not registered as resolvable type in a plain factory.
        // MessageSource registered (and found for autowiring) as a bean.
        // 设置几个主动拆卸的非凡规定,当在进行 IOC 的时候,如果有多个实现,就按指定的对象注入
        // 如果有多个 beanFactory 就注入该 beanFactory
        beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
        beanFactory.registerResolvableDependency(ResourceLoader.class, this);
        beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
        beanFactory.registerResolvableDependency(ApplicationContext.class, this);

        // Register early post-processor for detecting inner beans as ApplicationListeners.
        beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

        // Detect a LoadTimeWeaver and prepare for weaving, if found.
        // 减少 aspectJ 的反对
        // 在 java 中织入有三种形式,别离为编译器织入,类加载器织入,运行时织入
        // 编译器织入指通过非凡的编译器,将切面织入到 java 中
        // 类加载器织入指通过非凡的类加载器,在类字节码加载入 JVM 的时候,织入切面,相似 cglib
        //aspectj 采纳了两种织入形式,非凡编译器和类加载器,类加载器就是上面的 load_time_wave
        if (!NativeDetector.inNativeImage() && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
            // Set a temporary ClassLoader for type matching.
            beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
        }

        // Register default environment beans.
        // 注册默认的零碎环境 bean 到一级缓存中
        if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
        }
        if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
        }
        if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
        }
        if (!beanFactory.containsLocalBean(APPLICATION_STARTUP_BEAN_NAME)) {beanFactory.registerSingleton(APPLICATION_STARTUP_BEAN_NAME, getApplicationStartup());
        }
    }

这里大略执行了以下的步骤:
1. 设置 beanFactory 的类加载器为以后 context 的类加载器(反正就是设置一下类加载器)
2. 设置 beanfactory 的表达式语言处理器
3. 为 beanFactory 减少一个默认的 PropertyEditor(这个次要是对 bean 的属性设置治理的一个属性工具类,比方 date 的 format,咱们也能够进行自定义)
4. 增加默认的 beanPostProcessor,此类用来实现某些 aware 对象的注入,咱们后续会调用到。
5. 设置疏忽主动拆卸的接口,这些接口的实现是容器是须要 beanPostProcessor 注入的,是要在前面进行对立解决的,所以要对他们进行疏忽
6. 设置几个主动拆卸的非凡规定,当在进行 IOC 的时候,如果有多个实现,就按指定的对象注入(如果有多个 beanFactory 就注入该 beanFactory)
7. 减少 aspectJ 的反对
8. 注册默认的零碎环境 bean 到一级缓存中

这里咱们可能会看到很多不意识的类,其实问题不大,不须要晓得每一个类的作用是什么,只须要晓得,当初初始化这个类,会在将来的某一个工夫用到,这就足够了。

3. 总结
这个办法次要就是针对 beanFactory 容器进行的一些属性的初始化操作,咱们可能不晓得这些类的作用是什么,可能咱们后续看源码的时候,容器会忽然应用到几个不意识的类,这个时候咱们就要多留神这几个初始化办法,看看是否在这几个初始化办法外面进行了类的创立。

退出移动版