细读Spring源码（六）Spring源码设计架构

往期回顾：

• 细读Spring源码（一）---refresh()方法概览

• 细读Spring源码（二）---关于Spring中用到的设计模式

• 细读Spring源码（三）---深度剖析动态代理底层实现

• 细读Spring源码（四）---什么是IOC？

• 细读Spring源码（五）---AOP从实战到源码

今天早上又回顾了一下源码，总结出了下面的这张Spring设计思想图，其实网上有很多相关的图，我主要还是按照核心方法refesh的流程总结的，因为这也是Spring容器启动过程中初始化的核心，话不多说，直接上图：

我将容器的启动过程粗略地分成了上面的五个阶段，首先可以看到从始至终都要与BeanFactory进行交互，所以先来看看BeanFactory这个接口：

在源码中是这样描述的：

/**
 * The root interface for accessing a Spring bean container.
 * 访问Spring bean容器的根接口
 *
 * <p>This is the basic client view of a bean container;
 * further interfaces such as {@link ListableBeanFactory} and
 * {@link org.springframework.beans.factory.config.ConfigurableBeanFactory}
 * are available for specific purposes.
 * BeanFactory是访问Spring bean容器的根接口，这是一个bean容器基本的客户端视图，
 * 此外还有像ListableBeanFactory和ConfigurableBeanFactory这种为了特定目标使用的接口
 *
 * <p>This interface is implemented by objects that hold a number of bean definitions,
 * each uniquely identified by a String name. Depending on the bean definition,
 * the factory will return either an independent instance of a contained object
 * (the Prototype design pattern), or a single shared instance (a superior
 * alternative to the Singleton design pattern, in which the instance is a
 * singleton in the scope of the factory). Which type of instance will be returned
 * depends on the bean factory configuration: the API is the same. Since Spring
 * 2.0, further scopes are available depending on the concrete application
 * context (e.g. "request" and "session" scopes in a web environment).
 * 该接口会被持有大量bean定义的对象实现，每一个都是通过一个字符串类型的name进行唯一标识。
 * 根据bean的定义信息，工厂既可以返回一个已经存在对象的单独实例实例（原型设计模式），还可以返回一个能够被共享的单例实例（单例模式)
 * 返回什么类型的实例，将依赖bean工厂中scope的配置：具有相同的API。从Spring2.0开始，可以根据具体的应用上下文使用其他的scope,
 * 比如web应用中的request和session等
 *
 * <p>The point of this approach is that the BeanFactory is a central registry
 * of application components, and centralizes configuration of application
 * components (no more do individual objects need to read properties files,
 * for example). See chapters 4 and 11 of "Expert One-on-One J2EE Design and
 * Development" for a discussion of the benefits of this approach.
 * 这种实现方式的精髓在于它让BeanFactory成为应用组件的注册和配置中心，比如单个对象将不再需要去读取属性文件
 * 在《Expert One-on-One J2EE Design and Development》这本书的第4~11节就能讨论了该方法的优势
 *
/

从上面注释中可以获取三点重要信息：

1、这是访问Spring容器的根接口

2、这个接口被维护BeanDefinition信息的接口所继承，提供了对bean定义信息的管理，通过该接口，可以返回单例或多例的bean实例

3、它就像一个应用组件的注册和配置中心，集中管理容器中的bean，而不需要为了某个单独的bean单独读取配置文件

下面这种图中右边部分是该接口中的所有方法，左边注释部分说明实现该接口的工厂必须尽可能地支持标准bean生命周期的接口，同时给出了全部的初始化方法和它们的标准执行顺序，其实主要就是在实例化前后执行的BeanPostProcessor及它们的执行顺序。

接下来看看每个阶段在容器内都发生了什么事情：

第一阶段：注册BeanDefinition

BeanDefinition是一个接口，继承了AttributeAccessor, BeanMetadataElement ，用来管理Bean的属性和元数据，管理的数据有属性、构造器、参数、是否单例、是否懒加载等这些我们平时定义的信息。在这个阶段，主要是扫描我们定义的Java类，定义的方式有基于XML和基于注解两种方式，将每个类的描述信息封装成一个BeanDefinition对象，注册到工厂中，生成一个beanName->BeanDefinition的映射关系，以便后续使用。

第二阶段：执行BeanFactoryPostProcessor

在BeanDefinition中有下面这样一段注释信息：

This is just a minimal interface: The main intention is to allow a BeanFactoryPostProcessor to introspect and modify property values and other bean metadata.

翻译过来意思就是说：BeanDefinition只是一个最小的接口，设计它的主要目的是为了让BeanFactoryPostProcessor内省并修改属性值和其他bean的元信息，所以执行BeanFactoryPostProcessor的主要目的就是可以通过自定义实现对bean定义信息的修改，比如修改属性等。其实这个接口是bean工厂的后置处理器，它的操作范围是整个工厂，通过实现该接口，我们可以获取到工厂中已经注册的所有bean的定义信息，并对任意信息进行修改，下面举个例子：

 首先，定义一个bean

package com.spring.reading.bd.processor;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

/**
 * @author: cyhua
 * @createTime: 2021/12/6
 * @description: 定义一个普通的bean，含有一个属性,scope手动设置原型
 */
