认识Spring

什么是spring

我们常说的Spring是指Spring Framework，它是一种开源框架，它支持广泛的应用场景，可以令Java应用程序开发起来更简单。

用一句话来概括Spring：包含众多工具的 IoC 容器。

什么是 loC 

loC全称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 = 30;
        public void init(){
            System.out.println("轮胎的尺寸为：" + size);
        }
    }
}

 上述的代码中，固定了轮胎的尺寸为30，如果想要构建不同的尺寸的轮胎，就要修改代码，修改的代码如下：

public class CarExample {
    public static void main(String[] args) {
        Car car = new Car(40);
        car.init();
    }
    //汽车对象
    static class Car{
        private Framework framework;
        public Car(int size){
            framework = new Framework(size);
        }
       public void init(){
           framework.init();
       }
    }
    //车身
    static class Framework{
        private Bottom bottom;
        public Framework(int size){
            bottom = new Bottom(size);
        }
        public void init(){
            bottom.init();
        }
    }
    //底盘
    static class Bottom{
        private Tire tire;
        public Bottom(int size){
            tire = new Tire(size);
        }
        public void init(){
            tire.init();
        }
    }
    //轮胎
    static class Tire{
        //轮胎尺寸
        private int size ;
        public Tire(int size){
            this.size = size;
        }
        public void init(){
            System.out.println("轮胎的尺寸为：" + size);
        }
    }
}

从修改后的代码来看，要想要不同尺寸的轮胎，就要从上到下的修改整个调用链上的代码，可以看出代码的耦合性非常高，那如何解决上述的问题呢？我们尝试不在自己了类中创建下级类，改为传递的方式，代码如下：

public class CarExample {
    public static void main(String[] args) {
        Tire tire = new Tire(20);
        Bottom bottom = new Bottom(tire);
        Framework framework = new Framework(bottom);
        Car car = new Car(framework);
        car.run();
    }
    static class Car {
        private Framework framework;
        public Car(Framework framework) {
            this.framework = framework;
        }
        public void run() {
            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 Tire(int size) {
            this.size = size;
        }
        public void init() {
            System.out.println("轮胎：" + size);
        }
    }
}

改为传递方式的代码不需要一层一层的调用下层的代码，只需要将下层的代码传递到（注入）当前类中，无论某一级的代码如何变化，其他的代码都可以保持不变，这样代码之间就形成了解耦。我们来对比一下两种方式的实现思路：

 传统的实现方式是当前类需要控制并创建下一级的对象，依次往下，而使用传递的方式是将下一级的对象注入到当前的对象中，不再是上一级类创建下一级类，下一级类也不受上一级类的控制，控制权发生了改变，即使下一级类如何变化，当前类都不会受到影响，这就是控制反转。

那么Spring也可以说是包含众多工具的控制反转的容器。

说到IoC就不得不说DI，DI 是 Dependency Injection 的缩写，翻译成中⽂是“依赖注 入”的意思。所谓依赖注入，就是由 IoC 容器在运行期间，动态地将某种依赖关系注入到对象之中。所以，依赖注入（DI）和控制反转（IoC）是从不同角度描述同⼀件事情，就是指通过引⼊ IoC 容 器，利⽤依赖关系注⼊的⽅式，实现对象之间的解耦。 IoC 是“⽬标”也是⼀种思想，目标和思想只是⼀种指导原则， 而DI 就属于具体的实现。

Spring既然是容器，那么它也就具备两种基础功能：既能存储也能拿取，那么Spring的核心就是如何将对象存储到容器中和如何从容器中去取出对象。将对象存入到容器中，需要用的时候直接取出来用，用完直接放回去，等到下次需要的时候再取出来用。