⭐️前面的话⭐️

本篇文章介绍Spring的定义，相比于与Servlet的优势，学习难点，以及Spring基本设计思想，Ioc控制反转，DI等。

📒博客主页：未见花闻的博客主页
🎉欢迎关注🔎点赞👍收藏⭐️留言📝
📌本文由未见花闻原创，CSDN首发！
📆首发时间：🌴2022年7月21日
💭推荐书籍：📚《Spring实战》
💬参考在线编程网站：🌐牛客网🌐力扣
博主的码云gitee，平常博主写的程序代码都在里面。
博主的github，平常博主写的程序代码都在里面。
🍭作者水平很有限，如果发现错误，一定要及时告知作者哦！感谢感谢！

---

---

---

1.Spring系列框架概述

1.1什么是Spring框架

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

⽤⼀句话概括 Spring：Spring 框架是包含了众多⼯具⽅法的 IoC 容器。

1.2为什么要学习框架？

因为学习框架相当于从“⼩作坊”到“⼯⼚”的升级，⼩作坊什么都要⾃⼰做，⼯⼚是组件式装配，特点就 是⾼效。 框架更加易⽤、简单且⾼效。

使⽤ Spring Boot 项⽬演示框架相⽐于 Servlet 所具备的以下优点：

1. ⽆需配置 Tomcat，点击“运⾏”按钮就可以运⾏项⽬，因为Spring Boot 内置了 Web 容器可直接运行，但是Servlet需外挂Tomcat。
2. 快速添加外部 jar 包。
3. 快速发布项⽬（使⽤ java -jar ⽅式就可以发布）。
4. 对象⾃动装配。
5. 添加路由更加⽅便，⽆需每个访问地址都添加⼀个类。
6. …

或者说使用Servlet相比于Spring Boot有以下的不足：

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

1.3Spring框架学习的难点

• 配置⽐较多。
• 需要⼤量的外部 jar 包，在下载时容易出错。
• 会涉及简单的软件⼯程的设计思想（分层思想：前后端的分层思想；后端⼯程的分层思想）。
• 知识点相对来说⽐之前的知识更加的分散，要仔细听才能搞懂各个知识点的逻辑关系。
• 要记的东⻄很多，所以要⼤量地重复练习才能记住，⽐如各种注解。

Spring框架基本学习路线：Spring->Spring Boot->Spring MVC->MyBatis等

2.Spring框架设计思想

2.1Spring框架的概念

一句话： Spring 框架是包含了众多工具方法的 IoC 容器。

2.2容器是什么？

容器是用来容纳某种物品的（基本）装置。 就比如Map与Set属于数据储存的容器，Tomcat属于Web容器，同理Spring是一个Ioc容器，它包含了许多的工具和方法。

2.3Ioc是什么？

Ioc即IoC = Inversion of Control，直译过来就是控制反转的意思，这是一个比较抽象的概念，我们来通过一个例子来了解它。

我们都知道汽车，它包含轮胎，底座，车身等，我们造一辆汽车时，需要有车身，而车身需要有轮胎，最原始的想法就是造车时，需要车身，于是就new一个车身，而车身需要底座，于是就new一个底座，同理底座需要轮胎，那就造底座前new一个轮胎。

我们不难得到以下代码：

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);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

但是，我们的产品不是一成不变的，产品经理提出一个需求，说这个轮胎大小希望可以个性化，在产品经理眼里，这个问题的解决方案只是改一个参数而已，但是根据我们上面写的代码，我们需要往轮胎Tire类的构造方法加上一个参数，由于底盘Bottom类控制着Tire类，那么底盘类的构造方法也需要加上一个参数，以此类推，我们的车身Framework类与汽车Car类都需要为构造方法加上参数，于是我们得到了如下的代码：

public class NewCarUpdateExample {
    public static void main(String[] args) {
        Car car = new Car(20);
        car.run();
    }
    /**
     * 汽⻋对象
     */
    static class Car {
        private Framework framework;
        public Car(int size) {
            framework = new Framework(size);
        }
        public void run() {
            // 依赖⻋身
            framework.init();
        }
    }
    /**
     * ⻋身类
     */
    static class Framework {
        private Bottom bottom;
        public Framework(int size) {
            bottom = new Bottom(size);
        }
        public void init() {
            // 依赖底盘
            bottom.init();
        }
    }
    /**
     * 底盘类
     */
    static class Bottom {
        private Tire tire;

        public Bottom(int size) {
            tire = new Tire(size);
        }
        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);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

这样，如果需要个性化定制轮胎的大小，就可以只改动构造Car对象传入的参数就可以了。但是，如果产品经理又加上一个需求，说要定制轮胎的颜色，那我们又要加参数，加参数就意味着代码都得改，这样的代码耦合性太高了，为了解决这个问题，我们可以依据loc的思想，我们将控制权交出去，换句话说，需要轮胎Tire类时，你给我传一个Tire对象，我不去new一个Tire对象了，这样的话，就算在Tire类加参数也只需要改动Tire类的构造方法与相关执行方法与属性，顶多再改一下Tire对象的创建，同理其他类也一样，将对象作为参数传入到上级类的构造方法中去就行了，这个过程也叫做传入或注入。

由于我们创建Car时需要Framework，所以先要实例一个Framework对象，同理实例一个Framework对象需要Bottom对象，那么需先实例一个Bottom对象，一样，在实例Bottom对象之前需要实例一个Tire对象，于是需要先后创建Tire对象，Bottom对象，Framework对象后才能创建一个Car对象，我们可以得到如下的代码：

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);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

所以如果产品经理更改了需求，需要加参数或减少参数，Ioc的代码只需改动图中的两处代码即可，达到了解耦的目的。

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

所以Ioc有以下的优点：对象(Bean)的生命周期交给Ioc框架维护，作为程序员无需关注，说白点就是程序员不需要关注对象创建和销毁时机，这些工作加个Ioc框架（也就是Spring）做就行。

2.4Spring 是Ioc容器

我们知道Spring框架包含了多个工具方法放入Ioc容器，既然是容器，那它就有存于取的功能，这也是Spring最核心的功能：

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

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

2.5DI（依赖注入）

DI，即Dependency Injection，依赖注入。在pom.xml有一个依赖项，用来导入外部的资源，而这里的依赖注入，导入的不是外部的资源，而是对象。

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

Ioc与DI的区别是什么？

Ioc是一种思想，而DI是一种实现。

---

下期预告：spring 项目创建

觉得文章写得不错的老铁们，点赞评论关注走一波！谢谢啦！