Spring源码分析——spring源码之prepareBeanFactory(beanFactory)介绍

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容器进行的一些属性的初始化操作，我们可能不知道这些类的作用是什么，可能我们后续看源码的时候，容器会突然使用到几个不认识的类，这个时候我们就要多注意这几个初始化方法，看看是否在这几个初始化方法里面进行了类的创建。