【Spring】Spring是什么？

文章目录

前言
什么是Spring
什么是容器
什么是 IoC
Spring帮助网站

前言

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

什么是Spring

我们通常说的 Spring 指的是 Spring FrameWork。Spring 是一个开源的轻量级框架，它是为了简化企业级应用开发而设计的。Spring 提供了控制反转（IOC）和面向切面编程（AOP）等核心功能，使得开发者可以更加专注于业务逻辑的实现，而不需要关注底层的实现细节。Spring可以与各种第三方库和框架集成，如Hibernate、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）的方式将各个bean之间建立联系，从而减少了手动配置的工作量。同时，Spring容器还提供了丰富的扩展机制，使得开发者可以根据自己的需求对bean进行定制化配置。

什么是 IoC

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

传统程序开发

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

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

构建一辆车（Car Class），然而车需要依赖车身(FrameWork Class)，而车身需要依赖底盘（BottomClass），而底盘需要依赖轮胎（Tire Class)，最终程序的实现代码如下：

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通过将对象的依赖关系交给外部系统来管理，以解耦对象之间的关系，并提供了更高的灵活性和可测试性。

DI的主要实现方式包括构造函数注入、属性注入和方法注入。构造函数注入是最常见的DI方式，它通过在对象的构造函数中传递依赖对象来实现。属性注入是通过设置对象的属性来注入依赖对象。方法注入是一种更灵活的DI方式，它通过在对象的方法中传递依赖对象来实现。

DI的好处包括：