Spring核心与设计思想

最新推荐文章于 2023-06-11 17:43:03 发布

学习自省

最新推荐文章于 2023-06-11 17:43:03 发布

阅读量722

点赞数 1

文章标签： spring

本文链接：https://blog.csdn.net/c_study__c/article/details/130051663

版权

日升时奋斗，日落时自省

1、Spring概念

如果学java我们通常说的Spring就是指是Spring Framework（Spring框架），是一个开源框架，有众多佬维系着，Spring支持应用广泛，让开发更加简单

概念理解 Spring：Spring是包含了众多工具方法的IoC容器

首先先确定一个概念：IoC是一种思想，不是一个工具，而Spring正式用于IoC思想

注：重点在于容器和IoC的理解

1.1、容器

容器其实是就是我们日常理解的概念，能承载一些东西，例如：杯子可以承载水；杯子就是一个容器

此处的容器只不过承载的是代码了

我们之前也学过容器：

<1>List/Map ：数据存储容器

<2>Tomcat ： Web容器（存储Web项目）

1.2、IoC

Spring就是一个容器，但是这个容器具有IoC思想的容器（IoC容器）

IoC全称：Inversion of Control 翻译成中文是“控制反转”的意思，也就是说Spring是一个“控制反转”容器；

IoC思想怎么理解：“控制反转”：重点反转

1.2.1、IoC对比传统程序

<1>传统情况下：

当前有个 A -->B -->C 表示A控制B --> B控制C 这就是一个日常的操作

缺陷：如果C出现问题，就会导致 B出现问题，B出现问题，就会导致A出现问题（连锁问题）

我们代码也是如此：上层控制下层，耦合性很高，会给编写代码的人员带来后期维护的大难题，改动下层的一个代码，上层代码同样也要修改（所有点与点之间的联系都是依赖关系，被动关系）

<2>IoC情况下：

还是以A -->B -->C为例，IoC思想就是反转当前状态，A原来是掌控B的，但是现在让A只加载B，让其他人来操作B的使用，这样A在B修改时就会受到B的影响；C也同样让B只加载C，让其他人来操作C的使用，B在C修改的同时也不会影响到B；

上下层之间就降低了耦合性，如果我要修改C不会影响B，更不会影响A

1.2.2、举例说明

以一辆车的构架说明IoC思想的优势：

传统情况下：

一辆车（Car）需要车身（Framework）来维系，车身需要底盘（Bottom）来维系，底盘需要车轮（Tire）（直属于依赖关系）

注：英文标注表示下面代码的类名

传统情况的缺陷：当底层代码改动之后，整个调用链上的代码都需要修改

附代码（依赖关系）：

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(2);
        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("size -> "+size);
    }
}

IoC思想：

附代码：

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 trie){
        this.tire=trie;
    }
    public void init(){
        System.out.println("do Bottom...");
        tire.init();
    }
}

Trie类代码：

public class Tire {
    private int size=12;
    public Tire(int size){
        this.size=size;
    }
    public void init(){
        System.out.println("size -> "+size);
    }
}

Test测试类：

public class Test {
    //IoC是一种思想，不是一种插件，在很多地方都可以表现出来，主要是为了解耦性
    //降低代码的连接性，防止改一个代码而出现一连串的错误
    //IoC也叫做控制反转
    public static void main(String[] args) {
        Tire tire=new Tire(12);
        Bottom bottom =new Bottom(tire);
        FrameWork frameWork=new FrameWork(bottom);
        Car car=new Car(frameWork);
        car.init();
    }
}