Spring(一):Spring核心与设计思想(IoC、DI)

最新推荐文章于 2023-04-06 17:51:23 发布

No regrets、

最新推荐文章于 2023-04-06 17:51:23 发布

阅读量449

点赞数

分类专栏： Spring 文章标签： spring java 后端

本文链接：https://blog.csdn.net/m0_60631323/article/details/128275909

版权

Spring 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

一、Spring是什么

我们这里所说的Spring指的是SpringFrameWork，是一个开源框架。Spring支持广泛的应用场景，它可以让Java企业级的应用程序开发起来更简单。
一句话概括就是，Spring是包含了众多工具方法的IoC容器。

1.1 容器是什么？

容器就是用来容纳某种物品的装置

在之前我们用过的容器有，List/Map/Set -> 数据存储容器，Tomcat -> Web容器

1.2 什么是IoC？

IoC = Inversion of Control 翻译成中⽂是“控制反转”的意思，也就是说 Spring 是⼀个“控制反转”的容器

在看下面的示例之前我们先想一个问题，当我们在A类中需要B类时，应该怎样得到B类呢？我们正常的想法肯定是，既然我在A类中需要使用B，那么我直接在A类中new B()不就可以了吗。这种做法可以实现，但是有弊端-代码之前耦合度太高。
而控制反转的思想是怎么做的呢？之前在A类中需要使用B类，需要程序员自己通过程序和代码来控制B的生命周期(也就是控制B的创建和销毁)，Spring提供的实现方式是，如果在A类中需要使用B，此时不需要在A类中通过new 的方式得到B，也就是不需要再A类中控制B类的生命周期了，可以将这个控制权交给Spring，我们要在A类中使用B，直接从Spring中获取B就可以了。

【传统程序开发】
假如，我们现在构建⼀辆"车"的程序，我们的实现思路是这样的：建⼀辆车（Car Class），然而车需要依赖车身(FrameWork Class)，而车身需要依赖底盘（BottomClass），而底盘需要依赖轮胎（Tire Class），最终程序的实现代码如下
在这里插入图片描述
代码实现：

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

传统开发的问题：当最底层代码改动之后，整个调用链上的所有代码都需要修改

如何解决这个问题呢？

我们可以尝试不在每个类中自己创建下级类，这种方式代码之间的耦合性太高，因此我们只需将原来自己创建的下机类，改为传递的方式(也就是注入的方式)，因此我们不需要在当前类中创建下级类了，所以下级类即使发生变化(增加或减少参数)，当前类本身也不用修改任何代码，从而完成了程序的解耦。

【控制反转式程序开发】
我们把调⽤汽⻋的程序示例改造⼀下，把创建⼦类的⽅式，改为注⼊传递的⽅式，具体实现代码如下：

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