【Java】Spring核心与设计思想-蒲公英云

文章目录

Spring核心与设计思想
- 1. Spring是什么
- - 1.1 什么是容器
  - 1.2 什么是IOC
  - - 1.2.1 传统程序开发
    - 1.2.2 控制反转式程序开发
    - 1.2.3 对比总结规律
- 1.3 理解Spring IOC
- 1.4 DI概念说明

Spring核心与设计思想

1. Spring是什么

我们通常所说的Spring指的是Spring Framework（Spring框架），它是一个开源的框架。有着庞大而且活跃的社区，这也是长久不衰的原因。

用一句话来概括：Spring是包含了众多工具方法的IOC容器。

那么什么是容器？什么是IOC容器？

1.1 什么是容器

容器就是用来容纳某种物品。

什么是IOC？

IOC翻译成中文的意思就是“控制反转”的意思，也就是说Spring是一个控制反转的容器

1.2 什么是IOC

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

传统程序开发的缺陷：以上程序轮胎的尺寸是固定的，然而车的需求量越来越大，个性化需求也越来越多。这时候我们需要加工多种尺寸的轮胎

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

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

这种问题怎么解决那？

我们可以尝试不在每个类当中创建自己的下级类，如果自己创建下级类就会出现当下级类发生改变操作，自己也要跟着修改

此时，我们只需要将原来由自己创建的下级类改为传递的方式（也就是注入的方式）因为我们不需要在当前类当中创建下级类了，所以下级类发生变化（创建或减少参数），当前类本身也无需修改任何代码，这样就完成了程序的解耦

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

1.2.2 控制反转式程序开发

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 对比总结规律

在传统的代码当中，创建顺序是Car -> FrameWork -> Bottom -> Tire

改进的解耦之后的代码创建对象的顺序是：Tire -> Bottom -> FrameWork -> Car

我们发现一个规律：通用程序的实现代码，类的创建是反转的，传统代码Car控制并创建了FrameWork，依次往下。而改进之后的控制权发生反转不再是上级对象创建并控制下级对象了，而是下级对象注入到当前对象当中。下级的控制权不再由上级类控制了，这样即使下级类发生变化，当前类不受影响。这就是典型的控制反转，也就是IOC的实现思想