Spring学习(一)(IoC和DI)

1.Spring是什么？？？

天天都能听到Spring，Spring，Spring。这东西到底是什么东西，是一个框架。没错通常所说的 Spring 指的是 Spring Framework（Spring 框架），它是⼀个开源框架，有着活跃⽽庞⼤的社区，这就是它之所以能⻓久不衰的原因。Spring ⽀持⼴泛的应⽤场景，它可以让 Java 企业级 的应⽤程序开发起来更简单。其实很早之前就开始用它，只知道how to use感觉用起来方便，是一个框架，对于里面的含义，思想可以说是一点也不了解，我想现在很多的小伙伴也是一样的感觉，不太了解一个东西，感觉都在学习，都在用那么我也去学习，我也去使用。但是还是去花一点时间去了解了解是比较好的。

当然这样的定义在网上数不胜数，那么用一句话来概括的话：Spring 是包含了众多⼯具⽅法的 IoC 容器。

好了，这下更迷糊了。到底Spring是个什么，不说是个框架吗？那么什么是容器？什么是IoC容器？

1.1 容器是什么？？

日常生活中我们对于容器的认识：容器就是一个能够容纳盛放某种东西的一个装置。也就是这个容器能够“放”某些“物品”，用java之前的知识来说的话，能够举出一些容器的例子吗？

• List/Map  ： 它们能够“放”数据，是一个数据存储容器；
• Tomcat ： 能够存放web，是web容器。

通过这两个例子，大概知道了什么是容器，再计算机中什么是容器。

1.2 IoC是什么？？

上面我们给出的简单的Spring定义：Spring 是包含了众多⼯具⽅法的 IoC 容器。也就是说Spring是一个容器，什么容器？-----Spring是一个IoC容器（也就是可以放很多的IoC）。

IoC是什么捏？？？ IoC（Inversion of Control）翻译成中文是“控制反转的意思”，也就是说Spring是一个“控制反转”的容器。现在是不是仍然看不懂，别着急，我们从简单的代码示例来解决这个问题。

1.2.1 demo1（没有IoC思想的传统程序开发）

假设，以前的传统方案构建一辆“车”的程序：

传统模式

 在这样的方案下构建⼀辆⻋（Car Class），然⽽⻋需要依赖⻋身(FrameWork Class)，⽽⻋身需要依赖底盘（Bottom Class），⽽底盘需要依赖轮胎（Tire Class），最终程序的实现代码如下：

package demo;

public class CarFactory {
    public static void main(String[] args) {
        Car car = new Car();
        car.init();
    }

}
package demo;

public class Car {
    public Framework framework;

    public void init() {
        System.out.println("make a car");
        this.framework = new Framework();
        framework.init();

    }
    // 这种方式来传递变量，就会导致控制权完全在自己的手里，一旦依赖的对象
    // 发生变化，就会导致一系列的问题。因此需要IoC 控制反转。将控制权转移到第三方
    // 具体怎么来模拟实现，看IoC包下面的代码
}
package demo;

public class Bottom {
    public Tire tire;

    public void init(){
        System.out.println("make bottom");
        // 依赖轮胎
        this.tire = new Tire();
        tire.init();

    }
}
package demo;

public class Tire {
    private String color = "red";
    private double size = 17;

    public void init(){
        System.out.println("轮毂尺寸："+size+"\n"+"轮毂颜色："+color);
    }
}

上面代码的缺点很明显，轮胎的尺⼨的固定的，然⽽随着对的⻋的需求量越来越⼤，个性化需求也会越来越多，这时候我们就需要加⼯多种尺⼨的轮胎，那这个时候就要对上⾯的程序进⾏修改了，先从Tire类开始修改：

public class Tire {
    private String color ;
    private double size ;

    public Tire(String color, double size) {
        this.color = color;
        this.size = size;
    }

    public void init(){
        System.out.println("轮毂尺寸："+size+"\n"+"轮毂颜色："+color);
    }
}

修改完之后发现，当最底层代码改动之后，整个调⽤链上的所有代码都需要修改。修改完Tire需要修改Bottom，随之要修改Framework，最后修改Car......。因为我们在依赖的时候使用的对象是自己本身这个类所new出来的，一旦底层的代码发生了变化，那么实例化的代码也要发生变化。也就是说这个时候的控制权在自己的手里，并没有IoC的思想。

修改完的代码如下：

public class CarFactory {
    public static void main(String[] args) {
        Car car = new Car("red",17);
        car.init();
    }

}
public class Car {
    public Framework framework;

    public Car(String color, double size) {
        framework = new Framework(color,size);
    }

    public void init() {
        System.out.println("make a car");
        framework.init();
    }
    // 这种方式来传递变量，就会导致控制权完全在自己的手里，一旦依赖的对象
    // 发生变化，就会导致一系列的问题。因此需要IoC 控制反转。将控制权转移到第三方
    // 具体怎么来模拟实现，看IoC包下面的代码
}
public class Framework {
    public Bottom bottom;

    public Framework(String color, double size) {
        this.bottom = new Bottom(color,size);
    }

    public void init(){
        System.out.println("make framework");
        bottom.init();

    }
}
public class Bottom {
    public Tire tire;

    public Bottom(String color, double size) {
       tire = new Tire(color,size);
    }

    public void init(){
        System.out.println("make bottom");
        // 依赖轮胎
        tire.init();
    }


}
public class Tire {
    private String color ;
    private double size ;

    public Tire(String color, double size) {
        this.color = color;
        this.size = size;
    }

    public void init(){
        System.out.println("轮毂尺寸："+size+"\n"+"轮毂颜色："+color);
    }
}

