1. Spring 核心与设计思想

1. Spring 是什么？

1.1 什么是容器？

1.2 什么是 Ioc ？

1.2.1 传统程序开发

1.2.2 解决传统开发的缺陷

1.2.3 控制反转式程序开发

1.2.4 IoC 的实现思想（重点）

1.3 理解 Spring Ioc

1.4 DI 概念说明

1. Spring 是什么？

Spring 指的是 Spring Framework （spring 框架），它是一个开源框架，有着活跃而庞大的社区，这就是它之所以能长久不衰的原因。

Spring 是包含了众多工具方法的 IoC 容器。

1.1 什么是容器？

容器是用来容纳某种物品的装置。

List/Map -> 数据存储容器
Tomcat -> Web容器

1.2 什么是 Ioc ？

IoC = Inversion of Control 即 控制反转，也就是说 Spring 是一个“控制反转”的容器。

1.2.1 传统程序开发

是通过一层一层的依赖实现的。比如我们要构建一辆车，需要依赖车身，车身进而需要依赖底盘，底盘又需要依赖轮胎。因此一般的实现代码如下：

在 NewCarUpateExample 类中：

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

首先，我们先创建一个汽车对象：

/*** 汽车对象*/
public class Car {public void init(){// 依赖车身Framework framework = new Framework();framework.init();}
}

由于汽车对象需要依赖车身，因此我们创建一个车身类：

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

又因为车身依赖于底盘，因此创建底盘类：

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

最后，因为底盘依赖于轮胎，因此创建轮胎类：

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

在以上程序中，轮胎的尺寸是固定的，但是实际中根据各种需求，轮胎的尺寸也会发生变化，因此修改代码如下：

在 NewCarUpateExample 类中：

public class NewCarUpateExample {public static void main(String[] args) {Car car = new Car(20);car.run();}
}

/*** 汽车对象*/
public class Car {private Framework framework;public Car(int size){framework = new Framework(size);}public void run(){// 依赖车身framework.init();}
}

/*** 车身类*/
public class Framework {private Bottom bottom;public Framework(int size){bottom = new Bottom(size);}public void init(){// 依赖底盘bottom.init();}
}

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

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

从以上代码可以看出：当最底层的代码修改后，其他层的代码均需要进行修改。

1.2.2 解决传统开发的缺陷

如何解决代码之间的耦合性过高的问题呢？

我们只需要将原来自己创建的下级类，改为传递的方式（也就是注入），因为我们不需要在当前类中创建下级类，所以下级类发生变化时，当前类本身就无需再进行修改，这样就完成了程序的解耦。

1.2.3 控制反转式程序开发

接下来，在上述程序的基础上，我们将创建子类的方式改为注入传递的方式。

public class IocCarExample {public static void main(String[] args) {Tire tire = new Tire(20);Bottom bottom = new Bottom(tire);Framework framework = new Framework(bottom);Car car = new Car(framework);car.run();}
}

/*** 汽车对象*/
public class Car {private Framework framework;public Car(Framework framework){this.framework = framework;}public void run(){// 依赖车身framework.init();}
}

/*** 车身类*/
public class Framework {private Bottom bottom;public Framework(Bottom bottom){this.bottom = bottom;}public void init(){// 依赖底盘bottom.init();}
}

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

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

代码经过以上调整之后，无论底层如何变化，整个调用链是不用做任何改变的，这样就完成了代码之间的解耦。

1.2.4 IoC 的实现思想（重点）

在传统代码中对象创建的规律是：Car -> Framework -> Bottom -> TIre

改进之后解耦的代码的对象创建顺序是：TIre -> Bottom -> Framework -> Car

改进之后的控制权发生的反转，不再是上级对象创建并控制下级对象了，而是把下级对象注入当前对象中，下级的控制权不再由上级类控制了，这样即使下级类发⽣任何改变，当前类都是不受影响的，这就是典型的控制反转，也就是 IoC 的实现思想。

（对于依赖对象的管理的控制权反转，通过 Spring 来管理对象的生命周期。不是所有的对象都交给 Spring 管理，需要程序来告诉 Spring 管理哪些对象）。