IOC及DI功能分析与设计

Posted 2022-01-03 踩踩踩从踩

前言

本篇文章会从IOC分析，IOC设计实现 ，包括 bean工厂 bean定义 以及bean定义注册接口；以及di进行分析，BeanReference 如何找到对应的类进行依赖注入，构造参数依赖定义，并且怎么判断出bean工厂中参数依赖的问题。

IOC分析

IOC：Inversion of Control 控制反转， 也称依赖倒置（反转 ）

反转：依赖对象的获得被反转了。 由自己创建，反转为从IOC容器中获 取（和自动注入）

ioc 带来的好处：

• 代码更简洁，不需要去new要使用的对象了。

• 面向接口编程，使用者与具体类解耦， 易扩展、替换实现者。

• 可以方便进行AOP增强。

IOC容器的工作：负责创建、管理类实例，向使用者提供实例。

IOC容器负责来创建类实例对象，需要就从IOC容器中get。也称IOC容器为Bean工厂。

所以说在一些面试上问bean工厂是什么，其实也是在问ioc容器。

IOC容器设计&实现

实现一个ioc容器需要下面三个元素 

• bean工厂接口，ioc容器是实现抽象接口，向用户提供获取bean基本入口。

/**
 * Bean工厂，IOC容器最顶层的抽象
 */
public interface BeanFactory 
    /**
     * 用户端获取Bean的方法
     * @param beanName
     * @return
     */
    Object getBean(String beanName) throws Exception;

• bean定义接口，向ioc容器规定bean创建成什么样。
• bean定义的注册接口，如何将bean定义注册进入bean工厂，这就是bean定义注册接口的含义，也是为什么需要这个接口。

就是一个定义注册，我们可以给它定义一个定义注册接口

/**
 * Bean定义注册接口，用来完成Bean定义和Bean工厂之间沟通
 */
public interface BeanDefinitionRegistry 
    /**
     * 想Bean工厂，注册Bean定义信息
     * @param beanName
     * @param beanDefinition
     */
    void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionRegisterException;

    /**
     * 获取已经注册的BeanDefinition
     * @param beanName
     * @return
     */
    BeanDefinition getBeanDefinition(String beanName);

    /**
     * 是否包含了已经定义的beanName
     * @param beanName
     * @return
     */
    boolean containsBeanDefinition(String beanName);

为什么要用beanDefinitionReistery也是为了解决降低耦合，不至于强一致性。如果直接往里面注册，一旦bean定义修改了什么，则会修改具体的beanfactory.这里很像门面模式。

设计ioc时，一定是多用接口去隔绝开，从而进行扩展。这是spring的经典思想。

每个bean定义有一个唯一的名称  因此有了beanName.

BeanDefinition

BeanDefinition的用途就是告诉bean工厂该如何创建某类bean，

获得获得类的实例的方式  

• new 构造方法  

Person p = new Person();

• 工厂 静态方法 

public class PersonFactory
        public static Person getPerson()
            return new Person();
         

• 工厂 方法 

public class PersonFactory
    public Person getPerson()
    return new Person();
     

以及通过反射也好，还是  直接采用new  ，这里 在工厂中。一般需要知道。

Bean工厂帮我们创建bean时，它需要获知哪些信息，这都是在ioc中需要获取到的。

• new 构造方法  需要知道 类名
•  静态工厂方法  需要知道 工厂类名、工厂方法名
• 成员工厂方法 需要知道 工厂bean名  工厂方法名

并且需要考虑 单例 等信息。

bean定义是给bean工厂创建bean用的，那bean定义接口应向bean工厂提供哪些方法？

• 获取bean的类名：getBeanClass() :Class
• 获取工厂方法名：getFactoryMethodName():String
• 获取工厂bean名：getFactoryBeanName():String
• 是否是单例等方法：getScope():String isSingleton() isPrototype()

