Spring核心流程

简述

Spring认证框架是一个开放源代码的J2EE应用程序框架，由Rod Johnson发起，是针对bean的生命周期进行管理的轻量级容器（lightweight container）。 Spring是Java EE编程领域的一个轻量级开源框架，该框架由一个叫Rod Johnson的程序员在 2002 年最早提出并随后创建，是为了解决企业级编程开发中的复杂性，实现敏捷开发的应用型框架 。

核心模块

1.Spring core

    Spring框架核心：包涵IoC 容器、事件、资源、i18n、验证、数据绑定、类型转换、SpEL、AOP

2.SpringData

    事务、DAO 支持、JDBC、R2DBC、O/R 映射、XML 。

3.SpringWebServlet

    Spring MVC、WebSocket、SockJS、STOMP 消息传递。

4.SpringWebReactive

    Spring WebFlux、WebClient、WebSocket、RSocket。

5.SpringIntegration

    远程、JMS、JCA、JMX、电子邮件、任务、调度、缓存。

6.SpringTest

    模拟对象、TestContext 框架、Spring MVC 测试、WebTestClient。

Spring框架Bean生命周期流程图

核心基础类

1. BeanFactory

BeanFactory是IOC最基本的容器,根接口,负责生产和管理bean，它为其他具体的IOC容器提供了最基本的规范

// org.springframework.beans.factory.BeanFactory 
public interface BeanFactory {

	String FACTORY_BEAN_PREFIX = "&";

	Object getBean(String name) throws BeansException;

	<T> T getBean(String name, Class<T> requiredType) throws BeansException;
	
	Object getBean(String name, Object... args) throws BeansException;

	<T> T getBean(Class<T> requiredType) throws BeansException;

	<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;

	<T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);

	<T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);

	boolean containsBean(String name);

	boolean isSingleton(String name) throws NoSuchBeanDefinitionException;

	boolean isPrototype(String name) throws NoSuchBeanDefinitionException;

	boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;

	boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;

	@Nullable
	Class<?> getType(String name) throws NoSuchBeanDefinitionException;

	String[] getAliases(String name);
}

2. ApplicationContext

ApplicationContext 是spring继BeanFactory之外的另一个核心接口或容器，允许容器通过应用程序上下文环境创建、获取、管理bean

// org.springframework.context.ApplicationContext

// 访问应用程序组件的Bean工厂方法。从org.springframework.beans.factory.ListableBeanFactory继承。

// 以通用方式加载文件资源的能力。继承自org.springframe .core.io。ResourceLoader接口。---beanXML

// 向注册侦听器发布事件的能力。继承自ApplicationEventPublisher接口。

// •解析消息的能力，支持国际化。继承自MessageSource接口。

public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory, MessageSource, ApplicationEventPublisher, ResourcePatternResolver {
    String getId();

    String getApplicationName();

    String getDisplayName();

    long getStartupDate();

    ApplicationContext getParent();

    AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws IllegalStateException;
}

3. FactoryBean

FactoryBean 是一个特殊的Bean,在spring容器中会产生两个bean 一个是实现FactoryBean的实例 bean Name会加上& 一个是通过 getObject()方法返回的一个bean

// org.springframework.beans.factory.FactoryBean

public interface FactoryBean<T> {

	@Nullable  // 获取一个bean
	T getObject() throws Exception;

	@Nullable // bean 类型
	Class<?> getObjectType();

    // 是否单例
	default boolean isSingleton() {
		return true;
	}
}

4. BeanPostProcessor

BeanPostProcessor bean后置处理器根接口

// org.springframework.beans.factory.config.BeanPostProcessor
public interface BeanPostProcessor {

        // 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;
	}

}

5. BeanFactoryPostProcessor

BeanFactoryPostProcessor接口与BeanPostProcessor接口类似,可以对bean的定义(配置元数据)进行处理 在容器实例化任何其他的bean之前读取配置元数据,并有可能修改它；如果业务需要，可以配置多个BeanFactoryPostProcessor的实现类，通过"order"控制执行次序(要实现Ordered接口)。

// org.springframework.beans.factory.config.BeanFactoryPostProcessor
public interface BeanFactoryPostProcessor {
    void postProcessBeanFactory(ConfigurableListableBeanFactory var1) throws BeansException;
}

6. Aware

Aware 已感知的,意识到的,该接口在Spring中的定义是可以感知容器各个阶段的变化

// org.springframework.beans.factory.Aware
// BeanNameAware 拿到容器中bean的名称
// BeanFactoryAware 获取当前 BeanFactory ，这样可以调用容器的服务
// ApplicationContextAware 获取当前 ApplicationContext，这样可以调用容器的服务 一般都是通过这种方式去拿 spring 上下文
// MessageSourceAware 获取MessageSource相关文本信息
// ApplicationEventPublisherAware  感知发布事件
// ResourceLoaderAware 获取资源加载器 可以去加载外部资源

public interface Aware {

}

7. BeanDefinition

bean定义信息/bean 建模对象, 存储被Spring管理的bean的定义信息 懒加载、是否单例、Class信息等…

// org.springframework.beans.factory.config.BeanDefinition
// 部分源码
public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {

	// Read-only attributes

	boolean isSingleton();

	boolean isPrototype();

	boolean isAbstract();

	int getRole();

	String getDescription();

	String getResourceDescription();

	BeanDefinition getOriginatingBeanDefinition();

}

SpringContext核心流程代码

AbstractApplicationContext的refresh()方法是spring的核心，调用了一系列的方法，从而完成整个容器的初始化

    // org.springframework.context.support.AbstractApplicationContext
    @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.
			// 初始化 bean工厂 解析配置的过程 生成BeanDefinition（bean 定义信息） 和一个beanFactory 基础信息都存储在beanFactory里面
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// Prepare the bean factory for use in this context.
			// 加载上下文配置 类处理器等 相当于把属性创建好 后置处理器等
			prepareBeanFactory(beanFactory);

			try {
				// Allows post-processing of the bean factory in context subclasses.
				// 模板方法可由子类重写 进行beanFactory的处理
				postProcessBeanFactory(beanFactory);

				//  调用容器中注册的beanFactory后置处理方法
				// Invoke factory processors registered as beans in the context.
				invokeBeanFactoryPostProcessors(beanFactory);

				// 注册bean的前置后置处理器。（tips:触发时机是bean实例化后，在bean初始化的前后。）
				// Register bean processors that intercept bean creation.
				registerBeanPostProcessors(beanFactory);

				// 初始化国际化用到的资源
				// Initialize message source for this context.
				initMessageSource();

				// 初始化事件广播器
				// Initialize event multicaster for this context.
				initApplicationEventMulticaster();

				// 初始化其他特殊的bean，由特定的子类去实现
				// Initialize other special beans in specific context subclasses.
				onRefresh();

				// 注册事件监听器，发布需要提前广播的事件
				// Check for listener beans and register them.
				registerListeners();

				// 实例化剩下的非延迟加载的单例
				// Instantiate all remaining (non-lazy-init) singletons.
				finishBeanFactoryInitialization(beanFactory);

				// 完成容器启动，发布通知事件
				// Last step: publish corresponding event.
				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...
				resetCommonCaches();
			}
		}
	}

书山有路勤为径 ,学海无涯苦作舟

关注公众号回复：学习，领取技术书籍和面试资料