Spring IOC
前言
Spring框架为什么如此流行?
原来Spring框架解决了一个很关键的问题，它可以把对象之间的依赖关系转为用配置文件来管理，也就是它的依赖注入机制。IOC容器用来管理这些Bean，管理Bean的关系以及生命周期，然而这与之前将应用程序主动new对象不同，Spring实现使用IOC容器创建对象，对象的获取方式反转了，所以IOC容器也称为控制反转。面对繁琐的依赖关系，我们不用一个一个去new对象，直接使用IOC创建好的对象，这也正是IOC的方便之处。
Spring 核心组件：Bean Context，Core
Bean
Bean组件在org.springframework.beans包下，这个包下所有的类解决了Bean的定义，创建以及解析。
1.Bean的定义：主要有BeanDefinition描述，也可以说Spring中的Bean就是BeanDefinition的实例。Spring成功解析一个<bean/>节点后,在Spring的内部它就被转化为BeanDefinition对象。
2.Bean的创建：.Spring Bean的创建是典型的工厂设计模式，*接口是BeanFactory
3.Bean的解析：Bean的解析主要是对配置文件的解析
Context
context组件在org.framework.context包下,主要就是Bean关系的集合。给Spring提供了一个运行时环境用于存储对象的状态。ApplicationContext是*的父类
ApplicationContext继承了BeanFactory说明了Spring容器运行的主要对象是Bean
ApplicationContext实现了ResourceLoader接口说明ApplicationContext可以访问到外部资源。
Core
core组件就是发现，建立和维护每个Bean之间关系所需要的一系列工具。core组件其中一个重要的组成部分就是定义了资源的访问方式。
IOC的工作原理
下面我们看看IOC是怎样工作的呢？
先来一个小demo
MessageService.java
public interface MessageService {
String getMessage();
}
MessageServiceImpl.java
public class MessageServiceImpl implements MessageService {
public String getMessage() {
return "hello world";
}
}
application.xml
<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://www.springframework.org/schema/beans"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd" default-autowire="byName">
<bean id="messageService" class="com.kristin.spring.ioc.MessageServiceImpl"/>
</beans>
TestMessage.java
public class TestMessage {
public static void main(String[] args) {
// 用我们的配置文件来启动一个 ApplicationContext
ApplicationContext context = new ClassPathXmlApplicationContext("classpath:application.xml");
System.out.println("context 启动成功");
// 从 context 中取出我们的 Bean，而不是用 new MessageServiceImpl() 这种方式
MessageService messageService = context.getBean(MessageService.class);
// 这句将输出: hello world
System.out.println(messageService.getMessage());
}
}
运行结果:
IOC运行分析
从上面代码可以发现，IOC的入口就是ClassPathXmlApplicationContext的构造方法,下面我们看看源码是怎样写的
ClassPathXmlApplicationContext.java
public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
this(new String[] {configLocation}, true, null);
}
public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
throws BeansException {
super(parent);
setConfigLocations(configLocations); //根据提供的路径，处理成配置文件数组(以分号、逗号、空格、tab、换行符分割)
if (refresh) {
refresh(); //这里是核心代码
}
}
下面我们看一下refresh()
ClassPathXmlApplicationContext.java
@Override
public void refresh() throws BeansException, IllegalStateException {
//这里加锁,防止多个线程同时refresh()时出现问题
synchronized (this.startupShutdownMonitor) {
// 为刷新准备新的context,记录下容器的启动时间、标记“已启动”状态、处理配置文件中的占位符
prepareRefresh();
// 刷新所有BeanFactory的子容器
// 这步比较关键，这步完成后，配置文件就会解析成一个个 Bean 定义，注册到 BeanFactory 中，
// 当然，这里说的 Bean 还没有初始化，只是配置信息都提取出来了，
// 注册也只是将这些信息都保存到了注册中心(说到底核心是一个 beanName-> beanDefinition 的 map)
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// 准备BeanFactory,设置 BeanFactory 的类加载器，添加几个 BeanPostProcessor，手动注册几个特殊的 bean
prepareBeanFactory(beanFactory);
try {
// 这里是提供给子类的扩展点，到这里的时候，所有的 Bean 都加载、注册完成了，但是都还没有初始化
// 具体的子类可以在这步的时候添加一些特殊的 BeanFactoryPostProcessor 的实现类或做点什么事
postProcessBeanFactory(beanFactory);
// 调用 BeanFactoryPostProcessor 各个实现类的 postProcessBeanFactory(factory) 方法
invokeBeanFactoryPostProcessors(beanFactory);
// 注册 BeanPostProcessor 的实现类，注意看和 BeanFactoryPostProcessor 的区别
// 此接口两个方法: postProcessBeforeInitialization 和 postProcessAfterInitialization
// 两个方法分别在 Bean 初始化之前和初始化之后得到执行。注意，到这里 Bean 还没初始化
registerBeanPostProcessors(beanFactory);
// 初始化message source
initMessageSource();
// 初始化 event multicaster
initApplicationEventMulticaster();
// 刷新由子类实现的方法
onRefresh();
// 注册事件监听器，监听器需要实现 ApplicationListener 接口。
registerListeners();
// 初始化所有的 singleton beans
finishBeanFactoryInitialization(beanFactory);
// 最后，广播事件，ApplicationContext 初始化完成
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();
}
}
}
refresh函数主要包含了以下几个步骤:
1.构建BeanFactory,以便于产生所需的"演员"
2.注册可能感兴趣的事件
3.创建Bean实例对象
4.触发被监听的事件
创建BeanFactory的时序图:
继续看一看refresh()函数中调用的函数吧
AbstractApplicationContext.java
protected void prepareRefresh() {
// 记录启动时间,将 active 属性设置为 true，closed 属性设置为 false，它们都是 AtomicBoolean 类型
this.startupDate = System.currentTimeMillis();
this.closed.set(false);
this.active.set(true);
if (logger.isInfoEnabled()) {
logger.info("Refreshing " + this);
}
// Initialize any placeholder property sources in the context environment
initPropertySources();
// 校验 xml 配置文件
getEnvironment().validateRequiredProperties();
// Allow for the collection of early ApplicationEvents,
// to be published once the multicaster is available...
this.earlyApplicationEvents = new LinkedHashSet<ApplicationEvent>();
}
AbstractApplicationContext.java
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
// 关闭旧的 BeanFactory (如果有)，创建新的 BeanFactory，加载 Bean 定义、注册 Bean 等等
refreshBeanFactory();
// 返回刚刚创建的 BeanFactory
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (logger.isDebugEnabled()) {
logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
}
return beanFactory;
}
AbstractRefreshableApplicationContext.java
@Override
protected final void refreshBeanFactory() throws BeansException {
// 如果 ApplicationContext 中已经加载过 BeanFactory 了，销毁所有 Bean，关闭 BeanFactory
// 注意，应用中BeanFactory本来就是可以多个的，这里可不是说应用全局是否有 BeanFactory，而是当前ApplicationContext是否有BeanFactory
if (hasBeanFactory()) {
destroyBeans();
closeBeanFactory();
}
try {
// 初始化一个 DefaultListableBeanFactory
DefaultListableBeanFactory beanFactory = createBeanFactory();
// 用于 BeanFactory 的序列化
beanFactory.setSerializationId(getId());
// 设置 BeanFactory 的两个配置属性：是否允许 Bean 覆盖、是否允许循环引用
customizeBeanFactory(beanFactory);
// 加载 Bean 到 BeanFactory 中,这个方法很重要
loadBeanDefinitions(beanFactory);
synchronized (this.beanFactoryMonitor) {
this.beanFactory = beanFactory;
}
}
catch (IOException ex) {
throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
}
}
此时已经获得了BeanFactory
后面会陆续更新,暂时先整理到这里...
对了,以上文章整理自
https://javadoop.com/post/spring-ioc
《深入分析Java Web技术内幕》
感谢两位大神的文章及书籍