Spring IoC源码：refresh都干了什么

分手后的思念是犯贱 2021-12-02 01:01 326阅读 0赞

## IoC 构建过程 ##

首先是源码的入口之一AnnotationConfigApplicationContext：

public static void main(String[] args){
            AnnotationConfigApplicationContext annotationConfigApplicationContext =
                                                new AnnotationConfigApplicationContext(Config.class);
            User user = (User)annotationConfigApplicationContext.getBean("user");
            user.query();
        }

跟进去查看它的构造方法：

public class AnnotationConfigApplicationContext extends GenericApplicationContext implements AnnotationConfigRegistry {
        private final AnnotatedBeanDefinitionReader reader;
        private final ClassPathBeanDefinitionScanner scanner;
    
        public AnnotationConfigApplicationContext() {
            this.reader = new AnnotatedBeanDefinitionReader(this);
            this.scanner = new ClassPathBeanDefinitionScanner(this);
        }
        
        public AnnotationConfigApplicationContext(Class... annotatedClasses) {
            this();
            this.register(annotatedClasses);
            this.refresh();
        }
        ......
    ｝

首先this()调用无参构造，调用父类的无参构造

public class GenericApplicationContext extends AbstractApplicationContext implements BeanDefinitionRegistry {
        private final DefaultListableBeanFactory beanFactory;
        @Nullable
        private ResourceLoader resourceLoader;
        private boolean customClassLoader;
        private final AtomicBoolean refreshed;
    
        public GenericApplicationContext() {
            this.customClassLoader = false;
            this.refreshed = new AtomicBoolean();
            this.beanFactory = new DefaultListableBeanFactory();
        }
    
