读spring源码记录（六）-- prepareBeanFactory

“讲真，我要你现在快乐，毕竟等三十岁再买十八岁时喜欢的裙子就已经没什么意义了。”

承接上篇文章，继续记录

3.prepareBeanFactory（准备上下文使用的bean factory）

首先看一下prepareBeanFactory方法的代码

/**
     * 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.
        // 告诉内部bean工厂使用上下文的类加载器等
        //设置类加载器：存在则直接设置/不存在则新建一个默认类加载器
        beanFactory.setBeanClassLoader(getClassLoader());

        //设置EL表达式解析器（Bean初始化完成后填充属性时会用到）
        beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));

        //设置属性注册解析器PropertyEditor
        beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

        // Configure the bean factory with context callbacks.
        // 使用上下文回调配置Bean工厂。
        // 将当前的ApplicationContext对象交给ApplicationContextAwareProcessor类来处理，从而在Aware接口实现类中的注入applicationContext
        beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));

        //在工厂的ignoredDependencyInterfaces属性中添加Aware系列接口，
        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 interface not registered as resolvable type in a plain factory.
        // MessageSource registered (and found for autowiring) as a bean.
        // BeanFactory接口未在普通工厂中注册为resolvable类型。
        // MessageSource注册为Bean（并发现用于自动装配）。
        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.
        // 为了监测作为ApplicationListeners的内部类注册早期的post-processor（感觉翻译的怪怪的）
        // 注册ApplicationListenerDetector后置处理器，把实现了ApplicationListener接口的单例对象注册到容器的事件集合中去
        beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

        // Detect a LoadTimeWeaver and prepare for weaving, if found.
        // 如果发现LoadTimeWeaver，请准备织入（应该是跟AOP相关的属性）
        if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
            beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
            // Set a temporary ClassLoader for type matching.
            // 为匹配类型设置一个临时的ClassLoader
            beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
        }

        // Register default environment beans.
        // 注册默认的environment beans
        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());
        }
    }

首先第一眼看过去，感觉很简单，就是设置一些属性嘛，我第一遍看的时候，亦是这么感觉，看的很快，感觉没什么东西，但是仔细再看一次，发现了点东西。
前几行都没什么可关注的，都是设置一些属性，到beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));开始，beanFactory开始添加自己的BeanPostProcessor，可以看看addBeanPostProcessor方法的代码，

@Override
    public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor) {
        Assert.notNull(beanPostProcessor, "BeanPostProcessor must not be null");
        // Remove from old position, if any
        this.beanPostProcessors.remove(beanPostProcessor);
        // Track whether it is instantiation/destruction aware
        if (beanPostProcessor instanceof InstantiationAwareBeanPostProcessor) {
            this.hasInstantiationAwareBeanPostProcessors = true;
        }
        if (beanPostProcessor instanceof DestructionAwareBeanPostProcessor) {
            this.hasDestructionAwareBeanPostProcessors = true;
        }
        // Add to end of list
        this.beanPostProcessors.add(beanPostProcessor);
    }

/** BeanPostProcessors to apply in createBean */
private final List beanPostProcessors = new CopyOnWriteArrayList<>();

/** Indicates whether any InstantiationAwareBeanPostProcessors have been registered */
private volatile boolean hasInstantiationAwareBeanPostProcessors;

/** Indicates whether any DestructionAwareBeanPostProcessors have been registered */
private volatile boolean hasDestructionAwareBeanPostProcessors;

这个代码我们可以看到，这边就是将beanPostProcessor加入对应的List中，这个方法在下面多次调用到。可以注意一点的是CopyOnWriteArrayList这个类是线程安全的，可以在当前类查看,spring用的很多对象都是线程安全的，比我们在学校课本中学到的更丰富一点，值得积累，CopyOnWriteArrayList这个类添加数据时先copy出一个容器(可以简称副本)，再往新的容器里添加这个新的数据，最后把新的容器的引用地址赋值给了之前那个旧的的容器地址，但是在添加这个数据的期间，其他线程如果要去读取数据，仍然是读取到旧的容器里的数据。
回到prepareBeanFactory方法中，接下来是切面相关的配置，Load Time Weaving是AspectJ在类加载时期进行代码织入,如果容器中存在名为"loadTimeWeaver"的bean，则添加一个作用域为loadTimeWeaver的后置处理器(上下文将使用一个临时的ClassLoader进行类型匹配，以允许LoadTimeWeaver处理所有实际的bean类。)

// Register default environment beans.
        // 注册默认的environment beans
        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());
        }

最后几行代码，其实很简单，存在名为enviroment, systemProperties, systemEnviroment的几个LocalBean对象，则将其注册到beanFactory的Map singletonObjects这个ConcurrentHashMap上。
prepareBeanFactory就结束了，接下来是回到AbstractApplicationContext查看postProcessBeanFactory(beanFactory)方法。