前面的话

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

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

---

??导航小助手??

• 1.Spring系列框架概述
• • 1.1什么是Spring框架
  • 1.2为什么要学习框架？
  • 1.3Spring框架学习的难点
• 2.Spring框架设计思想
• • 2.1Spring框架的概念
  • 2.2容器是什么？
  • 2.3Ioc是什么？
  • 2.4Spring 是Ioc容器
  • 2.5DI（依赖注入）

---

---

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 项目创建

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