什么是控制反转(IoC)？什么是依赖注入（DI）？以及实现原理

分手后的思念是犯贱 2022-05-10 02:08 296阅读 0赞

IoC不是一种技术，只是一种思想，一个重要的面向对象编程的法则，它能指导我们如何设计出松耦合、更优良的程序。传统应用程序都是由我们在类内部主动创建依赖对象，从而导致类与类之间高耦合，难于测试；有了IoC容器后，把创建和查找依赖对象的控制权交给了容器，由容器进行注入组合对象，所以对象与对象之间是松散耦合，这样也方便测试，利于功能复用，更重要的是使得程序的整个体系结构变得非常灵活

IoC很好的体现了面向对象设计法则之一—— 好莱坞法则：“别找我们，我们找你”；即由IoC容器帮对象找相应的依赖对象并注入，而不是由对象主动去找

DI—Dependency Injection，即“依赖注入”：是组件之间依赖关系由容器在运行期决定，形象的说，即由容器动态的将某个依赖关系注入到组件之中。依赖注入的目的并非为软件系统带来更多功能，而是为了提升组件重用的频率，并为系统搭建一个灵活、可扩展的平台。通过依赖注入机制，我们只需要通过简单的配置，而无需任何代码就可指定目标需要的资源，完成自身的业务逻辑，而不需要关心具体的资源来自何处，由谁实现。

理解DI的关键是：“谁依赖谁，为什么需要依赖，谁注入谁，注入了什么”，那我们来深入分析一下：

●谁依赖于谁：当然是应用程序依赖于IoC容器；

●为什么需要依赖：应用程序需要IoC容器来提供对象需要的外部资源；

●谁注入谁：很明显是IoC容器注入应用程序某个对象，应用程序依赖的对象；

●注入了什么：就是注入某个对象所需要的外部资源（包括对象、资源、常量数据）

**本质上IoC和DI是同一思想下不同维度的表现** ,用通俗的话说就是，IoC是bean的注册，DI是bean的初始化

源码实现原理：

参考文章：

