Spring核心与设计思想

日升时奋斗，日落时自省 

目录

1、Spring概念

1.1、容器

1.2、IoC

1.2.1、IoC对比传统程序

1.2.2、举例说明

1.2.3、总结

2、DI概念理解

---

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();
    }
}

1.2.3、总结

Spring是包含了多个工具方法的IoC容器，一个IoC（控制反转）容器，具备两点功能

<1>将对象存入容器中；

<2>从容器中取出对象；

Spring的核心功能，就是将对象存入到Spring中，再从Spring中获取对象的过程，对象的创建和销毁的权利都交给Spring来管理了，Spring本身又具备了存储对象和获取对象的能力

Spring优势：将对象存储在IoC容器相当于将以后可能用的所有工具制作好都放到仓库中，需要的时候直接取就行了，用完再把它放回到仓库，new对象的方式相当于，每次需要工具了，才现做，用完也不会保存，下次再调用的时候需要再new，，这就是IoC容器和普通程序开发的区别

2、DI概念理解

提到IoC就会提及到DI，DI是Dependency Injection的缩写，翻译过来就是“依赖注入”

所谓以来依赖注入，就是由IoC容器在运行期间，动态地将某种依赖关系注入到对象中，依赖注入（DI）和控制反转（IoC）是从不同的角度的描述同一件事情，无非通过引入IoC容器，利用依赖注入的方式，实现对象之间的解耦

区别：

<1>IoC是一种思想，只是一种指导原则

<2>DI就是一种具体的实行方案