手写简单的Spring框架——my-mini-spring -- IOC篇 -- 简单的IOC容器 （一）

项目的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;
    }
}

当前的项目结构