如何理解Spring-Toy模板网

这篇具有很好参考价值的文章主要介绍了如何理解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,以此往下。而改进后的控制权发生了反转，不再是上级对象创建并控制下级对象了，而是下级对象注入到当前对象中，下级的控制权不在由上级类控制了，这样即使下级类发生了改变，当前类也不受影响的，这就是典型的“控制反转”。