Spring核心与设计思想（详解IoC、DI）

Spring是什么

Spring是一种多层的J2EE应用程序框架，其核心就是管理资源组件以及依赖关系，Spring框架为现代基于java的企业应用程序提供了一个全面的编程和配置模型。
管理资源组件以及依赖关系，包括IoC／DI．

什么是IoC

IoC＝Inversion　of　Control　翻译成中文是＂控制反转＂的意思。
下面我们通过一个构造车的例子来理解＂控制反转＂．

传统程序开发

构建一辆车，然后车要依赖车身，而车身需要依赖底盘，而底盘需要依赖轮胎。实现方式如下：

public class CarExample {
    public static void main(String[] args) {
        Car car=new Car();
        car.init();
    }
    //汽车对象
    static class Car {
        public void init() {
            //依赖车身
            Framework framework=new Framework();
            framework.init();
        }
    }
    //车身类
    static class Framework {
        public void init() {
            //依赖底盘
            Bottom bottom=new Bottom();
            bottom.init();
        }
    }
    //底盘类
    static class Bottom {
        public void init() {
            //依赖轮胎
            Tire tire=new Tire();
            tire.init();
        }
    }
    //轮胎类
    static class Tire {
        //设置轮胎大小
        private int size=20;
        public void init() {
            System.out.println("轮胎大小:"+size);
        }
    }
}

以上程序中轮胎的大小是固定的，但是随着人们对车的个性化需求不断提高，这时候我们就需要加工不同大小的轮胎。修改后代码如下：

public class newCarExample {
    public static void main(String[] args) {
        //创建车时就给它穿一个轮胎大小的参数
        Car car=new Car(30);
        car.run();
    }

    //汽车对象
    static class Car {
        //依赖车身
        private Framework framework;
        //Car接收轮胎大小的参并传给车身
        public Car(int size) {
            framework=new Framework(size);
        }
        public void run() {
            framework.run();
        }
    }

    //车身类
    static class Framework {
        //依赖底盘
        private Bottom  bottom;
        public Framework(int size) {
            bottom=new Bottom(size);
        }
        public void run() {
            bottom.run();
        }
    }
    //底盘类
    static class Bottom {
        //依赖轮胎
        private Tire tire;
        //Car接收轮胎大小的参并传给车身
        public Bottom(int size) {
            tire=new Tire(size);
        }
        public void run() {
            tire.run();
        }
    }
    //轮胎类
    static class Tire {
        private int size;
        public Tire(int size) {
            this.size=size;
        }
        public void run() {
            System.out.println("轮胎的大小:"+size);
        }
        
    }
}

根据上面程序可以看出当最底层的代码改动后，整个调用链上的所有代码都需要修改，这对于开发人员来说特别麻烦，那么如何进行修改呢？我们可以尝试不在每个类中自己创建下级类，将原先自己创建的下级类改为传递的方式（也就是注入的方式）．这样我们就不需要在当前类中创建下级类了，所以下级类即使发生变化，当前类本身也不需要修改任何代码．这就相当造车时，我们只需要把制造轮胎的大小告诉制造轮胎的公司，轮胎公司赋值制造各式各样的轮胎，我们并不关心轮胎具体的制造过程。

控制反转方式程序开发

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

    }

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

代码经过以上的调整，无论底层如何变化整个调用链都不用做任何改变，从而实现了更加灵活通用的程序设计．

对比

传统代码对象创建顺序：car－＞ Framework －＞Bottom －＞Tire
改进后的代码创建对象顺序是：Tire－＞Bottom－＞ Framework－＞car
通过以上我们可以发现，窗体代码是car控制并创建了Framework，Framework创建并创建了Bottom依次往下，而改进后的控制反转不再是上级对象创建并控制下级对象了，而是下级对象注入到当前对象中，下级的控制不再由上级类控制，这样即使下级类发生改变，当前类都不受影响，这就是典型的控制反转也是IoC的实现。

理解SpringIoC

Spring是一个IoC（控制反转）容器，具备下面两个基础功能：

• 将对象存放到容器
• 从容器中取出对象

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

将对象存放到容器中的好处：将对象存放在IoC容器就相当于将以后可能用到的所以工具制作好放到仓库中，需要的时候直接重仓库中取，用完再放回仓库。而new对象的方式就相当于，每次需要的工具就现做不需要了就扔掉，下次再需要的时候还要重新做，这就是IoC容器和普通程序开发的区别．

Spring是一个IoC容器，就是说对象的创建和销毁的权利都交给Spring来管理，它本身又具备了存储对象和获取对象的能力。

DI概念

DI＝Dependency　Injection的缩写，翻译成中文就是＂依赖注入“的意思。
依赖注入就是IoC容器在运行期间，动态的将某种依赖关系注入到对象之中。依赖注入（DI）和控制反转（IoC）是从不同的角度描述的同一件事情，指通过引用IoC容器，利用依赖注入的方式，实现对象之间的解耦．
IoC是控制反转是一种设计思想；DI依赖注入是控制反转的实现手段。
如：今天天气特别好，我要出去玩。我要出去玩是一种思想（IoC），那么具体是去爬山还是去放风筝这是具体的实现就是DI。