Spring的控制反转与依赖注入（IOC与DI）

引言

几段代码

现在我的手上有两个类：MainClass和ViceClass，并且两个类中都有同名的方法function，但是在ViceClass类中的function方法的实现需要调用MainClass类中的function方法。具体代码如下：

public class MainClass {
    public void function(){
        System.out.println("Print Something");
    }
}

public class ViceClass {
    public void function(){
        MainClass mainClass = new MainClass();
        mainClass.function();
    }
}

public class Main {
    public static void main(String[] args) {
        ViceClass viceClass = new ViceClass();
        viceClass.function();
    }
}

这样运行出来的代码就会输出"Print Something"。
分析一下： 当我们遇到这种情况，需要用ViceClass中的方法时，需要先去调用MainClass，这就是依赖关系

什么是依赖关系？
当a对象完成某些操作需要调用b对象中的方法来实现时，说明a依赖于对象b，a和b是依赖关系。

出现的问题-1

ViceClass类中MainClass对象的创建被写死在了ViceClass类的function方法中，当我们需要不同的MainClass时就无法更改，且不利于测试。

优化代码

为了让MainClass的创建不能被写死，我们可以在外部创建MainClass，再传入ViceClass的构造方法中。调整以后如下：

public class MainClass {
    public void function(){
        System.out.println("Print Something");
    }
}

public class ViceClass {
    
    private MainClass mainClass;
    
    public ViceClass(MainClass mainClass){
        this.mainClass = mainClass;
    }
    
    public void function(){
        mainClass.function();
    }
}

public class Main {
    public static void main(String[] args) {
        MainClass mainClass = new MainClass();
        ViceClass viceClass = new ViceClass(mainClass);
        viceClass.function();
    }
}

这样，MainClass的创建权就交给了使用者，你可以再Main.main中创建你想要的MainClass对象。

出现的问题-2

在上面的例子中，依赖的关系比较简单，仅仅是ViceClass依赖于MainClass，但当ViceClass需要依赖的类的个数变多时，这种优化方法就不行了，代码如下：

A a = new A(); 
C c = new C(); 
D d = new D(); 
E e = new E(); 
F f = new F();
 ... 
B b = new B(a,c,d,e,f,...);
b.m1();

使用者创建B对象之前，需要先将B依赖的对象都给创建好，然后B依赖的这些对象传递给B对象，如果有很多地方都需要用到B类型的对象，都采用这种new的写法，代码量比较大，也不方便维护，如果B中新增了依赖，又需采用new的方式先创建好被依赖的对象，然后将被依赖的对象填充给B对象。

上面创建对象之前，需要先将被依赖对象通过new的方式创建好，然后将其传递给B，这些工作都是B的使用者自己去做的，所有对象的创建都是由使用者自己去控制的，弊端上面也说了，代码量也比较大，代码耦合度比较高（依赖有调整，改动也比较大），也不利于扩展。

有没有什么解决方案？

那么有什么方法来解决这个问题呢？
在上面的方案中，不管是使用优化方案还是没有使用，一个对象的创建都是使用者去主动控制与创建的，那么能不能找一个第三方来把这个麻烦的事情来做了呢？
举个例子
当人们需要一件东西的时候，第一个反应就是找东西，例如想吃面包。在没有面包店的有面包店的两种情况下，你会怎么做？在没有面包店的情况下，最直观的做法就是按照自己的口味制作面包，也就是主动制作一个面包。然而如今面包店盛行，当你不想自己制作面包时可以去面包店，选择自己想要的面包。注意：你没有自己制作面包，而是由店家制作并且符合你的口味（也许吧😁）

控制反转（IoC）与依赖注入（DI）

Spring容器

这个Spring容器就好像刚刚提到的面包店，里面有各种各样的面包（bushi）。我们的程序启动的时候会创建一个Spring容器，会给Spring容器一个清单，清单中列出了需要创建的对象以及对象依赖关系，spring容器
会创建和组装好清单中的对象，然后将这些对象存放在spring容器中，当程序中需要使用的时候，可以到容器中查找获取，然后直接使用。

IOC控制反转

使用者之前使用B对象的时候都需要自己去创建和组装，而现在这些创建和组装都交给spring容器去给完成了，使用者只需要去spring容器中查找需要使用的对象就可以了；这个过程中B对象的创建和组装过程被反转了，之前是使用者自己主动去控制的，现在交给spring容器去创建和组装了，对象的构建过程被反转了，所以叫做控制反转；IOC是是面相对象编程中的一种设计原则，主要是为了降低系统代码的耦合度，让系统利于维护和扩展。

DI：依赖注入

依赖注入是spring容器中创建对象时给其设置依赖对象的方式，比如给Spring一个清单，需要创建B对象以及其他对象（可能包含B类型中需要依赖的对象），这时Spring在创建B的时候，会看B对象需要依赖于哪些对象，然后去查找一下清单中有没有包含这些被依赖的对象，如果有
就去将其创建好，然后将其传递给B对象；可能B需要依赖于很多对象，B创建之前完全不需要知道其他对象是否存在或者其他对象在哪里以及被他们是如何创建，而spring容器会将B依赖对象主动创建好并将其注入到B中去，比如spring容器创建B的时候，发现B需要依赖于A，那么spring容器在清单中找到A的定义并将其创建好之后，注入到B对象中。