类对象交给IOC容器来管理， 类对象的生命周期中还可能有什么生命阶段事情要做 。这都是需要考虑的

• 比如创建对象后可能需要进行一些初始化
• 还有有些对象在销毁时可能要进行一些特定的销毁逻辑（如释放资源）
• 那就在Bean定义中提供让用户可指定初始化、销毁方法。
• 对Bean工厂就需提供 getInitMethodName() getDestroyMethodName()

这肯定需要增强这些。

 这里在bean定义的接口上可以知道的。

/**
 * Bean定义，用来指定Bean构建信息接口
 */
public interface BeanDefinition 
    String SCOPE_SINGLETON = "singleton";
    String SCOPE_PROTOTYPE = "prototype";
    /**
     * 获取Bean的类名
     * @return
     */
    Class<?> getBeanClass();

    /**
     * 
     * @param beanClass
     */
    void setBeanClass(Class<?> beanClass);
    
    String getScope();
    void setScope(String scope);
    boolean isSingleton();
    boolean isPrototype();
    String getFactoryMethodName();
    void setFactoryMethodName(String factoryMethodName);
    String getFactoryBeanName();
    void setFactoryBeanName(String factoryBeanName);
    void setInitMethod(String initMethod);
    String getInitMethod();
    void setDestroyMethod(String destroyMethod);
    String getDestroyMethod();
     
    
    default boolean validate() 
        // 没有BeanCalss信息，只能通过成员工厂来构建对象
        if(getBeanClass() == null) 
            if(StringUtils.isBlank(getFactoryBeanName()) || StringUtils.isBlank(getFactoryMethodName()))
                return false;
            
        
        
        // Class存在的情况，还指定FactoryBeanName，构建对象的方式冲突
        if(getBeanClass() != null && StringUtils.isNotBlank(getFactoryBeanName())) 
            return false;
        
        return true;
    ;

定义的beandefinition bean定义。

 这是最常见的bean定义实现主要作的也是 定义的最多的 方法实现。获取到 这个在spring中  会解析并产生生成 bean定义。

在  默认的 DefaultBeanFactory  中  需要实现BeanFactory BeanDefinitionRegistry 接口来实现  的

public class DefaultBeanFactory implements BeanFactory, BeanDefinitionRegistry, Closeable 

这里实现 beanfactory工厂时，首先需要存储 bean定义的容器

 private Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>();

其次在实现时注册bean定义时， 判断 bean定义 是否可以添加

 @Override
    public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionRegisterException 
        Objects.requireNonNull(beanName, "注册bean需要指定beanName");
        Objects.requireNonNull(beanDefinition, "注册bean需要指定beanDefinition");
        
        if(!beanDefinition.validate()) 
            throw new BeanDefinitionRegisterException("名字为["+beanName+"]的bean定义不合法："+beanDefinition);
        
        
        if(containsBeanDefinition(beanName)) 
            throw new BeanDefinitionRegisterException("名字为["+beanName+"]已存在："+getBeanDefinition(beanName));
        
        beanDefinitionMap.put(beanName, beanDefinition);
    

然后以及获取 bean定义的方法  这些都比较简单。

 @Override
    public BeanDefinition getBeanDefinition(String beanName) 
        return beanDefinitionMap.get(beanName);
    

    @Override
    public boolean containsBeanDefinition(String beanName) 
        return beanDefinitionMap.containsKey(beanName);
    

在 获取 getBean时， 并创建  对应object对象。

先去缓存里面判断一下beanName对应的对象已经创建好了    这里需要创建一个全局的 bean

 private Map<String, Object> beanMap = new ConcurrentHashMap<>();

