Spring 核心

发布时间:2023-01-07 10:00

目录

1. loC是什么?

1.1  改变之前的程序

1.2 修改后的代码

1.3 解决上述代码耦合问题

 2. 理解Spring 是一个loC(控制反转)容器

3. DI (dependency injection) 依赖注入


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容器运行期间),动态地将某个依赖注入到类中。

(MS)

loC :将控制权反转,自己不再new一个对象,而是将控制权交给别人,将下级对象传入上级对象。

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

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

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

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

 

ItVuer - 免责声明 - 关于我们 - 联系我们

本网站信息来源于互联网,如有侵权请联系:561261067@qq.com

桂ICP备16001015号