@Data
@Component
@ToString
@NoArgsConstructor
@AllArgsConstructor
@Scope(value = BeanDefinition.SCOPE_PROTOTYPE)
public class Company {

    private String name;


}

注意：上面的第21行代码，将scope自定义为原型，即多例，为了在BeanFactoryPostProcessor中对它进行修改！！！

其次，自定义一个BeanFactoryPostProcessor

package com.spring.reading.bd.processor;

import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.config.ConstructorArgumentValues;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.stereotype.Component;

/**
 * @author: cyhua
 * @createTime: 2021/12/5
 * @description: bean工厂后置处理器
 */
@Component
public class ReadingBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        AbstractBeanDefinition beanDefinition = (AbstractBeanDefinition) configurableListableBeanFactory.getBeanDefinition("company");
        //获取构造函数的参数值
        ConstructorArgumentValues constructorArgumentValues = beanDefinition.getConstructorArgumentValues();
        //获取是否懒加载配置
        Boolean lazyInit = beanDefinition.isLazyInit();
        //获取scope配置
        String scope = beanDefinition.getScope();
        //获取注入模式配置：byName或byType
        int autowireMode = beanDefinition.getAutowireMode();
        //scope如果为空或多例，则修改scope为单例
        if (StringUtils.isBlank(scope) || scope.equals(BeanDefinition.SCOPE_PROTOTYPE)) {
            beanDefinition.setScope(BeanDefinition.SCOPE_SINGLETON);
        }
    }

}

上面代码中获取了几个比较常见的BeanDefinition信息，最后当scope为空或者为多例时，修改为单例。

接下来，写一个测试类，获取两个Company对象，并进行比较

package com.spring.reading.bd.processor;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * @author: cyhua
 * @createTime: 2021/12/5
 * @description:
 */
public class BeanDefinitionCaller {


    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(BeanDefinitionConfig.class);
        Company company1 = context.getBean("company", Company.class);
        Company company2 = context.getBean("company", Company.class);
        //比较两个对象是否相同：按道理已经设置成单例，会返回true
        System.out.println(company1 == company2);
    }
}

上面15、16行代码通过相同的beanName获取了两次bean实例

下面进行debug，看看在BeanFactoryPostProcessor中是否能获取到bean定义信息？

 可以看当程序成功进入自定义的bean工厂后置处理器，也获取到了具体的BeanDefinition，下面看下执行结果：

 可以看到获取到了两个相同的对象，说明bean工厂后置处理器生效，修改bean定义成功，这就是执行BeanFactoryPostProcessor的作用，主要还是为了处理自定义的逻辑，方便开发者进行扩展，而且整个扩展过程完全满足OCP原则，忍不住想说一句：妙！

第三阶段：注册BeanPostProcessors、监听器等

第三个阶段主要还是准备一些后续需要的特殊bean，比如bean的后置处理器BeanPostProcessor、用户处理国际化的MessageSource、发布事件的广播器ApplicationEventMulticaster以及监听事件的监听器，下面针对这四种特殊的bean进行说明：

1.BeanPostProcessor

BeanPostProcessor就是一个接口，包含两个方法：

　　　/**
     * 在bean实例化之后，初始化之前使用，可以对返回对实例进行修改，比如修改属性值
     * @param bean   要处理的bean实例
     * @param beanName  要处理的bean名称
     * @return     返回处理后的实例，默认返回传进来的实例
     * @throws BeansException
     */
    @Nullable
    default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