        ......
    }

这里创建了工厂（new DefaultListableBeanFactory()），这个DefaultListableBeanFactory是BeanFactory的一个实现类。之后我们将会用到它。

好了，在此之后我们进入重点refresh（），会调用父类 AbstractApplicationContext里的 refresh() 方法，这个方法就是构建整个 IoC 容器过程的完整代码，只要把这个方法里的每一行代码都了解了，基本上了解了大部分 Spring 的原理和功能。

refresh是一个模板方法，里面会调用12个方法。

@Override
    public void refresh() throws BeansException, IllegalStateException {
       synchronized (this.startupShutdownMonitor) {
          // Prepare this context for refreshing.
          //准备此上下文以进行刷新
          prepareRefresh();
    
          // Tell the subclass to refresh the internal bean factory.
          //这里是在子类中启动refreshBeanFactort()的地方
          ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    
          // Prepare the bean factory for use in this context.
          // 准备bean工厂以在此上下文中使用。
          prepareBeanFactory(beanFactory);
    
          try {
             // Allows post-processing of the bean factory in context subclasses.
             // 允许在上下文子类中对bean工厂进行后处理。
             postProcessBeanFactory(beanFactory);
    
             // Invoke factory processors registered as beans in the context.
             //调用beanFactory的后处理器，这些后处理器是在bean定义中向容器注册的
             invokeBeanFactoryPostProcessors(beanFactory);
    
             // Register bean processors that intercept bean creation.
             // 注册bean的后处理器，在bean创建过程中调用
             registerBeanPostProcessors(beanFactory);
    
             // Initialize message source for this context.
             //对上下文中的消息源进行初始化
             initMessageSource();
    
             // Initialize event multicaster for this context.
             //初始化上下文中的事件机制
             initApplicationEventMulticaster();
    
             // Initialize other special beans in specific context subclasses.
             //初始化其他的特殊bean
             onRefresh();
    
             // Check for listener beans and register them.
             //检查监听bean并且将这些bean向容器注册
             registerListeners();
    
             // Instantiate all remaining (non-lazy-init) singletons.
             //实例化所有的(non-lazy-init)单利
             finishBeanFactoryInitialization(beanFactory);
    
             // Last step: publish corresponding event.
                   //发布容器事件，结束refresh过程
             finishRefresh();
          }catch (BeansException ex) {
             if (logger.isWarnEnabled()) {
                logger.warn("Exception encountered during context initialization - " +
                      "cancelling refresh attempt: " + ex);
             }
    
             // Destroy already created singletons to avoid dangling resources.
             destroyBeans();
    
             // Reset 'active' flag.
             cancelRefresh(ex);
    
             // Propagate exception to caller.
             throw ex;
          }
    
          finally {
             // Reset common introspection caches in Spring's core, since we
             // might not ever need metadata for singleton beans anymore...
                   /**
                    * 重置Spring核心中的常见内省缓存，
                    * 从此我们开始可能再也不需要单例bean的元数据
                    */
             resetCommonCaches();
          }
       }
    }

### 1、startupShutdownMonitor 属性 ###

用于“刷新”和“销毁”的同步监视器，说白了就是一个锁。

### 2、prepareRefresh() 方法 ###

为刷新准备新的 context，设置其启动日期和活动标志以及执行一些属性的初始化。主要是一些准备工作，不是很重要的方法，可以先不关注。

### 3、obtainFreshBeanFactory() 方法 ###

用于获得一个新的 BeanFactory。

该方法会解析所有配置文件，加载所有 bean的定义，然后将这些 bean 的 beanName、beanName 和 bean 定义映射、beanName 和别名映射放到缓存中（beanDefinitionNames、beanDefinitionMap、aliasMap）。所有的 bean 相关的信息（bean的定义、初始化后的bean单例等等）和相关缓存都会放到 BeanFactory 中。

### 4、prepareBeanFactory(beanFactory) 方法 ###

配置 beanFactory 的标准上下文特征，例如上下文的 ClassLoader、后置处理器等。这个方法会注册3个默认环境bean：environment、systemProperties 和 systemEnvironment，注册2个bean后置处理器：ApplicationContextAwareProcessor 和 ApplicationListenerDetector。

### 5、postProcessBeanFactory(beanFactory) 方法 ###

允许在上下文子类中对 BeanFactory 进行后续处理，默认实现为空，留给子类实现。

### **6、invokeBeanFactoryPostProcessors(beanFactory) 方法** ###

*  1.实例化和调用所有已注册的 BeanDefinitionRegistryPostProcessor 和 BeanFactoryPostProcessor。注：BeanDefinitionRegistryPostProcessor 继承自 BeanFactoryPostProcessor，主要用来在常规 BeanFactoryPostProcessor 检测开始之前注册其他 bean 定义。
 *  2.会将 beanDefinitionNames 缓存中的所有 bean 的合并的 BeanDefinition 创建出来，并放到 mergedBeanDefinitions 缓存。

**注：Spring 中的 BeanFactoryPostProcessor 接口是 Spring 初始化 BeanFactory 时对外暴露的扩展点。**

### **7、registerBeanPostProcessors(beanFactory) 方法** ###

注册所有的 BeanPostProcessor，将所有实现了 BeanPostProcessor 接口的类加载到 BeanFactory 中。

### 8、initMessageSource() 方法 ###

初始化 MessageSource。

### 9、initApplicationEventMulticaster() 方法 ###

初始化 ApplicationEventMulticaster。

### 10、onRefresh() 方法 ###

该方法为模板方法，提供给子类扩展实现，可以重写以添加特定于上下文的刷新工作，默认实现为空。

### 11、registerListeners() 方法 ###

检查并注册监听器。

### 12、finishBeanFactoryInitialization(beanFactory) 方法 ###

实例化所有剩余的 bean 实例（非懒加载）。除了一些内部的bean、实现了 BeanFactoryPostProcessor 的 bean、实现了 BeanPostProcessor 的 bean，其他的 bean 都会在这个 finishBeanFactoryInitialization 方法中被实例化。

### 13、finishRefresh() 方法 ###

完成此 Context 的刷新，主要是推送上下文刷新完毕事件到监听器：ContextRefreshedEvent 。

其中，标红的是最为主要的方法。

**下面看一看BeanDifinition和DefaultListableBeanFactory**

## BeanDifinition源码分析 ##

一个BeanDefinition描述了一个bean的实例，包括属性值，构造方法参数值和继承自它的类的更多信息。BeanDefinition仅仅是一个最简单的接口，主要功能是允许BeanFactoryPostProcessor 例如PropertyPlaceHolderConfigure 能够检索并修改属性值和别的bean的元数据（译注）。

BeanDefinition接口用于描述一个bean实例的属性及构造参数等元数据；主要提供了父beanname，bean类型名，作用域，懒加载， bean依赖，自动注入候选bean，自动注入候选主要bean熟悉的设置与获取操作。同时提供了判断bean是否为单例、原型模式、抽象bean的操作，及获取bean的描述，资源描述，属性源，构造参数，原始bean定义等操作。最主的，BeanDefinition对Bean的配置信息进行了封装。

下面来看这个接口为其子类都提供了哪些具体的行为方法：

public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {
    
            /**
             * 这两个参数应该一看就明白了，singleton和prototype，这个可以看出spring默认提供这两种模式
             */
            String SCOPE_SINGLETON = ConfigurableBeanFactory.SCOPE_SINGLETON;
            String SCOPE_PROTOTYPE = ConfigurableBeanFactory.SCOPE_PROTOTYPE;
            /**
             * 表示一个应用的主要组成部分，比如一个用户定义的bean。
             */
            int ROLE_APPLICATION = 0;
            /**
             * - 表示一个支持一些比较大的配置的bean定义，如一个外部的组件定义
             */
            int ROLE_SUPPORT = 1;
            /**
             * - 表示一个内部使用的注册的bean组件定义，与终端用户无关。
             */
            int ROLE_INFRASTRUCTURE = 2;
    
            //attributes元素
    
            /**
             * - 设置bean定义的父name，如果有的话。
             */
            void setParentName(@Nullable String parentName);
    
            /**
             * 获取bean定义的父name，如果有的话
             */
            @Nullable
            String getParentName();
    
            /**
             * 设置bean定义的bean class name。在bean工厂后处理的过程中，类名可以被修改，典型的情况下
             * 将原始class的name，替换成一个可解析的变量。
             */
            void setBeanClassName(@Nullable String beanClassName);
    
            /**
             * 获取bean的class name 对应class的：class="spring.service.impl.MessageServiceImpl"
             */
            @Nullable
            String getBeanClassName();
    
            ······
        }

## DefaultListableBeanFactory ##

BeanDefinition会放到DefaultListableBeanFactory的beanDefinitionMap中。beanDefinitionMap的key为Bean的名称，value为BeanDefinition。

package org.springframework.beans.factory.support;
    