[https://blog.csdn.net/lisongjia123/article/details/52129340][https_blog.csdn.net_lisongjia123_article_details_52129340]

[https://blog.csdn.net/lisongjia123/article/details/52134396][https_blog.csdn.net_lisongjia123_article_details_52134396]

上面的文章根据源码进行分析，过程比较复杂，因此我进行了一个高度的抽象，希望来描述它们的实现原理：

简单的IoC控制反转代码实现，定义测试的Bean,Student和Teacher

public class Teacher {
        private String tName;
        // ....get set方法省略
    }
    
    public class Student {
        private String name;
        private String age;
        private Teacher teacher;
        // ....get set方法省略
    }

BeanDefined类，对bean的描述类：

public class BeanDefined {
        
        // bean的id
        private String beanId;
        
        // bean的文件路径
        private String classPath;
    
        public String getBeanId() {
            return beanId;
        }
        public void setBeanId(String beanId) {
            this.beanId = beanId;
        }
        public String getClassPath() {
            return classPath;
        }
        public void setClassPath(String classPath) {
            this.classPath = classPath;
        }
    }

BeanFactory --- 生成Bean的容器类：

测试类：

public class Test {
        public static void main(String[] args) throws Exception {
            // 1、声明注册bean
            BeanDefined beanObj = new BeanDefined();
            beanObj.setBeanId("student");
            beanObj.setClassPath("com.pojo.Student");
            List<BeanDefined> beanList = new ArrayList<BeanDefined>();
            beanList.add(beanObj);
    
            // 2、声明一个BeanFactory，类似于Spring中的ApplicationContext
            BeanFactory factory = new BeanFactory();
            factory.setBeanDefinedList(beanList);
    
            // 3、开发人员向BeanFactory索要实例对象
            Student student = (Student) factory.getBean("student");
            System.out.println(student);
        }
    }

测试结果截图：

![70][]

从代码里面可以看出来，我们是没有直接new学生类的，主要的思想是，定义BeanDefined对象添加进集合中，通过BeanFactory为我们生产出需要的对象，其中用到的核心技术就是：反射

用代码实现简单的依赖注入：

BeanDefined类需要做一定的修改：

public class BeanDefined {
        // bean的id
        private String beanId;
        // bean的文件路径
        private String classPath;
        // 存放属性的集合
        private Map<String, String> propertyMap = new HashMap<>(); 
        
        // ....省略set和get方法
    }

BeanFactory类需要做如下的修改:

public class BeanFactory {
    
        // 存放bean的集合
        private List<BeanDefined> beanDefinedList; 
    
        public List<BeanDefined> getBeanDefinedList() {
            return beanDefinedList;
        }
    
        public void setBeanDefinedList(List<BeanDefined> beanDefinedList) {
            this.beanDefinedList = beanDefinedList;
        }
    
        /**
         * 获取bean实例
         *
         * @param beanId
         * @return
         * @throws Exception
         */
        public Object getBean(String beanId) throws Exception {
            Object instance;
            for (BeanDefined bean : beanDefinedList) {
                if (beanId.equals(bean.getBeanId())) {
                    String classPath = bean.getClassPath();
                    Class classFile = Class.forName(classPath);
                    // 在spring中调用默认的构造方法，这里我们也调用默认的构造方法
                    instance = classFile.newInstance();
                    // 获取bean的属性配置
                    Map<String, String> propertyMap = bean.getPropertyMap();
                    if(propertyMap !=null) {
                        setValue(instance, classFile, propertyMap);
                    }
                    return instance;
                }
            }
            return null;
        }
    
        /**
         * 依赖注入的方法
         *
         * @param instance    当前的实例对象
         * @param classFile   当前实例对象所关联的类文件
         * @param propertyMap 属性
         */
        public void setValue(Object instance, Class classFile, Map<String, String> propertyMap) throws Exception {
            if(propertyMap !=null ) {
                /***
                 * 获取map的所有属性配置
                 */
                Set<String> proper = propertyMap.keySet();
                for(String string : proper) {
                    // 通过字符串拼接，拼出set方法名
                    char c = string.toUpperCase().charAt(0);
                    String s = "set" + c + string.substring(1);
                    // 获取当前属性的类型
                    Field field = classFile.getDeclaredField(string);
                    // 根据属性的类型进行调用
                    Method m = instance.getClass().getMethod(s, field.getType());
                    /**
                     * 直接try注入普通类型，或者catch注入bean工厂中的其他类型
                     */
                    try {
                        m.invoke(instance, propertyMap.get(string));
                    } catch (Exception e) {
                        m.invoke(instance, getBean(propertyMap.get(string)));
                    }
                }
            }
        }
    }

测试类代码需要做如下修改：

public class Test {
        public static void main(String[] args) throws Exception {
            // 1、声明注册bean
            BeanDefined beanObj = new BeanDefined();
            beanObj.setBeanId("student");
            beanObj.setClassPath("com.pojo.Student");
            // 设置 property
            Map<String, String> propertyMap = beanObj.getPropertyMap();
            propertyMap.put("name", "kxm");
            propertyMap.put("age", "22岁");
            propertyMap.put("teacher", "teacher");
            // 注册教师类
            BeanDefined teacher = new BeanDefined();
            teacher.setBeanId("teacher");
            teacher.setClassPath("com.pojo.Teacher");
            List<BeanDefined> beanList = new ArrayList<BeanDefined>();
            beanList.add(beanObj);
            beanList.add(teacher);
            
            // 2、声明一个BeanFactory，类似于Spring中的ApplicationContext
            BeanFactory factory = new BeanFactory();
            factory.setBeanDefinedList(beanList);
    
            // 3、开发人员向BeanFactory索要实例对象
            Student student = (Student) factory.getBean("student");
            System.out.println(student);
        }
    }

测试结果截图：

![70 1][]

仔细分析代码，我们可以发现，没有显示的new对象，也没用用set方法去赋值，但是模拟出来了依赖注入的效果，这也是Spring中依赖注入的原理，当然这里是最简单的实现，剩下的路，还需要骚年你自己走哇~

[https_blog.csdn.net_lisongjia123_article_details_52129340]: https://blog.csdn.net/lisongjia123/article/details/52129340
[https_blog.csdn.net_lisongjia123_article_details_52134396]: https://blog.csdn.net/lisongjia123/article/details/52134396
[70]: /images/20220510/2b2415b7d73e43e3add7f96fa22a12af.png
[70 1]: /images/20220510/c2aeaacfe53b45deaea5e9de030c22ba.png