Spring依赖注入与反转控制到底是个啥？

1. 引言

此文目的是用通俗易懂的语言讲清楚什么是依赖注入与反转控制，在看了大量的博客文章后归纳总结，便于后续巩固！我相信，大多数人像我一样，刚开始学习Spring框架的时候仅仅是在学习技术，记住如何做而非为何如此做。因此，本文结合生活例子与项目实际问题入手，讲清楚Spring入门的两个概念。其中，第二篇章管中窥豹需要具备Spring基础知识，你不用非常理解但至少你知道怎么写依赖注入。

2. 管中窥豹

话说，有一天蟹老板想开个餐馆，可是开什么店好呢？他列出了几个选择，牛排店、蟹肉煲店、炸鸡店，火锅店，他非常纠结。于是海绵宝宝告诉他你可以春天卖牛排、夏天卖蟹肉堡、秋天换卖炸鸡，冬天卖火锅。于是，蟹老板接纳了海绵宝宝的意见。春天到了，蟹老板叫海绵宝宝开发了一套店内点餐系统，于是海绵宝宝定义了如下代码：

public interface Chef {
    public void cook(); // 厨师长做菜
    public void sing(); // 厨师长唱歌
}

并且从海底世界招聘到了张三厨师长，张三厨师长很擅长做牛排，尤其是黑椒牛排一绝，他也喜欢唱歌，因此海绵宝宝写下了如下代码：

public class ZhangChef implements Chef {
    String name;
    int age;

    public ZhangChef(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public void cook() {
        System.out.println(name+"正在做黑椒牛排...");
    }
    @Override
    public void sing() {
        System.out.println(name+"唱着伤不起...");
    }
}

最后，在我们的蟹老板的英明带领下，嘉年华顺利开店：

public class Restaurant {
    private String name;
    private String specialty;

    Restaurant(String name, String specialty) {
        this.name = name;
        this.specialty = specialty;
    }

    public void kitchen(){
        ZhangChef zhang = new ZhangChef("张三",26);
        System.out.println("我们的厨师长是："+zhang.name+",今年高龄："+zhang.age);
        zhang.cook(); //厨师做菜
    }

}

运行结果>>>  我们的厨师长是：张三,今年高龄：26
            张三正在做黑椒牛排...

这三个月过的很快，蟹老板也赚了很多钱，海绵宝宝更是成为了本店的CTO，大家其乐融融，一片安好。可是明天就到了夏天，餐厅更换业务，开始经营蟹肉煲，于是张三厨师长被毕业了，李四厨师长正好擅长蟹肉煲，我们的厨师长现在换成了李四。晚上十点钟，海绵宝宝正在加班加点改代码，他需要把整个系统的厨师长换成李四，这是他换好的第一个文件：

public class LiChef implements Chef {
    String name;
    int age;
    public LiChef(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public void cook() {
        System.out.println(name+"正在做蟹肉煲...");
    }
    @Override
    public void sing() {
        System.out.println(name+"唱着撒浪嘿呦...");
    }
}

然后，他需要把整个系统所有方法的zhangChef换成LisiChef，海绵宝宝工作了一夜，第二天依旧没有改完，直到改了半个月后才把整个系统的Chef换完，于是海绵宝宝丢了CTO的职位，成为了普通打工仔程序员。海绵宝宝很不甘心，他辞去了工作，专心研究这个问题如何解决。他发现，Chef 类需要在 Restaurant 类中被实例化，他认为 Restaurant 过于依赖 Chef 了，这不是废话吗？餐厅当然依赖与厨师了，一瞬间他灵机一动说：这种依赖关系是不可避免的，这样做是过度耦合的，我需要给他们解耦！Chef 的控制权并不应该由餐厅掌控，而应该是需要的时候由第三方空降，于是他把Chef 变成了 Restaurant 类的一个变量，Restaurant 不具备实例化他的能力，而是由第三方实例化好后直接赋值给Chef变量，于是他改写成如下代码：

public class Restaurant {
    private String name;
    private String specialty;
    private Chef chef;
    #=====================================
    public void setChef(Chef chef) {
        this.chef = chef;
    } 
    #=====================================
    Restaurant(String name, String specialty) {
        this.name = name;
        this.specialty = specialty;
    }
    public void kitchen(){ 
        #======================
        chef = 第三方力量直接空投 ;
        #======================
        System.out.println("我们的厨师长是："+chef.name+",今年高龄："+chef.age);
        chef.cook(); //厨师做菜
    }
}

如上面代码所示，第三方力量直接空投怎么实现呢？海绵宝宝思考了一夜，他想到了注射器，能不能像打针一样，把已经实例化好的Chef直接注射到 "chef = 第三方力量直接空投 ;"中的chef 呢？经过漫长的研究，海绵宝宝研发了一款框架，这种框架就是用来解决此问题，因为这是今年春天开始经历的困难，于是他把该框架命名成Spring。

3.1 Spring 依赖注入

他感悟道：如果一个类A 的功能实现需要借助于类B，那么就称类B是类A的依赖，如果在类A的内部去实例化类B，那么两者之间会出现较高的耦合，一旦类B出现了问题，类A也需要进行改造，如果这样的情况较多，每个类之间都有很多依赖，那么就会出现牵一发而动全身的情况，程序会极难维护，并且很容易出现问题。要解决这个问题，就要把A类对B类的控制权抽离出来，交给一个第三方去做，把控制权反转给第三方，就称 作控制反转（IOC Inversion Of Control）。控制反转是一种思想，是能够解决问题的一种可能的结果，而依赖注入（Dependency Injection）就是其最典型的实现方法。由第三方（我们称作IOC容器）来控制依赖，把他通过构造函数、属性或者工厂模式等方法，注入到类A内，这样就极大程度的对类A和类B 进行了解耦。

上面 "chef = 第三方力量直接空投 ;" 写成：

