2.Spring 核心与设计思想

1.Spring 是什么?

用一句话概括 Spring : Spring 是包含了众多工具方法的IoC容器

① 什么是容器

容器是用来容纳某种物品的(基本)装置.

② 什么是 IoC?

Spring 是一个IoC 容器.

什么是IoC

IoC 翻译成中文的意思 为"控制反转",也就是说 Spring 是一个 "控制反转"的容器.

传统程序开发

假如我们现在构造一辆[车]的程序,实现思路.

构造一辆车,首先得有一个车身吧,车身需要一个底盘吧,底盘需要一个轮胎吧,这样才是一辆完整的车.

代码如下

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

传统程序开发的缺陷

1.轮胎的尺寸是固定的,随着对车的需求量越来越大,个性化需求也会越来越多,这个时候我们就需要加工多种尺寸的轮胎,这个时候及要对上面的程序进行修改

public class NewCarExample1 {
    public static void main(String[] args) {
        Car car = new Car(34);
        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 IocCarExample {
    public static void main(String[] args) {
        Tire tire = new Tire(56);
        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 Tire(int size){
            this.size = size;
        }
        public void init(){
            System.out.println("轮胎: " + size);
        }
    }
}

代码经过以上调整,无论底层如何变化,整个调用链是不用左任何改变的,这样就完成代码之间的解耦,从而实现了根据灵活,通用的程序设计

对比总结规律

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

③ 理解 Spring IoC

1.Spring 是包含了多个工具方法的IoC容器,这也是spring 最核心的总结

2.Spring 是一个 IoC (控制反转)容器,最基础的功能

​ 将对象存入到容器

​ 从容器中取出对象

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

IoC容器 和 普通程序开发区别

1.Ioc容器会把以后可能用到的所有工具制作好放到仓库中,需要的时候直接去就行了,用完在放回到仓库.

2.普通程序: 每次需要用的时候临时做,用完也不会保存,下次再用还得重新做

④ DI 概念说明

说到 IoC 不得不提的⼀个词就是“DI”，DI 是 Dependency Injection 的缩写，翻译成中⽂是“依赖注
⼊”的意思.

依赖注⼊，就是由 IoC 容器在运⾏期间，动态地将某种依赖关系注⼊到对象之中。所以，依赖注⼊（DI）和控制反转（IoC）是从不同的⻆度的描述的同⼀件事情，就是指通过引⼊ IoC 容器，利⽤依赖关系注⼊的⽅式，实现对象之间的解耦 .

IoC与DI的区别

IoC 是"目标"也是一种思想.

DI 是具体的实现