那么如何来解决这种传统开发中的缺陷呢？想要解决问题必须先找出问题出现的原因，那么出现这个问题的逻辑是为什么？？因为在这个示例中，我们当产生依赖的时候是自己创建了一个下级类，也即是自己new了一个类，此时下级类的底层代码发生来改变导致了整个调用链也发生改变。

现在知道了问题所在就可以去针对这个问题来做出方案去解决问题。我们只需要将原来由⾃⼰创建的下级类，改为传递的⽅式（也就是注⼊的⽅式），因为我们不需 要在当前类中创建下级类了，所以下级类即使发⽣变化（创建或减少参数），当前类本身也⽆需修改任 何代码，这样就完成了程序的解耦。（PS：解耦指的是解决了代码的耦合性，耦合性也可以换⼀种叫法叫程序相关性。好的程序代码的耦合 性（代码之间的相关性）是很低的，也就是代码之间要实现解耦。）

这就好⽐我们打造⼀辆完整的汽⻋，如果所有的配件都是⾃⼰造，那么当客户需求发⽣改变的时候， ⽐如轮胎的尺⼨不再是原来的尺⼨了，那我们要⾃⼰动⼿来改了，但如果我们是把轮胎外包出去，那 么即使是轮胎的尺⼨发⽣变变了，我们只需要向代理⼯⼚下订单就⾏了，我们⾃身是不需要出⼒的。（所有需要的东西都在一个容器中，当我们有需要的时候直接在容器中去找我们需要的东西）

 1.2.2 demo2（具有IoC思想的开发）

基于以上思路，我们把调⽤汽⻋的程序示例改造⼀下，把创建⼦类的⽅式，改为注⼊传递的⽅式，具体 实现代码如下：

package demo.IoC;

public class IoCCarFactory {
    public static void main(String[] args) {
        Tire tire = new Tire(17, "red");
        Bottom bottom = new Bottom(tire);
        Framework framework = new Framework(bottom);
        Car car = new Car(framework);
        car.init();
    }

}
public class Car {
    private Framework framework;
    public Car(Framework framework) {
        this.framework = framework;
    }
    public void init() {
        System.out.println("make a car");
        framework.init();
    }
}
public class Framework {
    private Bottom bottom;
    public Framework(Bottom bottom) {
        this.bottom = bottom;
    }
    public void init() {
        System.out.println("make framework");
        bottom.init();
    }
}
public class Bottom {
    private Tire tire;
    public Bottom(Tire tire) {
        this.tire = tire;
    }
    public void init() {
        System.out.println("make bottom");
        tire.init();
    }

}
public 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+"\n"+"轮毂颜色："+color);
    }
}

经过调整后的代码无论底层对象的代码怎么变动，调用链的代码是不用变动的，这样就完成了代码见的解耦，让整个程序的设计更加合理、更加灵活。此时当底层的代码发生改变只需要在IoCCarFactory类中的代码做出对应的改变，这里的IoCCarFactory就相当于存放各种对象的“容器”，控制权就发生了反转，而不是使用者本身来控制，使用者只需要在使用的时候传入一个所i需要的对象就可以了。

1.2.3 总结规律

在传统的代码中对象创建顺序是：Car -> Framework -> Bottom -> Tire

改进之后解耦的代码的对象创建顺序是：Tire -> Bottom -> Framework -> Car

 通⽤程序的实现代码，类的创建顺序是反的，传统代码是 Car 控制并创建了 Framework，Framework 创建并创建了 Bottom，依次往下，⽽改进之后的控制权发⽣的反转，不再是 上级对象创建并控制下级对象了，⽽是将下级对象注⼊将当前对象中，下级的控制权不再由上级类控制 了，这样即使下级类发⽣任何改变，当前类都是不受影响的，这就是典型的控制反转，也就是 IoC 的实现思想。

 1.3 理解Spring IoC

回到我们的主题 Spring，本⽂刚开始咱们就讲：Spring 是包含了多个⼯具⽅法的 IoC 容器，这就是对 Spring 最核⼼的总结。“集成多个⼯具⽅法”这事咱们以后慢慢再讲，那如何理解“Spring 是⼀个 IoC 容器”这句话呢？

既然 Spring 是⼀个 IoC（控制反转）容器，重点还在“容器”⼆字上，那么它就具备两个最基础的功能：

• 将对象存⼊到容器；
• 从容器中取出对象。

也就是说学 Spring 最核⼼的功能，就是学如何将对象存⼊到 Spring 中，再从 Spring 中获取对象的过程。

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

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

1.4 什么是DI??

说到 IoC 不得不提的⼀个词就是“DI”，DI 是 Dependency Injection 的缩写，翻译成中⽂是“依赖注 ⼊”的意思。 所谓依赖注⼊，就是由 IoC 容器在运⾏期间，动态地将某种依赖关系注⼊到对象之中。所以，依赖注⼊（DI）和控制反转（IoC）是从不同的⻆度的描述的同⼀件事情，就是指通过引⼊ IoC 容 器，利⽤依赖关系注⼊的⽅式，实现对象之间的解耦。

IoC 是“⽬标”也是⼀种思想，⽽⽬标和思想只是⼀种指导原则，最终还是要有可⾏的落地⽅案，⽽ DI 就属于具体的实现。

比如我们的目标：拥有健康的生活方式，包括均衡的饮食、适度的运动和良好的睡眠。（IoC）

落地方案：为了实现健康生活目标，具体的落地方案可能包括每天摄入五种不同颜色的水果和蔬菜，每周进行三次有氧运动和两次力量训练，每晚保持七到八小时的睡眠时间。(DI)

2. 总结

• Spring是什么？？如何理解Spring？？
• IoC和DI是什么？？有什么区别？？
• Spring最核心的功能是什么？？