2-Spring核心与设计思想

X-musk

已于 2023-07-15 08:39:50 修改

阅读量675

点赞数 1

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

于 2023-01-18 14:53:18 首次发布

本文链接：https://blog.csdn.net/WWXDwrn/article/details/128724312

版权

JavaEE 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

Spring是一个开源框架，提供IoC容器来管理对象。IoC（控制反转）意味着对象的创建和控制权转移给Spring，降低了代码间的耦合。DI（依赖注入）是IoC的实现方式，允许对象在运行时注入依赖。通过这种方式，当底层代码变化时，上层代码无需修改，实现了更好的解耦和灵活性。

摘要由CSDN通过智能技术生成

4.1.将对象(Bean)存入到容器(Spring)；

4.2.从容器中取出对象。

5.DI概念说明

6.IoC VS DI

1.Spring是什么？

Spring指Spring Framework(Spring框架)，它是一个开源免费框架，有着活跃而庞大的社区（版本升级迭代快），支持广泛的应用场景，能让Java企业级的应用程序开发起来更简单。因此而长久不衰。

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

2.容器是什么？

容器是用来容纳某种物品的（基本）装置。

之前接触的容器有：

List/Map->数据存储容器；
Tomcat->Web容器。

3.IoC是什么？

IoC=Inversion of Control翻译成中文是“控制反转”的意思，也就是之前需要自己去控制的东西现在交给Spring框架去控制。

3.1.传统程序开发

例：构建一辆车(Car Class)，而车需要依赖车身(Framework Class)，而车身需要依赖底盘(Bottom Class)，而底盘需要依赖轮胎(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(); //和init()方法是一个意思
    }

    /**
     * 汽车对象
     */
    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);
        }
    }
}

以上程序的问题：由于在每个类中自己创建下级类，当最底层的代码改动之后，整个调用链上的所有代码都需要修改。

3.2.控制反转式程序开发

为解决传统开发中的缺陷，便不在每个类中自己创建下级类，而是将原来由自己创建的下级类，改为传递（注入）的方式，这样下级类即使发生变化（创建或减少参数），当前类本身也无需修改任何代码，就完成了程序的解耦。

PS:解耦指的是解决了代码的耦合性/程序相关性。好程序代码的耦合性是很低的。

好比：打造一辆完整的汽车，如果所有的配件都是自己造，那么当客户需求发生改变时，比如轮胎尺寸不再是原来尺寸了，那就要自己动手来改了；但如果把轮胎外包出去，那即使轮胎尺寸改变，也只需向代理工厂下订单就行，自身不需要出力。

基于以上思想，对以上代码进行修改，修改轮胎尺寸并添加材质，创建子类的方式->注入传递的方式：

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;
        //材质
        private String type;

        public Tire(int size, String type) {
            this.size = size;
            this.type = type;
        }

        public void init() {
            System.out.println("轮胎尺寸：" + size + " | 材质：" + type);
        }
    }
}

3.3.对比总结规律

传统程序开发对象创建顺序：Car->Framework->Bottom->Tire；

控制反转式程序开发对象创建顺序：Tire->Bottom->Framework->Car。

改进之后的控制权发生反转，不再是上级对象创建并控制下级对象了，而是下级对象注入到当前对象中，下级的控制权不再由上级类控制了，这样即使下级类发生任何改变，当前类都是不受影响的，这就是典型的控制反转，也是IoC的实现思想。

4.理解Spring IoC

Spring是一个IoC容器(不代表Spring等于IoC容器，Spring只是IoC容器中的一种)，它就具备了最基础的功能：

4.1.将对象(Bean)存入到容器(Spring)；

4.2.从容器中取出对象。

对象的创建和销毁权力都交给Spring来管理了，它本身又具备了存储对象和获取对象的能力。程序员不需要自己去new对象了。

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

new对象：相当于每次需要工具时才现做，用完就扔掉也不保存，下次再用的时候还得重做。

Spring框架相比传统写法的优点

1）之前需要一个对象是需要去new的，现在不用去new,直接去spring中去取，好处是不再去关心一个对象它是什么时候创建的，什么时候销毁的，需要用的时候直接去用就行。
2）我直接去用一个对象，这个对象的修改，它的构造函数加上一个/多个参数或者去掉一个/多个参数，与我无关，我的代码不需要去管，直接去用就行。当最底层的代码发生变化时，我当前的代码是不需要发生改变的，从而实现了代码解耦的功能。