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. 更加高效

那么，我们来浅浅了解一下DI吧！！

其实，在刚刚接触到DI的时候，小编也是一脸迷茫，但是，经过短暂的学习，发现DI还是挺靠谱的！

Ioc《——》DI，相对于一对CP

DI是 Dependency  Injection(依赖注入)的缩写

所谓的依赖注入就是由Ioc容器在运行期间，动态的将某种依赖关系注入到对象之中，所以，依赖注入（DI）和控制反转（Ioc）是从不同的角度描述同一件事情，就是指：通过引入Ioc容器，利用依赖关系注入的方式，实现对象之间的解耦！

其实，说白了，依赖注入：将依赖的某个对象注入到当前类中的这个行为，就叫做依赖注入！

Ioc是一种思想，而DI是一种具体的实现技术！

如：今儿心情好，吃顿好的犒劳犒劳自己！则“吃顿好的”是思想和目标(Ioc)，但是，最后是吃海底捞还是吃杨国富？？这就是具体的实现，这就是DI

那么，我们可以看出：

1. Ioc：思想
2. Spring  Ioc：框架
3. DI：技术