1.初识Spring

Srping指的是Spring Framework(Spring 框架).我们经常会听见框架二字,其中java中最最主流的框架当属Spring.Spring是一个开源框架,有着活跃且庞大的社区.那说了这么多,Spring框架又是什么呢,又有什么作用呢?

再具体一点来说,Spring框架就是一个包含了众多工具方法的IoC容器.基于这个容器,Java企业级的开发可以变得更简单.那么问题又来了,IoC容器又是什么呢?

1.1 什么是容器

了解IoC容器之前,我们得先了解一下什么是容器.在java中,应该了解List/Map吧,List/Map就是一个数据存储的容器.还有Tomcat,它就是一个web容器.所以啊,容器啊,其实就和它字面上的意思差不多,就是用来容纳某种物品的装置,可放可取.List/Map存放的是一些数据,有些网站就是运行在tomcat这个容器上.那IoC容器具体是干嘛的呢?

1.2 什么是IoC

IoC全称Inversion of Control,翻译成中文就是"控制反转"的意思.也就是说Spring是一个"控制反转"的容器.怎么理解这个"控制反转"呢,我们先来看一个例子:

比如我现在要造一辆车:

第一种思想就是造车需要依赖车身,车身需要依赖底盘,底盘需要依赖轮胎.大致流程如下图:

代码实现:
public class NewCar {
    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 = 20;
        public void init() {
            System.out.println("轮胎尺⼨：" + size);
        }
    }
}
按照上诉思想,我们确实是可以实现一辆车的构造的.但是仔细想一下,我现在的车的轮胎尺寸是固定的,随着用户需求的增大,轮胎的尺寸需求可能不一样,这时,我们就需要改变一下代码了:
public class NewCar2 {
    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);
        }
    }
}
对比一下这两段代码,我们可以发现,就新增轮胎尺寸这一小改动,这个车的整个链就都要发生改动.

以上仅仅只是改动了轮胎的尺寸,但是随着用户需求的多样化,比如对轮胎的材质,样式等等可能会有各种各样的要求,每一个小的改动都会触发整个链,显然,这就加大了成本.那有没有另外一种思想,当我们修改底层代码时,不会影响到其他的业务代码呢?要找到另一种更好的方法,我们就要分析一下,为什么当前代码不太好.通过观察我们可以发现,一环扣一环是因为每一个类中都new了自己依赖的一个下级类,当下级类改变时,上级类就需要做出相应的更改.故这样的设计就会导致下级出现问题,上级就要进行修改.

所以为了降低它这个耦合度,我们就可以用以下这个方法:

我们不再在类中new一个它所依赖的下级类了,而是将下级类主动的传进去(也就是注入),按照这种方法,我们就不需要将new它的下级类,这样下级类改不改变都不会影响我当前类的设计.就成功完成了解耦.

按照以上的思路,我们将创建下级对象改为注入传递下级对象的方式,代码如下:
public class NewCar3 {
    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);
        }
    }
}
上述代码可以看出,我们没有在类中创建它所需要的对象了,而是将它所需要的对象传递了进来.

无论底层怎样改变,整个调用链都不需要做任何更改的,这就使我们的设计更灵活了.用图来表示就是:

对比总结规律:

第一种思想中对象创建顺序是：Car -> Framework -> Bottom -> Tire

第二种思想的对象创建顺序是：Tire -> Bottom -> Framework -> Car

从这张图片我们就可以看出,这两种设计方法对类的创建恰恰是相反的.第一种思想是:先创建汽车类,再由汽车类创建并控制车身类,然后车身类创建并控制底盘类,依次向下,直到底层.也就是说,由当前类创建并控制下级类的,依次向下,直到底层,环环相扣.而第二种思想是与第一种截然不同的是,将这种从上到下的控制权进行了反转.也就是说,下级类不再由当前类所创建了,而是下级类自己主动注入到当前类中.这样下级类就摆脱了当前类的控制,故下级类无论怎样变,都不会影响到当前类了,这就是典型的控制反转,也就是IoC的实现思想.

2.什么是IoC容器.

还是回到我们最开始的这句话上:Spring是一个包含了众多工具的IoC(控制反转)容器.至于这个"众多工具"我以后再讲,现在可以粗略的理解为具有很多功能.控制反转相信大家通过上述造车的例子已经有所了解了,就是通过注入"属性"的方法.将控制权反转.

Spring是一个包含了众多工具的IoC容器,这句话归根结底,就还是"容器"二字.既然是"容器",那它就具备两个最基本的功能:

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

所以我们要学习Spring最核心的功能就是,就是如何将对象存储到容器中,再从Spring中将对象取出来.

IoC容器和普通程序开发的区别:

将对象存储到IoC容器中就相当于我们在做一项工程时,将需要的工具都先存放在仓库里面.需要的时候直接取就行了,用完了再放回去.而之前new 对象的方式就相当于需要的时候就现做,用完了就销毁,某个时候又需要的话就再重新创建.这就是IoC容器和普通程序开发的区别.从中我们也可以发现IoC的优势之处.

Spring是一个IoC容器,说的是对象的创建和销毁都交给Spring来控制了.它本身又具有存储对象和获取对象的权利.