一、为什么要学框架？

学习框架相当于从 “小作坊” 到 “工厂” 的升级，小作坊什么都要自己做，工厂是组件式装配，特点就是高效。
框架更加易用、简单且高效。

框架的优点展示(SpringBoot VS Servlet)

使用 Spring Boot 项目演示框架相比于 Servlet 所具备的以下优点：

无需配置 Tomcat，点击 “运行” 按钮就可以运行项目，Spring Boot 内置了 Web 容器（可直接运
行）。
快速添加外部 jar 包。
快速发布项目（使用 java -jar 方式就可以发布）。
对象自动装配。
…

Servlet 项目开发

创建项目
- 创建 maven 项目
- 在中央仓库中查找 servlet 对应的版本和引用信息，添加 servlet 框架应用到 pom.xml
- 点击 maven 导入框架按钮，创建 java 源代码项目目录，配置路由文件 web.xml
编写代码
- 创建两个类（一个对应一个 url：一个添加用户url / 删除用户url)，继承 HttpServlet 重写 doGet/doPost 方法
- 使用 request 来获取参数
- 业务逻辑
- 设置返回的类型 / 设置编码格式 / 使用 resp 来返回结果
运行项目
- 社区版 idea 安装插件 smartomcat
- 下载并加压一个 tomcat (外置 tomcat)
- 配置 idea 中的 smartomcat -> 运行的 tomcat 指向本地 tomcat
- 运行项目
发布项目
- maven 打包、将打包好的 war / jar上传到服务器
- 在服务器上安装（下载并解压) tomcat
- 将 war 包放到 webapps
- 启动 tomcat，运行项目

SpringBoot 项目开发

创建项目
- 直接创建 SpringBoot 项目并勾选添加项目依赖即可
编写代码
- 使用注解，编写添加方法和删除方法
运行项目
- 直接运行 main 方法即可 (内置 tomcat)
发布项目
- maven 打包、将打包好的 war / jar 上传到服务器
- 使用 java -jar xxx.jar 直接运行项目

Servlet 痛点分析

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

而以上痛点问题，都可以通过 JavaEE 进阶框架解决

SpringBoot VS Servlet

SpringBoot 相比于 Servlet 的优点总结：

添加外部 jar 更容易，不易出错（版本问题无需关注）；
调试项目更加方便，无需配置 Tomcat；
发布项目更加方便，无需配置 Tomcat；
添加路由更加方便，无需每个访问地址都添加一个类
…

怎么学框架

先从基础框架 Spring 开始（工具箱）
Spring Boot 快速开发 Spring 脚手架
MyBatis 快速操作数据库
其他：日志、事务、拦截器…

框架学习中的难点

配置比较多。
需要大量的外部 jar 包，在下载时容易出错。
会涉及简单的软件工程的设计思想（分层思想：前、后端的分层思想；后端工程的分层思想）。
知识点相对来说比之前的知识更加的分散，要仔细听才能搞懂各个知识点的逻辑关系。

二、Spring 是什么？

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

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

1、容器

容器是用来容纳某种物品的（基本）装置。 ——来自：百度百科

我们想想，之前课程我们接触的容器有哪些？

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

2、loC

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

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

2.1、传统程序开发 NewCarExample

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

在这里插入图片描述

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

运行结果：轮胎尺寸：30

如果需要改变需求，提供一个尺寸，根据给定的尺寸定制不同的轮胎尺寸，修改代码：

	static class Tire {
    
    
        // 尺⼨
        private int size = 30;
        
        public void init(int size) {
    
    
            System.out.println("轮胎尺⼨：" + size);
        }
    }

但是不只是修改轮胎，因为底盘需要依赖轮胎，底盘也要发生改变

在这里插入图片描述

修改底盘代码：

    /**
     * 底盘类
     */
    static class Bottom {
    
    
        public void init(int size) {
    
    
            // 依赖轮胎
            Tire tire = new Tire();
            tire.init(size);
        }
    }

一直往上修改…

2.1.1、传统程序开发的缺陷 NewCarUpdateExample

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

