1.介绍Spring
1.1什么是Spring？
Spring是一个开源的企业级应用开发框架，它通过提供全面的基础设施支持，简化了Java应用程序的开发。Spring框架的核心目标是帮助开发者减少开发过程中常见的复杂性，尤其是在企业级应用开发中。Spring不仅是一个轻量级的容器，它还提供了很多与事务管理、安全性、消息服务、数据访问、Web应用开发等相关的功能模块。
简单来说，Spring就像一个“超级管家”，帮你管理Java应用程序中的对象和它们之间的关系，让代码更清晰、更易维护。如今，Spring已经成为Java生态系统中不可或缺的一部分，尤其是在构建现代Web应用和微服务时。
⽤⼀句具体的话来概括Spring: Spring 是包含了众多⼯具⽅法的 IoC 容器
那问题来了，什么是容器？什么是 IoC 容器？
1.2什么是容器？
容器是用来容纳某种物品的（基本）装置。–百度
生活中的水桶、收纳盒、柜子等等这些都是容器.
在编程中的容器有哪些呢？
•List/Map -> 数据存储容器
•Tomcat -> Web 容器
容器的作用是什么？
容器可以使我们处理事务的效率更高，比如：收纳盒可以分类物品，当我们使用工具时方便我们找物品。
像生活中的水桶、收纳盒、柜子这些都是可以看得到的具体的容器，而Spring容器我们暂且看不到，我们可以把Spirng容器理解为一个抽象的容器。
我们可以把具体的容器想象成一个抽象的容器：
想象一下，你在厨房做饭，需要各种工具：刀、锅、碗等等。如果每次用的时候都要自己去拿、洗、放回去，会很麻烦。现在假设有个智能助手，它不仅帮你把这些工具准备好，还在你需要时自动递给你，用完后收拾干净。这个“智能助手”就有点像Spring中的容器。
1.3什么是IoC？
IoC，全称Inversion of Control（控制反转），是Spring框架的核心设计原则之一。听起来有点抽象，但其实很好理解。
在传统的编程中，如果你需要一个对象，通常是你自己去创建它。比如需要创建一个User对象：
DatabaseConnection db = new DatabaseConnection();
这里，你（程序员）主动控制了DatabaseConnection对象的创建过程。但如果这个对象需要其他依赖（比如配置信息、日志工具），你就得手动把这些依赖塞进去，代码会变得越来越复杂。
IoC把这个“控制权”反转了。你不再直接创建和管理对象，而是把这个任务交给Spring容器。你只需要告诉容器：“我需要一个DatabaseConnection对象，它依赖这些东西。”然后容器会帮你创建好这个对象，把依赖注入进去，最后交给你使用。这个过程通常通过依赖注入(Dependency Injection, DI) 实现。
控制反转是⼀种思想, 在⽣活中也是处处体现.
⽐如⾃动驾驶, 传统驾驶⽅式, ⻋辆的横向和纵向驾驶控制权由驾驶员来控制, 现在交给了驾驶⾃动化系统来控制, 这也是控制反转思想在⽣活中的实现. ⽐如招聘, 企业的员⼯招聘,⼊职, 解雇等控制权, 由⽼板转交给给HR(⼈⼒资源)来处理
2.IoC介绍
2.1用一个例子来介绍IoC
2.1.1传统程序开发
需求: 造⼀辆⻋
我们的实现思路是这样的：
先设计轮⼦(Tire)，然后根据轮⼦的⼤⼩设计底盘(Bottom)，接着根据底盘设计⻋⾝(Framework)，最后根据⻋⾝设计好整个汽⻋(Car)。这⾥就出现了⼀个"依赖"关系：汽⻋依赖⻋⾝，⻋⾝依赖底盘，底盘依赖轮⼦.
Car类：
public class Car {
private Framework framework;
public Car(){
framework = new Framework();
System.out.println("Car Init .....");
}
public void run(){
System.out.println("Car run ");
}
}
Framework类：
public class Framework {
private Bottom bottom;
public Framework(){
bottom = new Bottom();
System.out.println("framework Init ....");
}
}
Bottom类：
public class Bottom {
private Tire tire;
public Bottom(){
tire = new Tire();
System.out.println("Bottom Init ....");
}
}
Tire类：
public class Tire {
private int size;
public Tire(){
this.size = 17;//设置轮子大小
System.out.println("Tire Init ....tire："+this.size);
}
}
Main类（测试类）：
public class Main {
static public void main(String[] args){
Car car=new Car();//轮子大小固定是17
car.run();
}
}
上面Car的轮子是固定的，如果我们在后续的业务中创建新轮子的Car时，需要把上面的类都修改：
Car类：
public class Car {
private Framework framework;
public Car(int size){
framework = new Framework(size);
System.out.println("Car Init .....");
}
public void run(){
System.out.println("Car run ");
}
}
Framework类：
public class Framework {
private Bottom bottom;
public Framework(int size){
bottom = new Bottom(size);
System.out.println("framework Init ....");
}
}
Bottom类：
public class Bottom {
private Tire tire;
public Bottom(int size){
tire = new Tire(size);
System.out.println("Bottom Init ....");
}
}
Tire类：
public class Tire {
private int size;
public Tire(int size){
this.size = size;//设置轮子大小
System.out.println("Tire Init ....tire："+this.size);
}
}
Main类（测试类）：
public class Main {
static public void main(String[] args){
//创建车的时候可以自定义轮子的大小
Car car1=new Car(17);
car1.run();
Car car2=new Car(21);
car2.run();
}
}
但是，当我们想给车添加颜色选择、驾驶座椅选择等等，每次都需要修改上面所有的代码，代码的维护性却很低.
从以上代码可以看出，以上程序的问题是：当最底层代码改动之后，整个调⽤链上的所有代码都需要修改.
程序的耦合度⾮常⾼(修改⼀处代码, 影响其他处的代码修改)
2.1.2 IoC思想的程序开发
在上⾯的程序中, 我们是根据轮⼦的尺⼨设计的底盘，轮⼦的尺⼨⼀改，底盘的设计就得修改. 同样因为我们是根据底盘设计的⻋⾝，那么⻋⾝也得改，同理汽⻋设计也得改, 也就是整个设计⼏乎都得改
我们尝试换⼀种思路, 我们先设计汽⻋的⼤概样⼦，然后根据汽⻋的样⼦来设计⻋⾝，根据⻋⾝来设计底盘，最后根据底盘来设计轮⼦. 这时候，依赖关系就倒置过来了：轮⼦依赖底盘， 底盘依赖⻋⾝，车身依赖汽车
这就类似我们打造⼀辆完整的汽⻋, 如果所有的配件都是⾃⼰造，那么当客⼾需求发⽣改变的时候，⽐如轮胎的尺⼨不再是原来的尺⼨了，那我们要⾃⼰动⼿来改了，但如果我们是把轮胎外包出去，那么即使是轮胎的尺⼨发⽣变变了，我们只需要向代理⼯⼚下订单就⾏了，我们⾃⾝是不需要出⼒的。
如何来实现呢？
我们可以尝试不在每个类中⾃⼰创建下级类，如果自己创建下级类就会出现当下级类发⽣改变操作，自己也要跟着修改.
此时，我们只需要将原来由自己创建的下级类，改为传递的⽅式（也就是注⼊的⽅式），因为我们不需要在当前类中创建下级类了，所以下级类即使发⽣变化（创建或减少参数），当前类本⾝也⽆需修改任何代码，这样就完成了程序的解耦。
IoC思想的程序设计：
Car类：
public class Car {
private Framework framework;
public Car(Framework framework){
this.framework = framework;
System.out.println("Car Init .....");
}
public void run(){
System.out.println("Car run ");
}
}
Framework类：
public class Framework {
private Bottom bottom;
public Framework(Bottom bottom){
this.bottom = bottom;
System.out.println("framework Init ....");
}
}
Bottom类：
public class Bottom {
private Tire tire;
public Bottom(Tire tire){
this.tire = tire;
System.out.println("Bottom Init ....");
}
}
Tire类：
public class Tire {
private int size;
public Tire(int size){
this.size = size;
System.out.println("Tire Init ....tire："+this.size);
}
}
Main类（测试类）：
public class Main {
static public void main(String[] args){
//创建轮子
Tire tire = new Tire(21);
//讲tire注入bottom中
Bottom bottom = new Bottom(tire);
//将bottom注入Framework中
Framework framework = new Framework(bottom);
//将framework注入car中
Car car = new Car(framework);
car.run();
}
}
代码经过以上调整，⽆论底层类如何变化，整个调⽤链是不⽤做任何改变的，这样就完成了代码之间的解耦，从⽽实现了更加灵活、通⽤的程序设计了。
2.2 IoC的优势
在传统的代码中对象创建顺序是：Car -> Framework -> Bottom -> Tire
改进之后解耦的代码的对象创建顺序是：Tire -> Bottom -> Framework -> Car
我们发现了⼀个规律，通⽤程序的实现代码，类的创建顺序是反的，传统代码是 Car 控制并创建了 Framework，Framework 创建并创建了 Bottom，依次往下；⽽改进之后的控制权发⽣的反转，不再是使用⽅对象创建并控制依赖对象了，⽽是把依赖对象注⼊将当前对象中，依赖对象的控制权不再由当前类控制了.
这样的话, 即使=依赖类发⽣任何改变，当前类都是不受影响的，这就是典型的控制反转，也就是 IoC 的实现思想。
学到这⾥, 我们⼤概就知道了什么是控制反转了, 那什么是控制反转容器呢, 也就是IoC容器
这部分代码, 就是IoC容器做的⼯作.
从上⾯也可以看出来, IoC容器具备以下优点:
资源不由使⽤资源的双⽅管理，而由不使⽤资源的第三⽅管理，这可以带来很多好处。第⼀，资源集中管理，实现资源的可配置和易管理。第⼆，降低了使⽤资源双⽅的依赖程度，也就是我们说的耦合度。
- 资源集中管理: IoC容器会帮我们管理⼀些资源(对象等), 我们需要使⽤时, 只需要从IoC容器中去取就可以了
- 我们在创建实例的时候不需要了解其中的细节, 降低了使⽤资源双⽅的依赖程度, 也就是耦合度.
3.DI介绍
DI，全称Dependency Injection（依赖注入），是IoC（控制反转）的一种具体实现方式。如果说IoC是一种思想，那么DI就是把它落地的“施工队”。简单来说，DI是指Spring容器主动将对象所需的依赖“注入”到对象中，而不是对象自己去创建或寻找依赖。
想象一下，你去餐厅吃饭，传统方式是你自己下厨：买菜、洗菜、切菜、炒菜，忙得不可开交。而有了DI，就像你坐下来点菜，服务员直接把热腾腾的饭菜端到你面前。你不需要关心食材从哪来、怎么做的，只管享用就行。DI也是这样，Spring容器负责准备好依赖（比如数据库连接、服务类），然后通过某种方式（构造器、Setter方法等）“端”给你。
DI的核心目标是让对象之间的关系更松散、更灵活。就像搭积木，你不用自己造积木块，只需要告诉Spring“我需要哪块”，它就帮你拼好。