【Spring】Spring是什么？

本文介绍: Spr in g 是什么？如何理解 Spr in g？IoC 和 DI 是啥？有什么区别？Spr in g 最核心的功能是啥？spring帮助网站

在这里插入图片描述

前言

前面我们学习了 servlet 的相关知识，但是呢？使用 serv let 进行网站的开发步骤还是比较麻烦的，而我们本身程序员就属于是比较懒的群体，所以为了解决咱们的这个 serv let 步骤较为复杂的情况，一些大佬就在 servle t 的基础上开发出了 Spr ing 框架，而 Sp r ing 也因为其轻量和开发效率高的特点，成为了 Jav a 圈子中非常受欢迎的一种框架。那么这篇文章我将为大家介绍一下什么是 Sp r ing。

什么是Sp r ing

我们通常说的 Spr ing 指的是 Spr ing Fram eWork。Spr ing 是一个开源的轻量级框架，它是为了简化企业级应用开发而设计的。Spr ing 提供了控制反转（IOC）和面向切面编程（AOP）等核心功能，使得开发者可以更加专注于业务逻辑的实现，而不需要关注底层的实现细节。Spr ing可以与各种第三方库和框架集成，如Hi b erna t e、Struts等，使得这些库和框架可以更加方便地在Spring应用程序中使用。此外，Spring还提供了一些模板类，用于简化常见的开发任务，如数据访问、事务管理等。

让我们看看官方的解释：什么是Spring？https://spring.io/why-spring
在这里插入图片描述

在这里插入图片描述

用一句话概括 Spring：Spring 是包含了众多工具方法的 IoC 容器。

那问题来了，什么是容器？什么是 IoC 容器？接下来我们一起来看。

什么是容器

Spring容器是Spring框架的核心组成部分，它负责管理Spring bean的生命周期和依赖关系。Spring容器是一个bean 工厂（BeanFactory），它负责实例化、配置和管理 bean。在Spring应用程序中，所有的bean都存储在Spring容器内，并通过IoC（控制反转）技术进行管理。Spring容器通过自动装配（autowiring）的方式将各个 b ean之间建立联系，从而减少了手动配置的工作量。同时，Spring容器还提供了丰富的扩展机制，使得开发者可以根据自己的需求对b ean进行定制化配置。

什么是 IoC

Spring IoC即控制反转（Inversion of Con trol），是一种设计思想，它通过将对象的创建和管理权交给Spring容器，降低了程序之间的耦合性，提高了系统的可维护性和可重用性。在Spring框架中，IoC主要通过XML配置文件、注解或Java配置等方式实现。通过使用IoC，应用程序的各个模块可以以松耦合的方式协同工作，提高了应用程序的可扩展性和可维护性。

传统程序开发

如何理解上面这段话呢？我们通过一个例子来解释。

假设我们现在构建一辆车的程序，实现思路是这样的。

在这里插入图片描述
构建一辆车（Car Clas s），然而车需要依赖车身(Fram eWork Clas s)，而车身需要依赖底盘（BottomClas s），而底盘需要依赖轮胎（Tire Clas s)，最终程序的实现代码如下：

public class NewCarExample {
	public static void main(String[] args) {
		Car car = new Car();
		car.init();
	} 
	
	/**
	* 汽车对象
	*/
	static class Car {
		public void init() {
			// 依赖车身
			Framework framework = new Framework();
			framework.init();
		}
	}
	
	/**
	* 车身类
	*/
	static class Framework {
		public void init() {
			// 依赖底盘
			Bottom bottom = new Bottom();
			bottom.init();
		}
	} 
	
	/**
	* 底盘类
	*/
	static class Bottom {
		public void init() {
			// 依赖轮胎
			Tire tire = new Tire();
			tire.init();
		}
	}

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

以上程序中，轮胎的尺寸的固定的，然而随着对的车的需求量越来越大，个性化需求也会越来越多，这时候我们就需要加工多种尺寸的轮胎，那这个时候就要对上面的程序进行修改了，修改后的代码如下所示：

public class NewCarUpdateExample {
	public static void main(String[] args) {
		Car car = new Car(20);
		car.run();
	} 
	
	/**
	* 汽车对象
	*/
	static class Car {
		private Framework framework;
		public Car(int size) {
			framework = new Framework(size);
		} 
		
		public void run() {
			// 依赖车身
			framework.init();
		}
	} 
	
	/**
	* 车身类
	*/
	static class Framework {
		private Bottom bottom;
		public Framework(int size) {
			bottom = new Bottom(size);
		} 
		
		public void init() {
			// 依赖底盘
			bottom.init();
		}
	} 
	
	/**
	* 底盘类
	*/
	static class Bottom {
		private Tire tire;
		public Bottom(int size) {
			tire = new Tire(size);
		} 
	
		public void init() {
			// 依赖轮胎
			tire.init();
		}
	} 
	
