Spring IoC容器、IoC与DI

目录

Spring是什么？

理解容器 

什么是IoC(Inversion of Control)

传统的new创建对象的方式中类与类的耦合程度很大。 

IoC的优势： 

Spring IoC容器最核心的功能 

什么是DI (Dependency Injection)

IoC和DI的区别 

---

Spring是什么？

Spring是指Spring Framework（Spring框架），它是开源的框架，有着很庞大的社区，通过使用Spring可以使我们的开发变的更简单。一句话概括的话：Spring是包含众多工具方法的IoC容器。

理解容器 

容器就是用来容纳某种物品的基本装置。

像我们之前学过的List，Map等等都是用来容纳元素的容器，像Tomcat就是用来存放Web应用程序的容器。

什么是IoC(Inversion of Control)

翻译过来就是控制权反转 

在谈到IoC的时候，我们总是会和传统的new创建对象的方式进行比较。 

我们知道：

传统的new创建对象的方式中类与类的耦合程度很大。 

例如：我们要创建一个汽车模型，按照传统的方式我们是这样实现的：

正常流程我们会在每一层下面去new下一层的对象

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

    }
    //框架
    static class Frame{
        //车架初始化
        public void FrameInit(){
            //在车架中new 车轮
            Tire tire=new Tire();
            //调用初始化方法
            tire.TireInit();
            System.out.println("车架已完成初始化");

        }

    }
    //车轮
    static class Tire{
        //车轮初始化
        public void TireInit(){
            System.out.println("车轮已完成初始化");
        }
    }
    //Car初始化
    private void Init(){
        //new 下一层对象
        Frame frame=new Frame();
        //调用下一层对象的初始化方法
        frame.FrameInit();//这一层方法中会new下一层的对象并调用初始化方法
        System.out.println("车辆已完成初始化>>  车辆制作完成！");
    }
}

这个时候如果我们有了新的需求就会牵一发而动全身。耦合性太高了。比如我们要实现轮胎的尺寸定制。就需要每个类中都进行修改：

public class Car {
    public static void main(String[] args) {
        Car car=new Car();
        car.Init(50);

    }
    //框架
    static class Frame{
        //车架初始化
        public void FrameInit(int size){
            //在车架中new 车轮
            Tire tire=new Tire();
            //调用初始化方法
            tire.TireInit(size);
            System.out.println("车架已完成初始化");

        }

    }
    //车轮
    static class Tire{
        //车轮初始化
        public void TireInit(int size){
            System.out.println("车轮已完成初始化");
            System.out.println("轮胎的尺寸为："+ size);
        }
    }
    //Car初始化
    private void Init(int size){
        //new 下一层对象
        Frame frame=new Frame();
        //调用下一层对象的初始化方法
        frame.FrameInit(size);//这一层方法中会new下一层的对象并调用初始化方法
        System.out.println("车辆已完成初始化>>  车辆制作完成！");
    }
}

 所以我们可以直接在每一层提供属性引用，直接指向下一层：

public class Car {
    //车架
    private Frame frame;
    //在构造方法中获得该车架
    public Car(Frame frame){
        this.frame=frame;
    }

    //在车的初始化方法中执行车架的初始化方法
    public void init(){
        frame.init();
    }

    //车架类
    static class Frame{
        //轮胎
        private Tire tire;
        //构造方法中获得该轮胎
        public Frame(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("轮胎的大小是:"+this.size);
        }
    }

    public static void main(String[] args) {
        //创建轮胎类，制定轮胎大小
        Tire tire=new Tire(20);
        //创建车架类,轮胎作为属性传递进去
        Frame frame=new Frame(tire);
        //创建一个Car类,frame作为属性传递下去
        Car car=new Car(frame);
    }
}

这时候，如果我们还需要修改Tire，只需要改动两个地方：一个是Tire类属性，一个是main方法中的参数，然后中间的调用过程就不用修改了，这时候耦合性就降低下来了。 

这个时候我们再说说IoC：

IoC的优势： 

实现代码解耦，同时把对象（Bean）交给了IoC进行维护，与传统的方式相比，IoC不再是上级对象创建控制下一层对象了，而是把下一层的对象注入到上一级对象当中，所以IoC就是把控制对象生命周期的权利交给了IoC容器。

传统方式与IoC方式的对比：

Spring IoC容器最核心的功能 

管理对象（Bean）在Spring中的存取。 

什么是DI (Dependency Injection)

翻译过来就是依赖注入 ，指的就是把对象（Bean）注入到IoC容器当中，如果外面想要获取该对象，就需要从容器中取

IoC和DI的区别 

IoC是一种重要的思想，是Spring的核心思想之一。这种思想就是控制权反转，把对象（Bean）的生命周期交给IoC容器，而DI则是IoC思想的具体实现 。比如我今天的心情比较好，我想出去玩。我想出去玩就是IoC，就是思想和目标，而我想出去玩我可以去动物园玩，也可以去游乐场玩，这就是DI,也就是具体的实现。