以上程序中，轮胎的尺寸的固定的，然而随着对的车的需求量越来越大，个性化需求也会越来越多，这时候我们就需要加工多种尺寸的轮胎，那这个时候就要对上面的程序进行修改了

——解决传统开发中的缺陷：

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

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

这就好⽐我们打造⼀辆完整的汽⻋，如果所有的配件都是⾃⼰造，那么当客户需求发⽣改变的时候，⽐如轮胎的尺⼨不再是原来的尺⼨了，那我们要⾃⼰动⼿来改了，但如果我们是把轮胎外包出去，那么即使是轮胎的尺⼨发⽣变变了，我们只需要向代理⼯⼚下订单就⾏了，我们⾃身是不需要出⼒的

修改后的代码如下所示：

public class NewCarUpdateExample {
    
    
    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;

        private String color;

        public Tire(int size, String color) {
    
    
            this.size = size;
            this.color = color;
        }
        public void init() {
    
    
            System.out.println("轮胎：" + size);
        }
    }
}

2.2、控制反转式程序开发 IocCarExample

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

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

此时改变需求，加入一个轮胎颜色，修改代码：

在这里插入图片描述

运行结果：轮胎：20 ——颜色：black

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

2.3、对比总结规律

在传统的代码中对象创建顺序是：Car -> Framework -> Bottom -> Tire
改进之后解耦的代码的对象创建顺序是：Tire -> Bottom -> Framework -> Car

在这里插入图片描述

我们发现了⼀个规律：通⽤程序的实现代码，类的创建顺序是反的，传统代码是 Car 控制并创建了Framework，Framework 创建并创建了 Bottom，依次往下，而改进之后的控制权发生的反转，不再是上级对象创建并控制下级对象了，而是下级对象把注入将当前对象中，下级的控制权不再由上级类控制了，这样即使下级类发生任何改变，当前类都是不受影响的，这就是典型的控制反转，也就是 IoC 的实现思想

**loC 优点：**实现代码的解耦；对象(Bean) 生命周期交给 loC 框架来维护，作为程序员无需在关注了。

3、理解 Spring IoC

Spring 是包含了多个工具方法的 IoC 容器，这就是对 Spring 最核心的总结。

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

Spring loC 容器最核心的功能：

将 Bean(对象）存储到 Spring(容器）中。
将Bean(对象)从 Spring(容器)中取出来。

也就是说学 Spring 最核心的功能，就是学如何将对象存入到 Spring 中，再从 Spring 中获取对象的过程

**将对象存放到容器中的好处：**将对象存储在 IoC 容器相当于将以后可能用的所有工具制作好都放到仓库中，需要的时候直接取就行了，用完再把它放回到仓库。而 new 对象的方式相当于，每次需要工具了，才现做，用完就扔掉了也不会保存，下次再用的时候还得重新做，这就是 IoC 容器和普通程序开发的区别

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

4、DI 概念说明

说到 IoC 不得不提的⼀个词就是“DI”，DI 是 Dependency Injection 的缩写，翻译成中文是“依赖注入”的意思

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

IoC 是 “目标” 也是⼀种思想，而目标和思想只是⼀种指导原则，最终还是要有可行的落地方案，而 DI 就属于具体的实现

比如说我今天心情比较好，吃一顿好的犒劳犒劳自己，那么“吃⼀顿好的”是思想和目标（是 IoC），但最后我是吃KF还是杨国福？这就是具体的实现，就是 DI

为什么要学框架？什么是Spring？

一、为什么要学框架？

框架的优点展示(SpringBoot VS Servlet)

Servlet 项目开发

SpringBoot 项目开发

Servlet 痛点分析

SpringBoot VS Servlet

怎么学框架

框架学习中的难点

二、Spring 是什么？

1、容器

2、loC

2.1、传统程序开发 NewCarExample

2.1.1、传统程序开发的缺陷 NewCarUpdateExample

2.2、控制反转式程序开发 IocCarExample

2.3、对比总结规律

3、理解 Spring IoC

4、DI 概念说明

猜你喜欢