Spring基础以及核心概念（IoC和DIQ）

1.Spring是什么

Spring是包含了众多工具方法 的IoC容器

2.loC（Inversion of Control ）是什么

IoC:控制反转,Spring是一个控制反转容器(控制反转对象的生命周期)

Spring是一个loC容器，我们之前学过的List/Map就是数据存储的容器，tomcat是Web的容器，

2.1 传统开发中的缺陷（耦合问题）

比如一个汽车程序（依赖注入）的设计，汽车依赖车身，车身依赖底层，底层依赖轮胎，每当轮胎要新加一些个性化设计，依赖轮胎的东西都要进行重加代码，耦合性太高（当一个类反发生改变，其他类也得做出相应的改变）
java 复制代码
public class Tire {
    private int size=20;
    public Tire(int size){
        this.size=size;
    }
    /**
     * 当tire 发生了个性化的改变，随之而变得就是依赖Tire 的Bottom
     * */
    public void init(){
        System.out.println("执行了轮胎的初始化方法，size="+this.size);
    }

}

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


public class Framework {
    private Bottom bottom;
    //车身依赖地盘
    public  Framework(int size){
        bottom = new Bottom(size);
    }
    public void init(){
        bottom.init();

    }

}

public class Car {
   private Framework framework;
    public Car(int size){
        framework=new Framework(size);
    }
    public void init(){
         framework.init();
    }
}
当新加入这段代码，后续就得改Bottom中的Bottom的构造方法，向其中传入参数int size,后续也得向Farmework,Car中的构造方法加入参数

用专业一点的话来讲就是：当底层代码改动后，整个调用链上所有的代码都需要修改

2.2 改进后（低耦合）------IoC思想

java 复制代码

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

public class Bottom {
    private Tire tire;
    public Bottom(Tire tire){
       // tire=new Tire();这是最初的写法
        this.tire = tire;

    }
    public void init(){
        System.out.println("执行 Bottom");
        //依赖轮胎
        tire.init();
    }
}

public class Framework {
    private Bottom bottom;
    public Framework(Bottom bottom){
        //之前是new一个Bottom对象,并且传入参数
       this.bottom = bottom;

    }
    public void init(){
        //依赖底盘；
        System.out.println("执行 Framework");
        bottom.init();
        //这一步就需要引用成员变量；
    }
}


public class Car {
    private Framework framework;
    public Car(Framework framework){
        this.framework=framework;
    }
    public void init(){
        System.out.println("执行Car");
        //依赖车身
        framework.init();
    }
}
public class App {
    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();
    }
}

改进后：传递一个Tire对象给Bottom。

本质上就是对象的生命周期发生了改变, 这张图很明显能看出来控制反转。

2.3 小结

可以发现，类的创建顺序是反的，传统代码是Car控制并创建Framework，Framework控制并创建Bottom,依次往下，而改进后控制权发生反转，不再是上级对象控制并创建下级对象，而是把下级对象注入到上级对象里面，下级的控制不再由上级类控制了，这样即使下级类发生任何改变，当前类都是不受控制的，这就是经典的控制反转，也是IoC思想。

3.理解Spring IoC

既然Spring是一个loC（控制反转）容器，重点还在"容器"二字上，那么它就具备两个最基础的功能：

将对象存入到容器；
从容器中取出对象。
也就是说学 Spring 最核心的功能，就是学如何将对象存入到Spring中，再从Spring 中获取对象的过程。

将对象存放到容器中的好处：将对象存储在loC 容器相当于将以后可能用的所有工具制作好都放到仓库中，需要的时候直接取就行了，用完再把它放回到仓库。而new 对象的方式相当于，每次需要工具了，才现做，用完就扔掉了也不会保存，下次再用的时候还得重新做，这就是loC容器和普通程序开发的区别。
Spring 是一个包含多个工具和方法的loC 容器，说的是对象的创建和销毁的权利都交给 Spring 来管理了，它本身又具备了存储对象和获取对象的能力。

4.DI（Dependency Injection）说明

DI(依赖注入)：在程序运行期间，动态的将某个对象引入到当前（/行为）的机制

IoC是思想，DI是具体的实现。