Spring 核心与设计思想网站首页 其他

Spring 核心与设计思想

银河罐头 2023-06-30 16:00:03

简介Spring 核心与设计思想

✏️作者：银河罐头
📋系列专栏：JavaEE

🌲“种一棵树最好的时间是十年前，其次是现在”

Spring 是什么？

通常所说的 Spring 指的是 Spring Framework(Spring 框架)。

Spring 是包含多种工具方法的 IoC容器。

什么是 IoC？

IoC(Inversion of Control): 控制反转

"控制反转"又是什么意思？

下面以一个程序来举例。

假如我们现在要写一个构建 Car 的程序。

实现思路是： Car(车) -> Framework(框架) -> Bottom(底盘) -> Tire(轮胎) -> Size(轮胎尺寸)

传统程序开发

// Car 类
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();
    }
}
// Framework 类
public class Framework {
    private Bottom bottom;
    public Framework(){
        bottom = new Bottom();
    }
    public void init(){
        System.out.println("do framework");
        bottom.init();
    }
}
// Bottom 类
public class Bottom {
    private Tire tire;
    public Bottom(){
        tire = new Tire();
    }
    public void init(){
        System.out.println("do bottom");
        tire.init();
    }
}
// Tire 类
public class Tire {
    private int size = 17;
    public void init(){
        System.out.println("do tire");
        System.out.println("size = " + size);
    }
}

可以发现上述代码中 size 是写死的，如果我想size = 另一个值，就需要改动上述代码。

// 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(40);
        car.init();
    }
}
// Framework 类
public class Framework {
    private Bottom bottom;
    public Framework(int size){
        bottom = new Bottom(size);
    }
    public void init(){
        System.out.println("do framework");
        bottom.init();
    }
}
// Bottom 类
public class Bottom {
    private Tire tire;
    public Bottom(int size){
        tire = new Tire(size);
    }
    public void init(){
        System.out.println("do bottom");
        tire.init();
    }
}
// Tire 类
public class Tire {
    private int size = 17;
    public Tire(int size){
        this.size = size;
    }
    public void init(){
        System.out.println("do tire");
        System.out.println("size = " + size);
    }
}

可以看出，当最底层的代码改了之后，从下到上整个调用链的代码都要改动，这些类彼此之间的耦合程度是非常高的。

如何解决上述问题？

目前是在每个类中自己创建下级类，如果对下级类的参数进行修改，那么整个类也得跟着改。那我现在就不在这个类里面创建下级类了，我交给别人去创建，需要时传递(注入)就可以了。这样就完成了程序的"解耦"。

控制反转式程序开发

// Car 类
public class Car {
    private Framework framework;
    public Car(Framework framework){
        this.framework = framework;
    }
    public void init(){
        System.out.println("do car");
        framework.init();
    }
}
// Framework 类
public class Framework {
    private Bottom bottom;
    public Framework(Bottom bottom){
        this.bottom = bottom;
    }
    public void init(){
        System.out.println("do framework");
        bottom.init();
    }
}
// Bottom 类
public class Bottom {
    private Tire tire;
    public Bottom(Tire tire){
        this.tire = tire;
    }
    public void init(){
        System.out.println("do bottom");
        tire.init();
    }
}
// Tire 类
public class Tire {
    private int size = 16;
    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);
    }
}
// Test 类
public class Test {
    public static void main(String[] args) {
        Tire tire = new Tire(30,"黑色");
        Bottom bottom = new Bottom(tire);
        Framework framework = new Framework(bottom);
        Car car = new Car(framework);
        car.init();
    }
}