最新消息:XAMPP默认安装之后是很不安全的,我们只需要点击左方菜单的 "安全"选项,按照向导操作即可完成安全设置。

追踪解析Spring ioc启动源码(3)

XAMPP教程 admin 799浏览 0评论
4 在bean factory中创造 bean
写在前面:该 part 是 Spring ioc 的核心,显得非常冗杂,Spring 内不知名的组件非常的多,有很多笔者也难以描述清楚,甚至也没见过。在介绍的时候会做适当的忽略。
该 part 的起点:
public AnnotationConfigApplicationContext(Class<?>… annotatedClasses) {
    this();
    register(annotatedClasses);
    refresh();                        // 4 在 bean factory 中创造 bean
}
来追踪这个方法的实现:
//AbstractApplicationContext.class
public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        //准备工作的配置
        //4.3
        prepareRefresh();
        //获取 bean factory
        //4.4
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
        //配置 bean factory
        //4.5
        prepareBeanFactory(beanFactory);
        try {
            //4.6
            postProcessBeanFactory(beanFactory);
            //4.7
            invokeBeanFactoryPostProcessors(beanFactory);
            //4.8
            registerBeanPostProcessors(beanFactory);
            //4.9
            initMessageSource();
            //4.10
            initApplicationEventMulticaster();
            //4.11
            onRefresh();
            //4.12
            registerListeners();
            //4.13
            finishBeanFactoryInitialization(beanFactory);
            //4.15
            finishRefresh();
        }catch (BeansException ex) {
            if (logger.isWarnEnabled()) {
                logger.warn(“Exception encountered during context initialization – ” +
                        “cancelling refresh attempt: ” + ex);
            }
            //4.16
            destroyBeans();
            //4.17
            cancelRefresh(ex);
            throw ex;
        }finally {
            //4.18
            resetCommonCaches();
        }
    }
}
4.1
在开始之前先来看一下 BeanPostProcessor:
public interface BeanPostProcessor {
    //此方法在 bean 初始化之前、bean 的构造方法调用之后执行
    @Nullable
    default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
    //此方法在 bean 初始化之后执行
    @Nullable
    default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
}
BeanPostProcessor 在 bean 的注册阶段就已经大量接触到了,在下列 bean 的创建阶段会更多的遇到,是 Spring ioc 的重要组成部分。
Spring 容器本身在初始化的时候就会注册很多个 BeanPostProcessor 接口的实现类到 BeanFactory 中。这些类会被 BeanFactory 实例成 bean,并特殊存放到一个列表中。在其它普通 bean 的初始化(即为 init 方法被调用时)之前,轮循 BeanPostProcessor 列表,执行 postProcessBeforeInitialization(…) 方法;在其它普通 bean 的初始化之后,再次轮训 BeanPostProcessor 列表,执行 postProcessAfterInitialization(…) 方法。
从出入参可知,这两个方法用于在 bean 的初始化阶段对 bean 进行功能增强操作,包括但不限于代码织入(asm)、切面操作(aop)等。
作为 Spring 的使用者,只要是自行编写实现了该接口的类,然后通过配置将该类作为 Bean 注册到 Spring 中,就会被 Spring 一视同仁的作为内部 BeanPostProcessor 对待。
4.2
再来看一下创建 bean 的核心方法,即 BeanUtil.instantiateClass(…):
//BeanUtil.class
public static <T> T instantiateClass(Constructor<T> ctor, Object… args) throws BeanInstantiationException {
    Assert.notNull(ctor, “Constructor must not be null”);
    try {
        //设置 accessible = true,即为去掉 privite 关键词对构造的影响
        ReflectionUtils.makeAccessible(ctor);
        //这个返回语句主要是为了兼容 kotlin 语言,对于 java 来说主要是 ctor.newInstance(args)
        //本质是调用 bean 的构造器来实例化 bean
        return (KotlinDetector.isKotlinReflectPresent() && KotlinDetector.isKotlinType(ctor.getDeclaringClass()) ?
                KotlinDelegate.instantiateClass(ctor, args) : ctor.newInstance(args));
    }catch (InstantiationException ex) {
        throw new BeanInstantiationException(ctor, “Is it an abstract class?”, ex);
    }catch (IllegalAccessException ex) {
        throw new BeanInstantiationException(ctor, “Is the constructor accessible?”, ex);
    }catch (IllegalArgumentException ex) {
        throw new BeanInstantiationException(ctor, “Illegal arguments for constructor”, ex);
    }catch (InvocationTargetException ex) {
        throw new BeanInstantiationException(ctor, “Constructor threw exception”, ex.getTargetException());
    }
}
BeanUtil 是 bean 的实例化的关键,Spring 的其它代码都是在做各种判断,但是真正实例化 bean 的就这一句。
4.3
看下方代码片段:
//AbstractApplicationContext.class
protected void prepareRefresh() {
    //记录下启动时间
    this.startupDate = System.currentTimeMillis();
    //这两个变量与优雅关闭有关,这里确定 Spring 未关闭
    this.closed.set(false);
    this.active.set(true);
    //logger 日志相关代码均不作描述了
    if (logger.isDebugEnabled()) {
        if (logger.isTraceEnabled()) {
            logger.trace(“Refreshing ” + this);
        }
        else {
            logger.debug(“Refreshing ” + getDisplayName());
        }
    }
    //初始化 property
    //该方法是空的
    initPropertySources();
    //检查读取到的 properties 键值对
    getEnvironment().validateRequiredProperties();
    //新建一个集合,这个集合用于储存需要立即通知的事件
    this.earlyApplicationEvents = new LinkedHashSet<>();
}
closed 和 active 都是定义在 AbstractApplicationContext 中的 AtomicBoolean,用以管理 Spring 容器的状态:
//容器是否处于活动中
private final AtomicBoolean active = new AtomicBoolean();
//容器是否已经关闭
private final AtomicBoolean closed = new AtomicBoolean();
initPropertySources() 方法其实是一个预留下的空方法:
//AbstractApplicationContext.class
protected void initPropertySources() {
}
getEnvironment() 在之前的代码里看到过,用来获取一个新创建出来的 StandardEnvironment 对象,而 validateRequiredProperties() 是定义在 AbstractEnvironment 中的方法:
//AbstractEnvironment.class
public void validateRequiredProperties() throws MissingRequiredPropertiesException {
    this.propertyResolver.validateRequiredProperties();
}
propertyResolver 是一个定义在 AbstractEnvironment 中的 PropertySourcesPropertyResolver 对象,顾名思义,是用来管理 properties 配置文件中读取到的值的。来看一下 validateRequiredProperties():
//AbstractPropertyResolver.class
public void validateRequiredProperties() {
    //新建了一个 Exception,用于在出错情况下进行返回
    MissingRequiredPropertiesException ex = new MissingRequiredPropertiesException();
    //这里的字面意思上可以看出,这个 for 循环语句用于从 requiredProperties 这个集合里获取每个 properties key
    for (String key : this.requiredProperties) {
        //getProperty(key) 方法会用 key 去获取 value 值,然后进行空值比对
        if (this.getProperty(key) == null) {
            //如果存在 null,则加入到错误信息里
            ex.addMissingRequiredProperty(key);
        }
    }
    //错误信息不为空,证明上述代码中存在值为 null 的,就直接抛出异常
    if (!ex.getMissingRequiredProperties().isEmpty()) {
        throw ex;
    }
}
4.4
看下方代码片段:
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
追踪 obtainFreshBeanFactory() 方法:
//AbstractApplicationContext.class
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
    refreshBeanFactory();
    return getBeanFactory();
}
追踪 refreshBeanFactory() 方法的内部实现:
//GenericApplicationContext.class
protected final void refreshBeanFactory() throws IllegalStateException {
    if (!this.refreshed.compareAndSet(false, true)) {
        //抛出错误,提示大意为:已经调用过一次 “refresh” 了
        throw new IllegalStateException(
                “GenericApplicationContext does not support multiple refresh attempts: just call ‘refresh’ once”);
    }
    //存入一个用于序列化的 id
    this.beanFactory.setSerializationId(getId());
}
refreshed 是一个定义在 GenericApplicationContext 中的 AtomicBoolean 类型对象。AtomicBoolean 的 compareAndSet(…) 方法等同于进行如下操作:
//比较 AtomicBoolean 当前的值和第一个参数是否相等,如果一致,则将 AtomicBoolean 当前的值换成第二个值。
//以下为模拟代码,AtomicBoolean 的真实实现大多数是使用虚拟机底层代码完成,是原子化的操作
if(atomicBoolean == false){
    atomicBoolean = true;
    return true;
}else{
    return false;
}
this.beanFactory.setSerializationId(getId()) 会将 AbstractApplicationContext 内的 id 存入一个定义在 DefaultListableBeanFactory 中的 map 对象里。
4.5
看下方代码片段:
prepareBeanFactory(beanFactory);
追踪代码实现:
//AbstractApplicationContext.class
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    //存入 AnnotationConfigApplicationContext 中的 classLoader
    beanFactory.setBeanClassLoader(getClassLoader());
    //StandardBeanExpressionResolver 用于解析 Spring EL 表达式的解析器
    beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
    //ResourceEditorRegistrar 用于各种 bean 与 String 之间进行转换的属性编辑器
    beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
    //ApplicationContextAwareProcessor 用于注入各类 aware bean
    beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
    //在自动装配(autowire)阶段要忽略的接口类
    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.registerResolvableDependency(BeanFactory.class, beanFactory);
    beanFactory.registerResolvableDependency(ResourceLoader.class, this);
    beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
    beanFactory.registerResolvableDependency(ApplicationContext.class, this);
    //ApplicationListenerDetector 用于类型是 ApplicationListener 的bean添加到事件广播器
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
    //代码动态织入
    //LOAD_TIME_WEAVER_BEAN_NAME = “loadTimeWeaver”
    if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
        //LoadTimeWeaverAwareProcessor 用于在 bean 初始化之前检查 bean 是否实现了LoadTimeWeaverAware 接口
        //与 Spring aop 代码织入相关的 BeanPostProcessor
        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
        //用于类型匹配的 classloader
        beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    }
    //注册 properties 和 environment 相关的 bean
    //这里不仅会注册,而且会直接将这些 bean 存放到 singleObject 中(即为直接实例化出来)
    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());
    }
}
代码动态织入是 Spring 底层 cglib 的相关概念,暂时不展开。
4.6
看下方代码片段:
postProcessBeanFactory(beanFactory);
在 AbstractApplicationContext 中该方法是一个空方法:
//AbstractApplicationContext.class
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
}
该方法预留给 AbstractApplicationContext 的子类去实现,目的是在 bean factory 装配完成之后做一些定制化处理 AbstractApplicationContext。在 AnnotationConfigApplicationContext 及其父类中没有重写该方法。
4.7
看下方代码片段:
invokeBeanFactoryPostProcessors(beanFactory);
追踪代码实现:
//AbstractApplicationContext.class
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
    if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
        beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    }
}
这段代码和上述 4.4 中的一段几乎是一摸一样的,Spring 在这里做了二次验证。
4.8
看下方代码片段:
registerBeanPostProcessors(beanFactory);
从字面意思可以看出就是在 beanFactory 中注册 BeanPostProcessor。注册的本质是将 BeanPostProcessor 保存到一个列表里。从源码里看,该列表是定义在 AbstractBeanFactory 中的 beanPostProcessors。
追踪代码实现:
//AbstractApplicationContext.class
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}
继续追踪:
//PostProcessorRegistrationDelegate.class
public static void registerBeanPostProcessors(
            ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
    //根据 class 获取到所有符合的 bean,即 BeanPostProcessor 的子类
    String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
    //beanFactory.getBeanPostProcessorCount() 获取到的数字是在 4.4 中 set 的 BeanPostProcessor 的数量
    int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
    //BeanPostProcessorChecker 是 PostProcessorRegistrationDelegate 的私有静态内部类
    //如果一个 bean 没有被所有的 BeanPostProcessor 处理完毕,BeanPostProcessorChecker 就会打印日志
    beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
    //处理 Order 相关接口
    //Order 是一个用于排序的接口
    //用于存放实现了 PriorityOrdered 接口的 BeanPostProcessor
    List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
    //用于存放实现了 MergedBeanDefinitionPostProcessor 接口的 BeanPostProcessor
    List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
    //用于存放实现了 Ordered 接口的 BeanPostProcessor
    List<String> orderedPostProcessorNames = new ArrayList<>();
    //其它 BeanPostProcessor
    List<String> nonOrderedPostProcessorNames = new ArrayList<>();
    for (String ppName : postProcessorNames) {
        //isTypeMatch(…) 方法会判断该名称的 bean 和 class 类型是否一致
        //这里查看是否实现了 PriorityOrdered 接口
        if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            //获取 bean 并添加到一个列表中
            BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
            priorityOrderedPostProcessors.add(pp);
            if (pp instanceof MergedBeanDefinitionPostProcessor) {
                //继续判断是否实现了 MergedBeanDefinitionPostProcessor 接口
                internalPostProcessors.add(pp);
            }
        }else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
            //如果并非实现了 PriorityOrdered 接口就判断是否实现了 Ordered 接口
            orderedPostProcessorNames.add(ppName);
        }else {
            //均无,则存入 nonOrderedPostProcessorNames 列表中
            nonOrderedPostProcessorNames.add(ppName);
        }
    }
    //对于实现了 PriorityOrdered 接口的 BeanPostProcessor 进行排序
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    //依次注册这些 BeanPostProcessor
    registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
    //下方代码块和上方很雷同,注册实现了 Ordered 接口的 BeanPostProcessor
    List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
    for (String ppName : orderedPostProcessorNames) {
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
        orderedPostProcessors.add(pp);
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
            internalPostProcessors.add(pp);
        }
    }
    sortPostProcessors(orderedPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, orderedPostProcessors);
    //注册没有实现任何排序接口的 BeanPostProcessor
    List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
    for (String ppName : nonOrderedPostProcessorNames) {
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
        nonOrderedPostProcessors.add(pp);
        if (pp instanceof MergedBeanDefinitionPostProcessor) {
            internalPostProcessors.add(pp);
        }
    }
    registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
    //对于实现了 MergedBeanDefinitionPostProcessor 接口的 BeanPostProcessor 会统一进行排序并注册
    sortPostProcessors(internalPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, internalPostProcessors);
    //ApplicationListenerDetector 用于在 bean 初始化后检查是否实现了 ApplicationListener 接口
    //从代码来看,实现了该接口的 bean 会被存入一个叫 applicationListeners 的列表中
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}
综合来看这个方法的主体是对 BeanPostProcessor 进行依次的存储(会影响到 BeanPostProcessor 的执行顺序)。
次序的依据主要是看这些 BeanPostProcessor 是否实现了 Order 及其相关的接口。
4.9
看下方代码片段:
initMessageSource();
追踪代码实现:
//AbstractApplicationContext.class
protected void initMessageSource() {
    //获取 beanFactory
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    //MESSAGE_SOURCE_BEAN_NAME = “messageSource”
    //先去查看 beanFactory 中是否有该名称的 bean
    if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
        //获取到这个 bean
        this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
        //主体思路是将数据源存入这个 bean 中
        if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
            HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
            if (hms.getParentMessageSource() == null) {
                //存入默认的数据源
                //getInternalParentMessageSource() 方法会先
                hms.setParentMessageSource(getInternalParentMessageSource());
            }
        }
        if (logger.isTraceEnabled()) {
            logger.trace(“Using MessageSource [” + this.messageSource + “]”);
        }
    }else {
        //没有这个 bean 的情况下就自定义一个,并存入到 beanFactory 中
        DelegatingMessageSource dms = new DelegatingMessageSource();
        dms.setParentMessageSource(getInternalParentMessageSource());
        this.messageSource = dms;
        beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
        if (logger.isTraceEnabled()) {
            logger.trace(“No ‘” + MESSAGE_SOURCE_BEAN_NAME + “‘ bean, using [” + this.messageSource + “]”);
        }
    }
}
Spring 中可以配置多套配置文件,之间通过 messageSource 进行切换。
4.10
看下方代码片段:
initApplicationEventMulticaster();
追踪代码实现:
//AbstractApplicationContext.class
protected void initApplicationEventMulticaster() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    //APPLICATION_EVENT_MULTICASTER_BEAN_NAME = “applicationEventMulticaster”
    //检查是否存在名称为 applicationEventMulticaster 的 bean
    if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
        //如果存在则赋值给 applicationEventMulticaster
        this.applicationEventMulticaster =
                beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
        if (logger.isTraceEnabled()) {
            logger.trace(“Using ApplicationEventMulticaster [” + this.applicationEventMulticaster + “]”);
        }
    }else {
        //没有的话就创建一个,并注册与赋值
        this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
        beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
        if (logger.isTraceEnabled()) {
            logger.trace(“No ‘” + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + “‘ bean, using ” +
                    “[” + this.applicationEventMulticaster.getClass().getSimpleName() + “]”);
        }
    }
}
applicationEventMulticaster 是一个观察者模式的应用,可以理解为是用来分发数据给监听器(Listener)的中转站。
4.11
看下方代码片段:
onRefresh();
默认该方法为空:
//AbstractApplicationContext.class
protected void onRefresh() throws BeansException {
}
预留用于处理特殊的 bean。
4.12
registerListeners();
追踪代码实现:
//AbstractApplicationContext.class
protected void registerListeners() {
    //遍历 applicationListeners 列表
    //往 applicationEventMulticaster 内部的列表 applicationListeners 里添加
    //applicationListener 用于在容器初始化时期监听事件
    for (ApplicationListener<?> listener : getApplicationListeners()) {
        getApplicationEventMulticaster().addApplicationListener(listener);
    }
    //获取可能存在的使用者自行定义的监听器,同样添加到列表里
    String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
    for (String listenerBeanName : listenerBeanNames) {
        getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
    }
    //获取所有的 event,放到一个列表里
    Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
    this.earlyApplicationEvents = null;
    if (earlyEventsToProcess != null) {
        for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
            getApplicationEventMulticaster().multicastEvent(earlyEvent);
        }
    }
}
特定的监听器用于监听某一类的 event,在容器启动时生效,对 event 做出处理。
监听器被储存在 applicationEventMulticaster 中,发生事件的时候被告知。
4.13
finishBeanFactoryInitialization(beanFactory);
追踪代码实现:
//AbstractApplicationContext.class
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    //CONVERSION_SERVICE_BEAN_NAME = “conversionService”
    //conversionService 这个 bean 用于映射数据类型,比如将前端的字符串类型数据转成日期等
    //由使用者自主实现并配置,默认情况下没有这个 bean
    if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
                beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
            beanFactory.setConversionService(
                    beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
        }
    //如果 beanFactory 里没有 embeddedValueResolver,就会从 environment 里获取并加载到里面
    //embeddedValueResolver 是和配置文件读取相关的组件
    if (!beanFactory.hasEmbeddedValueResolver()) {
        beanFactory.addEmbeddedValueResolver((strVal) -> {
            return this.getEnvironment().resolvePlaceholders(strVal);
        });
    }
    //以下代码用于提前实例化代码织入相关的 bean
    String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    String[] var3 = weaverAwareNames;
    int var4 = weaverAwareNames.length;
    for(int var5 = 0; var5 < var4; ++var5) {
        String weaverAwareName = var3[var5];
        this.getBean(weaverAwareName);
    }
    //将 classLoader 置空,因为已经用不到了,所以清除掉,节省内存
    beanFactory.setTempClassLoader((ClassLoader)null);
    //这个方法会将 beanName 列表转换成一个字符串数组,节省内存
    beanFactory.freezeConfiguration();
    //实例化 bean 的核心方法
    beanFactory.preInstantiateSingletons();
}
来看一下 beanFactory.preInstantiateSingletons() 方法:
//DefaultListableBeanFactory.class
public void preInstantiateSingletons() throws BeansException {
    if (logger.isTraceEnabled()) {
        logger.trace(“Pre-instantiating singletons in ” + this);
    }
    //将 beanName 列表拷贝一份
    List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
    //遍历
    for (String beanName : beanNames) {
        //获取每个 bean
        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
        //需要最终确认 bean 不是抽象类,且为单例的,且不是惰性加载的
        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
            //判断其是否实现了 FactoryBean 接口
            //FactoryBean 是 Spring 留出的可供使用者选择的用于生产 bean 的工厂模式接口
            if (isFactoryBean(beanName)) {
                Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                //二次判断
                if (bean instanceof FactoryBean) {
                    final FactoryBean<?> factory = (FactoryBean<?>) bean;
                    //是否期望被 init
                    boolean isEagerInit;
                    //系统存在权限问题的时候才会进入到这个判断语句中
                    if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                        //AccessController.doPrivileged(…) 方法用于 java 的权限控制
                        //此处调用了此方法用于剔除权限对 Spring 的控制
                        //此处与下方代码都调用了 SmartFactoryBean 接口的 isEagerInit() 方法进行判断
                        isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
                                        ((SmartFactoryBean<?>) factory)::isEagerInit,
                                getAccessControlContext());
                    }else {
                        isEagerInit = (factory instanceof SmartFactoryBean &&
                                ((SmartFactoryBean<?>) factory).isEagerInit());
                    }
                    //实例化
                    if (isEagerInit) {
                        getBean(beanName);
                    }
                }
            }else {
                //其实对于绝大多数普通的 bean,是直接调用这个语句进行实例化的
                getBean(beanName);
            }
        }
    }
    //此处再次循环获取 bean ,用于对实现了 SmartInitializingSingleton 接口的 bean 进行特殊操作
    //SmartInitializingSingleton 接口内有一个 afterSingletonsInstantiated() 方法,会在完成 bean 的实例化之后执行
    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();
            }
        }
    }
}
4.14
所以最终实例化 bean 的是 getBean(…) 方法,此方法不仅可以用于从容器中取出 bean,也是实例化 bean 的具体实现。
追踪其具体代码实现:
//AbstractBeanFactory.class
public Object getBean(String name) throws BeansException {
    return doGetBean(name, null, null, false);
}
继续来看 doGetBean(…) 方法:
//AbstractBeanFactory.class
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
            @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
    final String beanName = transformedBeanName(name);
    Object bean;
    //对于之前已经实例过的 bean,会在这个方法里获取到
    //如果没有实例化过,那么此处获取的是 null
    Object sharedInstance = getSingleton(beanName);
    //args 是用于实例化 bean 过程中传入构造器的参数
    //此处传入的 args 为 null
    if (sharedInstance != null && args == null) {
        if (logger.isTraceEnabled()) {
            if (isSingletonCurrentlyInCreation(beanName)) {
                logger.trace(“Returning eagerly cached instance of singleton bean ‘” + beanName +
                        “‘ that is not fully initialized yet – a consequence of a circular reference”);
            }else {
                logger.trace(“Returning cached instance of singleton bean ‘” + beanName + “‘”);
            }
        }
        //此方法用于处理 FactoryBean 的情况,如果没有的话是直接返回 sharedInstance 的
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }else {
        //如果 bean 正在创建,会抛出异常
        if (isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }
        //先取出父类中存放的 parentBeanFactory,如果有实现的话就用该工厂来创建 bean
        //本例中没有使用 parentBeanFactory
        BeanFactory parentBeanFactory = getParentBeanFactory();
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
            String nameToLookup = originalBeanName(name);
            if (parentBeanFactory instanceof AbstractBeanFactory) {
                return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                        nameToLookup, requiredType, args, typeCheckOnly);
            }else if (args != null) {
                return (T) parentBeanFactory.getBean(nameToLookup, args);
            }else if (requiredType != null) {
                return parentBeanFactory.getBean(nameToLookup, requiredType);
            }else {
                return (T) parentBeanFactory.getBean(nameToLookup);
            }
        }
        //这里会将 bean 标记为已经创建
        if (!typeCheckOnly) {
            markBeanAsCreated(beanName);
        }
        try {
            //获取 bean 的包装类
            final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            //bean 不能是一个 abstract 修饰的类,否则会报错
            checkMergedBeanDefinition(mbd, beanName, args);
            //depends-on 用来处理要实例化某个 bean,必须先实例化另一个 bean 的情况
            String[] dependsOn = mbd.getDependsOn();
            if (dependsOn != null) {
                for (String dep : dependsOn) {
                    //处理循环依赖的问题
                    if (isDependent(beanName, dep)) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                “Circular depends-on relationship between ‘” + beanName + “‘ and ‘” + dep + “‘”);
                    }
                    //注册要依赖的 bean
                    registerDependentBean(dep, beanName);
                    try {
                        //实例化要依赖的 bean
                        getBean(dep);
                    }catch (NoSuchBeanDefinitionException ex) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                “‘” + beanName + “‘ depends on missing bean ‘” + dep + “‘”, ex);
                    }
                }
            }
            //是否是单例的
            if (mbd.isSingleton()) {
                sharedInstance = getSingleton(beanName, () -> {
                    try {
                        //实例化 bean 的核心方法
                        return createBean(beanName, mbd, args);
                    }catch (BeansException ex) {
                        //如果报错的话会销毁掉这个 bean
                        destroySingleton(beanName);
                        throw ex;
                    }
                });
                bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
            }else if (mbd.isPrototype()) {
                //如果 scope 注解为 prototype,则每次获取 bean 的时候都会创建新的 bean 实例
                Object prototypeInstance = null;
                try {
                    beforePrototypeCreation(beanName);
                    prototypeInstance = createBean(beanName, mbd, args);
                }
                finally {
                    afterPrototypeCreation(beanName);
                }
                bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
            }else {
                //获取 scope 注解的值,如果是 null 的话会报错
                String scopeName = mbd.getScope();
                final Scope scope = this.scopes.get(scopeName);
                if (scope == null) {
                    throw new IllegalStateException(“No Scope registered for scope name ‘” + scopeName + “‘”);
                }
                try {
                    //这一步的操作和上方代码块几乎是一样的
                    Object scopedInstance = scope.get(beanName, () -> {
                        beforePrototypeCreation(beanName);
                        try {
                            return createBean(beanName, mbd, args);
                        }finally {
                            afterPrototypeCreation(beanName);
                        }
                    });
                    bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                }catch (IllegalStateException ex) {
                    throw new BeanCreationException(beanName,
                            “Scope ‘” + scopeName + “‘ is not active for the current thread; consider ” +
                            “defining a scoped proxy for this bean if you intend to refer to it from a singleton”,
                            ex);
                }
            }
        }catch (BeansException ex) {
            cleanupAfterBeanCreationFailure(beanName);
            throw ex;
        }
    }
    //requiredType 是使用者传入的 class 对象,使用者可以将 bean 转换成该类型并输出
    if (requiredType != null && !requiredType.isInstance(bean)) {
        try {
            T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
            if (convertedBean == null) {
                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
            }
            return convertedBean;
        }catch (TypeMismatchException ex) {
            if (logger.isTraceEnabled()) {
                logger.trace(“Failed to convert bean ‘” + name + “‘ to required type ‘” +
                        ClassUtils.getQualifiedName(requiredType) + “‘”, ex);
            }
            throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
        }
    }
    //返回 bean
    return (T) bean;
}
继续追踪 createBean(…) 方法:
//AbstractAutowireCapableBeanFactory.class
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
            throws BeanCreationException {
    if (logger.isTraceEnabled()) {
        logger.trace(“Creating instance of bean ‘” + beanName + “‘”);
    }
    RootBeanDefinition mbdToUse = mbd;
    //获取 bean 的 class,然后在再次确定了 bean 的 class 无误之后,克隆一份 bean 并存入 bean class
    Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
    if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
        mbdToUse = new RootBeanDefinition(mbd);
        mbdToUse.setBeanClass(resolvedClass);
    }
    //重写的方法解析
    try {
        mbdToUse.prepareMethodOverrides();
    }catch (BeanDefinitionValidationException ex) {
        throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
                beanName, “Validation of method overrides failed”, ex);
    }
    try {
        //根据注释来看,这个方法是使用 BeanPostProcessor 去进行动态代理
        //如果存在对应的 BeanPostProcessor,返回的是动态代理的类,而不是 bean 本身
        Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
        if (bean != null) {
            return bean;
        }
    }catch (Throwable ex) {
        throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
                “BeanPostProcessor before instantiation of bean failed”, ex);
    }
    try {
        //实例化 bean 的核心方法
        Object beanInstance = doCreateBean(beanName, mbdToUse, args);
        if (logger.isTraceEnabled()) {
            logger.trace(“Finished creating instance of bean ‘” + beanName + “‘”);
        }
        return beanInstance;
    }catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
        throw ex;
    }catch (Throwable ex) {
        throw new BeanCreationException(
                mbdToUse.getResourceDescription(), beanName, “Unexpected exception during bean creation”, ex);
    }
}
继续追踪 doCreateBean(…) 方法:
//AbstractAutowireCapableBeanFactory.class
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
            throws BeanCreationException {
    //BeanWrapper 是 bean 的另一种包装
    BeanWrapper instanceWrapper = null;
    if (mbd.isSingleton()) {
        //factoryBeanInstanceCache 是一个 map 对象,用于缓存 wrapper
        //此处从缓存中删除并返回此 wrapper
        instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    }
    //如果没有的话会创建一个
    if (instanceWrapper == null) {
        //这一步会实例化 bean
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    //获取 bean 实例
    final Object bean = instanceWrapper.getWrappedInstance();
    //获取 class
    Class<?> beanType = instanceWrapper.getWrappedClass();
    if (beanType != NullBean.class) {
        mbd.resolvedTargetType = beanType;
    }
    synchronized (mbd.postProcessingLock) {
        if (!mbd.postProcessed) {
            try {
                //该方法会轮询 BeanPostProcessor 列表进行 bean 的增强操作
                applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
            }catch (Throwable ex) {
                throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                        “Post-processing of merged bean definition failed”, ex);
            }
            mbd.postProcessed = true;
        }
    }
    //是否是单例,是否允许循环引用,该单例 bean 是否在创建中
    //isSingletonCurrentlyInCreation(beanName) 方法会去集合 singletonsCurrentlyInCreation 中搜寻 beanName
    //如果存在,证明该 bean 正在被初始化,初始化完成之后会从该集合中删除掉,功能相当于锁
    boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
            isSingletonCurrentlyInCreation(beanName));
    if (earlySingletonExposure) {
        if (logger.isTraceEnabled()) {
            logger.trace(“Eagerly caching bean ‘” + beanName +
                    “‘ to allow for resolving potential circular references”);
        }
        //将 beanName 注册到 singletonFactories 和 registeredSingletons 中
        addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    }
    //添加一个 bean 的引用 exposedObject
    Object exposedObject = bean;
    try {
        //该方法会根据配置来填充 mbd 中
        populateBean(beanName, mbd, instanceWrapper);
        //将信息填充到 exposedObject 中
        exposedObject = initializeBean(beanName, exposedObject, mbd);
    }catch (Throwable ex) {
        if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
            throw (BeanCreationException) ex;
        }else {
            throw new BeanCreationException(
                    mbd.getResourceDescription(), beanName, “Initialization of bean failed”, ex);
        }
    }
    if (earlySingletonExposure) {
        //getSingleton(…) 方法的第二个参数代表是否允许循环引用,这里输入的是 false(不允许)
        //对于一般的 bean,这里获取到的 earlySingletonReference = null
        Object earlySingletonReference = getSingleton(beanName, false);
        if (earlySingletonReference != null) {
            if (exposedObject == bean) {
                exposedObject = earlySingletonReference;
            }else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
                String[] dependentBeans = getDependentBeans(beanName);
                Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
                for (String dependentBean : dependentBeans) {
                    if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                        actualDependentBeans.add(dependentBean);
                    }
                }
                if (!actualDependentBeans.isEmpty()) {
                    throw new BeanCurrentlyInCreationException(beanName,
                            “Bean with name ‘” + beanName + “‘ has been injected into other beans [” +
                            StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
                            “] in its raw version as part of a circular reference, but has eventually been ” +
                            “wrapped. This means that said other beans do not use the final version of the ” +
                            “bean. This is often the result of over-eager type matching – consider using ” +
                            “‘getBeanNamesOfType’ with the ‘allowEagerInit’ flag turned off, for example.”);
                }
            }
        }
    }
    //注册需要执行销毁方法的 bean
    try {
        registerDisposableBeanIfNecessary(beanName, bean, mbd);
    }catch (BeanDefinitionValidationException ex) {
        throw new BeanCreationException(
                mbd.getResourceDescription(), beanName, “Invalid destruction signature”, ex);
    }
    return exposedObject;
}
继续追踪 createBeanInstance(…) 方法:
//AbstractAutowireCapableBeanFactory.class
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
    //获取到 bean 的 class
    Class<?> beanClass = resolveBeanClass(mbd, beanName);
    //如果 class 不为空,且修饰语非 public,且没有设置 accessible = true
    if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                “Bean class isn’t public, and non-public access not allowed: ” + beanClass.getName());
    }
    //如果 BeanDefinition 中有保存 Supplier,则使用该方式去获取 bean
    //Supplier 是 jdk8 中配合函数式编程所添加的用于获取 bean 的接口
    //Supplier 每次获取的 bean 都不是同一个
    Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
    if (instanceSupplier != null) {
        return obtainFromSupplier(instanceSupplier, beanName);
    }
    //如果有工厂方法,就用工厂方法进行实例化
    if (mbd.getFactoryMethodName() != null) {
        return instantiateUsingFactoryMethod(beanName, mbd, args);
    }
    boolean resolved = false;
    boolean autowireNecessary = false;
    if (args == null) {
        synchronized (mbd.constructorArgumentLock) {
            //查看是否缓存了构造器
            if (mbd.resolvedConstructorOrFactoryMethod != null) {
                resolved = true;
                //这里要判断构造器的参数是否使用了 Autowire 注解
                autowireNecessary = mbd.constructorArgumentsResolved;
            }
        }
    }
    if (resolved) {
        if (autowireNecessary) {
            //如果使用了 Autowire 注解就会进入这个方法进行实例化
            return autowireConstructor(beanName, mbd, null, null);
        }else {
            //常规的实例化 bean
            return instantiateBean(beanName, mbd);
        }
    }
    //如果一个继承了 BeanPostProcessor 接口的 bean 的构造器参数使用了 Autowire 注解,会在此处单独处理
    Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
    if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
            mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
        return autowireConstructor(beanName, mbd, ctors, args);
    }
    //获取首选的构造器
    //在该版本的 RootBeanDefinition 里,该方法没有方法体,直接返回 null
    //也就是说,该代码是不启用的
    ctors = mbd.getPreferredConstructors();
    if (ctors != null) {
        return autowireConstructor(beanName, mbd, ctors, null);
    }
    //实例化 bean
    return instantiateBean(beanName, mbd);
}
继续追踪 instantiateBean(…) 方法:
//AbstractAutowireCapableBeanFactory.class
protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
    try {
        Object beanInstance;
        final BeanFactory parent = this;
        //再次检测权限环境
        //此例中没有涉及
        if (System.getSecurityManager() != null) {
            beanInstance = AccessController.doPrivileged((PrivilegedAction<Object>) () ->
                    getInstantiationStrategy().instantiate(mbd, beanName, parent),
                    getAccessControlContext());
        }else {
            //实例化 bean
            beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
        }
        //将 bean 包装成 BeanWrapper 并返回
        BeanWrapper bw = new BeanWrapperImpl(beanInstance);
        initBeanWrapper(bw);
        return bw;
    }catch (Throwable ex) {
        throw new BeanCreationException(
                mbd.getResourceDescription(), beanName, “Instantiation of bean failed”, ex);
    }
}
继续追踪 instantiate(…) 方法:
//SimpleInstantiationStrategy.class
public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
    //不需要方法重载,就不需要 cglib 帮助了
    if (!bd.hasMethodOverrides()) {
        Constructor<?> constructorToUse;
        synchronized (bd.constructorArgumentLock) {
            //先尝试查看 BeanDefinition 中是否保存了构造器,如果没有保存,就在下方从 class 中拿出来
            constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
            if (constructorToUse == null) {
                final Class<?> clazz = bd.getBeanClass();
                if (clazz.isInterface()) { //bean 不能是一个接口
                    throw new BeanInstantiationException(clazz, “Specified class is an interface”);
                }
                try {
                    //这里验证权限设置
                    if (System.getSecurityManager() != null) {
                        constructorToUse = AccessController.doPrivileged(
                                (PrivilegedExceptionAction<Constructor<?>>) clazz::getDeclaredConstructor);
                    }else {
                        //获取构造器
                        constructorToUse = clazz.getDeclaredConstructor();
                    }
                    bd.resolvedConstructorOrFactoryMethod = constructorToUse;
                }catch (Throwable ex) {
                    throw new BeanInstantiationException(clazz, “No default constructor found”, ex);
                }
            }
        }
        //实例化 bean
        return BeanUtils.instantiateClass(constructorToUse);
    }else {
        //使用 cglib 进行 bean 的实例化
        return instantiateWithMethodInjection(bd, beanName, owner);
    }
}
此小节是整个实例化 bean 过程中最冗长,也最核心的部分。
这中间 Spring 做了大量的验证和业务判断,但是实际上最终 bean 的实例化并不复杂。
4.15
finishRefresh();
追踪代码实现:
//AbstractApplicationContext.class
protected void finishRefresh() {
    //清空缓存,即将 resourceCaches 这个 map 对象置空
    clearResourceCaches();
    //实例化一个类型为 DefaultLifecycleProcessor 的 bean,用于控制 bean 的生命周期
    initLifecycleProcessor();
    getLifecycleProcessor().onRefresh();
    //刷新上下文事件
    //ContextRefreshedEvent 并没有业务逻辑
    publishEvent(new ContextRefreshedEvent(this));
    //此方法会将 applicationContext 保存到 LiveBeansView 中的一个集合内
    LiveBeansView.registerApplicationContext(this);
}
到此为止,正常的 ApplicationContext 的初始化流程就完成了。
4.16
看下方代码片段:
destroyBeans();
这个方法的实现:
//AbstractApplicationContext.class
protected void destroyBeans() {
    getBeanFactory().destroySingletons();
}
destroySingletons() 是定义在 DefaultListableBeanFactory 中的方法:
//DefaultListableBeanFactory.class
public void destroySingletons() {
    super.destroySingletons();
    //manualSingletonNames 是一个用来存放已经被创建的单例 bean 的名字的 Set集合
    this.manualSingletonNames.clear();
    clearByTypeCache();
}
这里的 super.destroySingletons() 调用的是其父类 DefaultSingletonBeanRegistry 中的方法:
//DefaultSingletonBeanRegistry.class
public void destroySingletons() {
    if (logger.isTraceEnabled()) {
        logger.trace(“Destroying singletons in ” + this);
    }
    synchronized (this.singletonObjects) {
        this.singletonsCurrentlyInDestruction = true;
    }
    String[] disposableBeanNames;
    synchronized (this.disposableBeans) {
        disposableBeanNames = StringUtils.toStringArray(this.disposableBeans.keySet());
    }
    for (int i = disposableBeanNames.length – 1; i >= 0; i–) {
        destroySingleton(disposableBeanNames[i]);
    }
    this.containedBeanMap.clear();
    this.dependentBeanMap.clear();
    this.dependenciesForBeanMap.clear();
    //清空相关的集合内的引用对象,并且销毁已经创建的 bean
    clearSingletonCache();
}
再来看一下 clearByTypeCache() 方法:
//DefaultListableBeanFactory.class
private void clearByTypeCache() {
    this.allBeanNamesByType.clear();
    this.singletonBeanNamesByType.clear();
}
4.17
看下方代码片段:
cancelRefresh(ex);
这个方法的实现:
//AbstractApplicationContext.class
protected void cancelRefresh(BeansException ex) {
    //传入的 exception 其实并没有用到
    this.active.set(false);
}
active 是定义在 AbstractApplicationContext 中的一个 AtomicBoolean:
private final AtomicBoolean active = new AtomicBoolean();
这里将其的值设置为 false。
4.18
看下方代码片段:
resetCommonCaches();
具体实现
//AbstractApplicationContext.class
protected void resetCommonCaches() {
    //主要是将 util 类里的一些 static 修饰的集合和 map 对象进行置空。
    ReflectionUtils.clearCache();
    AnnotationUtils.clearCache();
    ResolvableType.clearCache();
    CachedIntrospectionResults.clearClassLoader(getClassLoader());
}
从 4.16 到 4.18 的代码总体都比较简单,就是把各种的相关的集合、map、列表都清空掉,将 bean 的引用对象也都 remove 掉。
实际上是优雅关闭的过程。
二 一点唠叨
· Spring 的代码实在是太庞大了,刚开始想要尽可能详细的去解释每个组件,但是后来觉得难度略大
· Spring 的小部分组件和代码在笔者看来是有些莫名其妙的,且都没有查到详细而合理的解释
· Spring 的代码很明显使用了防御性的编程原则,保证了每个方法都足够健壮,但是同时造成了重复验证和冗余
· Spring 显然非常强调易用性和泛用性,提供了繁多的功能,甚至有部分是显得过于灵活的,如果笔者未读源码大概一辈子都不会知道
· Spring 对组件状态的控制异常复杂且精确
· Spring 对内存的控制很苛刻

转载请注明:XAMPP中文组官网 » 追踪解析Spring ioc启动源码(3)

您必须 登录 才能发表评论!