什么是spring框架？

一、Spring 是什么？

我们通常所说的 Spring 指的是 Spring Framework （ Spring 框架），它是一个开源框架，有着活跃而庞大的社区，这就是它之所以能长久不衰的原因。Spring 支持广泛的应用场景，它可以让 Java 企业级的应用程序开发起来更简单。

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

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

1.1 什么是容器？

容器是用来容纳某种物品的（基本）装置。

例如：

• List/Map -> 数据存储容器
• Tomcat -> Web 容器

1.2 什么是 IoC？

Spring 也是一个容器， Spring 是什么容器呢？ Spring 是一个 IoC 容器。

什么是 IoC？

IoC = Inversion of Control 翻译成中文是 “ 控制反转 ” 的意思，也就是说 Spring 是一个 “ 控制反转 ” 的容器，怎么理解这句话呢，我们先从以下示例开始。

1.2.1 传统程序开发

假如，我们现在构建一辆 “ 车 ” 的程序，我们的实现思路是这样的：

 

构建一辆车（ Car Class ），然而车需要依赖车身 (FrameWork Class) ，而车身需要依赖底盘（ Bottom Class），而底盘需要依赖轮胎（ 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);
        }
    }
}

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

解决传统开发中的缺陷

如何解决上述问题呢？

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

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

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

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

1.2.2 控制反转式程序开发

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

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);
        }
    }
}

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