Spring IoC容器、IoC与DI

港控/mmm° 2024-03-23 15:30 165阅读 0赞

**目录**

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创建对象的方式中类与类的耦合程度很大。**  ####

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

![df3b583839674c1d9d62556165135a2f.png][]

正常流程我们会在每一层下面去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方式的对比：

![856e30c18abc4a448b32e5f993787b12.png][]

#### Spring IoC容器最核心的功能 ####

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

## 什么是DI (Dependency Injection) ##

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

#### IoC和DI的区别 ####

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

[df3b583839674c1d9d62556165135a2f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/750e7dc2b651400b9db5032e91e40b7d.png
[856e30c18abc4a448b32e5f993787b12.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/411c1615c6694b44bda2f108b80694f2.png