    ApplicationContext applicationContext = new
            ClassPathXmlApplicationContext("applicationContext.xml");
    Chef chef = (Chef) applicationContext.getBean("chef");

<bean id="chef" class="com.myjava.zhangChef"/>

这一步还不是依赖注入，只是使用Spring的API实例化对象。因为有setChef 方法，我们可以配置Spring容器调用set方法进行注入，如下才是依赖注入，Spring会自动调用setChef方法给chef设置实例对象，因此不需要上面那一句“chef = 第三方力量直接空投”。真正的空投看不见！

<bean id="chef" class="com.myjava.LiChef"/>
<bean id="restaurant" class="com.myjava.Restaurant">
    <property name="chef" ref="chef"/>
</bean>

如果A类需要使用B类，那么我们称为B是A的依赖，我们需要Spring容器（第三方）将依赖B的示例注射给A。因此，需要在Spring核心配置文件中声明控制权，将指定全限定名称的类的控制权（创建权）交给Spring管理，意味着我们可以通过Spring的getBean()实例化。如果类 chef 后期需要升级维护，我们只需要更改其中的代码或者指定其他的类全限定名称(class名称)。

3.2 Bean 的依赖注入方式有两种

①构造方法

创建有参构造

public class UserServiceImpl implements Userservice{
    private UserDao userDao;
    public UserServiceImpl(UserDao userDao){
        this.userDao = userDao;
    }
}

配置Spring容器调用有参构造时进行注入

<bean id="userDao" class="com.myjava.dao.impl.UserDaoImpl"/>
<bean id="userService" class="com.myjava.service.impl.UserServiceImpl">                     <constructor-arg name="userDao" ref="userDao"></constructor-arg>
</bean>

②set方法

在UserServiceImpl中添加setUserDao方法

public class UserServiceImpl implements UserService {
    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;  
        } 
    @Override    
    public void save() {      
            userDao.save();
    }
}

配置Spring容器调用set方法进行注入

<bean id="userDao" class="com.myjava.dao.impl.UserDaoImpl"/>
<bean id="userService" class="com.myjava.service.impl.UserServiceImpl">
    <property name="userDao" ref="userDao"/>
</bean>

4. 总结

依赖注入是反转控制的一种实现方法，我个人认为依赖外置比依赖注入更好理解，当然我可能理解的不太深刻有错误。因为原来的程序是直接在A里面实例化B，如果B变了那将导致很多业务代码需要改，这种依赖关系又是无法消除的，只能减弱这种依赖。那么，可以考虑将依赖写到配置文件中，需要的时候注入即可，这里将依赖写到配置文件可以说是依赖外置，但是Spring在运行时是实例化对象然后通过Set或者构造方法将其注入到A类中，因此，这是一个相对的说法。从A类角度出发是外置，从Spring角度是注入。以上内容参考了知乎胡小国博主的文章，感谢！以上内容有错误希望指正！