IoC 容器
先学会使用再研究源码,切勿本末倒置,Spring 的控制反转无非是 BeanFactory 和 Context Application
- mini-spring/changelog.md at main · DerekYRC/mini-spring (opens new window)
- 第01章:开篇介绍,我要带你撸 Spring 啦! | 小傅哥 bugstack 虫洞栈 (opens new window)
# 简单的 Bean 管理
IoC 容器:由 BeanDefinitionMap、BeanFactoryPostProcessor、BeanPostProcessor、BeanMap 等等容器共同组成、共同完成、提供依赖注入和控制反转功能的一组集合
# 反射和动态代理
反射和动态代理是实现 IoC 控制反转和 Bean 管理的核心技术和思路
反射:从字节码获取类信息,从而反向构造对象的过程
- 通过类名(字符串)去拿取字节码信息,再通过解析字节码中包含的类信息(如类名、方法、字段等元数据)来实现对类的动态操作,如创建、方法调用等
- 这是一个反向构造的过程,在 Spring 中,多用注解的形式,对所有的对象进行一个反向构造和统一管理,即 IoC 的实现
一个正向构造的例子
Apple apple = new Apple(); //直接初始化,「正射」
apple.setPrice(4);
2
两个反射创建对象的例子
// 通过 Class 对象的 newInstance 方法
Class clz = Apple.class;
Apple apple = (Apple)clz.newInstance();
2
3
// 通过 Constructor 对象 newInstance 方法
Class clz = Apple.class;
Constructor constructor = clz.getConstructor();
Apple apple = (Apple)constructor.newInstance();
2
3
4
通过 Constructor 对象创建类对象可以选择特定构造方法,而通过 Class 对象则只能使用默认的无参数构造方法
下面的代码调用了一个有参数的构造方法进行了类对象的初始化
Class clz = Apple.class;
Constructor constructor = clz.getConstructor(String.class, int.class);
Apple apple = (Apple)constructor.newInstance("红富士", 15);
2
3
这两种方法其本质上都是 Method.invoke 的交互,但是其具体实现方式在内部有两种
- C++ native 原生实现:Native 版本一开始启动快,但是随着运行时间边长,速度变慢
- Java 实现:Java 版本一开始加载慢,但是随着运行时间边长,速度变快
- JDK 源码使用了代理的设计模式(一个接口,两种代理实现)去进行优化:第一次类加载使用
NativeMethodAccessorImpl,当反射调用超 15 次后,使用MethodAccessorGenerator生成的MethodAccessorImpl对象实现反射
动态代理
- 动态:类的创建是动态进行的,在需要时才进行创建,而不是一开始全部 new 好
- 代理:有代理,就有原主,这里的代理和代理模式中的代理有相似之处,例如一个父类接口,有两个子类实现,这两个子类就是父类的代理(在实例化时,创建的是父类,实例化的是子类代理)
动态代理的实现和反射机制、字节码增加技术息息相关,常常被应用于 IoC / AOP 场景
# Java record
com.northboat.winterframework.beans.factory.config.BeanDefinition
public record BeanDefinition(Object bean) {}
record 是 Java 14 引入的语法糖,用于简化数据类,包括自动的构造方法、字段访问、equals()、hashCode()、toString,本质是隐式的 final 类
以上 record 等价于
public final class BeanDefinition {
private final Object bean;
public BeanDefinition(Object bean) { this.bean = bean; }
public Object getBean() { return bean; }
// ... equals(), toString()
}
2
3
4
5
6
# BeanFactory 单例
BeanFactory:维护一个Map<String, BeanDefinition> beanDefinitionMap,通过类名返回对应的BeanDefinition.bean()
通过 Class 类进行对象的自动创建,复杂的继承设计(司马了),BeanDefinition 中的 Bean 改为 Class 类型,在 Bean Factory 中维护两个核心的 Map
Map<String, Object> singletonObjects存放已实例化的单例对象Map<String, BeanDefinition> beanDefinitionMap存放 Bean 的类 Class 信息,用于 Bean 对象的自动实例化
核心思路是:在 getBean 时,先从单例表singletonObjects中 get,若没有,则根据 Bean 信息表beanDefinitionMap中的类信息进行 createBean 并放入单例表
这里存在一个单例的并发管理问题,即用于存放单例对象或者 Bean 信息的哈希表是否要采用 ConcurrentHashMap,Spring 源码中
DefaultSingletonBeanRegistry的singletonObjects是ConcurrentHashMapDefaultListableBeanFactory的beanDefinitionMap是普通HashMap,但通过beanDefinitionLock锁保证线程安全- 获取 Bean 时通过
getSingleton()方法结合双重检查锁 + 同步块确保单例
这是由于
beanDefinitionMap在起 Bean 时,scan Class 类就完成了写,在之后均为读操作,不涉及频繁的读写交替- 而单例表
singletonObjects除了频繁的读任务,当找不到对象时,还要被beanDefinitionMap写,所以采用安全但效率低的 ConcurrentHashMap
另外还有一个问题,上面也说了,BeanDefinition 存放Class bean,在通过 BeanDefinition 创建对象时,采用 newInstance 的方式,这个方法在 Java 9 就已废弃,并且无法接受含入参的对象创建
Object bean = null;
try {
bean = beanDefinition.getBeanClass().newInstance();
} catch (InstantiationException | IllegalAccessException e) {
throw new BeansException("Instantiation of bean failed", e);
}
2
3
4
5
6
# 含参构造和属性注入
# 通过反射实例化实现含参构造
接入实例化策略 InstantiationStrategy
实例化策略接口
public interface InstantiationStrategy {
// 初始化 Bean
Object instantiate(BeanDefinition beanDefinition, String beanName, Constructor<?> ctor, Object[] args) throws BeansException;
}
2
3
4
采用 JDK 和 CGLib 两种方式实现 instantiate 接口
SimpleInstantiationStrategy:通过构造函数 ctor 和入参列表 args 进行 newInstanceCglibSubclassingInstantiationStrategy:同理,enhancer 通过setSuperclass → setCallback → create过程创建对象
doGetBean:改造原有的 createBean 过程:getBean(类名, 参数) → 无 Bean → createBean(类名, 参数, 策略),增加一个根据构造入参获取 Bean 的方法
com.northboat.winterframework.beans.factory.BeanFactory
public interface BeanFactory {
public Object getBean(String beanName) throws BeansException;
// 传递构造函数入参获取实例对象
public Object getBean(String beanName, Object... args) throws BeansException;
}
2
3
4
5
6
在下层 AbstractBeanFactory 中对 getBean 进行改写
com.northboat.winterframework.beans.factory.support.BeanFactory
public abstract class AbstractBeanFactory extends DefaultSingletonBeanRegistry implements BeanFactory {
// 实现 BeanFactory 的 getBean 接口
@Override
public Object getBean(String beanName){
return doGetBean(beanName);
}
@Override
public Object getBean(String beanName, Object... args) throws BeansException {
return doGetBean(beanName, args);
}
}
2
3
4
5
6
7
8
9
10
11
12
将统一的获取 Bean 逻辑写在 doGetBean 中
protected <T> T doGetBean(String beanName, Object... args) throws BeansException {
Object bean = getSingleton(beanName);
if(bean != null){
return (T) bean;
}
// 当 Bean Object 并未初始化,使用 Class 对象进行实例化
BeanDefinition beanDefinition = getBeanDefinition(beanName);
return (T) createBean(beanName, beanDefinition, args);
}
// 获取 Bean Class 实例,用于创建 Bean Object
protected abstract BeanDefinition getBeanDefinition(String beanName) throws BeansException;
// 根据入参 args 创建 Object 并存入单例的 Map 中
protected abstract Object createBean(String beanName, BeanDefinition beanDefinition, Object... args) throws BeansException;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
createBean 逻辑在更下层的 AbstractAutowireCapableBeanFactory 的createBeanInstance()中实现,以此实现自动装配
com.northboat.winterframework.beans.factory.support.AbstractAutowireCapableBeanFactory
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory{
// 初始化实例化策略
private InstantiationStrategy instantiationStrategy = new CglibSubclassingInstantiationStrategy();
@Override
protected Object createBean(String beanName, BeanDefinition beanDefinition, Object[] args) throws BeansException {
Object bean = null;
try {
bean = createBeanInstance(beanDefinition, beanName, args);
} catch (Exception e) {
throw new BeansException("Instantiation of bean failed", e);
}
addSingleton(beanName, bean);
return bean;
}
protected Object createBeanInstance(BeanDefinition beanDefinition, String beanName, Object[] args) {
Constructor<?> constructor = null;
Class<?> beanClass = beanDefinition.getBeanClass();
Constructor<?>[] declaredConstructors = beanClass.getDeclaredConstructors();
for(Constructor<?> ctor: declaredConstructors){
if(args != null && ctor.getParameterTypes().length == args.length){
constructor = ctor;
break;
}
}
return getInstantiationStrategy().instantiate(beanDefinition, beanName, constructor, args);
}
public InstantiationStrategy getInstantiationStrategy() {
return instantiationStrategy;
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
这里直接用 Class.getParameterTypes 获取所有的构造函数,再和传入的构造函数进行参数长度的比较,若一致,则认定这是需要的构造函数
测试:新建带入参的 UserService
public record UserService(String name) {
public void queryUserInfo(){
System.out.println(name + " is querying user info");
}
}
2
3
4
5
在 BeanFactory 中注册后进行 getBean
@Test
public void testBeanFactory(){
DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
// 通过 class 注册 Bean
BeanDefinition userServiceBean = new BeanDefinition(UserService.class);
beanFactory.registerBeanDefinition("userService", userServiceBean);
// 获取 Bean
// 第一次没有实例化,会调用 createBean
UserService userService = (UserService) beanFactory.getBean("userService", "northboat");
userService.queryUserInfo();
}
2
3
4
5
6
7
8
9
10
11
12
13
14
输出
northboat is querying user info
这里需要略过一个 JDK 的安全策略,在 JDK 9 及以后,引入了更加严格的安全策略,不允许 CGLib 如此简单的创建代理类
需要在编译命令处(run→edit configurations或者运行小箭头处点击三个浮点而后edit)的Build and run后缀添加
--add-opens java.base/java.lang=ALL-UNNAMED
--add-opens java.base/java.lang.reflect=ALL-UNNAMED
--add-opens java.base/java.security=ALL-UNNAMED
2
3
当然用 JDK 8 不会遇到这个问题
# 属性注入和 Bean 依赖
对 BeanDefinition 进行进一步的改造
- 这是创建 Bean 对象的核心,包含对象的 Class 定义
- 在这一阶段将引入对象的属性列表 PropertyValues,以便进行更深层次的初始化
这里暂不考虑 Bean 的循环依赖问题(让我想起 JVM 的类加载,双亲委派模型,“向上委派,向下查找”),只进行简单的对象属性注入和 Bean 对象依赖,即,在创建 Bean 时,同时填充该类的内置属性和内置的 Bean 对象
# PropertyValues
首先我们要让 BeanDefinition “拥有属性”,这一步很重要,通过一个List<PropertyValue>和record PropertyValue(String name, Object value)来实现
public record PropertyValue(String name, Object value){ /* 省略一些 setter/getter */ }
public record PropertyValues(List<PropertyValue> propertyValueList) { /* 省略一些 setter/getter */ }
2
改写 BeanDefinition,自此一个 BeanDefinition 除了包含对应 Bean 的 Class 类,还包含其所有内置属性的信息(Bean 对象将被标注为 BeanReference)
com.northboat.winterframework.beans.factory.config.BeanDefinition
public class BeanDefinition {
private Class<?> beanClass;
private PropertyValues propertyValues;
public BeanDefinition(Class<?> beanClass){
this.beanClass = beanClass;
this.propertyValues = new PropertyValues();
}
public BeanDefinition(Class<?> beanClass, PropertyValues propertyValues){
this.beanClass = beanClass;
// 若传入的 propertyValues 为空,则创建一个空的 propertyValues
this.propertyValues = propertyValues != null ? propertyValues : new PropertyValues();
}
// setter and getter...
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
改写后的 BeanDefinition 将维护
- 当前 Bean 对应的 Class 类,用于 Bean 的创建
- 一个
List<Pair<String, Object>>的数据结构(PropertyValues),是当前 Bean 的属性列表,相当于属性填充的模板
# Bean 依赖关系
即在一个 Bean 中,存在某个内置属性,同样是一个 Bean
在 PropertyValues 中,对于 Bean 对象的表示(即当前 Bean 的内置属性包含另一个 Bean),用 BeanReference 来实现
com.northboat.winterframework.beans.factory.config.BeanReference
public record BeanReference(String beanName) {}
它只需要包含 Bean 引用的名字就行,譬如 UserService 含有 UserDao 这样一个 Bean
public class UserService {
private String uId;
private UserDao userDao;
}
2
3
4
那么在其对应的 BeanDefinition 中的 PropertyValues,就会有一项
// 将 Bean 属性写入 propertyValues
propertyValues.addPropertyValue(new PropertyValue("userDao", new BeanReference("userDao")));
2
而后,显然,填充属性是在 Bean 对象创建之后的一个操作,于是我们改动 createBean 的实现即可(在AbstractAutowireCapableBeanFactory中),在createBeanInstance后对创建的 Bean 对象进行属性填充
com.northboat.winterframework.beans.factory.support.AbstractAutowireCapableBeanFactory
@Override
protected Object createBean(String beanName, BeanDefinition beanDefinition, Object[] args) throws BeansException {
Object bean = null;
try {
bean = createBeanInstance(beanDefinition, beanName, args);
// 填充属性
applyPropertyValues(beanName, bean, beanDefinition);
} catch (Exception e) {
throw new BeansException("Instantiation of bean failed", e);
}
addSingleton(beanName, bean);
return bean;
}
2
3
4
5
6
7
8
9
10
11
12
13
14
通过 hutool 的 BeanUtil 进行属性的填充
BeanUtil.setFieldValue(Object bean, String name, Object value);
以上函数将属性name: value填充至对象bean中
protected void applyPropertyValues(String beanName, Object bean, BeanDefinition beanDefinition) {
try{
PropertyValues propertyValues = beanDefinition.getPropertyValues();
for(PropertyValue propertyValue: propertyValues.getPropertyValues()){
String name = propertyValue.name();
Object value = propertyValue.value();
// 这里只是一个简单的模拟
// 就是说,如果当前的属性是 beanReference 的一个引用,说明这个属性也是一个 Bean
// 那么就直接从 Map 中 getBean 以获取这个 Bean 的实例化对象
if(value instanceof BeanReference beanReference){
// 如果 A 依赖于 B,获取 B 的实例化
value = getBean(beanReference.beanName());
}
BeanUtil.setFieldValue(bean, name, value);
}
}catch (Exception e){
throw new BeansException("Error setting property values: " + beanName);
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
测试代码
@Test
public void testBeanFactory(){
DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
// 注册 UserDao
beanFactory.registerBeanDefinition("userDao", new BeanDefinition(UserDao.class));
// 设置内置属性 uId 和 userDao
PropertyValues propertyValues = new PropertyValues();
propertyValues.addPropertyValue(new PropertyValue("uId", "10001"));
propertyValues.addPropertyValue(new PropertyValue("userDao", new BeanReference("userDao")));
// 注册 UserService 并将内置属性注入
BeanDefinition userServiceBean = new BeanDefinition(UserService.class, propertyValues);
beanFactory.registerBeanDefinition("userService", userServiceBean);
// 获取 UserService Bean
UserService userService = (UserService) beanFactory.getBean("userService");
userService.queryUserInfo();
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
在构造 UserService 这个 Bean 时,根据他的 BeanDefinition,就会通过他内置的 PropertyValues 进行属性填充,例如
- 把
10001填充进 UserService 的uId字段 - 把
getBean("userDao")填充进userDao字段(这里是一个对 Bean 的特殊处理,具体可以看applyPropertyValues()的代码)
输出
Querying user info of 10001: northboat
说明 UserDao 被正常注入(queryUserInfo()正常调用返回northboat),uId 也被正常注入(查询的是用户10001)
打断点发现 UserDao 明显是 CGLib 生成的对象,说明在注入 UserDao 时进行了getBean("userDao")并触发了 UserDao 的 createBean
这个 Bean 套 Bean 的自动注入有点优雅了,getBean的自动套娃实现
# 资源加载器和 XML 解析器
设计目标:将 Bean 的注册通过 xml 配置文件自动化实现,把以下的三个步骤,通过 Spring 配置文件的方式将 Bean 对象实例化
// 注册 UserDao
beanFactory.registerBeanDefinition("userDao", new BeanDefinition(UserDao.class));
// 设置内置属性 uId 和 userDao
PropertyValues propertyValues = new PropertyValues();
propertyValues.addPropertyValue(new PropertyValue("uId", "10001"));
propertyValues.addPropertyValue(new PropertyValue("userDao", new BeanReference("userDao")));
// 注册 UserService 并将内置属性注入
BeanDefinition userServiceBean = new BeanDefinition(UserService.class, propertyValues);
beanFactory.registerBeanDefinition("userService", userServiceBean);
2
3
4
5
6
7
8
9
10
11
问题的重点是:添加能解决 Spring 配置的读取、解析、注册 Bean 的操作
# 资源加载模块
上图描述了一个资源加载器的架构模块和功能
那么在实际操作中,如何将这个“资源加载系统”接入现有的 Bean Factory?
答案是:通过BeanDefinitionRegistry接口进行接入
- 在之前的代码中,
BeanDefinitionRegistry早已提供了registerBeanDefinition方法,并在下层中实现(将 BeanDefinition 存入相应的 Map 中)。那么理论上,我只需要在资源加载器中传入这个 Map,就可以将解析出来的 Bean 信息进行 put - 或者更方便的方法是,直接传入一个
BeanDefinitionRegistry,在解析时直接调用registerBeanDefinition将 Bean 注册到这个BeanDefinitionRegistry的 Map 中
这样处理不会影响下层其他功能的实现,即仅修改注册和与获取无关,无需修改getBean/createBean 的任何代码
现在我们尝试做一个 Bean 的注入器 Reader,将BeanDefinitionRegistry和ResourceLoader注入,并实现 Bean 的加载
com.northboat.winterframework.beans.factory.support.AbstractBeanDefinitionReader
public abstract class AbstractBeanDefinitionReader implements BeanDefinitionReader {
public AbstractBeanDefinitionReader(BeanDefinitionRegistry registry, ResourceLoader resourceLoader){
this.registry = registry;
this.resourceLoader = resourceLoader;
}
// getRegistry() / getResourceLoader() 略
}
2
3
4
5
6
7
8
这一层仅进行注册器和加载器的构造,不进行具体的实现,我发现一个规律,Java 的一个接口设计
- 最上层是一个或多个 interface,将所有需要的方法罗列
- 中间是多层 abstract class,会将上层接口的方法逻辑实现,像是一层伪码,会声明真正干事的代码方法,但逻辑仍留给下层实现
- 下层是一个或多个 class,这一层会把所有的方法逻辑都实现
在下层进行doLoadBeanDefinitions逻辑的实现
com.northboat.winterframework.beans.factory.xml.XmlBeanDefinitionReader
public class XmlBeanDefinitionReader extends AbstractBeanDefinitionReader {
public XmlBeanDefinitionReader(BeanDefinitionRegistry registry, ResourceLoader resourceLoader) {
super(registry, resourceLoader);
}
// loadBeanDefinitions(Resource resource)
// loadBeanDefinitions(Resource... resources)
// loadBeanDefinitions(String location)
// doLoadBeanDefinitions(InputStream inputStream)
}
2
3
4
5
6
7
8
9
10
在具体的使用中,我们先创建一个DefaultListableBeanFactory(这个类同时继承了 BeanFactory 和 BeanDefinitionRegistry)和一个 ResourceLoader
// 1.初始化 BeanFactory
DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
DefaultResourceLoader resourceLoader = new DefaultResourceLoader();
2
3
4
而后将这俩一起丢到加载器中进行 Bean 加载
// 2. 读取配置文件&注册Bean
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory, resourceLoader);
reader.loadBeanDefinitions("classpath:winter.xml");
2
3
实际上就是:XmlBeanDefinitionReader通过ResourceLoader解析配置为一个个 BeanDefinition,然后将其 put 到BeanDefinitionRegistry对应的Map<String, BeanDefinition>里
# 泛型 getBean
晕了,别急,到这里已经可以实现类的自动加载,但现在引入一个新的需求,我想要的 getBean 的时候,自动返回对应的对象,而不是 Object 对象,即实现一个泛型<T> T的 getBean 方法,这里需要修改最上层位于 BeanFactory 接口的 getBean,而后在 AbstractBeanFactory 中进行具体的实现
interface BeanFactory
+ <T> T getBean(String name, Class<T> requiredType)
↓
abstract class AbstractBeanFactory
+ <T> T getBean(String name, Class<T> requiredType)
2
3
4
5
其实实现很简单,就是将传入的Class<T> requiredType对原先返回 Object 的 getBean 进行一个强转
@Override
public <T> T getBean(String beanName, Class<T> type) throws BeansException {
return (T) getBean(beanName);
}
2
3
4
这个泛型传递形式第一次见,传入一个Class<T> type,编译器会自动解析 T 为 type 的对象类型
再然后,为了在后续扩展功能,仿照 Spring 的设计结构,引入更多的接口和继承,这里和 Bean 的配置加载以及泛型的返回都没啥关系,只是为了后续的扩展
好,以上就是本次迭代的需求,在这一步我已经不能自己管理包结构了,有点复杂了,我需要照着教程来才能看懂
现在的系统已经相当“冗余”了,至此的类继承关系如下图所示
# 应用上下文生命周期管理
Bean 的生命周期管理
# ApplicationContext
应用上下文是比 BeanFactory 更高级的 IoC 容器
- BeanFactory 是 spring 的基础设施,面向 spring 本身
- 而 ApplicationContext 面向 spring 的使用者,应用场合使用 ApplicationContext
“上下文”即指 Bean 的生命周期,即 bean 的加载,到注册、修改、实例化和扩展,当前 Bean 的生命周期如下图所示
在整个之前的代码中,实际上已经完成了 Bean 的加载、注册和实例化
- 这一节首先是在实现 Bean 实例化的前置和后置处理,给用户以扩展/修改 Bean 的接口
- 而后将上述的五个步骤封装为一个完整的上下文 Context 供用户调用
在 Spring 中,提供了BeanFactoryPostProcessor 和 BeanPostProcessor(几乎是在使用 Spring 框架额外新增开发自己组建需求的两个必备接口)
BeanFactoryPostProcessor:Bean 前置处理,允许 Bean 对象注册后、实例化前,对 Bean 的定义信息(BeanDefinition)进行修改BeanPostProcessor:Bean 后置处理,在 Bean 对象实例化之后修改 Bean 对象,也可以替换 Bean 对象,这一操作与后面要实现的 AOP 有着密切的关系
Spring 应用上下文和对 Bean 对象扩展机制的类关系
这个继承我已经有点懵逼了说实话,照猫画虎了有点,我发现前面有写错的继承关系,居然没影响下层实现,绷不住了,这就是我们 Java
# BeanFactoryPostProcessors
代码的核心思路是:先提供两个函数接口,在 Context 中维护一个 Factory,通过 refresh 函数将 invokeBeanFactoryPostProcessors 和 registerBeanPostProcessors 过程注入到 Factory 中
- 前者会获取所有的 BeanFactoryPostProcessor,并调用其 postProcessBeanFactory 方法修改 Factory 中对应 BeanDefinition 的 PropertyValues(通过 addPropertyValue 方法)
- 后者会获取所有的 BeanPostProcessor,并将其注册进 Factory 中的
List<BeanPostProcessor> beanPostProcessors(通过 List 的 add 操作)
com.northboat.winterframework.context.support.AbstractApplicationContext
public abstract class AbstractApplicationContext extends DefaultResourceLoader implements ConfigurableApplicationContext {
@Override
public void refresh() throws BeansException {
// 重新创建 BeanFactory,并加载 BeanDefinition
refreshBeanFactory();
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
// 注入 BeanFactoryPostProcessors
invokeBeanFactoryPostProcessors(beanFactory);
// 注入 BeanPostProcessors
registerBeanPostProcessors(beanFactory);
// 初始化单例对象
beanFactory.preInstantiateSingletons();
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
可以发现,在这里 BeanFactoryPostProcessors 就已经起作用了,在实际上修改了Map<String, BeanDefinition> beanDefinitionMap中 BeanDefinition 的内容
# BeanPostProcessor
BeanPostProcessor 在这一步,只是注册到 List 中,真正起作用是在 creatBean 时
com.northboat.winterframework.beans.factory.support.AbstractAutowireCapableBeanFactory
// 创建实例
bean = createBeanInstance(beanDefinition, beanName, args);
// 填充属性
applyPropertyValues(beanName, bean, beanDefinition);
// 执行初始化方法和 BeanPostProcessor 的前置和后置处理方法
bean = initializeBean(beanName, bean, beanDefinition);
2
3
4
5
6
通过 initializeBean 方法执行对象创建的前置和后置操作
private Object initializeBean(String beanName, Object bean, BeanDefinition beanDefinition){
// BeanPostProcessor Before 处理
Object wrappedBean = applyBeanPostProcessorsBeforeInitialization(bean, beanName);
// 待完成内容,调用初始化函数
invokeInitMethods(beanName, wrappedBean, beanDefinition);
// After 处理
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
return wrappedBean;
}
2
3
4
5
6
7
8
9
至此封装了 Factory 到 Context 中,并通过 Context 维护了 Bean 的生命周期
# 初始化和销毁方法
在加载 Bean 的时候,在 xml 文件指定该 Bean 的初始化方法和销毁方法,并注入 Bean 的生命周期,显然,这一过程应该和 BeanPostProcessor 一样,作用于 createBean 时期
# 初始化方法注入
正如 initializeBean 方法,在初始化的前置和后置之间,预留了一个invokeInitMethods(beanName, wrappedBean, beanDefinition)方法用于注入初始化过程
com.northboat.winterframework.beans.factory.support.AbstractAutowireCapableBeanFactory
// 待完成内容,调用初始化函数
invokeInitMethods(beanName, wrappedBean, beanDefinition);
2
流程应该和加载属性类似,通过 XmlBeanDefinitionReader 从 xml 读入初始化和销毁方法,存放在 BeanDefinition 中,然后在初始化时,从 Class.getMethods 中 invoke 执行同名的初始化函数
com.northboat.winterframework.beans.factory.config.BeanDefinition
public class BeanDefinition {
// 用于创建的 Class 类
private Class beanClass;
// 对象的内置属性
private PropertyValues propertyValues;
// 初始化和销毁方法
private String initMethodName;
private String destroyMethodName;
// ...get/set
}
2
3
4
5
6
7
8
9
10
# 销毁方法注入和执行
而销毁方法通过同样的 xml 方式进行注册、反射方式进行执行,在最上层提供一个destroy接口,这个接口的实现逻辑和 init 一样,通过方法名 invoke 反射执行
com.northboat.winterframework.beans.factory.DesposableBean
public interface DisposableBean {
void destroy() throws Exception;
}
2
3
那么如何触发这个 destroy 方法呢?答案是扩展单例 Bean 工厂
因为最后在销毁的时候,实际上销毁的是private Map<String, Object> singletonObjects中的实例对象,我们重新引入一个数据结构DisposableBeanAdapter
com.northboat.winterframework.beans.factory.support.DisposableBeanAdapter
public class DisposableBeanAdapter implements DisposableBean {
private final Object bean;
private final String beanName;
private String destroyMethodName;
}
2
3
4
5
在这个结构中维护了单例 bean 对象和其对应的销毁方法,同时实现了DispoableBean的 destroy 方法,在单例注册工厂中,多维护一个 Map
com.northboat.winterframework.beans.factory.support.DefaultSingletonBeanRegistry
public class DefaultSingletonBeanRegistry implements SingletonBeanRegistry {
private Map<String, Object> singletonObjects = new HashMap<>();
private final Map<String, DisposableBean> disposableBeans = new HashMap<>();
}
2
3
4
5
- 注册时,每加入一个单例,同时往
desposableBeans里加入其对应的DisposableBeanAdapter - 在调用 destroy 方法时,通过 beanName 去这个 Map 中去找出对应 Bean 的
DesposableBeanAdapter并执行 destroy
在 createBean 时去进行 put 操作
com.northboat.winterframework.beans.factory.support.AbstractAutowireCapableBeanFactory
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory {
@Override
protected Object createBean(String beanName, BeanDefinition beanDefinition, Object[] args) throws BeansException {
Object bean = null;
try {
// 创建实例
bean = createBeanInstance(beanDefinition, beanName, args);
// 填充属性
applyPropertyValues(beanName, bean, beanDefinition);
// 执行初始化方法和 BeanPostProcessor 的前置和后置处理方法
bean = initializeBean(beanName, bean, beanDefinition);
} catch (Exception e) {
throw new BeansException("Instantiation of bean failed", e);
}
// 注册实现了 DisposableBean 接口或者 destroyMethodName 字段不为空的 Bean 对象
registerDisposableBeanIfNecessary(beanName, bean, beanDefinition);
addSingleton(beanName, bean);
return bean;
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
registerDisposableBeanIfNecessary实现Map disposableBeans的构造:当当前 Bean 继承了 DisposableBean 或其销毁方法字段不为空,将其 put 进 disposableBeans
protected void registerDisposableBeanIfNecessary(String beanName, Object bean, BeanDefinition beanDefinition) {
if(bean instanceof DisposableBean || StrUtil.isNotEmpty(beanDefinition.getDestroyMethodName())) {
registerDisposableBean(beanName, new DisposableBeanAdapter(bean, beanName, beanDefinition));
}
}
2
3
4
5
为什么要单独拉一个 DisposableBean 来设计销毁操作?直接根据 beanName 去 beanDefinitionMap 中找出对应的 BeanDefinition 然后读出 destroyMethodName 再反射执行不好吗?
可能你会想这里怎么有一个适配器的类呢,因为销毁方法有两种甚至多种方式,目前有
实现接口 DisposableBean、配置信息 destroy-method,两种方式。而这两种方式的销毁动作是由 AbstractApplicationContext 在注册虚拟机钩子后,虚拟机关闭前执行的操作动作那么在销毁执行时不太希望还得关注都销毁那些类型的方法,它的使用上更希望是有一个统一的接口进行销毁,所以这里就新增了适配类,做统一处理
简单来说,销毁操作的执行位置很特殊,又因为 Bean 的种类太多,destroy 的操作需要多种方式实现,所以这里拉一个接口出来做单独的处理
其实本质上是因为:希望做到不同领域模块下只负责各自需要完成的功能,避免因为扩展导致类膨胀到难以维护
销毁的调用:在ConfigurableBeanFactory中定义销毁所有单例对象的接口
public interface ConfigurableBeanFactory extends HierarchicalBeanFactory, SingletonBeanRegistry {
// 销毁单例对象
void destroySingletons();
}
2
3
4
在DefaultSingletonBeanRegistry中实现这个逻辑
public class DefaultSingletonBeanRegistry implements SingletonBeanRegistry {
// 销毁单例
public void destroySingletons() {
Set<String> keySet = this.disposableBeans.keySet();
Object[] disposableBeanNames = keySet.toArray();
for (int i = disposableBeanNames.length - 1; i >= 0; i--) {
Object beanName = disposableBeanNames[i];
DisposableBean disposableBean = disposableBeans.remove(beanName);
try {
disposableBean.destroy();
} catch (Exception e) {
throw new BeansException("Destroy method on bean with name '" + beanName + "' threw an exception", e);
}
}
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
这里的继承逻辑很奇怪,为什么会这样关联?
ConfigurableBeanFactory extend SingletonBeanRegistryDefaultSingletonBeanRegistry implements SingletonBeanRegistry
然后在ConfigurableBeanFactory的destroySingletons接口会关联到DefaultSingletonBeanRegistry的实现?
其实是这样的
- 先是单例这一脉的继承:存储原始 BeanDefinition 和单例对象
SingletonBeanRegistry:定义获取和注册接口DefaultSingletonBeanRegistry:维护两个 Map 分别实现了 get 和 destroyFactoryBeanRegistrySupport:维护一个 Map 引入缓存机制
- 再是 BeanFactory 这一脉的继承:管理 Bean 对象的生命周期
BeanFactory → HierarchicalBeanFactoryConfiguableBeanFactory:这里他同时扩展了HierarchicalBeanFactory和SingletonBeanRegistry,将两个族系联系起来AbstractBeanFactory:扩展FactoryBeanRegistrySupport,继承ConfigurableBeanFactory
那么这样就组合在AbstractBeanFactory中实现了destroy,为什么捏?
- 因为在
ConfiguableBeanFactory定义了destroy但未实现,按道理来说应该在继承了ConfiguableBeanFactory的AbstractBeanFactory中去实现 - 但同时,
AbstractBeanFactory又扩展了FactoryBeanRegistrySupport,自动继承了他的destroy函数,正好填上了上面尚未实现的空
这样的多层继承 / 实现 + 组合复用的方式在 Spring 运用的非常广泛灵活
但到这里还没有完,因为这里的销毁是在 Factory 层面的销毁,我们要进一步把它暴露到 Context 中,于是在ConfigurableApplicationContext定义close接口
public interface ConfigurableApplicationContext extends ApplicationContext{
// 刷新容器
void refresh() throws BeansException;
// 销毁 Bean 工厂中所有单例
void close();
// 向虚拟机添加钩子,以观测销毁方法的调用
void registerShutdownHook();
}
2
3
4
5
6
7
8
最后在AbstractApplicationContext中实现close逻辑,并将close操作通过registerShutdownHook注册进虚拟机钩子,于是就会发生:在 Context 销毁时,触发所有单例对象的 destroy(复杂死你大坝了)
public abstract class AbstractApplicationContext extends DefaultResourceLoader implements ConfigurableApplicationContext {
@Override
public void close(){
getBeanFactory().destroySingletons();
}
// 这里的线程钩子注册,实际上是当前对象销毁时执行的方法,即在 Context 销毁时执行 close 方法
@Override
public void registerShutdownHook(){
Runtime.getRuntime().addShutdownHook(new Thread(this::close) {});
}
}
2
3
4
5
6
7
8
9
10
11
12
# 注册线程销毁钩子
在 BeanFactory 中实现后,还需要向外给 Context 暴露接口
com.northboat.winterframework.context.ConfigurableApplicationContext
public interface ConfigurableApplicationContext extends ApplicationContext {
void refresh() throws BeansException;
void close();
void registerShutdownHook();
}
2
3
4
5
- close 方法即遍历 Map 中所有 DispsableBean 执行其 destroy 方法
- registerShutdownHook 方法向 JVM 注册当前 Context 的销毁钩子函数
具体实现如下
public abstract class AbstractApplicationContext extends DefaultResourceLoader implements ConfigurableApplicationContext {
@Override
public void close(){
getBeanFactory().destroySingletons();
}
// 这里的线程钩子注册,实际上是当前对象销毁时执行的方法,即在 Context 销毁时执行 close 方法
@Override
public void registerShutdownHook(){
Runtime.getRuntime().addShutdownHook(new Thread(this::close) {});
}
}
2
3
4
5
6
7
8
9
10
11
12
配置文件:src.test.resources.winter
<?xml version="1.0" encoding="UTF-8"?>
<beans>
<bean id="userDao" class="com.northboat.winterframework.test.bean.UserDao" init-method="initDataMethod" destroy-method="destroyDataMethod"/>
<bean id="userService" class="com.northboat.winterframework.test.bean.UserService">
<property name="uId" value="10001"/>
<property name="company" value="腾讯"/>
<property name="location" value="深圳"/>
<property name="userDao" ref="userDao"/>
</bean>
</beans>
2
3
4
5
6
7
8
9
10
11
12
13
在测试中,以相同的方式读取 xml 和 getBean,当然多了一个注册钩子的过程
@Test
public void test_xml() {
// 1.初始化 BeanFactory
ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:winter.xml");
applicationContext.registerShutdownHook();
// 2. 获取Bean对象调用方法
UserService userService = applicationContext.getBean("userService", UserService.class);
String result = userService.queryUserInfo();
System.out.println("测试结果:" + result);
}
2
3
4
5
6
7
8
9
10
11
将会有 initDataMethod、afterPropertiesSet 和 destroyDataMethod 的输出
Running initDataMethod
UserService afterPropertiesSet
测试结果:northboat,腾讯,深圳
UserService destroy
Running destroyDataMethod
2
3
4
5
这里Running initDataMethod和Running destroyDataMethod是UserDao输出的
- 这里 UserDao 并没有继承 DisposableBean 接口,为什么会被配置一个 DisposableAdpter 呢?
而UserService afterPropertiesSet和UserService destroy是UserService输出的
# Aware 感知
Aware 感知是标记性接口,让具体的 Bean 类能感受到其所属的 BeanFactory 和 ApplicationContext
- BeanFactoryAware
- ApplicationContextAware
实现思路:在 Bean 的初始化过程中把 BeanFactory 和 Context 作为内置属性塞进 Bean
- 在 BeanFactory 初始化 Bean 过程中为 Bean 填充 BeanFactory 属性
- 在
postProcessBeforeInitialization阶段填充 Context 属性,具体来说:
# BeanFactory 的感知
进行postProcessBeforeInitialization之前进行填充,因为这一过程都是在 BeanFactory 中发生的,所以填充时直接set(this)就行
让 Bean 继承 Aware 系接口,同时维护 Context 和 BeanFactory 属性
public class UserService implements BeanNameAware, BeanClassLoaderAware, ApplicationContextAware, BeanFactoryAware {
private ApplicationContext applicationContext;
private BeanFactory beanFactory;
}
2
3
4
5
在创建UserService这个 Bean 时,在initializeBean阶段对 Bean 的 BeanFactory 属性进行set(this)的填充
这里的 Aware 系接口
BeanNameAware维护setBeanNameBeanClassLoaderAware维护setBeanClassLoaderApplicationContextAware维护setApplicationContext接口- ...
这些 set 方法都需要在 UserService 中进行重写
@Override
public void setApplicationContext(ApplicationContext context) throws BeansException {
this.applicationContext = context;
}
@Override
public void setBeanClassLoader(ClassLoader classLoader) throws BeansException {
System.out.println("setBeanClassLoader: " + classLoader);
}
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
this.beanFactory = beanFactory;
}
@Override
public void setBeanName(String name) {
System.out.println("setBeanName: " + name);
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
com.northboat.winterframework.beans.factory.support.AbstractAutowireCapableBeanFactory
private Object initializeBean(String beanName, Object bean, BeanDefinition beanDefinition) {
// invokeAwareMethods
if (bean instanceof Aware) {
if (bean instanceof BeanFactoryAware) {
((BeanFactoryAware) bean).setBeanFactory(this);
}
if (bean instanceof BeanClassLoaderAware){
((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader());
}
if (bean instanceof BeanNameAware) {
((BeanNameAware) bean).setBeanName(beanName);
}
}
// 1. 执行 BeanPostProcessor Before 处理
Object wrappedBean = applyBeanPostProcessorsBeforeInitialization(bean, beanName);
// 执行 Bean 对象的初始化方法
try {
invokeInitMethods(beanName, wrappedBean, beanDefinition);
} catch (Exception e) {
throw new BeansException("Invocation of init method of bean[" + beanName + "] failed", e);
}
// 2. 执行 BeanPostProcessor After 处理
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
return wrappedBean;
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
# ApplicationContext 的感知
在 ApplicationContext 添加BeanPostProcessor时,将自身作为 Context 参数构造一个 Processor,而后这个 Processor 在执行postProcessBeforeInitialization时,将 Context 再注入 Bean
具体的填充发生在applyBeanPostProcessorsBeforeInitialization时期,即 BeanPostProcessor 的前置操作中
- 定义一个实现类
ApplicationContextAwareProcessor在postProcessBeforeInitialization中实现setContext的逻辑 - 在 Context 创建 BeanFactory 时,将这个 BeanPostProcessor 注册进 BeanFactory
- 这样,只要是这个 Context 在创建 Bean ,都会在
applyBeanPostProcessorsBeforeInitialization时执行这个 setApplicationContext 的操作
com.northboat.winterframework.context.support.ApplicationContextAwareProcessor
public class ApplicationContextAwareProcessor implements BeanPostProcessor {
private final ApplicationContext applicationContext;
public ApplicationContextAwareProcessor(ApplicationContext applicationContext) {
this.applicationContext = applicationContext;
}
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
if (bean instanceof ApplicationContextAware){
((ApplicationContextAware) bean).setApplicationContext(applicationContext);
}
return bean;
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
这里 ApplicationContextAwareProcessor 的构造和设置发生在 ApplicationContext 的 refresh 方法中
com.northboat.winterframework.context.support.AbstractApplicationContext
public abstract class AbstractApplicationContext extends DefaultResourceLoader implements ConfigurableApplicationContext {
@Override
public void refresh() throws BeansException {
// 创建 BeanFactory,并加载 BeanDefinition
refreshBeanFactory();
// 获取 BeanFactory
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
// 添加 ApplicationContextAwareProcessor,让继承自 ApplicationContextAware 的 Bean 对象都能感知所属的 ApplicationContext
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
invokeBeanFactoryPostProcessors(beanFactory);
registerBeanPostProcessors(beanFactory);
beanFactory.preInstantiateSingletons();
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
在测试中,令 Service 继承感知器并实现 set 方法
com.northboat.winterframework.test.bean.UserService
public class UserService implements BeanNameAware, BeanClassLoaderAware, ApplicationContextAware, BeanFactoryAware {
// 上下文和工厂感知
private ApplicationContext applicationContext;
private BeanFactory beanFactory;
@Override
public void setApplicationContext(ApplicationContext context) throws BeansException {
this.applicationContext = context;
}
@Override
public void setBeanClassLoader(ClassLoader classLoader) throws BeansException {
System.out.println("setBeanClassLoader: " + classLoader);
}
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
this.beanFactory = beanFactory;
}
@Override
public void setBeanName(String name) {
System.out.println("setBeanName: " + name);
}
// ...getter
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
通过 Context 注册并获取 Bean 后,打印其感知到的 BeanFactory、BeanName、ApplicationContext 以及 ClassLoader
@Test
public void test_xml() {
// 1.初始化 BeanFactory
ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:winter.xml");
applicationContext.registerShutdownHook();
// 2. 获取Bean对象调用方法
UserService userService = applicationContext.getBean("userService", UserService.class);
String result = userService.queryUserInfo();
System.out.println("测试结果:" + result);
System.out.println("ApplicationContextAware:" + userService.getApplicationContext());
System.out.println("BeanFactoryAware:" + userService.getBeanFactory());
}
2
3
4
5
6
7
8
9
10
11
12
13
得到
Running initDataMethod
setBeanClassLoader: jdk.internal.loader.ClassLoaders$AppClassLoader@63947c6b
setBeanName: userService
测试结果:northboat,腾讯,深圳
ApplicationContextAware:com.northboat.winterframework.context.support.ClassPathXmlApplicationContext@fd07cbb
BeanFactoryAware:com.northboat.winterframework.beans.factory.support.DefaultListableBeanFactory@3571b748
Running destroyDataMethod
2
3
4
5
6
7
为什么会有Running initDataMethod和Running destroyDataMethod的打印?因为在 xml 中指定了 UserDao 的初始化和销毁方法,这个 Bean 在创建过程会被加入disposableBeans并执行初始化和销毁方法
# FactoryBean 自定义 Bean
FactoryBean 是一种特殊的 bean,当向容器获取该 bean 时(getBean()时),容器不是返回其本身,而是返回其FactoryBean.getObject方法的返回值
这样开发者可通过自定义编码方式构造复杂的 bean 并注入 BeanFactory,例如 MyBatisBean 就是通过这样的方式定义和返回,这对 Spring 的生态构造有着重大意义
FactoryBean 的实现逻辑比较简单
- 当容器发现 bean 为 FactoryBean 类型时,调用其 getObject 方法返回最终 bean
- 当
FactoryBean.isSingleton() == true,将最终 bean 放进缓存中,下次从缓存中获取
改动点围绕AbstractBeanFactory.getBean()进行
# 修改 BeanDefinition
增加 scope 字段,区分当前 Bean 是单例 singleton 还是原型 prototype(默认单例),同时提供设置类型的接口setScope
com.northboat.winterframework.beans.factory.config.BeanDefinition
public class BeanDefinition {
String SCOPE_SINGLETON = ConfigurableBeanFactory.SCOPE_SINGLETON;
String SCOPE_PROTOTYPE = ConfigurableBeanFactory.SCOPE_PROTOTYPE;
private String scope = SCOPE_SINGLETON;
private boolean singleton = true;
private boolean prototype = false;
// Class, PropertyValues, String(MethodName)
//在xml注册Bean定义时,通过scope字段来判断是单例还是原型
public void setScope(String scope) {
this.scope = scope;
this.singleton = SCOPE_SINGLETON.equals(scope);
this.prototype = SCOPE_PROTOTYPE.equals(scope);
}
// ...get/set
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
在读取 xml 文件创建 BeanDefinition 时填充当前 Bean 的 scope
com.northboat.winterframework.beans.factory.xml.XmlBeanDefinitionReader
public class XmlBeanDefinitionReader extends AbstractBeanDefinitionReader {
protected void doLoadBeanDefinitions(InputStream inputStream) throws ClassNotFoundException {
for (int i = 0; i < childNodes.getLength(); i++) {
// 判断元素
if (!(childNodes.item(i) instanceof Element)) continue;
// 判断对象
if (!"bean".equals(childNodes.item(i).getNodeName())) continue;
// 解析标签
Element bean = (Element) childNodes.item(i);
String id = bean.getAttribute("id");
String name = bean.getAttribute("name");
String className = bean.getAttribute("class");
String initMethod = bean.getAttribute("init-method");
String destroyMethodName = bean.getAttribute("destroy-method");
String beanScope = bean.getAttribute("scope");
// 获取 Class,方便获取类中的名称
Class<?> clazz = Class.forName(className);
// 优先级 id > name
String beanName = StrUtil.isNotEmpty(id) ? id : name;
if (StrUtil.isEmpty(beanName)) {
beanName = StrUtil.lowerFirst(clazz.getSimpleName());
}
// 定义Bean
BeanDefinition beanDefinition = new BeanDefinition(clazz);
beanDefinition.setInitMethodName(initMethod);
beanDefinition.setDestroyMethodName(destroyMethodName);
if (StrUtil.isNotEmpty(beanScope)) {
beanDefinition.setScope(beanScope);
}
// ...
// 注册 BeanDefinition
getRegistry().registerBeanDefinition(beanName, beanDefinition);
}
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
在创建 Bean 时,需要判断当前 BeanDefinition 是否是单例,当为单例 scope == singleton 时,才进行单例初始化 addSingleton
- 单例模式和原型模式的区别就在于是否存放到内存中,如果是原型模式那么就不会存放到内存中,每次获取都重新创建对象,另外非 Singleton 类型的 Bean 不需要执行销毁方法
- 所以这里的代码会有两处修改,一处是 createBean 中判断是否添加到
addSingleton(beanName, bean),另外一处是 registerDisposableBeanIfNecessary 销毁注册中的判断if (!beanDefinition.isSingleton()) return
com.northboat.winterframework.beans.factory.support.AbstractAutowireCapableBeanFactory
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory {
private InstantiationStrategy instantiationStrategy = new CglibSubclassingInstantiationStrategy();
@Override
protected Object createBean(String beanName, BeanDefinition beanDefinition, Object[] args) throws BeansException {
Object bean = null;
try {
bean = createBeanInstance(beanDefinition, beanName, args);
// 给 Bean 填充属性
applyPropertyValues(beanName, bean, beanDefinition);
// 执行 Bean 的初始化方法和 BeanPostProcessor 的前置和后置处理方法
bean = initializeBean(beanName, bean, beanDefinition);
} catch (Exception e) {
throw new BeansException("Instantiation of bean failed", e);
}
// 注册实现了 DisposableBean 接口的 Bean 对象
registerDisposableBeanIfNecessary(beanName, bean, beanDefinition);
// 判断 SCOPE_SINGLETON、SCOPE_PROTOTYPE
if (beanDefinition.isSingleton()) {
addSingleton(beanName, bean);
}
return bean;
}
protected void registerDisposableBeanIfNecessary(String beanName, Object bean, BeanDefinition beanDefinition) {
// 非 Singleton 类型的 Bean 不执行销毁方法
if (!beanDefinition.isSingleton()) return;
if (bean instanceof DisposableBean || StrUtil.isNotEmpty(beanDefinition.getDestroyMethodName())) {
registerDisposableBean(beanName, new DisposableBeanAdapter(bean, beanName, beanDefinition));
}
}
// ... 其他功能
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
# FactoryBean 接口与服务注册
向用户提供 FactoryBean 接口,以实现自定义 Bean
com.northboat.winterframework.beans.factory.FactoryBean
// 提供自定义 Bean 接口,用户的自定义 Bean 将通过这个接口实现
public interface FactoryBean<T> {
T getObject() throws Exception;
Class<?> getObjectType();
boolean isSingleton();
}
2
3
4
5
6
扩展单例注册器,多增加一个对象 Object 缓存 Map
com.northboat.winterframework.beans.factory.support.FactoryBeanRegistrySupport
public abstract class FactoryBeanRegistrySupport extends DefaultSingletonBeanRegistry{
// Object 的缓存,先从这取,如果没有直接从 FactoryBean 中获取,再存入缓存
private final Map<String, Object> factoryBeanObjectCache = new ConcurrentHashMap<>();
}
2
3
4
5
增加获取 FactoryBean 的方法
protected Object getCachedObjectForFactoryBean(String beanName){
Object object = this.factoryBeanObjectCache.get(beanName);
return (object != NULL_OBJECT ? object : null);
}
protected Object getObjectFromFactoryBean(FactoryBean factory, String beanName){
// 若为单例
if(factory.isSingleton()){
Object object = this.factoryBeanObjectCache.get(beanName);
if(object == null){
object = doGetObjectFromFactoryBean(factory, beanName);
this.factoryBeanObjectCache.put(beanName, (object != null ? object : NULL_OBJECT));
}
return (object != NULL_OBJECT ? object : null);
} else {
// 若不是单例,直接通过 BeanFactory 返回
return doGetObjectFromFactoryBean(factory, beanName);
}
}
private Object doGetObjectFromFactoryBean(FactoryBean factory, String beanName){
try {
return factory.getObject();
} catch (Exception e){
throw new BeansException("FactoryBean threw exception on object [" + beanName + "] creation", e);
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
这里的NULL_OBJECT是一个静态的空Object,作为原型对象在单例 Map 中的占位
com.northboat.winterframework.beans.factory.support.DefaultSingletonBeanRegistry
public class DefaultSingletonBeanRegistry implements SingletonBeanRegistry {
// 设置一个空值,作为 Map 的占位
protected static final Object NULL_OBJECT = new Object();
}
2
3
4
5
# 修改 doGetBean 逻辑
在 getBean 过程加入 scope 的判断,若是 FactoryBean,需要通过 getObject 去返回对象,若是单例,保持原有逻辑不变
public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
@Override
public Object getBean(String beanName){
return doGetBean(beanName, null);
}
@Override
public Object getBean(String beanName, Object... args) throws BeansException {
return doGetBean(beanName, args);
}
// 返回相应对象,在这做一个强转的封装
@Override
public <T> T getBean(String beanName, Class<T> type) throws BeansException {
return (T) getBean(beanName);
}
protected <T> T doGetBean(final String beanName, final Object[] args) throws BeansException {
Object sharedInstance = getSingleton(beanName);
if(sharedInstance != null){
return (T) getObjectForBeanInstance(sharedInstance, beanName);
}
// 当 Bean Object 并未初始化,使用 Class 对象进行实例化
BeanDefinition beanDefinition = getBeanDefinition(beanName);
Object bean = createBean(beanName, beanDefinition, args);
return (T) getObjectForBeanInstance(bean, beanName);
}
private Object getObjectForBeanInstance(Object beanInstance, String beanName){
if(!(beanInstance instanceof FactoryBean<?> factoryBean)){
return beanInstance;
}
// factoryBean 在 if 语句中定义
// 先从缓存中获取
Object object = getObjectFromFactoryBean(factoryBean, beanName);
// 若缓存中不存在,则从 factoryBean 中获取
if(object != null){
object = getObjectFromFactoryBean(factoryBean, beanName);
}
return object;
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
# 代理类实现和 JOL 测试
这里我们废弃掉原来的 UserDao,新建一个接口类 MyUserDao,他仅有唯一的一个功能 queryUserName(并且没有下层实现)
com.northboat.winterframework.test.bean.MyUserDao
public interface MyUserDao {
String queryUserName(String uId);
}
2
3
具体的查询逻辑我们使用代理的方式实现,通过继承FactoryBean<MyUserDao>
- 通过 FactoryBean 的 getObject 接口返回一个 UserDao 对象,而这个 UserDao 对象是使用代理增强技术实现的一个 Object
- 返回的 Object 是 UserDao 的代理,可以理解为一个子类,通过强转的形式作为一个 UserDao 返回
public class ProxyBeanFactory implements FactoryBean<MyUserDao> {
// 代理类实现 MyUserDao 对象的返回
@Override
public MyUserDao getObject() throws Exception {
InvocationHandler handler = (proxy, method, args) -> {
Map<String, String> hashMap = new HashMap<>();
hashMap.put("10001", "小傅哥");
hashMap.put("10002", "八杯水");
hashMap.put("10003", "阿毛");
return "你被代理了 " + method.getName() + ":" + hashMap.get(args[0].toString());
};
return (MyUserDao) Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), new Class[]{MyUserDao.class}, handler);
}
@Override
public Class<?> getObjectType() {
return MyUserDao.class;
}
@Override
public boolean isSingleton() {
return true;
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
在 UserService 中将 MyUserDao 作为一个内置属性注入
public class UserService {
private String uId;
private String company;
private String location;
private MyUserDao userDao;
public String queryUserInfo(){
return userDao.queryUserName(uId) + "," + company + "," + location;
}
}
2
3
4
5
6
7
8
9
10
而后在配置文件中加入 UserService 和 ProxyBeanFactory 的 Bean 配置信息
<?xml version="1.0" encoding="UTF-8"?>
<beans>
<bean id="userService" class="com.northboat.winterframework.test.bean.UserService" scope="prototype">
<property name="uId" value="10001"/>
<property name="company" value="腾讯"/>
<property name="location" value="深圳"/>
<property name="userDao" ref="proxyUserDao"/>
</bean>
<bean id="proxyUserDao" class="com.northboat.winterframework.test.bean.ProxyBeanFactory"/>
</beans>
2
3
4
5
6
7
8
9
10
11
12
13
在测试中,通过 ClassPathXmlApplicationContext 读入,完成 Bean 的创建、获取和调用
public class ApiTest {
@Test
public void test_prototype() {
// 1.初始化 BeanFactory
ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:winter.xml");
applicationContext.registerShutdownHook();
// 2. 获取Bean对象调用方法
UserService userService01 = applicationContext.getBean("userService", UserService.class);
UserService userService02 = applicationContext.getBean("userService", UserService.class);
// 3. 配置 scope="prototype/singleton"
System.out.println(userService01);
System.out.println(userService02);
// 4. 打印十六进制哈希
System.out.println(userService01 + " 十六进制哈希:" + Integer.toHexString(userService01.hashCode()));
System.out.println(ClassLayout.parseInstance(userService01).toPrintable());
}
@Test
public void test_factory_bean() {
// 1.初始化 BeanFactory
ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:winter.xml");
applicationContext.registerShutdownHook();
// 2. 调用代理方法
UserService userService = applicationContext.getBean("userService", UserService.class);
System.out.println("测试结果:" + userService.queryUserInfo());
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
在 spring.xml 配置文件中,对 UserService 设置了 scope="prototype" 这样就每次获取到的对象都是通过新 createBean 中返回的一个新的对象,这是因为,只有标记为 singleton 的对象才会被放进单例池
if(beanDefinition.isSingleton()){
addSingleton(beanName, bean);
}
2
3
所以每次getSingleton都会返回空,于是重走一遍 create 过程
这里判断对象是否为一个会看到打印的类对象的哈希值,所以我们把十六进制哈希打印出来,打印结果如下
com.northboat.winterframework.test.bean.UserService@747ddf94
com.northboat.winterframework.test.bean.UserService@35e2d654
com.northboat.winterframework.test.bean.UserService@747ddf94 十六进制哈希:747ddf94
2
3
可以发现 userService1 和 userService2 是两个不同的对象,说明原型模式生效
另外,调用 UserService 的 queryUserName 方法去调用另一个 Bean UserDao
System.out.println("测试结果:" + userService.queryUserInfo());
输出
测试结果:你被代理了 queryUserName:northboat,腾讯,深圳
说明代理类生效
这里出现了意料之外的问题,CGLib 的初始化又和 JDK17 冲突了,解决了一下失败了,所以在测试的时候使用了 JDK 自带的反射进行对象构造