Spring 核心loC

Youcan.

已于 2022-10-14 15:21:46 修改

阅读量1.2k

点赞数 2

分类专栏： JavaEE Java 文章标签： spring java servlet

于 2022-07-01 16:46:00 首次发布

本文链接：https://blog.csdn.net/m0_48273471/article/details/125556259

版权

Java 同时被 2 个专栏收录

76 篇文章 3 订阅

订阅专栏

JavaEE

41 篇文章 2 订阅

订阅专栏

2. 🐾理解Spring 是一个loC（控制反转）容器

3. 🐾DI （dependency injection）依赖注入

4. loC 、DI 总结及优点

1. 🐾loC是什么？

Spring 相当于是一个容器，可以用来容纳物品。

List / Map ---- 数据存储容器

Tomcat ---- Web容器

loC 就是“控制反转” 的意思，也可以说是：Spring 是一个“控制反转”的容器，loC 可以解决程序之间的耦合问题。

1.1 🐾改变之前的程序

🚗 一辆汽车 ----> 依赖于车身 ----> 依赖于底盘 ----> 依赖于轮胎

public class L1 {
    //汽车
    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 static void main(String[] args) {
        Car car = new Car();
        car.init();
    }
}

缺点：

轮胎的尺寸固定，不能随意更改轮胎尺寸以及满足其他要求。

1.2 🐾修改后的代码

public class L1 {
    //汽车
    static class Car{
        private Framework framework;

        public Car(int size,String type) {
            framework = new Framework(size,type);
        }
        public void init() {
            //依赖于车身
            framework.init();
        }
    }
    //车身
    static class Framework{
        private Bottom bottom;

        public Framework(int size,String type) {
            bottom = new Bottom(size,type);
        }
        public void init() {
            //依赖于底盘
            bottom.init();
        }
    }
    //底盘
    static class Bottom{
        private Tire tire;

        public Bottom(int size,String type) {
            tire = new Tire(size,type);
        }
        public void init() {
            //依赖于轮胎
            tire.init();
        }
    }

    //轮胎
    static class Tire{
        //尺寸
        private int size;
        private String type;

        public Tire(int size,String type) {
            this.size = size;
            this.type = type;
        }
        public void init() {
            System.out.println("轮胎尺寸" + size + " 材质" + type);
        }
    }
    public static void main(String[] args) {
        Car car = new Car(20,"金");
        car.init();
    }
}

以上两种代码存在问题：当轮胎要求（最底层代码）发生变化时，整个调用链都需要修改。

解决该问题：

不在每个类中创建下级类，改为传递的方式，此时当下级类发生变化，当前类无需修改任何代码，即就是解耦（解耦是指解决了代码的耦合性，也可以说是解决了程序相关性）。

就相当于，需要一辆完整的汽车，但是每个客户需求不一样，比如有的要求轮子大小，那么我们就可以将轮胎制作交给专门制作轮胎的工厂，只需要告诉他们我们需要的轮胎尺寸大小，将我们对轮胎控制权转给这个轮胎工厂，工厂拥有这个轮胎的控制权。

1.3 🐾解决上述代码耦合问题

轮胎传递给 ----> 底盘传递给 ----> 车身传递给 ----> 🚗一辆汽车

解决代码耦合问题之前，类的创建顺序是反的，car 创建 Framework ，Framework再创建Bottom......解决代码耦合问题时，不再是上级对象创建并控制下级对象，而是把下级对象传入给上级对象，下级对象不再由上级对象控制，即使下级对象发生代码改变，也不会影响上级变化。这就是控制反转，也是loC实现的思想。

public class L1 {
    //汽车
    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;
        private String type;

        public Tire(int size,String type) {
            this.size = size;
            this.type = type;
        }
        public void init() {
            System.out.println("轮胎尺寸" + size + " 材质" + type);
        }
    }
    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();
    }
}

2. 🐾理解Spring 是一个loC（控制反转）容器

Spring 是包含多个工具方法的loC容器

Spring 是一个 loC 容器：对象的创建和销毁权力都交给Spring 管理，而Spring 本身就具有存储对象和获取对象的权力。

Spring 具备的核心功能：

💫 将对象（Bean）存入到容器中

💫 从容器中取出对象

为什么要将对象存储到容器中？

将对象存储到 loC 容器中相当于将以后可能用到的所有工具制作好放到仓库里，需要的时候直接取出，用完再放回仓库。

之前所用的 new 一个对象，每次在需要工具的时候才开始制作，用完就扔掉。

3. 🐾DI （dependency injection）依赖注入

在程序运行期间（loC容器运行期间），动态地将某个依赖注入到类中。

4. loC 、DI 总结及优点

（MS）

loC ：将控制权反转，自己不再new一个对象，而是将控制权交给Spring的bean工厂帮我们创建管理。这也是Spring的核心思想，通过面向接口编程的方式来实现对业务组件的动态依赖。也意味着，loC是Spring针对解决代码耦合而存在的。

在实际应用中，Spring通过配置文件（xml或者properties）指定需要实例化的java类，包括这些类的一组初始化值，通过加载读取配置文件，用Spring提供的方法（getBean（））就可以获取到我们想要的根据指定配置进行初始化的实例对象。

DI：依赖注入。在需要某个类中要使用另外一个类，不需要new，直接注入一个依赖。

组件之间依赖关系由容器在运行期决定，形象的说，即由容器动态的将某个依赖关系注入到组件之中。依赖注入目的是为了提升组件的重用率，并未系统搭建一个灵活、可扩展的平台。通过依赖注入机制，我们只需要通过简单的配置，而无需任何代码就可指定目标需要的资源，完成自身的业务逻辑，而不需要关心具体的资源来自何处，有谁实现。

从不同的角度来描述同一件事。

loC ：是一种指导思想，比如说，今天中午想吃KFC

DI：是具体的实现，比如，今天中午吃了KFC