总结一下 Spring的IOC、DI

最新推荐文章于 2023-04-12 14:13:42 发布
转载 最新推荐文章于 2023-04-12 14:13:42 发布 · 840 阅读 · 0
文章标签：

#ioc #spring #file #class #java #interface

本文探讨了软件设计中的依赖关系及其优化手段，包括依赖倒置原则的应用，并介绍了控制反转(IoC)的概念及其实现方式。

IOC、DI模式

1.依赖

依赖就是有联系，有地方使用到它就是有依赖它，一个系统不可能完全避免依赖。如果你的一个类或者模块在项目中没有用到它，恭喜你，可以从项目中剔除它或者排除它了，因为没有一个地方会依赖它。下面看一个简单的示例：

[java] view plain copy print ?
  1. /// <summary> 
  2.     /// 用户播放媒体文件 
  3.     /// </summary> 
  4.     public class OperationMain 
  5.     { 
  6.  
  7.         public void playMedia() 
  8.         { 
  9.             MediaFile _mtype = new MediaFile(); 
  10.             Player _player = new Player(); 
  11.  
  12.             _player.play(_mtype); 
  13.         } 
  14.     } 
  15.     /// <summary> 
  16.     /// 播放器 
  17.     /// </summary> 
  18.     public class Player 
  19.     { 
  20.         public void play(MediaFile file){ } 
  21.     } 
  22.     /// <summary> 
  23.     /// 媒体文件 
  24.     /// </summary> 
  25.     public class MediaFile 
  26.     {    }  
/// <summary>
    /// 用户播放媒体文件
    /// </summary>
    public class OperationMain
    {

        public void playMedia()
        {
            MediaFile _mtype = new MediaFile();
            Player _player = new Player();

            _player.play(_mtype);
        }
    }
    /// <summary>
    /// 播放器
    /// </summary>
    public class Player
    {
        public void play(MediaFile file){ }
    }
    /// <summary>
    /// 媒体文件
    /// </summary>
    public class MediaFile
    {    }


上面是一个用户用播放器播放文件简单示例，用户操作是OperationMain类中的playMedia方法，打开一个播放器，选择一个文件来播放。先看看他们之间的依赖关系，可以简单找到有3个依赖

  1. Player依赖MediaFile
  2. OperationMain依赖Player
  3. OperationMain依赖MediaFile

2.依赖倒置

需求增加了，要用不同的播放器，播放不同的文件，我们要抽象出来，减少耦合。

耦合关系就是依赖关系，如果依赖关系相当繁杂，牵一发而动全身，很难维护；依赖关系越少，耦合关系就越低，系统就越稳定，所以我们要减少依赖。

幸亏Robert Martin大师提出了面向对象设计原则----依赖倒置原则： 　　

  • A. 上层模块不应该依赖于下层模块，它们共同依赖于一个抽象。 　
  • B. 抽象不能依赖于具象，具象依赖于抽象。

理解：A.上层是使用者，下层是被使用者，这就导致的结果是上层依赖下层了，下层变动了，自然就会影响到上层了，导致系统不稳定，甚至是牵一发而动全身。那怎么减少依赖呢？就是上层和下层都去依赖另一个抽象，这个抽象比较稳定，整个就来说就比较稳定了。

B.面向对象编程时面向抽象或者面向借口编程，抽象一般比较稳定，实现抽象的具体肯定是要依赖抽象的，抽象不应该去依赖别的具体，应该依赖抽象。

上面播放器的示例中，我们已经找到依赖关系了，现在我们要按照依赖倒置原则，来进行优化。

根据原则如下改动：

  • Player依赖MediaFile，好办，让Player和MediaFile都去依赖一个抽象IMediaFile
  • OperationMain依赖Player，好办，让OperationMain和Player都依赖一个抽象IPlayer
  • OperationMain依赖MediaFile，好办，让OperationMain和MediaFile都依赖一个抽象IMediaFile
  • IPlayer不能依赖具体MediaFile，应该依赖于具体MediaFile的抽象IMediaFile

结构很简单，于是代码大致如下：

[java] view plain copy print ?
  1. package ioc; 
  2.  
  3. /**
  4. * @author: 特种兵—AK47
  5. * @创建时间：2012-10-9 上午09:59:56
  6. *
  7. * @类说明 ：用户播放媒体文件
  8. */ 
  9. public class OperationMain { 
  10.     public void playMedia(IPlayer iplayer, IMediaFile imediaFile) { 
  11.         iplayer.play(imediaFile); 
  12.     } 
  13. }  
