Spring核心与设计思想

最新推荐文章于 2024-04-09 21:58:05 发布

海绵宝宝养的的小窝

最新推荐文章于 2024-04-09 21:58:05 发布

阅读量137

点赞数

分类专栏： Spring框架学习文章标签： spring java 后端

本文链接：https://blog.csdn.net/qq_59689127/article/details/126115452

版权

Spring框架学习专栏收录该内容

8 篇文章 0 订阅

订阅专栏

文章目录

Spring是什么
- 传统的构建开发
- 控制反转式程序开发
理解Spring Ioc
DI

学习框架相当于从小作坊到工厂的升级，小作坊是什么都要做，工厂是组装式装配，特点就是效率高，且框架更易于使用，因此对于Spring的学习是大势所趋。

Spring是什么

Spring指的是 Spring Framework（Spring 框架），它是⼀个开源框架，有着活跃⽽庞⼤的社区，这就是它之所以能⻓久不衰的原因。Spring ⽀持⼴泛的应⽤场景，它可以让 Java 企业级的应⽤程序开发起来更简单。

Spring是一个包含了众多工具的Ioc容器。

Ioc = Inversion of Control，翻译成中文就是"控制反转"的意思，也就是说Spring是一个控制反转的容器。

传统的构建开发

以构造一辆汽车为例,初始情况下，每辆车的需求都是相同的
在这里插入图片描述

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

/**
 * 车 依赖车身
 */
class Car{
    public void init(){
        FrameWork frameWork = new FrameWork();
        frameWork.init();
    }
}

/**
 * 车身 依赖底盘
 */
class FrameWork{
    public void init(){
        Bottom bottom = new Bottom();
        bottom.init();
    }
}

/**
 * 底盘 依赖于轮胎
 */
class Bottom{
    public void init(){
        Tire tire = new Tire();
        tire.init();
    }
}

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

随着时间推移，人们不在满足只有一种类型的车辆，个性化需求越来越多，我们假设只更改了轮胎尺寸，那么代码：
在这里插入图片描述
我们可以清楚的看到当底层代码发生更改时，整个调用链的代码都需要修改。

如何解决上述问题？
我们可以尝试不在每个类中自己创建下级类，如果自己创建下级类就会出现当下级类发生改变操作，自己也要跟着修改。此时，我们只需要将原来由自己创建的下级类，改为传递的方式（也就是注入的方式），因为我们不需要在当前类中创建下级类了，所以下级类即使发生变化（创建或减少参数），当前类本身也无需修改任何代码，这样就完成了程序的解耦。

控制反转式程序开发

public class CarTest {

    public static void main(String[] args) {
        Tire tire = new Tire(10,"猛男粉");
        Bottom bottom = new Bottom(tire);
        FrameWork frameWork = new FrameWork(bottom);
        Car car = new Car(frameWork);
        car.init();
    }
}

class Car{
    private FrameWork frameWork;
    public Car(FrameWork frameWork){
        this.frameWork = frameWork;
    }
    public void init(){
        frameWork.init();
    }
}

class FrameWork{
    private Bottom bottom;
    public FrameWork(Bottom bottom){
        this.bottom = bottom;
    }
    public void init(){
        bottom.init();
    }
}

class Bottom{
    private Tire tire;

    public Bottom(Tire tire){
        this.tire = tire;
    }

    //初始化轮胎
    public void init(){
        tire.init();
    }
}

class Tire{
    private int size;
    private String color;
    public Tire(int size,String color){
        this.size = size;
        this.color = color;
    }
    public void init(){
        System.out.println("轮胎尺寸" + size + " 轮胎颜色 " + color);
    }
}

代码经过以上调整，无论底层类如何变化，整个调用链是不用做任何改变的，只需创建底层类时增添或修改参数，这样就完成了代码之间的解耦，从而实现了更加灵活、通用的程序设计了。
在这里插入图片描述

我们发现了⼀个规律：通⽤程序的实现代码，类的创建顺序是反的，传统代码是Car 控制并创建了Framework，Framework创建并创建了Bottom，依次往下，⽽改进之
后的控制权发⽣的反转，不再是上级对象创建并控制下级对象了，而是下级将对象注
入到当前对象中，下级的控制权不再由上级类控制了，这样即使下级类发生任何改
变，当前类都是不受影响的，这就是典型的控制反转，也就是IoC的实现思想。