Spring核心与设计思想

追梦不止～

已于 2023-04-14 16:26:53 修改

阅读量594

点赞数 3

文章标签： spring java spring boot

于 2023-04-13 21:18:16 首次发布

本文链接：https://blog.csdn.net/m0_64318128/article/details/130139316

版权

Spring是一个开源框架，核心是IoC容器，实现控制反转和依赖注入，降低代码间的耦合度，提高应用的灵活性和可测试性。IoC是将对象的创建权交给容器，而DI是IoC的一种实现，通过注入依赖对象实现解耦。

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

什么是Spring？

我们通常说的Spring是一个开源框架，它可以让应用程序的开发更加简单。

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

它最核心的功能就是容器管理。

什么是IoC？什么是容器？

容器

所谓容器，就是一个装物品的器具，比如我们日常生活中的水杯，它是装载水的容器。

在编程中，List、ArrayList、HashMap、线程池.....都可以看做是一个容器。

IoC

IoC，是一种设计思想，它的全称是 Inversion of Control ，翻译成中文就是 “控制反转” 的意思。

控制反转：

将创建对象的工作交给容器，此时对象的实例不需要调用者来创建，而是由容器来创建，容器会负责控制程序之间的关系，而不是调用者通过代码控制。

这样，控制权从应用代码转给了容器，控制权发生了反转，这就是控制反转，是Spring的最核心思想之一。

举个例子：

比如我要用程序造一辆车。

那么在造车之前我要先造出车身。

//汽车类
public class Car {
    //车身类
    private Framework framework;
    public Car() {
        framework = new Framework();
    }
    //造车
    public void init() {
        System.out.println("do Car");
        framework.init();
    }
}

在造车身之前要先造出车的底盘。

//车身类
public class Framework {
    //底盘类
    private Bottom bottom;
    public Framework() {
        bottom = new Bottom();
    }
    //造底盘
    public void init() {
        System.out.println("do Framework");
        bottom.init();
    }
}

造出车的底盘之前要先造出符合它的轮胎。

//底盘类
public class Bottom {
    //轮胎类
    private Tire tire;
    public Bottom() {
        tire = new Tire();
    }
    //造底盘
    public void init() {
        System.out.println("do Bottom");
        tire.init();
    }
}

造轮胎需要给轮胎一个尺寸。

//轮胎类
public class Tire {
    //轮胎尺寸
    private int size = 10;
    //造轮胎
    public void init() {
        //输出轮胎的尺寸
        System.out.println("size -> " + size);
    }
}

层层创建之后，我们对汽车类的创造过程进行输出：

//汽车类
public class Car {
    //车身类
    private Framework framework;
    public Car() {
        framework = new Framework();
    }
    //造车
    public void init() {
        System.out.println("do Car");
        framework.init();
    }
    //输出汽车
    public static void main(String[] args) {
        Car car = new Car();
        car.init();
    }
}

输出如下：

根据上述的步骤我们造出了一台车，但是这个时候，我想让用户自己定制轮胎的尺寸大小，那么我就要从Car类开始对轮胎的尺寸进行一个输入，然后其他的类也都要依次加上参数的传递。

如下：

//汽车类
public class Car {
    private Framework framework;
    public Car(int size) {
        framework = new Framework(size);
    }
    public void init() {
        System.out.println("do Car");
        framework.init();
    }

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

//车身类
public class Framework {
    private Bottom bottom;
    public Framework(int size) {
        bottom = new Bottom(size);
    }
    public void init() {
        System.out.println("do Framework");
        bottom.init();
    }
}

//底盘类
public class Bottom {
    private Tire tire;
    public Bottom(int size) {
        tire = new Tire(size);
    }
    public void init() {
        System.out.println("do Bottom");
        tire.init();
    }
}

//轮胎类
public class Tire {
    public int size = 10;
    public Tire(int size) {
        this.size = size;
    }
    public void init() {
        System.out.println("size -> " + size);
    }
}

此时我们在Car类中进行输入15，此时输出如下：

输出是符合我们预期的，但是我们也可以发现一个问题，我的轮胎类修改/添加/删除了一个属性，那么这一系列的类都要进行修改，耦合度很高。

这是因为我们每个类都在内部创建了其依赖的下一个类的对象，也就是说本类对其他类对象进行控制，此时若是这个被控制的对象所对应的类发生了改变，那么本类就也需要对代码进行整改。

而使用IoC的思想“控制反转”，就可以对代码进行一个整改，我们不再对其依赖的类在本类里进行实例化，而是将控制权交托出去，使用时，我们只需要获取对象，而不需要管这个对象的其他依赖。

如下：

//汽车类
public class Car {
    private Framework framework;
    public Car(Framework framework) {
        this.framework = framework;
    }
    public void init() {
        System.out.println("do car...");
        framework.init();
    }
}

//车身类
public class Framework {
    private Bottom bottom;
    public Framework(Bottom bottom) {
        this.bottom = bottom;
    }
    public void init() {
        System.out.println("do Framework...");
        bottom.init();
    }
}

//底盘类
public class Bottom {
    private Tire tire;
    public Bottom(Tire tire) {
        this.tire = tire;
    }
    public void init() {
        System.out.println("do Bottom...");
        tire.init();
    }
}

//轮胎类
public class Tire {
    private int size = 17;
    private String color = "绿色";

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

    public void init() {
        System.out.println("size -> " + size + " color -> " + color);
    }
}

//输出
public class Test {
    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.init();
    }
}

上面的代码和前面的代码的区别就是：使用IoC思想，将依赖的类通过第三方（Test类）获取到，这样即使依赖的类发生了改变，本类也不需要进行修改，只需要第三方进行修改即可。这就是一个控制权反转的过程。