    @SuppressWarnings("serial")
    public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
            implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
    
        private static Class<?> javaxInjectProviderClass = null;
    
        static {
            try {
                javaxInjectProviderClass =
                        ClassUtils.forName("javax.inject.Provider", DefaultListableBeanFactory.class.getClassLoader());
            }
            catch (ClassNotFoundException ex) {
                // JSR-330 API not available - Provider interface simply not supported then.
            }
        }
    
    
        /** 序列化ID映射到工厂实例的Map：Map from serialized id to factory instance */
        private static final Map<String, Reference<DefaultListableBeanFactory>> serializableFactories =
                new ConcurrentHashMap<>(8);
    
        /** 可选ID，用于序列化：Optional id for this factory, for serialization purposes */
        private String serializationId;
    
        /** Whether to allow re-registration of a different definition with the same name */
        /** 是否允许同名字不同定义的bean重新注册*/
        private boolean allowBeanDefinitionOverriding = true;
    
        /** Whether to allow eager class loading even for lazy-init beans */
        /** 是否允许bean基至是延迟加载的bean马上加载*/
        private boolean allowEagerClassLoading = true;
    
        /** Optional OrderComparator for dependency Lists and arrays */
        /** 可选的用于依赖集合和数组的比较器*/
        private Comparator<Object> dependencyComparator;
    
