学习框架相当于从小作坊到工厂的升级，小作坊是什么都要做，工厂是组装式装配，特点就是效率高，且框架更易于使用，因此对于Spring的学习是大势所趋。

Spring是什么

Spring指的是 Spring Framework（Spring 框架），它是⼀个开源框架，有着活跃⽽庞⼤的社区，这就是它之所以能⻓久不衰的原因。Spring ⽀持⼴泛的应⽤场景，它可以让 Java 企业级的应⽤程序开发起来更简单。

Spring是一个包含了众多工具的Ioc容器。

Ioc = Inversion of Control，翻译成中文就是"控制反转"的意思，也就是说Spring是一个控制反转的容器。

传统的构建开发

以构造一辆汽车为例,初始情况下，每辆车的需求都是相同的

public class CarTest {
    public static void main(String[] args) {
        Car car = new Car();
        car.init();
    }
}

/**
 * 车 依赖车身
 */
class Car{
    public void init(){
        FrameWork frameWork = new FrameWork();
        frameWork.init();
    }
}

/**
 * 车身 依赖底盘
 */
class FrameWork{
    public void init(){
        Bottom bottom = new Bottom();
        bottom.init();
    }
}

/**
 * 底盘 依赖于轮胎
 */
class Bottom{
    public void init(){
        Tire tire = new Tire();
        tire.init();
    }
}

class Tire{
    private int size = 15;
    public void init(){
        System.out.println("轮胎尺寸" + 15);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

随着时间推移，人们不在满足只有一种类型的车辆，个性化需求越来越多，我们假设只更改了轮胎尺寸，那么代码：

我们可以清楚的看到当底层代码发生更改时，整个调用链的代码都需要修改。

如何解决上述问题？
我们可以尝试不在每个类中自己创建下级类，如果自己创建下级类就会出现当下级类发生改变操作，自己也要跟着修改。此时，我们只需要将原来由自己创建的下级类，改为传递的方式（也就是注入的方式），因为我们不需要在当前类中创建下级类了，所以下级类即使发生变化（创建或减少参数），当前类本身也无需修改任何代码，这样就完成了程序的解耦。

控制反转式程序开发

public class CarTest {

    public static void main(String[] args) {
        Tire tire = new Tire(10,"猛男粉");
        Bottom bottom = new Bottom(tire);
        FrameWork frameWork = new FrameWork(bottom);
        Car car = new Car(frameWork);
        car.init();
    }
}

class Car{
    private FrameWork frameWork;
    public Car(FrameWork frameWork){
        this.frameWork = frameWork;
    }
    public void init(){
        frameWork.init();
    }
}

class FrameWork{
    private Bottom bottom;
    public FrameWork(Bottom bottom){
        this.bottom = bottom;
    }
    public void init(){
        bottom.init();
    }
}

class Bottom{
    private Tire tire;

    public Bottom(Tire tire){
        this.tire = tire;
    }

    //初始化轮胎
    public void init(){
        tire.init();
    }
}

class Tire{
    private int size;
    private String color;
    public Tire(int size,String color){
        this.size = size;
        this.color = color;
    }
    public void init(){
        System.out.println("轮胎尺寸" + size + " 轮胎颜色 " + color);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

代码经过以上调整，无论底层类如何变化，整个调用链是不用做任何改变的，只需创建底层类时增添或修改参数，这样就完成了代码之间的解耦，从而实现了更加灵活、通用的程序设计了。

我们发现了⼀个规律：通⽤程序的实现代码，类的创建顺序是反的，传统代码是Car 控制并创建了Framework，Framework创建并创建了Bottom，依次往下，⽽改进之
后的控制权发⽣的反转，不再是上级对象创建并控制下级对象了，而是下级将对象注
入到当前对象中，下级的控制权不再由上级类控制了，这样即使下级类发生任何改
变，当前类都是不受影响的，这就是典型的控制反转，也就是IoC的实现思想。

理解Spring Ioc

既然说Spring是一个包含了众多工具的Ioc容器，那么重点还是在容器上面，那么它就具备两个最基本的功能：

• 将对象存入到Spring中
• 将对象从Spring中取出来

也就是说Spring最核心的功能就是上述两条~

Spring 是⼀个 IoC 容器，说的是对象的创建和销毁的权利都交给 Spring 来管理了，它本身⼜具备了存储对象和获取对象的能⼒。

DI

说到Ioc，就不得不说DI了，DI 是 Dependency Injection 的缩写，翻译成中⽂是“依赖注⼊”的意思。

所谓依赖注⼊，就是由 IoC 容器在运⾏期间，动态地将某种依赖关系注⼊到对象之中。

说清楚点就是，Ioc是一个思想，而DI是这个思想的一种实现方式~

所以，依赖注入（DI）和控制反转（IoC）是从不同的角度的描述的同一件事情，就是指通过引入IoC 容器，利用依赖关系注入的方式，实现对象之间的解耦。