	/**
	* 轮胎类
	*/
	static class Tire {
		// 尺寸
		private int size;
		public Tire(int size) {
			this.size = size;
		} 
		
		public void init() {
			System.out.println("轮胎尺寸：" + size);
		}
	}
}

从以上代码可以看出，以上程序的问题是：当最底层代码改动之后，整个调用链上的所有代码都需要修改。

那么如何解决这个问题呢？

我们可以尝试不在每个类中自己创建下级类，如果自己创建下级类就会出现当下级类发生改变操作，自己也要跟着修改。

此时，我们只需要将原来由自己创建的下级类，改为传递的方式（也就是注入的方式），因为我们不需要在当前类中创建下级类了，所以下级类即使发生变化（创建或减少参数），当前类本身也无需修改任何代码，这样就完成了程序的解耦。

解耦指的是解决了代码的耦合性，耦合性也可以换一种叫法叫程序相关性。好的程序代码的耦合性（代码之间的相关性）是很低的，也就是代码之间要实现解耦。

这就好比我们打造一辆完整的汽车，如果所有的配件都是自己造，那么当客户需求发生改变的时候，比如轮胎的尺寸不再是原来的尺寸了，那我们要自己动手来改了，但如果我们是把轮胎外包出去，那么即使是轮胎的尺寸发生变变了，我们只需要向代理工厂下订单就行了，我们自身是不需要出力的。

控制反转式程序开发

我们把调用汽车的程序示例改造一下，把创建子类的方式，改为注入传递的方式，具体实现代码如下：

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();
	} 
	
	static class Car {
		private Framework framework;
		
		public Car(Framework framework) {
			this.framework = framework;
		} 
	
		public void run() {
			framework.init();
		}
	} 
	
	static class Framework {
		private Bottom bottom;
		public Framework(Bottom bottom) {
			this.bottom = bottom;
		}
		
		public void init() {
			bottom.init();
		}
	} 
	
	static class Bottom {
		private Tire tire;
		public Bottom(Tire tire) {
			this.tire = tire;
		}
		
		public void init() {
			tire.init();
		}
	} 
	
	static class Tire {
		private int size;
		public Tire(int size) {
			this.size = size;
		} 
		
		public void init() {
			System.out.println("轮胎：" + size);
		}
	}
}

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

在这里插入图片描述

在传统的代码中对象创建顺序是：Car -> Framework -> Bottom -> Tire
改进之后解耦的代码的对象创建顺序是：Tire -> Bottom -> Framework -> Car

在这里插入图片描述
通用程序的实现代码，类的创建顺序是反的，传统代码是 Car 控制并创建了
Framework，Framework 创建并创建了 Bottom，依次往下，而改进之后的控制权发生的反转，不再是上级对象创建并控制下级对象了，而是下级对象把注入将当前对象中，下级的控制权不再由上级类控制了，这样即使下级类发生任何改变，当前类都是不受影响的，这就是典型的控制反转，也就是 IoC 的实现思想。

理解Spring IoC

在传统的程序设计中，对象之间的依赖关系通常是由程序内部通过new关键字创建对象来实现的。这种方式会导致程序内部与具体的对象实现紧密耦合，一旦对象实现发生改变，程序其他部分的代码也需要相应地进行修改。这不仅增加了开发成本，也增加了代码的维护难度。

而Spring IoC则将对象的创建和管理权交给了Spring容器。在Spring容器中，所有的对象都被称为bean，并通过配置文件或注解等方式进行注册。当程序需要使用某个bean时，Spring容器会负责查找和注入该bean，而程序本身并不需要关心具体的bean实例化和管理。这种方式将对象的创建和管理权从程序转移到了Spring容器，从而实现了控制反转。

控制反转的好处在于：

降低耦合性：通过将对象的创建和管理权交给Spring容器，程序与其他对象之间的耦合性降低，使得程序更加灵活、可维护和可重用。
提高可扩展性：由于对象的创建和管理权交给了Spring容器，当需要添加新的功能或模块时，只需要在Spring容器中注册相应的bean即可。这使得应用程序可以更加方便地进行扩展和升级。
简化开发：使用Spring IoC可以简化开发过程。开发者只需要关注业务逻辑的实现，而不需要花费过多的精力在对象的创建和管理上。
提高性能：虽然使用Spring IoC会增加一些额外的开销，但在大多数情况下，这种开销是微不足道的。而且，通过使用Spring IoC，可以减少不必要的对象创建和销毁，从而提高应用程序的性能。

DI

说到 IoC 不得不提的一个词就是“DI”，DI 是 Dependency Injection 的缩写，翻译成中文是“依赖注入”的意思。

DI（Dependency Injection）是一种软件设计模式，它用于实现松耦合和可测试性的代码结构。在常规的编程模式中，对象通常自己负责创建和管理它所依赖的其他对象，这导致了高度的依赖性，使得对象难以重用和测试。而DI通过将对象的依赖关系交给外部系统来管理，以解耦对象之间的关系，并提供了更高的灵活性和可测试性。