　　　/**
     * 在bean初始化之后执行，可以对完成初始化的对象进行进一步的处理，比如生成代理对象，AOP中使用
     * @param bean 要处理的bean
     * @param beanName 要处理的bean名称
     * @return
     * @throws BeansException 返回处理后的实例，默认返回传进来的实例
     */
    @Nullable
    default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

如注释所述，该接口提供了两个默认实现的方法，用于在初始化前后，对已经完成实例化的对象进行处理，虽然是接口，但是因为有了默认实现，开发时无需实现，但是可以通过自定义的后置处理器对bean进行特殊的处理，在AOP中，代理对象的生成就是利用了这里的postProcessAfterInitialization方法。

 可以看到在spring中，已经又了很多该接口的实现类！

2.MessageSource

用于处理国际化的接口，源码中是这样描述的：

/**
 * Strategy interface for resolving messages, with support for the parameterization
 * and internationalization of such messages.
 *
 * <p>Spring provides two out-of-the-box implementations for production:
 * <ul>
 * <li>{@link org.springframework.context.support.ResourceBundleMessageSource}: built
 * on top of the standard {@link java.util.ResourceBundle}, sharing its limitations.
 * <li>{@link org.springframework.context.support.ReloadableResourceBundleMessageSource}:
 * highly configurable, in particular with respect to reloading message definitions.
 * </ul>
/

1、解析消息的策略接口，能够支持消息的参数化和国际化。

2、在Spring中提供了两个开箱即用的实现类：

一个构建在Java标准ResourceBundle之上的类ResourceBundleMessageSource

一个高度可配置的ReloadableResourceBundleMessageSource，值得一提的就是它能够重载消息定义

一般在支持国际化的项目中需要用到，知道有这么个接口即可！

3.ApplicationEventMulticaster

用户发布事件的接口，它的继承关系图如下：

 有两个存在继承关系的实现类，这个在之前spring中的设计模式一文中有分析其源码，使用的是观察者模式，这里不再赘述。

4.ApplicationListener

有事件发布，就有事件监听，这个接口跟上面的广播器构成了观察者模式，用来处理spring中各种事件， 在设计模式中也讲过，这里不再赘述！

第四阶段：创建bean（实例化-初始化-放入容器）

下面来到第四个阶段，也是最重要、最复杂的一个阶段，前三个阶段都是在为这个阶段做准备的，在这个阶段，需要有一个意识：就是spring创建一个完整的对象需要经过三个大的步骤：

实例化-->属性填充-->初始化，而在初始化前后又可能会执行一些后置处理器

实例化阶段：只是在内存中开辟了一块空间，底层是通过bean定义信息推断出无参构造函数，然后选择合适的策略进行实例化，最后返回一个被Wrapper包装的实例，核心代码如下，一个位于BeanUtils类中的静态方法：

/**
     * Convenience method to instantiate a class using the given constructor.
     * <p>Note that this method tries to set the constructor accessible if given a
     * non-accessible (that is, non-public) constructor, and supports Kotlin classes
     * with optional parameters and default values.
     * 使用给定的构造器调用实例化方法，需要注意的是，如果传递的是一个无访问全县的构造器，比如非public的，这个方法首先会尝试开启访问权限
     *，而且通过可选参数支持Kotlin类和默认值
     * @param ctor the constructor to instantiate  实例化构造器
     * @param args the constructor arguments to apply (use {@code null} for an unspecified 构造器参数
     * parameter, Kotlin optional parameters and Java primitive types are supported)
     * @return the new instance
     * @throws BeanInstantiationException if the bean cannot be instantiated
     * @see Constructor#newInstance
     */
    public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
        Assert.notNull(ctor, "Constructor must not be null");
        try {
            //尝试将构造函数设置为可访问的
            ReflectionUtils.makeAccessible(ctor);
            if (KotlinDetector.isKotlinReflectPresent() && KotlinDetector.isKotlinType(ctor.getDeclaringClass())) {
                return KotlinDelegate.instantiateClass(ctor, args);
            }
            else {
                //获取构造器中的参数
                Class<?>[] parameterTypes = ctor.getParameterTypes();
                //判断构造器中的参数个数是否比传进来的参数个数少，多则抛异常
                Assert.isTrue(args.length <= parameterTypes.length, "Can't specify more arguments than constructor parameters");
                Object[] argsWithDefaultValues = new Object[args.length];
                //组装构造器的参数
                for (int i = 0 ; i < args.length; i++) {
                    if (args[i] == null) {
                        Class<?> parameterType = parameterTypes[i];
                        argsWithDefaultValues[i] = (parameterType.isPrimitive() ? DEFAULT_TYPE_VALUES.get(parameterType) : null);
                    }
                    else {
                        argsWithDefaultValues[i] = args[i];
                    }
                }
                //通过构造方法创建一个bean实例
                return ctor.newInstance(argsWithDefaultValues);
            }
        }
        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());
        }
    }