构建的方式有三种：构造函数、静态工厂、成员工厂  在进行判断是否  创建 bean等功能

  @Override
    public Object getBean(String beanName) throws Exception 
        return doGetBean(beanName);
    

    private Object doGetBean(String beanName) throws Exception 
        Objects.requireNonNull(beanName, "beanName不能为空");

        // 先去缓存里面判断一下beanName对应的对象已经创建好了
        Object bean = beanMap.get(beanName);
        if(bean != null) return bean;
        
        // 构建的方式有三种：构造函数、静态工厂、成员工厂
        BeanDefinition bd = beanDefinitionMap.get(beanName);
        Objects.requireNonNull(bd, "找不到["+beanName+"]的bean定义信息");
        Class<?> type = bd.getBeanClass();
        if(type != null)
            // 通过构造函数
            if(StringUtils.isBlank(bd.getFactoryMethodName())) 
                bean = createBeanByConstructor(bd);
            else // 通过静态工厂方式构建对象
                bean = createBeanByStaticFactory(bd);
            
        else
            // 成员工厂方式构建对象
            bean = createBeanByFactoryBean(bd);
        
        
        // 开始Bean生命周期
        if(StringUtils.isNotBlank(bd.getInitMethod())) 
            doInitMethod(bean, bd);
        
        
        // 对单例bean的处理
        if(bd.isSingleton())
            beanMap.put(beanName, bean);
        
        
        return bean;
    

通过判断beanclass去判断  使用构造方法去创建对应的 类。

    private Object createBeanByConstructor(BeanDefinition bd) throws Exception 
        Object instance = bd.getBeanClass().newInstance();
        return instance;
    

通过静态工厂方式构建对象 因为是静态方法  则可以采用直接采用 class.getmethod获取到  invoke方法。

  private Object createBeanByStaticFactory(BeanDefinition bd) throws Exception 
        Class<?> type = bd.getBeanClass();
        Method method = type.getMethod(bd.getFactoryMethodName(), null);
        return method.invoke(type, null);
    

成员工厂方式构建对象  要获取到 factorybean  通过getbean的方式去获取。

   private Object createBeanByFactoryBean(BeanDefinition bd) throws Exception 
        String factoryBeanName = bd.getFactoryBeanName();
        Object factoryBean = getBean(factoryBeanName);
        Method method = factoryBean.getClass()
                .getMethod(bd.getFactoryMethodName(), null);
        return method.invoke(factoryBean, null);
    

最终去创建出一个正常的bean出来。

以及  最后的  开始Bean生命周期

  // 开始Bean生命周期
        if(StringUtils.isNotBlank(bd.getInitMethod())) 
            doInitMethod(bean, bd);
        
        

  private void doInitMethod(Object bean, BeanDefinition bd) throws Exception 
        Method method = bean.getClass().getMethod(bd.getInitMethod(), null);
        method.invoke(bean, null);
    

对单例bean的处理

 // 对单例bean的处理
        if(bd.isSingleton())
            beanMap.put(beanName, bean);
        

这里都需要作的操作。

最后添加针对单例Bean执行销毁方法 

@Override
    public void close() throws IOException 
        // 针对单例Bean执行销毁方法
        for(Map.Entry<String, BeanDefinition> e : beanDefinitionMap.entrySet()) 
            String beanName = e.getKey();
            BeanDefinition definition = e.getValue();
            
            if(definition.isSingleton() && StringUtils.isNotBlank(definition.getDestroyMethod())) 
                Object instance = beanMap.get(beanName);
                if(instance == null) continue;
                
                Method m = null;
                try 
                    m = instance.getClass().getMethod(definition.getDestroyMethod(), null);
                    m.invoke(instance, null);
                 catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException ex) 
                    ex.printStackTrace();
                
            
        
    

设计一个简单的 ioc容器 。

DI分析

这里就涉及到依赖的分析，包括构造参数依赖 属性依赖  。

依赖注入的本质 是给入构造参数值，给属性赋值

因为赋值，才要考虑怎么 赋值给某个值。

对于参数值、属性值  有可能是 直接值、bean依赖

对于这种构造参数 的注入  需要找到依赖关系。

直接值会有哪几种情形   这里对于 mybatis等比较热的框架都会考虑的事情。

