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

​ 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/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 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();
                return instance;
            }
        }
        return null;
    }
}

测试类：

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);
    }
}

测试结果截图：

从代码里面可以看出来，我们是没有直接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);
    }
}

测试结果截图：

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