Spring的核心与设计思想

news2025/1/17 0:04:56

IoC

传统程序开发思想

传统程序开发的缺陷

控制反转式程序开发

对比总结

理解Spring IoC

总结

我们通常所说的Spring指的是Spring Framework(Spring 框架),它是一个开源的框架,有着活跃而庞大的社区,Spring支持广泛的应用场景,可以让Java企业级的应用程序开发起来更加简单高效.

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

理解这句话,我们需要明白什么是IoC,什么是容器.

容器就是用来容纳某种物品的基本装置,我们之前也接触过容器,像List,Map是数据存储的容器,Tomcat就是Web容器.

IoC

IoC = Inversion of Control,控制反转.也就是说Spring是一个控制反转的容器.

我们举一个例子来深刻理解"控制反转":

我们用程序来构建一辆车,汽车依赖于车身,车身依赖于底盘,底盘依赖于轮胎.

传统程序开发思想

传统的思想构建一辆车,我们是从上往下,依靠着彼此之间的依赖关系逐层实现.

代码:

public class NewCarExample {
    public static void main(String[] args) {
        Car car = new Car();
        car.init();
    }

    //汽车对象
    static class Car{
        public void init(){
            System.out.println("do car");
            //依赖车身
            Framework framework = new Framework();
            framework.init();
        }
    }

    static class Framework{
        //依赖底盘
        public void init(){
            System.out.println("do framework");
            Bottom bottom = new Bottom();
            bottom.init();
        }
    }

    static class Bottom{
        public void init(){
            //依赖轮胎
            System.out.println("do bottom");
            Tire tire = new Tire();
            tire.init();
        }
    }

    static class Tire{
        //尺寸
        private int size = 17;
        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() {
            // 依赖⻋身
            System.out.println("do car");
            framework.init();
        }
    }
    static class Framework {
        private Bottom bottom;

        public Framework(int size) {
            bottom = new Bottom(size);
        }

        public void init() {
            // 依赖底盘
            System.out.println("do framework");
            bottom.init();
        }
    }
    static class Bottom {
        private Tire tire;
        public Bottom(int size) {
            tire = new Tire(size);
        }
        public void init() {
            // 依赖轮胎
            System.out.println("do bottom");
            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(15);
        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(){
            System.out.println("do car");
            framework.init();
        }
    }

    static class Framework{
        private Bottom bottom;
        public Framework(Bottom bottom){
            this.bottom = bottom;
        }
        public void init(){
            System.out.println("do framework");
            bottom.init();
        }
    }

    static class Bottom{
        private Tire tire;
        public Bottom(Tire tire){
            this.tire = tire;
        }
        public void init(){
            System.out.println("do bottom");
            tire.init();
        }
    }

    static class Tire{
        private int size = 20;
        public Tire(int size){
            this.size = size;
        }
        public void init(){
            System.out.println("轮胎尺寸: " + size);
        }
    }
}