• 基本数据类型值、String
• 数组、集合
• Properties
• map

本质：参数值、属性值，都是值。bean工厂在进行依赖注入时，就是给入值。

在DI设计时，如何告诉bean工厂该给入什么构造参数值？即如何来定义参数依赖？  

如何来定义属性依赖？  

对于构造参数的值，如何去定义。

这都需要如何怎么去解决这个问题。

如何考虑 这些构造参数 ，怎么进行依赖设计。

参数可以多个，用什么存储

• 集合：List

按参数顺序放入List  顺序来表示  参数得顺序。

参数值可以是直接值，也可以是bean依赖，如何表示：Object?

• 可以，也只能用Object了。
• List<Object> constructorArgumentValues

如果用Object来表示值，如何区分是Bean依赖？

为Bean依赖定义一种数据类型 （BeanReference），bean工厂在构造Bean实

例时，遍历判断参数是否是BeanReference， 如是则替换为依赖的bean实例。

/**
 * 表示Bean依赖的类
 */
public class BeanReference 
    private String beanName;
    public BeanReference(String beanName) 
        this.beanName = beanName;
    

    public String getBeanName() 
        return beanName;
    

如果直接值是数组、集合等，它们的元素中有的是bean依赖，怎么处理？

  元素值还是用BeanReference，同样bean工厂 在使用时需遍历替换。

在BeanDefinition中增加获得构造参数值的接口

DI实现

首先需要把bean定义中的构造参数引用转为真实的值，在DefaultBeanFactory中增加一个方法来干这事。

使用 getConstructorArgumentValues  方法去转换成真实得事情。

    private Object[] getConstructorArgumentValues(BeanDefinition bd) throws Exception 
        List<?> args = bd.getConstructorArgumentValues();
        return getRealVaues(args);
    

 整个值的解析转换。

这里对于ioc进行创建出来的对象， 如果带有参数的情况。 则需要 创建类进行修改。

    private Object createBeanByConstructor(BeanDefinition bd) throws Exception 
        Object instance = null;
        if(CollectionUtils.isEmpty(bd.getConstructorArgumentValues())) 
            instance = bd.getBeanClass().newInstance();
        else
            Object[] args = getConstructorArgumentValues(bd);
            if(args == null) 
                instance = bd.getBeanClass().newInstance();
            else 
                return determineConstructor(bd, args).newInstance(args);
            
        
        return instance;
    

找对应的构造函数，有参数了，如何断定是哪个构造方法、哪个工厂方法

• 方法是可以重载的

• 形参定义时可能是接口或父类，实参则是具体的子实现

• 反射提供的获取的构造方法、方法的API

判断逻辑：

•  1 先根据参数的类型进行精确匹配查找，如未找到，则进行第2步查找；
•  2获得所有的构造方法，遍历，通过参数数量过滤，再比对形参类型与实参类型。

determineConstructor  用来判断  选择使用那个构造参数。

包括 创建 一个方法

  private Constructor determineConstructor(BeanDefinition bd, Object[] args) throws Exception 

找到无参构造方法  进行判断返回

 Constructor ct = null;
        if(args == null) return bd.getBeanClass().getConstructor(null);
        Class<?>[] paramType = new Class[args.length];

对于原型Bean，从第二次开始获取Bean实例时，可以直接从第一次缓存中获取构造方法

        // 对于原型Bean，从第二次开始获取Bean实例时，可以直接从第一次缓存中获取构造方法
        ct = bd.getConstructor();
        if(ct != null) return ct;

根据参数类型获取构造方法

  int j = 0;
        for(Object p : args) 
            paramType[j++] = p.getClass();
        

找到对应的class.

 根据 类型 找到 对应的构造方法

ct = bd.getBeanClass().getConstructor(paramType);

