Spring---Spring IOC与DI

亦凉 2022-10-27 02:27 167阅读 0赞

什么是IOC？

控制反转（Inversion of Control，缩写为IoC），是[面向对象编程][Link 1]中的一种设计原则，可以用来减低计算机代码之间的[耦合度][Link 2]。其中最常见的方式叫做[依赖注入][Link 3]（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup）。通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。---百度百科

什么是DI？

所谓依赖注入（Dependency Injection），就是由IOC容器在运行期间，动态地将某种依赖关系注入到对象之中。

举例：

举一个现实中的例子，我们要设计汽车：先设计轮子，根据轮子大小设计底盘，然后根据底盘设计车身，最后根据车身设计完成整个汽车。这时候设计汽车的各个步骤间就存在着强依赖关系：汽车依赖车身，车身依赖底盘，底盘依赖轮子。

对应代码：

//轮胎类
    public class Tire {
        private int size;
        public Tire(){
           this.size=50;
           System.out.println("轮胎尺寸为"+size);
        }
    }

//底盘类
    public class Chassis{
        private Tire tire;
        public Chassis(){
            this.tire=new Tire();
        }
    }

//车身类
    public class Bodywork {
        private Chassis chassis;
        public Bodywork (){
            this.chassis=new Chassis ();
        }
    }

//测试类
    public class Test {
        public static void main(String[] args) {
            Car mycar=new Car();
            mycar.run();
        }
    }

执行结果：

![20210203192201149.png][]

现在看似没有任何的问题，但是市场需求变了，要把车轮改大，这样能提高速度。

对应代码：

//轮胎类
    public class Tire {
        private int size;
        public Tire(int size){
           this.size=size;
           System.out.println("轮胎尺寸为"+size);
        }
    }

//底盘类
    public class Chassis{
        private Tire tire;
        public Chassis(int size){
            this.tire=new Tire(size);
        }
    }

//车身类
    public class Bodywork {
        private Chassis chassis;
        public Bodywork (int size){
            this.chassis=new Chassis (size);
        }
    }

//测试类
    public class Test {
        public static void main(String[] args) {
            int size=50;
            Car mycar=new Car();
            mycar.run();
        }
    }

执行结果：

![20210203192211622.png][]

之前我们是根据轮子大小设计的底盘，此时轮子大小变化，底盘的大小也必须修改，同样的道理，车身也要进行修改，整体看来，整个设计全部都要修改。很显然，严重违反了开放封闭的设计原则，在实际的项目中，一个类的依赖项可能会有很多，如果要修改，我们可能需要修改成千上万的类，代码维护成本太高，这是不可取的。

如何解决这个问题呢？此时， 我们需要进行控制反转（Inversion of Control），通过依赖注入（Dependency Injection）的方式实现。

//轮胎类
    public class Tire {
        private int size;
        Tire(int size){
            this.size=size;
        }
    }

//底盘类
    public class Chassis{
        private  Tire tire;
        Chassis(Tire tire){
            this.tire=tire;
        }
    }

//车身类
    public class Bodywork{
        private Chassis chassis;
        Bodywork(Chassis chassis){
            this.chassis=chassis;
        }
    }

//测试类
    public class Test {
        public static void main(String[] args) {
          mycar.run();
          int size=50;
          Tire tire=new Tire(size);
          Chassis chassis=new Chassis(tire);
          Bodywork bodywork=new Bodywork(chassis);
          Car mycar=new Car(bodywork);
          mycar.run();
        }
    }

执行结果：

![20210203192211622.png][]

刚刚上面已经公布了答案，我们是通过依赖注入的方式来实现的控制反转。其实就是把底层类作为参数传入上层，从而实现了上层类对下层类的“控制”，让原本上层依赖下层转换为下层依赖上层。

[Link 1]: https://baike.baidu.com/item/%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1%E7%BC%96%E7%A8%8B/254878
[Link 2]: https://baike.baidu.com/item/%E8%80%A6%E5%90%88%E5%BA%A6/2603938
[Link 3]: https://baike.baidu.com/item/%E4%BE%9D%E8%B5%96%E6%B3%A8%E5%85%A5/5177233
[20210203192201149.png]: /images/20221024/55addbcb23074ebf9f2218e10e4e0abe.png
[20210203192211622.png]: /images/20221024/9ee92d692b6644af8067b43328037e2a.png