属性填充阶段：该阶段是在完成实例化之后，初始化之前执行的，填充属性，就是给属性赋值，比如数据库连接信息中有很多初始化值，就是在这个阶段进行填充

初始化阶段：该阶段是在完成实例化及属性填充之后执行的，而且在执行真正的初始化前后又要执行一些BeanPostProcessor的后置处理器，核心代码如下，调用AbstractAutowireCapableBeanFactory#initializeBean方法：

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
        if (System.getSecurityManager() != null) {
            AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                invokeAwareMethods(beanName, bean);
                return null;
            }, getAccessControlContext());
        }
        else {
            //执行aware:回调实现了Aware接口的方法：设置beanName、classLoader、beanFactory等
            invokeAwareMethods(beanName, bean);
        }

        //初始化之前执行
        Object wrappedBean = bean;
        if (mbd == null || !mbd.isSynthetic()) {
            wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
        }

        try {
            //执行自定义初始化方法
            invokeInitMethods(beanName, wrappedBean, mbd);
        }
        catch (Throwable ex) {
            throw new BeanCreationException(
                    (mbd != null ? mbd.getResourceDescription() : null),
                    beanName, "Invocation of init method failed", ex);
        }
        //初始化之后执行
        if (mbd == null || !mbd.isSynthetic()) {
            wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
        }

        return wrappedBean;
    }

第16行，会执行BeanPostProcessor的postProcessBeforeInitialization方法

第21行，会执行初始化方法，这个方法可以自定义，就是在bean定义是指定的init-method

第30行，会执行BeanPostProcessor的postProcessAfterInitialization方法

下面是完成最终初始化的核心代码，调用AbstractAutowireCapableBeanFactory#invokeInitMethods方法：

/**
     * Give a bean a chance to react now all its properties are set,
     * and a chance to know about its owning bean factory (this object).
     * This means checking whether the bean implements InitializingBean or defines
     * a custom init method, and invoking the necessary callback(s) if it does.
     * 给bean一个反应它所有的属性都完成设置和了解它所属工厂的机会，这意味着不管bean实现了InitializingBean接口还是自定义了一个初始化方法，都会在这个地方被调用
     * @param beanName the bean name in the factory (for debugging purposes) ：bean在工厂中的名称
     * @param bean the new bean instance we may need to initialize：准备去初始化的实例对象
     * @param mbd the merged bean definition that the bean was created with 创建该bean的合并bean定义信息
     * (can also be {@code null}, if given an existing bean instance)
     * @throws Throwable if thrown by init methods or by the invocation process
     * @see #invokeCustomInitMethod
     */
    protected void invokeInitMethods(String beanName, Object bean, @Nullable RootBeanDefinition mbd)
            throws Throwable {

        //判断是否实现了InitializingBean接口，如果实现了就去执行afterPropertiesSet方法
        boolean isInitializingBean = (bean instanceof InitializingBean);
        if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
            if (logger.isTraceEnabled()) {
                logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
            }
            if (System.getSecurityManager() != null) {
                try {
                    AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
                        ((InitializingBean) bean).afterPropertiesSet();
                        return null;
                    }, getAccessControlContext());
                }
                catch (PrivilegedActionException pae) {
                    throw pae.getException();
                }
            }
            else {
                ((InitializingBean) bean).afterPropertiesSet();
            }
        }

        //执行自定义的初始化方法
        if (mbd != null && bean.getClass() != NullBean.class) {
            String initMethodName = mbd.getInitMethodName();
            if (StringUtils.hasLength(initMethodName) &&
                    !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
                    !mbd.isExternallyManagedInitMethod(initMethodName)) {
                invokeCustomInitMethod(beanName, bean, mbd);
            }
        }
    }

如注释所述，初始化其实就是调用用户自定义的init-method方法和afterPropertiesSet方法！