package ioc;

/**
 * @author: 特种兵—AK47
 * @创建时间：2012-10-9 上午09:59:56
 * 
 * @类说明 ：用户播放媒体文件
 */
public class OperationMain {
	public void playMedia(IPlayer iplayer, IMediaFile imediaFile) {
		iplayer.play(imediaFile);
	}
}

[java] view plain copy print ?
  1. package ioc; 
  2.  
  3. /**
  4. * @author: 特种兵—AK47
  5. * @创建时间：2012-10-9 上午10:03:23
  6. *
  7. * @类说明 ：要播放的媒体文件
  8. */ 
  9. public interface IMediaFile { 
  10.  
  11.     public void getSetPath(); 
  12.  
  13. }  
package ioc;

/**
 * @author: 特种兵—AK47
 * @创建时间：2012-10-9 上午10:03:23
 * 
 * @类说明 ：要播放的媒体文件
 */
public interface IMediaFile {

	public void getSetPath();

}

[java] view plain copy print ?
  1. package ioc; 
  2.  
  3. /**
  4. * @author: 特种兵—AK47
  5. * @创建时间：2012-10-9 上午10:03:39
  6. *
  7. * @类说明 ：
  8. */ 
  9. public class Mp3File implements IMediaFile { 
  10.  
  11.     @Override 
  12.     public void getSetPath() { 
  13.         // TODO Auto-generated method stub 
  14.         System.out.println("播放 [Mp3] 格式的文件"); 
  15.     } 
  16.  
  17. }  
package ioc;

/**
 * @author: 特种兵—AK47
 * @创建时间：2012-10-9 上午10:03:39
 * 
 * @类说明 ：
 */
public class Mp3File implements IMediaFile {

	@Override
	public void getSetPath() {
		// TODO Auto-generated method stub
		System.out.println("播放 [Mp3] 格式的文件");
	}

}


[java] view plain copy print ?
  1. package ioc; 
  2.  
  3. /**
  4. * @author: 特种兵—AK47
  5. * @创建时间：2012-10-9 上午10:03:39
  6. *
  7. * @类说明 ：
  8. */ 
  9. public class Mp4File implements IMediaFile { 
  10.  
  11.     @Override 
  12.     public void getSetPath() { 
  13.         // TODO Auto-generated method stub 
  14.         System.out.println("播放 [Mp4] 格式的文件"); 
  15.     } 
  16.  
  17. }  
package ioc;

/**
 * @author: 特种兵—AK47
 * @创建时间：2012-10-9 上午10:03:39
 * 
 * @类说明 ：
 */
public class Mp4File implements IMediaFile {

	@Override
	public void getSetPath() {
		// TODO Auto-generated method stub
		System.out.println("播放 [Mp4] 格式的文件");
	}

}

[java] view plain copy print ?
  1. package ioc; 
  2.  
  3. /**
  4. * @author: 特种兵—AK47
  5. * @创建时间：2012-10-9 上午10:02:41
  6. *
  7. * @类说明 ：播放组件的抽象类
  8. */ 
  9. public interface IPlayer { 
  10.  
  11.     public void play(IMediaFile imediaFile); 
  12.  
  13. }  
package ioc;

/**
 * @author: 特种兵—AK47
 * @创建时间：2012-10-9 上午10:02:41
 * 
 * @类说明 ：播放组件的抽象类
 */
public interface IPlayer {

	public void play(IMediaFile imediaFile);

}

[java] view plain copy print ?
  1. package ioc; 
  2.  
  3. /**
  4. * @author: 特种兵—AK47
  5. * @创建时间：2012-10-9 上午10:02:59
  6. *
  7. * @类说明 ：
  8. */ 
  9. public class Player implements IPlayer { 
  10.  
  11.     @Override 
  12.     public void play(IMediaFile imediaFile) { 
  13.         imediaFile.getSetPath(); 
  14.     } 
  15.  
  16. }  
package ioc;

/**
 * @author: 特种兵—AK47
 * @创建时间：2012-10-9 上午10:02:59
 * 
 * @类说明 ：
 */
