my-mini-spring
项目的Github地址:github仓库
Gitee地址:gitee仓库
个人博客地址:sillybaka的博客
此篇所在的分支为:simple-bean-factory
该篇实现了BeanFactory的大概继承体系结构,以及实现了简单的生成Bean
IOC篇
Bean的生命周期
1、简单的IOC容器(beanFactory 仅支持创建bean、获取bean)
当前Bean的生命周期为:获取bean定义 --> 实例化bean --> 装配属性
当前的BeanFactory继承体系
1. 工厂模式实现BeanFactory
这里采用懒汉式的设计,要先将Bean定义注册进注册表(但不创建Bean对象),在首次获取Bean时才创建
1.1 BeanDefinition(Bean需要定义)
用于定义bean信息的类,包含bean的class类型、构造参数、属性值等信息,每个bean对应一个
public class BeanDefinition<T> {
/**
* Bean的名字
*/
private String name;
/**
* Bean的类型
*/
private Class<T> type;
/**
* Bean所带的参数类型
*/
private Class<?>[] parameterTypes;
/**
* Bean所带的属性值
*/
private Object[] values;
public BeanDefinition(String name,Class<T> type){
this.name = name;
this.type = type;
}
}
1.2 BeanRegistry(Bean实例的注册表)
Bean的实例在创建之后,需要一个表来缓存,方便以后通过beanName和beanType来获取bean实例对象
public interface SingletonBeanRegistry {
/**
* 注册bean到注册表中
* @param beanName bean的名字
* @param bean bean的实例对象
*/
void registerBean(String beanName, Object bean);
/**
* 根据bean的类型来获得单例实例对象
* @param beanClass bean的类型
* @return bean的实例
*/
Object getSingletonBean(Class<?> beanClass);
/**
* 根据bean的名字来获得单例实例对象
* @param beanName bean的名字
* @return bean的实例
*/
Object getSingletonBean(String beanName);
}
1.3 BeanFactory(获取并创建Bean实例)
BeanFactory封装了对不同类型的bean的创建逻辑,方便对bean实例的创建
public interface BeanFactory {
/**
* 获取bean
* @param beanName bean的名字
* @return bean的实例对象
*/
Object getBean(String beanName);
}
1.4 BeanDefinitionRegistry(Bean定义的注册表)
每个Bean有各自的定义,它的定义也要用一个表存起来,方便通过beanName或beanType来获取
public interface BeanDefinitionRegistry {
/**
* 向beanName注册它的bean定义
* @param beanName
* @param beanDefinition
* @param <T>
*/
<T> void registerBeanDefinition(String beanName, BeanDefinition<T> beanDefinition);
}
1.5 AbstractAutowireCapableBeanFactory(自动装配工厂 装配Bean属性)
每个Bean都有各自的属性、参数类型、不同的参数值(封装在Bean定义中),不同的名字,我们要有一个装配工厂将Bean的定义封装进其实例对象中。
// 抽象的BeanFactory,实现了BeanFactory的通用方法,其他交由子类实现
public abstract class AbstractBeanFactory extends DefaultSingletonBeanRegistry implements BeanFactory {
@Override
public Object getBean(String beanName) {
Object bean = getSingletonBean(beanName);
// 如果bean为空,则说明注册表中没有 需要在工厂创建
if(bean == null){
// 双重校验
synchronized (AbstractBeanFactory.class){
bean = getSingletonBean(beanName);
if(bean == null){
bean = createBean(beanName,getBeanDefinition(beanName));
// 注册进注册表
registerBean(beanName,bean);
}
}
}
return bean;
}
/**
* 创建名为beanName的Bean实例
* 创建策略由实现类决定
*/
protected abstract <T> T createBean(String beanName, BeanDefinition<T> beanDefinition);
/**
* 根据beanName获取它的bean定义
*/
protected abstract BeanDefinition<?> getBeanDefinition(String beanName);
}
// 抽象的自动装配工厂,定义了创建bean的抽象逻辑,委托给子类实现
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory{
@Override
protected <T> T createBean(String beanName, BeanDefinition<T> beanDefinition) {
return doCreate(beanName,beanDefinition);
}
/**
* 创建Bean实例的实际逻辑,由子类实现
* @param beanName
* @param beanDefinition
* @param <T>
* @return
*/
public abstract <T> T doCreate(String beanName,BeanDefinition<T> beanDefinition);
}
1.6 DefaultListableBeanFactory(默认的能够生成完整Bean实例的工厂)
BeanDefinition存放在BeanDefinitionRegistry(注册表)中,而BeanFactory只负责Bean实例的创建逻辑,我们要如何获取到Bean的定义呢?
将注册表与工厂相结合,这样工厂即能用来注册bean定义,也能够用来生成bean实例对象
public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory implements BeanDefinitionRegistry {
/**
* bean定义的注册表
*/
private static final Map<String,BeanDefinition<?>> BEAN_DEFINITION_REGISTRY = new HashMap<>();
@Override
protected BeanDefinition<?> getBeanDefinition(String beanName) {
if(StrUtil.isBlank(beanName)){
throw new IllegalArgumentException("beanName不能为空");
}
BeanDefinition<?> beanDefinition = BEAN_DEFINITION_REGISTRY.get(beanName);
if(beanDefinition == null){
log.error("不存在该beanName的bean定义:{}",beanName);
throw new IllegalArgumentException("不存在该beanName的bean定义");
}
return beanDefinition;
}
@Override
public <T> void registerBeanDefinition(String beanName, BeanDefinition<T> beanDefinition) {
if(StrUtil.isBlank(beanName)){
throw new IllegalArgumentException("beanName不能为空");
}
BEAN_DEFINITION_REGISTRY.put(beanName,beanDefinition);
}
@Override
public <T> T doCreate(String beanName, BeanDefinition<T> beanDefinition) {
String name = beanDefinition.getName();
if(!name.equals(beanName)){
log.error("BeanName和BeanDefinition中的名字不对应,创建bean实例失败");
throw new IllegalArgumentException("BeanName和BeanDefinition中的名字不对应,创建bean实例失败");
}
Class<T> clazz = beanDefinition.getType();
Class<?>[] parameterTypes = beanDefinition.getParameterTypes();
Object[] parameterValues = beanDefinition.getValues();
T beanInstance = null;
try {
Constructor<T> constructor = clazz.getConstructor(parameterTypes);
beanInstance = constructor.newInstance(parameterValues);
} catch (NoSuchMethodException | InvocationTargetException | InstantiationException | IllegalAccessException e) {
log.error(e.getMessage());
}
return beanInstance;
}
}
当前的项目结构