        /** Resolver to use for checking if a bean definition is an autowire candidate */
        /** 用于检查一个类定义是否有自动注入请求的解析器*/
        private AutowireCandidateResolver autowireCandidateResolver = new SimpleAutowireCandidateResolver();
    
        /** Map from dependency type to corresponding autowired value */
        /** 依赖类型到对应的注入值的映射*/
        private final Map<Class<?>, Object> resolvableDependencies = new ConcurrentHashMap<>(16);
    
        /** Map of bean definition objects, keyed by bean name */
        /** bean定义名字到bean定义数据实体的映射*/
        private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);
    
        /** Map of singleton and non-singleton bean names, keyed by dependency type */
        /** 依赖类型到对应bean名字的映射，包括单例和非单例*/
        private final Map<Class<?>, String[]> allBeanNamesByType = new ConcurrentHashMap<>(64);
    
        /** Map of singleton-only bean names, keyed by dependency type */
        /** 依赖类型到对应bean名字的映射，仅包含单例*/
        private final Map<Class<?>, String[]> singletonBeanNamesByType = new ConcurrentHashMap<>(64);
    
        /** List of bean definition names, in registration order */
        /** 所有bean定义的名字的集合，按注册次序*/
        private volatile List<String> beanDefinitionNames = new ArrayList<>(256);
    
        /** List of names of manually registered singletons, in registration order */
        /** 手工注册的单例bean定义的名字的集合，按注册次序*/
        private volatile Set<String> manualSingletonNames = new LinkedHashSet<>(16);
    
        /** Cached array of bean definition names in case of frozen configuration */
        /** 缓存bean定义名字的数组*/
        private volatile String[] frozenBeanDefinitionNames;
    
        /** Whether bean definition metadata may be cached for all beans */
        /** 是否允许bean定义的元数据被缓存，以用于所有的bean*/
        private volatile boolean configurationFrozen = false;
    
    
        /**
         * Create a new DefaultListableBeanFactory.
         */
        public DefaultListableBeanFactory() {
            super();
        }
    
        /**
         * Create a new DefaultListableBeanFactory with the given parent.
         * @param parentBeanFactory the parent BeanFactory
         */
        public DefaultListableBeanFactory(BeanFactory parentBeanFactory) {
            super(parentBeanFactory);
        }
    
    
        /**
         * Specify an id for serialization purposes, allowing this BeanFactory to be
         * 指定一个ID用于序列化操作，如有需要允许这个BeanFactory通过这个ID反序化为此BeanFactory对象
         * deserialized from this id back into the BeanFactory object, if needed.
         */
        public void setSerializationId(String serializationId) {
            if (serializationId != null) {
                serializableFactories.put(serializationId, new WeakReference<>(this));
            }
            else if (this.serializationId != null) {
                serializableFactories.remove(this.serializationId);
            }
            this.serializationId = serializationId;
        }
    
        /**
         * Return an id for serialization purposes, if specified, allowing this BeanFactory
         * to be deserialized from this id back into the BeanFactory object, if needed.
         * @since 4.1.2
         */
        public String getSerializationId() {
            return this.serializationId;
        }
    
        /**
         * Set whether it should be allowed to override bean definitions by registering
         * a different definition with the same name, automatically replacing the former.
         * If not, an exception will be thrown. This also applies to overriding aliases.
         * <p>Default is "true".
         * @see #registerBeanDefinition
         */
        public void setAllowBeanDefinitionOverriding(boolean allowBeanDefinitionOverriding) {
            this.allowBeanDefinitionOverriding = allowBeanDefinitionOverriding;
        }
    
        /**
         * Return whether it should be allowed to override bean definitions by registering
         * a different definition with the same name, automatically replacing the former.
         * @since 4.1.2
         */
        public boolean isAllowBeanDefinitionOverriding() {
            return this.allowBeanDefinitionOverriding;
        }
    
        /**
         * Set whether the factory is allowed to eagerly load bean classes
         * 设置该工厂是否被允许马上加载bean定义
         * even for bean definitions that are marked as "lazy-init".
         * 即使是被标记为延迟加载的bean定义
         * <p>Default is "true". Turn this flag off to suppress class loading
         * for lazy-init beans unless such a bean is explicitly requested.
         * 如果有明确的要求，可以关闭这个标志以阻止延迟加载的类加载
         * In particular, by-type lookups will then simply ignore bean definitions
         * without resolved class name, instead of loading the bean classes on
         * demand just to perform a type check.
         * 尤其是by-type查找的时候总是忽略bean的这此定义，不解析类名，而是根据需要加载bean仅仅是完成一个类型检查
         * @see AbstractBeanDefinition#setLazyInit
         */
        public void setAllowEagerClassLoading(boolean allowEagerClassLoading) {
            this.allowEagerClassLoading = allowEagerClassLoading;
        }
    
        /**
         * Return whether the factory is allowed to eagerly load bean classes
         * even for bean definitions that are marked as "lazy-init".
         * @since 4.1.2
         */
        public boolean isAllowEagerClassLoading() {
            return this.allowEagerClassLoading;
        }
    
        /**
         * Set a {@link java.util.Comparator} for dependency Lists and arrays.
         * @see org.springframework.core.OrderComparator
         * @see org.springframework.core.annotation.AnnotationAwareOrderComparator
         */
        public void setDependencyComparator(Comparator<Object> dependencyComparator) {
            this.dependencyComparator = dependencyComparator;
        }
    
        /**
         * Return the dependency comparator for this BeanFactory (may be {@code null}.
         */
        public Comparator<Object> getDependencyComparator() {
            return this.dependencyComparator;
        }
    
        /**
         * Set a custom autowire candidate resolver for this BeanFactory to use
         * when deciding whether a bean definition should be considered as a
         * candidate for autowiring.
         * 给这个工厂设置一个定制的自动注入请求解析器，以便当决定是否一个bean的定义可以考虑为自动注入请求时使用
         */
        public void setAutowireCandidateResolver(final AutowireCandidateResolver autowireCandidateResolver) {
            Assert.notNull(autowireCandidateResolver, "AutowireCandidateResolver must not be null");
            if (autowireCandidateResolver instanceof BeanFactoryAware) {
                if (System.getSecurityManager() != null) {
                    final BeanFactory target = this;
                    AccessController.doPrivileged(new PrivilegedAction<Object>() {
                        @Override
                        public Object run() {
                            ((BeanFactoryAware) autowireCandidateResolver).setBeanFactory(target);
                            return null;
                        }
                    }, getAccessControlContext());
                }
                else {
                    ((BeanFactoryAware) autowireCandidateResolver).setBeanFactory(this);
                }
            }
            this.autowireCandidateResolver = autowireCandidateResolver;
        }
    
        /**
         * Return the autowire candidate resolver for this BeanFactory (never {@code null}).
         */
        public AutowireCandidateResolver getAutowireCandidateResolver() {
            return this.autowireCandidateResolver;
        }
    
    
        @Override
        public void copyConfigurationFrom(ConfigurableBeanFactory otherFactory) {
            super.copyConfigurationFrom(otherFactory);
            if (otherFactory instanceof DefaultListableBeanFactory) {
                DefaultListableBeanFactory otherListableFactory = (DefaultListableBeanFactory) otherFactory;
                this.allowBeanDefinitionOverriding = otherListableFactory.allowBeanDefinitionOverriding;
                this.allowEagerClassLoading = otherListableFactory.allowEagerClassLoading;
                this.autowireCandidateResolver = otherListableFactory.autowireCandidateResolver;
                this.resolvableDependencies.putAll(otherListableFactory.resolvableDependencies);
            }
        }
        }