public class Player implements IPlayer {

	@Override
	public void play(IMediaFile imediaFile) {
		imediaFile.getSetPath();
	}

}

测试程序：

[java] view plain copy print ?
  1. package ioc; 
  2.  
  3. import org.junit.Test; 
  4.  
  5. /**
  6. * @author: 特种兵—AK47
  7. * @创建时间：2012-10-9 上午10:08:25
  8. *
  9. * @类说明 ：
  10. */ 
  11. public class IocTest { 
  12.  
  13.     @Test 
  14.     public void testIoc() { 
  15.         OperationMain opmn = new OperationMain(); 
  16.         opmn.playMedia(new Player(), new Mp3File()); 
  17.         opmn.playMedia(new Player(), new Mp4File()); 
  18.     } 
  19. }  
package ioc;

import org.junit.Test;

/**
 * @author: 特种兵—AK47
 * @创建时间：2012-10-9 上午10:08:25
 * 
 * @类说明 ：
 */
public class IocTest {

	@Test
	public void testIoc() {
		OperationMain opmn = new OperationMain();
		opmn.playMedia(new Player(), new Mp3File());
		opmn.playMedia(new Player(), new Mp4File());
	}
}

运行一下：

[html] view plain copy print ?
  1. 播放 [Mp3] 格式的文件 
  2. 播放 [Mp4] 格式的文件  
播放 [Mp3] 格式的文件
播放 [Mp4] 格式的文件

上面代码进行了抽象，可以看到，目的是减少了依赖，但是看上去依赖关系增加了，如用户PlayMedia方法，依赖还增加了依赖接口和具体的实现，但是接口是稳定的，可以不考虑，具体的实现才是变动的，这个依赖还是要的，要播放文件，必定要用到具体的播放器和具体文件。

3.控制反转(IoC)/依赖注入(DI)

强调一下，IOC跟DI要表达的是一个意思

现实生活中，是具体的播放器和具体的媒体文件没有关系，你给它一个Mp3文件他可以播放，给它一个Mp4文件它也可以播放，你删掉你的媒体文件，播放器照样在，具体什么播放器，播放什么文件，控制权全部是我们用户自己。

上面的示例中基本实现了隔离，具体的播放器跟具体的媒体隔离了，具体的播放器只跟媒体接口和播放器接口有关。但是PlayMedia的方法里面的具体对象，写死了，控制权非常小，如果我想用百度影音播放呢，我想换一首音乐呢，只能重新改代码，那控制怎么进行转移呢？

我们可以通过反射来创建，把具体的文件名写在配置文件里，这时候客户端代码也不用变了，只需要改配置文件就好了，稳定性又有了提高，如下：

[java] view plain copy print ?
  1. public void PlayMedia() { 
  2.     IMediaFile _mtype = Assembly.Load(ConfigurationManager.AppSettings["AssemName"]).CreateInstance(ConfigurationManager.AppSettings["MediaName"]); 
  3.     IPlayer _player = Assembly.Load(ConfigurationManager.AppSettings["AssemName"]).CreateInstance(ConfigurationManager.AppSettings["PlayerName"]); 
  4.  
  5.     _player.Play(_mtype); 
  6. }  
	public void PlayMedia() {
		IMediaFile _mtype = Assembly.Load(ConfigurationManager.AppSettings["AssemName"]).CreateInstance(ConfigurationManager.AppSettings["MediaName"]);
		IPlayer _player = Assembly.Load(ConfigurationManager.AppSettings["AssemName"]).CreateInstance(ConfigurationManager.AppSettings["PlayerName"]);

		_player.Play(_mtype);
	}


这个具对象是哪一个，全由配置文件来控制了，这个具体对象的控制权交给了配置文件了，这也是人们常说的控制反转。

控制反转IoC是Inversion of Control的缩写，是说对象的控制权进行转移，转移到第三方，比如转移交给了IoC容器，它就是一个创建工厂，你要什么对象，它就给你什么对象，有了IoC容器，依赖关系就变了，原先的依赖关系就没了，它们都依赖IoC容器了，通过IoC容器来建立它们之间的关系。

