一、Spring是什么？

Spring 框架是一个用于构建企业级 Java 应用程序的开源框架—指的是Spring Framework（Spring 框架）。它提供了一种综合性的编程和配置模型，用于开发灵活、可扩展、可维护的应用程序。Spring 框架提供了许多功能和特性，帮助开发人员快速构建企业应用程序。

具体来说，Spring可以看作一个包含众多工具方法的IOC容器，Spring的出现就是让开发更简单。

那么，什么是IOC？什么又是容器？下面我们来逐渐讲解~

二、为什么要学习框架？

因为学习框架相当于从“小作坊”到“工厂”的升级，小作坊什么都要自己做，工厂是组件式装配，特点就是高效。

框架更加易⽤、简单且高效。

之前我们使用的Servlet有以下缺点：

添加外部 jar 不⽅便，容易出错，比如添加了⼀个不匹配的外部 jar 版本。
运行和调试的时候需要配置 Tomcat 不⽅便。
发布不方便，Servlet 项目必须依靠外置的 Tomcat（外置的 Web 容器）运行。
路由配置不方便，⼀个访问地址对应⼀个 Servlet 类。
…

而Spring Boot 对比 Servlet 的优点：

快速添加外部 jar 包。
调试项目更方便，无需配置 Tomcat，点击“运行”按钮就可以直接运行项目，因为 Spring Boot 内置了 Tomcat 容器可直接运行。
发布项目更加方便，无需配置 Tomcat，使用 java -jar xxx.jar 的方式就可以发布。
对象自动装配。
添加路由更加方便，无需每个访问地址都添加⼀个类。
…

Spring框架基本学习应用路线：Spring全家桶 -> MyBatis -> Redis ...等。

三、Spring核心概念

3.1 什么是容器？

通俗来理解，容器就是装某种东西的器件。

在Java开发中，容器通常是指Web容器或IOC容器。Web容器是一种用于运行Web应用程序的容器，例如Tomcat、Jetty等。IoC容器是一种反转控制容器，例如Spring框架的Bean容器，它管理了应用程序中的对象，并负责注入对象之间的依赖关系。

3.2 什么是IOC？

IOC = Inversion of Control 翻译成中⽂是“控制反转”的意思。这是一种思想，在java的常规代码中，我们需要程序猿自己进行 new 对象来控制生命周期，而控制反转就是将对象的生命周期交给Spring来控制，不再根据程序猿来创建对象。

说到这里，有些人可能不理解，下面来举个例子：

假如，我们现在构建⼀辆“汽⻋”的程序，要有车身、底盘、轮胎等

传统思想的代码实现：

package old;

/**
 * 传统开发方式, 耦合性问题
 */
// 汽车类
public class Car {
    // 车身
    private Framework framework;

    public Car() {
        framework = new Framework();
    }

    public void init() {
        System.out.println("do car");
        // 汽车的组建依赖于车身
        framework.init();
    }
}

package old;

// 车身类
public class Framework {
    private Bottom bottom;

    public Framework() {
        bottom = new Bottom();
    }

    public void init() {
        System.out.println("do framework");
        // 车身的组建依赖于底盘
        bottom.init();
    }
}

package old;

// 底盘类
public class Bottom {
    private Tire tire;

    public Bottom() {
        tire = new Tire();
    }

    public void init() {
        System.out.println("do bottom");
        // 底盘的组建依赖于轮胎
        tire.init();
    }
}

package old;

// 轮胎类
public class Tire {
    private int size = 20;

    public void init() {
        System.out.println("size -> " + size);
    }
}

package old;

public class Test {
    public static void main(String[] args) {
        Car car = new Car();
        car.init();
    }
}

此时，如果我们需要定制个性化的轮胎，就需要改动Tire类的构造方法，进行传入颜色，大小等。但是问题就来了，一旦修改了最底层的Tire，上面所有互相依赖的类，都需要修改构造方法，进行传参。牵一发而动全身！这就是最大的问题！！

在传统的编程模式中，程序猿则需要手动创建对象，并负责它们之间的依赖关系。 而在IOC的编程模式中，程序员只需要定义好对象及其依赖关系的配置，IOC容器则根据这些配置来自动创建和管理对象。通过 IOC编程思想，我们可以很好的解决上述问题。

那么，使用IOC思想的代码：

尝试不在每个类中⾃⼰创建下级类，我们只需要将原来由⾃⼰创建的下级类，改为传递的⽅式（也就是注⼊的⽅式），所以下级类即使发⽣变化（创建或减少参数），当前类本身也⽆需修改任何代码。

public class Car {
    private Framework framework;

    public Car(Framework framework) {
        this.framework = framework;
    }

    public void init() {
        System.out.println("执行 Car");
        // 依赖车身
        framework.init();
    }
}

public class Framework {
    private Bottom bottom;

    public Framework(Bottom bottom) {
        this.bottom = bottom;
    }

    public void init() {
        System.out.println("执行 Framework");
        // 依赖底盘
        bottom.init();
    }
}


public class Bottom {
    private Tire tire;

    public Bottom(Tire tire) {
        this.tire = tire;
    }

    public void init() {
        System.out.println("执行 Bottom");
        // 依赖轮胎
        tire.init();
    }
}

public class Tire {
    private int size = 20;
    private String color;

    public Tire(int size, String color) {
        this.size = size;
        this.color = color;
    }

    public void init() {
        System.out.println("轮胎——size：" + size +
                " | color：" + color);
    }
}


public class App {
    public static void main(String[] args) {
        Tire tire = new Tire(30, "粉色");
        Bottom bottom = new Bottom(tire);
        Framework framework = new Framework(bottom);
        Car car = new Car(framework);
        car.init();
    }
}