第五阶段：管理生命周期、发布刷新事件 

这是最后一个阶段，应该说是容器启动过程，或容器实例化过程中的最后一个阶段，因为完整的过程中最后应该是要执行bean的销毁。

这个阶段主要就是给上下文设置生命周期处理器，以管理这个上下文中bean的生命周期，如果工厂中有，就直接赋值，工厂中没有，就new一个再赋值，核心代码如下，AbstractApplicationContext#initLifecycleProcessor方法：

/**
     * Initialize the LifecycleProcessor.
     * Uses DefaultLifecycleProcessor if none defined in the context.
     *
     * @see org.springframework.context.support.DefaultLifecycleProcessor
     */
    protected void initLifecycleProcessor() {
        ConfigurableListableBeanFactory beanFactory = getBeanFactory();
        if (beanFactory.containsLocalBean(LIFECYCLE_PROCESSOR_BEAN_NAME)) {
            this.lifecycleProcessor =
                    beanFactory.getBean(LIFECYCLE_PROCESSOR_BEAN_NAME, LifecycleProcessor.class);
            if (logger.isTraceEnabled()) {
                logger.trace("Using LifecycleProcessor [" + this.lifecycleProcessor + "]");
            }
        } else {
            DefaultLifecycleProcessor defaultProcessor = new DefaultLifecycleProcessor();
            defaultProcessor.setBeanFactory(beanFactory);
            this.lifecycleProcessor = defaultProcessor;
            beanFactory.registerSingleton(LIFECYCLE_PROCESSOR_BEAN_NAME, this.lifecycleProcessor);
            if (logger.isTraceEnabled()) {
                logger.trace("No '" + LIFECYCLE_PROCESSOR_BEAN_NAME + "' bean, using " +
                        "[" + this.lifecycleProcessor.getClass().getSimpleName() + "]");
            }
        }
    }

然后将上下文刷新事件通过第三阶段注册的广播器进行广播，在广播方法中，实际调用的是监听器的方法，核心代码如下：

protected void publishEvent(Object event, @Nullable ResolvableType eventType) {
        Assert.notNull(event, "Event must not be null");

        // Decorate event as an ApplicationEvent if necessary
        ApplicationEvent applicationEvent;
        if (event instanceof ApplicationEvent) {
            applicationEvent = (ApplicationEvent) event;
        } else {
            applicationEvent = new PayloadApplicationEvent<>(this, event);
            if (eventType == null) {
                eventType = ((PayloadApplicationEvent<?>) applicationEvent).getResolvableType();
            }
        }

        // Multicast right now if possible - or lazily once the multicaster is initialized
        if (this.earlyApplicationEvents != null) {
            this.earlyApplicationEvents.add(applicationEvent);
        } else {
            getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
        }

        // Publish event via parent context as well...
        if (this.parent != null) {
            if (this.parent instanceof AbstractApplicationContext) {
                ((AbstractApplicationContext) this.parent).publishEvent(event, eventType);
            } else {
                this.parent.publishEvent(event);
            }
        }
    }

第19行，获取广播器并广播事件，广播事件接口会传事件和事件类型：

public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
        //第一步：调用resolveDefaultEventType方法解析事件的类型，会返回类的全限定名
        ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
        Executor executor = getTaskExecutor();
        //根据事件和事件类型获取监听器
        for (ApplicationListener<?> listener : getApplicationListeners(event, type)) {
            if (executor != null) {
                //异步执行监听任务
                executor.execute(() -> invokeListener(listener, event));
            }
            else if (this.applicationStartup != null) {
                StartupStep invocationStep = this.applicationStartup.start("spring.event.invoke-listener");
                invokeListener(listener, event);
                invocationStep.tag("event", event::toString);
                if (eventType != null) {
                    invocationStep.tag("eventType", eventType::toString);
                }
                invocationStep.tag("listener", listener::toString);
                invocationStep.end();
            }
            else {
                //将事件event通知给监听器listener
                invokeListener(listener, event);
            }
        }
    }

如上代码所示，通过invokeListener(listener, event)完成了事件的监听，具体的逻辑就交给具体的监听器处理了。

到此为止，spring的设计思想梳理的也差不多了，知道了这些，就会对spring有一个更加具体的整体把控了，可能有些地方描述的不够清楚，都是凭自己的理解写的，仅供参考，我也会继续向前深入研究，向后回头反思！