Spring IOC 和 DI详解
m0_61876562的博客
04-22 1794
IOC 是Spring的核心思想。其实IOC在前面 Spring MVC 部分我们就已经用到了。代码部分，我们在类上添加@RestController 和 @Controller 注解, 就是把这个对象交给Spring管理Spring 框架启动时就会加载该类。把对象交给Spring管理, 就是IoC思想。IOC: Inversion of Control (控制反转), 也就是说 Spring 是一个"控制反转"的容器.什么是控制反转呢?也就是控制权反转。什么的控制权发生了反转?
12.＜SpringIOC&DI【扫描路径+DI详解+经典面试题+总结】＞
最新发布
m0_73456341的博客
09-08 1364
本篇博客主要讲解 扫描路径 DI详解：三种注入方式及优缺点 经典面试题 总结
unity 控制反转 带实例
05-21
unity 控制反转 依赖注入 带实例，dll、简单明了，快速入门、拿来即用。
IoC模式
weixin_34349320的博客
10-09 270
1.依赖 依赖就是有联系，有地方使用到它就是有依赖它，一个系统不可能完全避免依赖。如果你的一个类或者模块在项目中没有用到它，恭喜你，可以从项目中剔除它或者排除它了，因为没有一个地方会依赖它。下面看一个简单的示例： /// <summary> /// 用户播放媒体文件 /// </summary> public class Ope...
IoC模式（控制反转、依赖注入）
weixin_33849942的博客
04-16 150
IoC就是IoC，不是什么技术，是一种设计模式。IoC 亦称为 “依赖倒置原则”("Dependency Inversion Principle")。 控制反转（Inversion of Control，英文缩写为IoC）是一个重要的面向对象编程的法则来削减计算机程序的耦合问题。 控制反转还有一个名字叫做依赖注入（Dependency Injection）。简称DI。 可...
从入门到入土6-IOC控制依赖注入反转
qq_14919677的博客
07-08 121
ASP.NET Core内置了IOC容器， 无处不在的依赖注入DI，控制反转IOC 理解 1 理解依赖倒置原则DIP—面向抽象编程和架构设计 2 为了彻底的DIP，就需要工厂—IOC容器的需求就诞生了 3 目标：IOC控制反转—好处：稳定可扩展的架构 4 手段：通过依赖注入DI来完成IOC 实现 1 容器2件事儿：注册映射–实例化 2 实现IOC：必须依赖注入–无限级—递归—属性注入方法注入 3 单接口多实现—指定参数别名 4 单接口多实现—多个名称–依赖注入时基于特性需要指定名称— -指定参数---
ioc（依赖、依赖倒置、依赖注入）
rancho628的博客
03-27 396
先看一下这个大佬的博客 https://www.cnblogs.com/fuchongjundream/p/3873073.html 我只是画个图 1. 这个很不友好，要换Player或者MeidaFile要重新修改Player和MeidaFile，还要修改OperationMain 2. 这个好很多了，要换Player或者MeidaFile只要重新修改Player和Meida...
SpringIOC DI循环依赖实例详解
08-24
SpringIOC DI 循环依赖实例详解 SpringIOC 是一个基于依赖注入（Dependency Injection，简称 DI）的容器，用于管理 Bean 的生命周期。 DI 循环依赖是指在 Bean 初始化过程中出现的循环依赖问题，即一个 Bean 依赖于...
Spring IOC DI AOP 事务)
12-14
总结来说，Spring框架通过IOC和DI实现了组件的松耦合，通过AOP实现了关注点的分离，同时提供了强大的事务管理功能，极大地提升了Java应用的开发效率和质量。理解和掌握这些核心概念，对于任何Spring开发者都是至关...
Spring IOC和DI实现原理及实例解析
08-19
Spring IOC和DI实现原理及实例解析 Spring IOC（Inversion of Control，控制反转）是Spring框架的基础，它简单地说就是创建对象由以前的程序员调用new构造方法，变成了交由Spring创建对象。DI（Dependency Inject，...
ioc 依赖倒置_什么是依赖倒置？ 是IoC吗？
danpu0978的博客
05-09 378
ioc 依赖倒置 今天，我们将讨论所有主题中最令人困惑的主题之一，看看我们能否解开依赖倒置，控制倒置和依赖注入的混乱局面。 理解每个名称的细节并不完全重要，因为许多人最终会互换使用它们。 我们不太可能要纠正此博客文章中的所有内容。 重要的是我们了解每个主题背后的概念和想法，并了解每个主题试图解决的架构问题。 今天，我们将专注于依赖倒置，并稍微了解一下控制倒置。 依赖倒置是根...
Unity（1）控制反转
weixin_30919919的博客
08-09 316
控制反转 依赖注入方式 DI Types（Dependency injection） 接口注入 在接口中定义需要注入的信息。 首先定义一个接口，组件的注入将通过这个接口进行，该接口应由组件提供者提 供，任何想使用该组件的类都必须实现这个接口。 public interface ILog { void Log(string messag...
.NET使用依赖注入，控制反转
u011511086的专栏
04-12 1149
.net依赖注入，控制反转
ASP.MVC_API IOC框架 unity 实现控制反转
ItDotNet的博客
07-10 378
1*新建接口和实现类namespace IService { public interface Itest { string getReturn(); } }namespace Services { public class test : Itest { public string getReturn() { ...
[Unity 设计模式]IOC依赖倒置
学无止境的专栏
06-08 1972
[Unity]IOC依赖倒置1.前言最近在看《游戏开发与设计模式》一书，看到控制反转设计模式，作者说：上层模块不应该依赖于下层模块，上层模块和下层模块都应该依赖于接口，这样能减少耦合。然后附带举了个例子，我觉得特别好，就是一台计算机是属于上层模块，里面硬盘属于下层模块，计算机依赖于硬盘，硬盘是计算机的基本组成部件之一。这里提到依赖一词，下面就详细谈谈依赖。2.依赖依赖就是一种联系关系，人对人的依赖那
Unity IOC（控制反转）与DI（依赖注入）
weixin_45754664的博客
12-05 378
IOC与DI都是为了降低类与类之间的耦合度。 耦合性 耦合性也叫块间联系。指软件系统结构中各模块间相互联系紧密程度的一种度量。模块之间联系越紧密，其耦合性就越强，模块之间越独立则越差，模块间耦合的高低取决于模块间接口的复杂性，调用的方式以及传递的信息。 形象的说，就是要将代码写的和电脑一样，主类就是电脑的主机箱，当程序需要实现什么功能的时候只需要在其他的类引入接口，就像电脑上的usb接口。 在我们...
【Unity】 HTFramework框架（四十二）【进阶篇】使用依赖注入（控制反转模式）
神码编程
01-04 2985
更新日期：2022年1月4日。 Github源码：[点我获取源码] Gitee源码：[点我获取源码] 索引依赖注入使用InjectPathInjectUI作用域 依赖注入 控制反转模式是一种经典设计模式，关于其概念我就不再过多描述，直接进入正题，目前这里仅支持两种依赖注入方式： 1.InjectPath：通过路径注入依赖； 2.InjectUI：注入UI逻辑类对象； 使用 InjectPath InjectPath只能注入GameObject或组件，通过路径注入： public class Test :.
.NET深入学习- - 控制反转(依赖注入)
AndroidOrCsharp
03-05 1243
1IoC理论的背景 我们都知道，在采用面向对象方法设计的软件系统中，它的底层实现都是由N个对象组成的，所有的对象通过彼此的合作，最终实现系统的业务逻辑。 图1：软件系统中耦合的对象 一块机械手表的工作就类似上面的情形，各个齿轮分别带动时针、分针和秒针顺时针旋转，从而在表盘上产生正确的时间。图1中描述的就是这样的一个齿轮组，它拥有多个独立的齿轮，这些齿轮相互啮合在一起，协...
Spring.NET教程（一）控制反转(依赖注入)(基础篇)
lzhdim的专栏
11-05 314
在学习Spring.NET这个控制反转(IoC)和面向切面(AOP)的容器框架之前，我们先来看一下什么是控制反转(IoC)。 控制反转（Inversion of Control，英文缩写为IoC），也叫依赖注入（Dependency Injection）。我个人认为控制反转的意思是依赖对象(控制权)发生转变，由最初的类本身来管理依赖对象转变为IoC框架来管理这些对象，使得依赖脱离类本身的控制，从...
掌握SpringIOC与DI：案例工程代码下载
### Spring IOC与DI概念解析 #### Spring IOC容器 Spring IOC（Inversion of Control，控制反转）是一个核心概念，在Spring框架中通过依赖注入（DI）的方式来管理对象的创建、配置和生命周期。通过IOC容器，可以...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值