持续创作，加速成长！这是我参与「掘金日新计划 · 10 月更文挑战」的第1天，点击查看活动详情

(写文章，记录学习过程~)

Spring是什么？

Spring是一个框架。

什么是框架？

框架可以理解为是别人写好并包装好的工具，让我们在面对一些场景时能快速使用。
(小作坊到工厂的升级)

为什么要学Spring框架？

在没了解Spring框架之前，我们的项目大部分都是基于 servlet + jdbc 来完成的。而我们在写项目的时候就能明显的发现，代码写起来很繁琐，基本上都是事事亲为，这大大降低了我们写项目的效率，并且还容易出错(纠错很费劲)。

创建项目

servlet：

创建一个 maven 项目。

在 maven 中央仓库找到 servlet 对应的版本并添加依赖到 pom.xml 文件中。

点击 maven 刷新按钮，并创建 java 源代码目录。

SpringBoot：

直接创建SpringBoot项目，并勾选需要的依赖。

编写项目

servlet:

创建一个类继承 HttpServlet，重写 doPost/doGet 方法，并添加 url。

使用 request 来获取参数。

通过参数计算响应数据(也就是业务逻辑)。

设置返回值类型，设置编码格式，通过 response 返回响应。

SpringBoot：

在Controller类中编写一个方法，并加上url。

处理业务逻辑。

直接返回数据。

运行项目

servlet:

如果是社区版IDEA，需要下载 SmartTomcat 插件。

在本地电脑上也下载一个 tomcat。

配置运行tomcat指向本地tomcat。

最后才能运行程序。

SpringBoot：

直接运行 main 方法即可。

发布项目

servlet:

基于 maven 打一个 war 包。

在自己的云服务器上安装对应版本的 tomcat 、mysql 、jdk。

将本地打成的 war 包放到云服务器上的 tomcat 里的 webapps 目录下。

启动云服务器上的 tomcat。

SpringBoot:

基于 maven 打一个 jar 包。

在云服务器上安装 mysql 、jdk。

将 jar 包放到云服务器上，使用 java -jar xxx.jar 运行项目。

从上述几个方面的对比，我们就可以发现使用 Spring 框架来开发一个项目的效率远大于使用 servlet 来开发的效率，所以接下来就详细介绍一些 Spring 框架。

Spring的定义

用一句通俗的话来总结：Spring就是一个拥有众多工具方法的IOC容器。

容器:

一种用来存放物体的基本装置。
(tomcat 就是一个 servlet 容器)
(List/Map 就是一个数据存储容器)

IOC

中文叫作控制反转。

举个例子: "造车"

// 车类
class Car {
    public void createCarSuccess(){
        CarBody carBody = new CarBody();
        carBody.createCarSuccess();
    }
}

// 车身类
class CarBody{
    public void createCarSuccess(){
        Chassis chassis = new Chassis();
        chassis.createCarSuccess();
    }
}

// 底盘类
class Chassis{
    public void createCarSuccess(){
        Wheel wheel = new Wheel();
        wheel.createCarSuccess();
    }
}

// 轮子类
class Wheel{
    private int size = 20;

    public void createCarSuccess(){
        System.out.println("轮子大小："+size);
    }
}

public class Test {
    public static void main(String[] args) {
        // 制造一辆小汽车
        Car car = new Car();
        // 调用建造方法
        car.createCarSuccess();
    }
}

上面代码中造车的流程就传统程序开发流程。我们一开始就 new Car()，这时我们发现想要有 Car 对象，就必须要有车身(CarBody类)。所以我们就要在 Car类里 new CarBody()。同样的，在 CarBody类里发现也需要一个 Chassis类，所以重复上述的操作，new Chassis()。最后在 Chassis类里 new Wheel类。这时一辆 Car 才完整的制造了出来。

分析：

在这个流程中，我们会发现构建⼀辆⻋（Car），然⽽⻋需要依赖⻋身(CarBody)，⽽⻋身需要依赖底盘（Chassis），⽽底盘需要依赖轮胎（Wheel）。这样就会出现一个问题:假设当最底层代码改动之后，那么整个调⽤链上的所有代码都需要修改，也就说当前类决定了下级类的生命周期。。

比如：一般来说，车的轮子应该可以定制。而在上面的代码中如果需要用户自定义 Wheel类中的 size 值，那么就需要将用户的需求通过参数，一级一级的传到 Wheel 类中。这样就需要使整个调用链进行修改。

使用IOC之后

// 车类
class Car {

    private CarBody carBody;

    public Car(CarBody carBody){
        this.carBody = carBody;
    }

    public void createCarSuccess(){
        carBody.createCarSuccess();
    }
}

// 车身类
class CarBody{

    private Chassis chassis;

    public CarBody(Chassis chassis){
        this.chassis = chassis;
    }
    public void createCarSuccess(){
        chassis.createCarSuccess();
    }
}

// 底盘类
class Chassis{

    private Wheel wheel;

    public Chassis(Wheel wheel){
        this.wheel = wheel;
    }

    public void createCarSuccess(){
        wheel.createCarSuccess();
    }
}

// 轮子类
class Wheel{
    private int size = 20;

    // 相当于用户可以自定义网站了
    public Wheel(int size){
        this.size = size;
    }

    public void createCarSuccess(){
        System.out.println("轮子大小："+size);
    }
}

public class Test {
    public static void main(String[] args) {
       // 将需要的部件都准备好（这些就相当于交给了IOC容器来管理，也就是Spring）
       Wheel wheel = new Wheel(100);
       Chassis chassis = new Chassis(wheel);
       CarBody carBody = new CarBody(chassis);
       Car car = new Car(carBody);

       // 最后创建车
       car.createCarSuccess();
    }
}

观察使用IOC之后的代码，我们很容易就能发现它的一个最大的优点：实现了代码解耦，它将对象的创建交给了IOC容器(Spring)，作为程序员的我们就不再关注对象的创建了。当我们需要时，直接使用就行了。并且更改后的代码，整个调用链都发生了反转，上级类不再控制下级类的创建和销毁了。当上级类需要下级类的时候，只需要将下级类注入到上级类中就行了。

Spring IOC

从上面我们了解了什么叫 IOC(控制反转)。将整个调用链反转过来，类中不再自己直接new对象了，而是通过外部注入的方式将对象给拿到。

那什么是Spring IOC？
最开始的时候，我们说Spring是一个拥有众多工具方法的IOC容器。
所以 Spring 就可以理解成一个仓库,它负责来管理那些被控制反转的 bean 对象的创建和销毁。在程序员需要使用的时候，就可以直接从仓库里拿出来用，而不需要自己进行对象的管理。

总结：Spring的两大核心功能

将 bean 对象(java对象)存放到 IOC 容器中。
从 IOC 容器中将 bean 对象取出来。

IOC与DI

说到 IOC ，那就要了解一些 DI 。DI 的中文叫 依赖注入，通俗的讲就是把一个东西拿过来用。

那它和IOC的关系？

IOC 与 DI 可以看成是站在不同的角度描述同一件事。IOC 就是由 Spring 来负责控制对象的生命周期和对象间的关系。IOC 的一个重点是在系统运行中，动态的向某个对象提供它所需要的其他对象。这一点是通过DI（依赖注入）来实现的。

所以可以这样说：IOC 是一种思想，DI 是IOC思想的具体实现。

内容总结：
Spring 是什么？怎么理解 Spring？
IOC 与 DI 是什么？有什么区别？
Spring 的核心功能是什么？

Spring(核心思想)