Spring核心与设计思想

Spring

Spring是包含了众多工具方法的IoC容器
我们所遇到过的容器还有以下两个：
1、List / Map --> 数据容器 2、Tomcat --> Web容器

什么是IoC

IoC（Inversion of Control）中文意思为“控制反转”，Spring为一个控股反转的容器

传统程序开发

要构建一辆车，实现思路如下：Car->Fromework->Bottom->tire
构建⼀辆⻋（Car Class），然⽽⻋需要依赖⻋身(FrameWork Class)，⽽⻋身需要依赖底盘（Bottom Class），⽽底盘需要依赖轮胎（Tire Class）

public class CarDemo {
    public static void main(String[] args) {
        int size;
        Car car = new Car();
        //启动车
        car.run();
    }

    static class Car{
        public void run(){
            //依赖车身
            Framework framework = new Framework();
            framework.init();
        }
    }

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

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

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

若要修改Tire类（轮胎），则整个代码都要修改

public class CarDemo {
    public static void main(String[] args) {
        //业务代码
        Car car = new Car();
        //启动车
        car.run(30);
    }

    static class Car{
        public void run(int size){
            //依赖车身
            Framework framework = new Framework();
            framework.init(size);
        }
    }

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

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

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

传统开发的缺点：最底层类被修改时，整个调用链都需要去修改，这种现象的代码叫做耦合问题

解决思路
我们要将原来由⾃⼰创建的下级类，改为传递的⽅式（也就是注⼊的⽅式），因为我们不需 要在当前类中创建下级类了，所以下级类即使发⽣变化（创建或减少参数），当前类本身也⽆需修改任何代码，这样就完成了程序的解耦。

控制反转式程序开发

控股反转IoC的基础实现：

public class  IoCCarDemo {
    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();
    }

    static class Car{
        private Framework framework;
        public Car(Framework framework){
            this.framework = framework;
        }
        public void init(){
            framework.init();
        }
    }

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

    static class Bottom{
        //接收注入的轮胎对象
        private Tire tire;

        public Bottom(Tire tire){
            //注入下层依赖对象
            this.tire = tire;
        }

        public void init(){
            tire.init();
        }
    }

    static class Tire{
        private int size;
        public  String color;
        public Tire(int size, String color){
            this.size = size;
            this.color = color;
        }


        public void init(){
            System.out.println("轮胎：" + size);
            System.out.println("颜色：" + color);
        }
    }
}

IoC创建类是从底层向上创建的
Tire->Bottom->Framework->car
区别：
1、创建类的顺序发生改变（反转）
2、底层调用方类发生改变后，IoC模式整个调用链的代码不需要改变，实现了类于引用类的解耦
3、在传统开发上，若要使用依赖类，则需要自己创建和管理类的生命周期，IoC无需自己管理对象的生周期

即使下级类发⽣任何改变，当前类都是不受影响的，这就是典型的控制反转，也就是 IoC 的实现思想

如何理解Spring IoC

Spring是包含了众多个工具方法的IoC容器
容器则有两个基础功能，1、将对象存入到容器 2、从容器取出对象

学Spring的最核心功能就是学如何将对象存入到Spring中，在从中获取对象的过程

将对象存放到容器中的好处：将对象存储在 IoC 容器相当于将以后可能⽤的所有⼯具制作好都放到仓库中，需要的时候直接取就⾏了，⽤完再把它放回到仓库。⽽ new 对象的⽅式相当于，每次需要⼯具 了，才现做，⽤完就扔掉了也不会保存，下次再⽤的时候还得重新做，这就是 IoC 容器和普通程序开 发的区别

对象的创建和销毁的权利都交给 Spring 来管理，它本身则具备了存储对象和获取对象的能⼒。

DI

DI：依赖注入（具体实现手段/具体实现技术），是 Dependency Injection 的缩写
在IoC容器启动时，动态将对象注册到容器中的一种手段

    static class Car{
        private Framework framework;
        public Car(Framework framework){
        //依赖注入
            this.framework = framework;
        }
        public void init(){
            framework.init();
        }
    }

其中 this.framework = framework; 就为依赖注入
IoC是控制反转，一种设计思想，只是一种指导原则。DI则是具体的实现手段。