Servlet 与Spring对比！

前言：

Spring相关的框架知识，算是目前公司在用的前沿知识了，很重要！！

那么以Spring为基础的框架有几个？

以Spring为基础的框架包括若干模块，其中主要的有Spring Framework、Spring Boot、Spring Cloud等。

1. Spring Framework：这是最基础的Spring框架，它包括了ioc依赖注入，Context上下文、bean管理等功能模块。Spring框架的主要目的就是简化Java后端开发工作，它由20个左右不同的模块组成，这些模块分别是Test、Core Container（核心容器）、Data Access/Integration（数据访问/集成）、Web、AOP/Aspect（应用对象解耦）、Instrumentation和Messaging（检测消息）。
2. Spring Boot：这个框架的目标是简化Spring应用和服务的创建、开发与部署，比如它可以简化配置文件，使用嵌入式web服务器，含有诸多开箱即用的微服务功能。
3. Spring Cloud：它是一系列框架的集合，主要用于构建分布式系统，提供配置管理、服务发现、断路器、智能路由、微代理、控制总线等功能。

   在使用这些框架时，可以根据具体的需求来选择性地使用所需要的模块，以满足企业级应用开发的需求。

相比于Spring Framework和Spring Cloud而言，小编主要着重于Spring Boot框架相关的知识来进行讲解的！当然，Spring Boot也算是很常见的框架之一了！

Servlet痛点分析：

1. 添加外部jar不方便，容易出错（比如：添加了一个不匹配的外部jar版本）
2. 运行和调试的时候，需要配置tomcat，不方便
3. 发布不方便，Servlet项目必须依靠外置的tomcat（外置的Web容器运行）
4. 路由配置不方便，一个访问地址对应一个Servlet类！
5. …………………………

Spring基础与核心概念：

官网：spring.io

一句话概述Spring：包含了众多工具方法的Ioc容器！

那么，什么是容器？？

容器是用来容纳某种物品的（基本）装置（如：水杯）

那么，我们之前课程所接触到的容器有哪些？？

• List / Map《——》数据存储容器
• tomcat《——》Web容器
• ……………………

Ioc：全文为：Inversion of Control（汉语意思为：控制反转）实际意义为：控制(权)反转

那么，也就是说：Spring是一个“控制反转”的容器！

A对象掌握B对象的控制权（实列化），但由于B对象参数等的改变，导致A对象如何控制B对象也会发生相应的变化，为解决这一问题，将B对象给第三方，此时，A对象对B对象的控制权转移/交接给第三方，这就是控制(权)反转！！

当最底层发生变化时，整个调用链都需要修改——》耦合！（耦合：两个/两个以上的对象，相互依赖）

接下来，我们来通过传统的解法来构造一个“车”吧！！

接下来，我们来看一下相关的代码吧：

车轮胎：

public class Tire {
    //车轮胎
    public int size=17;//车身尺寸

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

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

底盘：

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

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

    public void init(){
        System.out.println("do bottom");
        tire.init();
    }
}

车身：

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

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

    public void init(){
        System.out.println("do bottom");
        bottom.init();
    }
}

车：

public class Car {
    //车
    private Framework framework;
    public Car(int size){
        framework=new Framework(size);
    }

    public void init(){
        System.out.println("do Car");
        framework.init();
    }

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

上述代码的运行结果为：

但是，对于上述的代码，当我们对其增加一个属性：color颜色的时候，其相关代码就会发生大幅度的改变！其耦合性太高！因此，我们需要对其解耦操作：Ioc高级写法：

更改后的代码为：

车轮胎：

public class Tire2 {
    //车轮胎
    public int size=17;//车身尺寸
    private String color="红色";

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

    public void init(){

        System.out.println("size -->" +size + "color -->"+color);
    }
}

底盘：

public class Bottom2 {
    //底盘
    private Tire2 tire2;

    public Bottom2(Tire2 tire2) {
        this.tire2=tire2;
    }

    public void init(){
        System.out.println("do bottom2~~");
        tire2.init();
    }
}

车身：

public class Framework2 {
    //车身
    private Bottom2 bottom2;

    public Framework2(Bottom2 bottom) {
        this.bottom2 = bottom;
    }

    public void init(){
        System.out.println("do framework2~~");
        bottom2.init();
    }
}

车：

public class Car2 {
    //车
    private Framework2 framework2;
    public Car2(Framework2 framework2){
        this.framework2=framework2;
    }

    public void init(){
        System.out.println("do Car2~~~");
        framework2.init();
    }

}

测试类：

public class Test {
    //测试类
    public static void main(String[] args) {
        Tire2 tire2=new Tire2(20,"黑色");
        Bottom2 bottom2=new Bottom2(tire2);
        Framework2 framework2=new Framework2(bottom2);
        Car2 car2=new Car2(framework2);
        car2.init();
    }
}

那么，上述代码的运行结果为：

那么，经过上述的代码，我们可以看出：

Ioc不是一个具体的技术，它是一个思想（控制权转移）！

Ioc最比较重要的功能：解耦

既然Spring是一个Ioc（控制反转）容器，重点还在“容器”二字上，那么，它就具有两个最基础的功能：

1. 将对象存入到容器（存对象）
2. 从容器中取出对象（取对象）

上面两个是Spring Ioc最核心（基础）操作！！

---

Spring是一个Ioc容器，说的是对象的创建和销毁的权利都交给Spring来管理了，它本身具备了存储对象和获取对象的能力！

那么，我们来看一下：Spring Ioc的优点：

1. 解耦
2. 使用更加方便（不需要手动创建和关注这个对象背后的依赖关系）
3. 更加高效