本文已收录于专栏 🌲《Spring从入门到实战》🌲

专栏前言

   大家好，我是执梗。本专栏将从Spring入门开始讲起，详细讲解各类配置的使用以及原因，到使用SpringBoot进行开发实战，旨在记录学习生活的同时也希望能帮到大家，如果对您能有所帮助，还望能点赞关注该专栏，对于专栏内容有错还望您可以及时指点，非常感谢大家 🌹。

1.什么是Spring？

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

  如果用一句话来概括：什么是Spring这个问题？
我的回答是：Spring是包含了众多工具方法的IOC容器
   当然接踵而至的问题来了？什么是容器呢？什么又是IOC呢？

2.什么是容器？

  这个很好理解，容器就是用来容纳某种物品的装置。比如我们生活中常用的水杯，水桶这些都可以看做是容器。
  当然在之前的学习过程中我们也肯定接触过一些容器

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

3.什么是IOC？

  Spring也是一个容器，是一个IOC容器，那么说明是IOC呢？
  IoC = Inversion of Control 翻译成中⽂是 “控制反转” 的意思，也就是说 Spring 是⼀个“控制反转”的容器。

  想详细搞清楚IOC的含义，我们从一个开发一辆小汽车的案例来详细讲解：
现在我们构建一辆车，我们的实现思路是这样的：

  一辆车的构造肯定需要车身、而车身需要底盘，底盘需要轮胎。两两之间存在相互依赖的关系。
我们可以根据业务逻辑写出以下代码：

1.传统开发写法

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

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

public class NewCarExample {
    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
60
61
62
63
64
65
66
67
68
69
70

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

如何解决上述问题呢？

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

PS：解耦指的是解决了代码的耦合性，耦合性也可以换⼀种叫法叫程序相关性。好的程序代码的耦合性（代码之间的相关性）是很低的，也就是代码之间要实现解耦。这就好⽐我们打造⼀辆完整的汽车，如果所有的配件都是⾃⼰造，那么当客户需求发⽣改变的时候，比如轮胎的尺寸不再是原来的尺⼨了，那我们要⾃⼰动⼿来改了，但如果我们是把轮胎外包出去，那么即使是轮胎的尺寸发⽣改变了，我们只需要向代理⼯⼚下订单就⾏了，我们⾃身是不需要出力的。

2.控制反转式程序开发

public class NewCarExample {
    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
47
48
49
50
51
52
53
54
55
56
57
58

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

4.对比总结规律

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

5.理解 Spring IoC

  本⽂刚开始咱们就讲：Spring 是包含了多个⼯具⽅法的 IoC 容器，这就是
对 Spring 最核⼼的总结。“集成多个⼯具⽅法”这事咱们以后慢慢再讲，那如何理解 “Spring 是⼀个 IoC容器” 这句话呢？

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

• 将对象存入到容器
• 从容器中取出对象

也就是说学Spring 最核心的功能，就是学如何将对象存入到 Spring 中，再从 Spring 中获取对象的过程。 Spring 是⼀个 IoC 容器，说的是对象的创建和销毁的权利都交给 Spring 来管理了，它本身⼜具备了存储对象和获取对象的能⼒。