当没找到 时，遍历所有的 构造参数，判断形参跟实参进行类型匹配 

 if(ct == null) 
            Constructor<?>[]  cts = bd.getBeanClass().getConstructors();
            // 判断逻辑：先判断参数数量，依次判断形参跟实参进行类型匹配
            outer: for(Constructor<?> c : cts) 
                Class<?>[] paramterTypes = c.getParameterTypes();
                if(paramterTypes.length == args.length) 
                    for(int i = 0; i < paramterTypes.length; i++) 
                        if(!paramterTypes[i].isAssignableFrom(args[i].getClass())) 
                            continue outer;
                        
                    
                    ct = c;
                    break outer;
                
            
        

最后进行调用构造方法

 if(ct != null) 
            if(bd.isPrototype()) 
                bd.setConstructor(ct);
            
        else 
            throw new Exception("找不到对应的构造方法："+bd);
        

这里主要两点 主要是要怎么确认 对于bean参数的类型怎么用来区分，以及构造实例时，对参数怎么判断，选择使用那个构造参数 ，判断的逻辑就是 先根据参数的类型进行精确匹配查找，找到了最好，如果找不到 则对比形参类型与实参类型，进行判断。

当我们判断出构造方法或工厂方法后，对于原型Bean,下次获取Bean是否就可以省去

判断了？

也就是说，对于原型bean，我们可以缓存下这个构造方法或工厂方法。

这都需要做的。

  private Object createBeanByStaticFactory(BeanDefinition bd) throws Exception 
        Class<?> type = bd.getBeanClass();
        Object[] realArgs = getRealVaues(bd.getConstructorArgumentValues());
        Method method = determineFactoryMethod(bd, realArgs, type);
        return method.invoke(type, realArgs);
    

determineFactoryMethod 也需要判断具体的方法

 循环依赖如何处理 

构造实例对象时的循环依赖，会陷入僵死局面，是不允许构造实例时的循环依赖的。如何发

现循环依赖？

加入一个正在构造的bean的记录，每个bean开始构造时加入到该记录中，构造完成后

从记录中移除。如果有依赖，先看依赖的bean是否在构造中，如是就构成了循环依赖，抛出异常

属性依赖

某个属性依赖某个值

描述属性依赖

定义属性依赖描述实体类PropertyValue   ，对于多个依赖，则 采用list来存储，

/**
 * 属性值类型，用作属性依赖注入
 */
public class PropertyValue 
    private String name;
    private Object value;

    public PropertyValue(String name, Object value) 
        super();
        this.name = name;
        this.value = value;
    

    public String getName() 
        return name;
    

    public void setName(String name) 
        this.name = name;
    

    public Object getValue() 
        return value;
    

    public void setValue(Object value) 
        this.value = value;
    

创建bean成功过后，需要 执行      setPropertyDIVAlues(bd, bean); 完成属性注入。

 private void setPropertyDIVAlues(BeanDefinition bd, Object instance) throws Exception 
        if (CollectionUtils.isEmpty(bd.getPropertyValues())) 
            return;
        
        for (PropertyValue pv : bd.getPropertyValues()) 
            if (StringUtils.isBlank(pv.getName())) 
                continue;
            
            Class<?> clazz = instance.getClass();
            Field p = clazz.getDeclaredField(pv.getName());

            p.setAccessible(true);

            Object rv = pv.getValue();
            Object v = null;
            if (rv == null) 
                v = null;
             else if (rv instanceof BeanReference) 
                v = this.doGetBean(((BeanReference) rv).getBeanName());
             else if (rv instanceof Object[]) 
                // TODO 处理集合中的bean引用
             else if (rv instanceof Collection) 
                // TODO 处理集合中的bean引用
             else if (rv instanceof Properties) 
                // TODO 处理properties中的bean引用
             else if (rv instanceof Map) 
                // TODO 处理Map中的bean引用
             else 
                v = rv;
            

            p.set(instance, v);

        
    

针对属性注入是相对来说简单的。只需要判断需要引入的类型就可以。