如何理解Spring

用一句话概括：Spring是包含众多工作方法的IOC容器

怎么理解这句话？如何理解IOC？如何理解容器？

什么是IOC

IOC是Inversion of Control的缩写，译为“控制反转”。那什么是“控制反转”呢？
举个例子，我们要抽象一辆车，车依赖于车身，车身依赖于底盘，底盘依赖于车轮。

在没有使用spring之前，实现代码如下

public class Old {
	static class Car{
		private FrameWork frameWork;
		public Car(int size) {
			frameWork = new FrameWork(size);
		}
		public void init() {
			System.out.println("执行了car的init方法");
			frameWork.init();
		}
	}
	static class FrameWork{
		private Bottom bottom;
		public FrameWork(int size) {
			bottom = new Bottom(size);
		}
		public void init() {
			System.out.println("执行了frameWork的init方法");
			bottom.init();
		}
	}
	static class Bottom{
		private Tire tire;
		public Bottom(int size) {
			tire = new Tire(size);
		}
		public void init() {
			System.out.println("执行了bottom的init方法");
			tire.init();
		}
	}
	static class Tire {
		public int size;

		//此时添加一个属性
		//        public String color;
		//        public Tire(int size, String color) {
		//            this.size = size;
		//        }
		public Tire(int size) {
			this.size = size;
		}
		public void init() {
			System.out.println("轮胎尺寸：" + size);
		}
	}
	public static void main(String[] args) {
		Car car = new Car(30);
		car.init();
	}
}

如果给轮胎添加一个颜色属性，那么整个调用链都要进行改动，每个类的构造方法都需要进行调整，整个代码的耦合度就非常高了。在上述代码中对象的生命周期是由程序员来控制的，程序员new创建对象, 销毁对象。而如果引入IOC思想，将对象的创建，销毁的权利交给Spring，来Spring来帮我们管理对象，程序员就不用手动new对象，这个过程就是“控制反转”。
接下来利用IOC思想来改造上面代码

public class Ioc {
	static class Car{
		private FrameWork frameWork;
		public Car(FrameWork frameWork) {
			this.frameWork = frameWork;
		}
		public void init() {
			System.out.println("执行了car的init方法");
			frameWork.init();
		}
	}
	static class FrameWork{
		private Bottom bottom;
		public FrameWork(Bottom bottom) {
			this.bottom = bottom;
		}
		public void init() {
			System.out.println("执行了frameWork的init方法");
			bottom.init();
		}
	}
	static class Bottom{
		private Tire tire;
		public Bottom(Tire tire) {
			this.tire = tire;
		}
		public void init() {
			System.out.println("执行了bottom的init方法");
			tire.init();
		}
	}
	static class Tire {
		public int size;

		//此时添加一个属性
		//        public String color;
		//        public Tire(int size, String color) {
		//            this.size = size;
		//        }
		public Tire(int size) {
			this.size = size;
		}
		public void init() {
			System.out.println("轮胎尺寸：" + size);
		}
	}
	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.init();
	}
}

当要给车轮添加新的属性时，只需要修改Tire类的构造方法，而其他类不需要进行修改，整个调用链没有进行调整，代码的耦合度得到降低。

没有引入IOC思想时，Car控制并创建FrameWork,FrameWork控制并创建Bottom,以此往下。而改进后的控制权发生了反转，不再是上级对象创建并控制下级对象了，而是下级对象注入到当前对象中，下级的控制权不在由上级类控制了，这样即使下级类发生了改变，当前类也不受影响的，这就是典型的“控制反转”。

什么是容器

容器顾名思义就是存放东西的装置。咱们前面学的集合就是用来存放数据的，学Servlet时用的tomcat就是用来存放Web网站的。而这里的IOC容器就是用来存放托管对象，需要使用到对象时就从容器中取，想要托管对象时就往容器中放。

DI

DI是“Dependency Injection"的缩写，译为”依赖注入“。IOC是设计思想，而DI就是依据IOC思想实现出来的具体技术。DI帮助我在IOC容器运行期间，动态的把对象注入到另外一个对象中。所以IOC和DI本质没有区别

Spring是通过引入IOC容器，利用DI依赖注入的方式，实现了对象之间的解耦合