【转】Spring的IOC、DI .

Spring的IOC和DI Spring框架中的IOC(控制反转)和DI(依赖注入)是核心设计原则,旨在降低代码耦合度,提高应用程序的可测试性和可维护性。IOC通过将对象的创建权交给Spring容器,反转了传统的控制流程,而DI则是在对象创建过程中,由容器自动注入所需的依赖。IOC和DI相辅相成,共同实现解耦,使得开发者可以专注于业务逻辑,而不必手动管理对象的创建和依赖关系。DI主要有构造器注入、Setter注入和字段注入三种方式,各有优缺点。通过合理使用IOC和DI,可以构建出更加模块化、灵活且易于扩展的应用程序。 阅读详情

 

IOC、DI模式

1.依赖

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

  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

结构很简单,于是代码大致如下:

 

  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);
	}
}

  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();

}

 

  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] 格式的文件");
	}

}


 

  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] 格式的文件");
	}

}

 

  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);

}

  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();
	}

}

测试程序:

  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());
	}
}

运行一下:

  1. 播放 [Mp3] 格式的文件  
  2. 播放 [Mp4] 格式的文件  
播放 [Mp3] 格式的文件
播放 [Mp4] 格式的文件

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

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

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

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

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

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

  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容器来建立它们之间的关系。

Unity StrangeIoc框架Signal类用法详解 Unity StrangeIoc框架Signal类使用讲解的一个Demo 。 立即下载

相关推荐

unity 控制反转 带实例

unity 控制反转 依赖注入 带实例,dll、简单明了,快速入门、拿来即用。

Unity3D C# IOCContainer-DI/IOC容器-依赖关系解耦处理

在大学学习中应该会经常见到,比如Java中大名鼎鼎的,还有C#中的Autofac。可以帮助我们,让对象只需关注自己的业务逻辑,而不需要关心如何创建和维护其他对象。我这么说可能太过于高大上,我们举一个浅显的例子餐厅类需要一个厨师类和一个服务员类来运行,也就是说餐厅类依赖于这两个类,有时可能需要更换。我们可以使用IOC容器来管理这些依赖关系。

yueh0607 873

unityStrangeIoc

前言 unity的框架,除了各大公司自己内部使用的,开源并好用的实际并不是很多,我会慢慢挖掘,依次写出自己的一点见解,错误的地方,望各路大神指正。 一、基本概念 控制反转(Inversion of Control,英文缩写为IOC),我的理解就是,原本A类要获取B类的对象,需要你在A类中自己New一个对象,那么是由A来获取并控制B的对象,IOC就是把对象获取的这个过程交给容器和依赖注入来处理,A类并不知道B的对象是哪里来的,对B对象的控制,由自己变成了其他类,官方一点的概念可以百度,这个还是蛮多的。 二、StrangeIOC基础类型 实际要理解一个框架的类型,还是要自己看源码,这里我只说一下几个重要类型的作用,这个看源码的时候有个印象,也方便理解,而且说这部分的帖子也很多,我就不再赘述了。 1.Context 上下文组件定义程序边界,也就是可以把一个程序定义成多上下文,让代码更加模块化 它提供了程序入口,也算是框架中耦合度最高的地方 2.Binder和Binding 这两个类是这个框架最重要的组成部分 Binding存储了对象的绑定关系,而Binder存储了Binding的对象 3.View和Mediator MVCS中的View层,View只用于显示,也就是View只负责管理UI,Mediator负责界面逻辑,事件响应等 4.Model MVCS中的Model层,负责数据部分 5.Command MVCS中的Control层,负责执行逻辑代码 6.Service MVCS中的Service层,负责与第三方交互,这个Service我理解的,并不是一定指代服务器,也可以是其他的软件,什么都可以,它就是我们程序对外的接口 7.Dispatcher 派发器是框架内通信主线的其中一种,用来派发消息,触发命令,从而进一步解耦 8.Signal 信号是框架内另外一种通信主线,它采用强类型,来绑定信号和命令之间的关系,实现消息响应的触发 9.ReflectionBinder 反射部分,通过binding来获取类的信息,存储在ReflectedClass中 10.injector 注入器,通过反射获取的信息,来实例化请求的对象 --------------------- 作者:蓝天小僧 来源:优快云 原文:https://blog.csdn.net/zcaixzy5211314/article/details/80876228 版权声明:本文为博主原创文章,转载请附上博文链接!

IoC模式

1.依赖 依赖就是有联系,有地方使用到它就是有依赖它,一个系统不可能完全避免依赖。如果你的一个类或者模块在项目中没有用到它,恭喜你,可以从项目中剔除它或者排除它了,因为没有一个地方会依赖它。下面看一个简单的示例: /// <summary> /// 用户播放媒体文件 /// </summary> public class Ope...

weixin_34349320的博客 306

国密证书实战:在CentOS 7上构建GmSSL私有CA与完整证书链

本文详细介绍了在CentOS 7操作系统上,使用GmSSL工具构建私有国密证书颁发机构(CA)与完整证书链的实战指南。内容涵盖从部署GmSSL、创建国密根CA、签发服务器与客户端证书,到生产环境安全加固与最佳实践的全流程,旨在帮助系统管理员和安全工程师建立统一、可控的内部国密安全通信体系。

jenkins8butler的博客 502

学习 Bootstrap 5 之 Tables

学习 Bootstrap 5 之 表格表格 (Tables)1. 创建表格(1). 使用原生的表格标签(2). 使用Bootstrap 5 的提供的表格标签类(3). 原生与Bootstrap创建出来的表格的对比2. 表格样式(1). 表格样式的效果(2). 表格样式的使用1). 用于 <table> 标签2). 用于 <thead> <tbody> <tfoot> 标签 表格 (Tables) 1. 创建表格 (1). 使用原生的表格标签 <tabl

qq_37354060的博客 2130

Unity3D的MVC框架(一)——StrangeIOC与Extension的扩展介绍

Unity3D的MVC框架(一)——Strange IOC与Extension的扩展介绍 StrangeIoC框架是一个超轻量级和高度可扩展反转(IOC)框架,专门为c#和Unity编写,它是基于MVC框架扩展的。即MVCS框架。M(models),V(view),C(controller),S(services)。详细的信息可以查看其官方文档。 作为一款依赖注入/控制反转(IOC)的MVC框架,...

xc54959595的博客 1078

STM32F103C8T6的PC13-15引脚配置避坑指南:为什么你的IO口不工作?

本文详细解析了STM32F103C8T6的PC13-15引脚作为普通IO口不工作的原因及解决方案。这三个引脚默认关联侵入检测和低速外部时钟等特殊功能,需先禁用TAMPER和LSE,并开启AFIO时钟,才能正确配置为普通GPIO。文章提供了标准外设库和HAL库的配置步骤、常见问题排查方法及硬件设计注意事项。

weixin_29169899的博客 523

微软自研的IOC注入框架——Unity的基本使用

IOC是Inversion of Control的简写,也就是控制反转的意思。有接触过设计模式和抽象开发的工程师都应该知道这一概念。指的是软件功能的实现过程都是通过操作抽象来实现。常见的IOC框架还有AutoFac等。

magicchz的博客 946

PDD psnl_verification anti_content 生成顺序与环境校验说明

K不是明文 URL,而是从当前href再派生出来的一小段摘要值。页面 URL 变,K会跟着变但K不是直接肉眼可读的 URL 字串可以把它理解成“URL 的短摘要字段”。这一步是最容易被误解的地方。它吃进去的是压缩后的中间串不是直接吃环境字段它内部还带有长度预算 / 字符映射 / 位置处理逻辑所以最终看到的环境字段 bytes协议头deflate 压缩自定义编码多层叠加后的结果。先把字段总包做再把压缩结果转成raw再拼fTail最后走做字符级输出因此,当前看到的协议字段流。

码王吴彦祖的博客 70

AI金融投资002:批量下载巨潮资讯基金招募说明书

封闭式基础设施证券投资基金招募说明书 AI金融投资002:批量下载巨潮资讯基金招募说明书

LuckyHanMo的博客 2202

[转]深入浅出讲解Spring IOC和DI的区别

很多人都会把ioc和di说成同一个东西,其实IOC和DI虽然在概念上可以笼统地视为同一事物,但其本质上存在区别。控制反转)从容器的角度描述,而DI(Dependency Injection,依赖注入)则从应用程序的角度描述。换言之,IOC是依赖倒置原则的设计思想,而DI则是该原则的具体实现方式。因此,我们希望能够更加严谨地区分这两个概念,以更好地理解和应用它们。

Admans的专栏 236

OpenClaw赚钱实录:从“养龙虾“到可持续变现的实践指南——OpenClaw的赚钱底层逻辑与“记忆”革命

AI 的商业价值不在于替代思考,而在于沉淀关系。当 Agent 记住你的偏好、你的历史、你的目标,它就不再是冷冰冰的软件,而是成为数字化的关系资产。这种资产的稀缺性不在于技术复杂度,而在于时间无法被压缩——你无法用更好的算法替代 3 个月的协作记忆。在这场“记忆革命”中,护城河不是模型参数,而是用户与 AI 共同书写的历史。OpenClaw 用一套优雅的文件系统架构,将这种历史转化为可积累、可复用、可变现的数字资产。从“计算即服务”(CaaS)到“记忆即服务”(MaaS)。

冯·诺依曼 1347

Spring 的DI和IoC实例详解(转)

Spring 的DI和IoC实例详解 [url]http://www.99inf.net/SoftwareDev/Java/50677.htm[/url]

zwhc的专栏 118

Simulink开发项1000例实战专栏--实例161:基于Simulink实现电动汽车电机驱动系统的建模与仿真

通过上述步骤,我们成功实现了基于Simulink的电动汽车电机驱动系统的建模与仿真。该系统能够全面评估电机驱动系统的性能,验证控制策略的有效性,并通过优化设计提高车辆的动力性和效率。引入智能预测:结合人工智能技术,实现更智能的控制策略。扩展功能:增加对多种电机类型的支持,提升系统通用性。实验验证:将仿真模型应用于实际硬件,进行实验验证,评估其在实际工况下的表现。

xiaoheshang_123的博客 191

华为OD机试 - 魔法收积木 - 二进制(Java 新系统 200分)

华为OD机试 新系统 题库疯狂收录中,刷题。

学Java,找哪吒 444

(转)关于spring的两个概念:IoC(控制反转) ,DI(依赖注入)

所谓IoC,对于spring框架来说,就是由spring来负责控制对象的生命周期和 对象间的关系。这是什么意思呢,举个简单的例子,我们是如何找女朋友的?常见的情况是,我们到处去看哪里有长得漂亮身材又好的mm,然后打听她们的兴趣爱  好、qq号、电话号、ip号、iq号……,想办法认识她们,投其所好送其所要,然后嘿嘿……这个过程是复杂深奥的,我们必须自己设计和面对每个环节。传  统的程序开发也是如此,

老张的小记 1296

锂电池充电器电路设计 里面有电路

锂电池充电器电路设计 里面有电路 3.7V升压到5V电路设计。

spring 核心技术 IOC容器是什么

什么是IOC容器 英文:Inversion of control (控制反转) 描述:把对象的创建,赋值,管理工作交给代码之外的容器实现,也就是对象的创建是由其他的外部资源来完成的 控制:创建对象,对象属性赋值,对象之间的关系管理 反转:把原来的开发人员管理,创建对象的工作交给外码之外的容器实现,由容器代替开发人员管理、创建、赋值。 什么是正转:由开发人员手动创建对象 通过new 创建对象 控制反转:在这个容器里面,这个容器代替了人员创建对象,赋值,管理的工作。 为什么使用IOC 对象的管理更加松散

m0_46409345的博客 277

怀旧版电脑GBC模拟器

再现原版GBC掌机的界面,电脑运行连游戏界面都一样大小,很怀旧,很真实,(英文版)强烈推荐,很小的文件,很难才找到的。

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0, 兼容Win7/Win10/WinXP,解压就可用。

浅谈 Spring IOC

Ioc—Inversion of Control,即“控制反转”,不是什么技术,而是一种设计思想。在Java开发中,Ioc意味着将你设计好的对象交给容器控制,而不是传统的在你的对象内部直接控制。如何理解好Ioc呢?理解好Ioc的关键是要明确“谁控制谁,控制什么,为何是反转(有反转就应该有正转了),哪些方面反转了”,那我们来深入分析一下

程序员小奎的博客 842

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

springMVC干货系列:从零搭建springMVC+mybatis(三):spring两大核心之IOC/DI学习(转)

前言 上篇讲了SpringMVC的实现原理以及常用的注解,其实里面都用到的spring的核心概念,那就是IOC/DI,今天给大家介绍下这核心概念IOC/DI。 正文 分享Iteye的开涛这位技术牛人对Spring框架的IOC的理解,写得非常通俗易懂。 IoC是什么 Ioc—Inversion of Control,即“控制反转”,不是什么技术,而是一种设计思想。在Java开发中,Ioc意...

hahavslinb的专栏 230

浅谈对Spring IOC以及DI的理解

浅谈对Spring IOC以及DI的理解

luoyepiaoxue2014的博客 3万+

Spring | 初识IOC

快速目录 如何理解IOC 理解DI及其与IOC间的关系 IOC内容 Spring如何实现IOC 参考资料 1 如何理解IOC IOC全称是Inversion of Control,翻译中文就是“控制反转”。针对“控制反转”,提出三个问题:控制是谁控制谁?反转怎么理解?为什么要反转?正转不好吗? IOC的主要作用是创建bean以及管理其与依赖bean之间的关系,所以IOC也可以理解为各bean之...

星空下的程序猿 290

Spring的IOC核心技术、DI依赖注入

1.什么是IOC IOC-iInverse of Control,控制反转,将对象的创建权力反转给Spring框架!! 控制反转(Inversion of Control,缩写为loC),是面向对象编程中的一种设计原则,可以用来减低计尊机代码之 间的耦合度。 解决问题:使用IOC可以解决的程序耦合性高的问题!!| 2、什么是控制反转,谁控制谁,控制什么,为何是反转 1、传统Java SE程序设计,...

阿火 274

Spring之IOC

Spring入门   Spring可以作为三大框架之一,取决于它的两个特性:IOC和AOP 1. IOC是什么?   IOC(Inversion of Control)就是将你设计好的对象交给容器管理,但是为什么要取IOC这个名字呢?IOC的中文意思是控制反转,那么这个反转在哪里呢?正转又是什么? 我们传统的java SE设计是直接在对象内部通过new的方式创建对象,这是程序主动的去创建一个依赖...

听风便是雨的博客 193

spring ioc通俗的解释

学习过Spring框架的人一定都会听过Spring的IoC(控制反转) 、DI(依赖注入)这两个概念,对于初学Spring的人来说,总觉得IoC 、DI这两个概念是模糊不清的,是很难理解的,今天和大家分享网上的一些技术大牛们对Spring框架的IOC的理解以及谈谈我对Spring Ioc的理解。 1.1、IoC是什么   Ioc—Inversion of Control,即“控制反

让人生充满永动的势能 1056

【spring】IOC与DI

DI,即依赖注入(Dependency Injection),是一种实现控制反转(IOC)原则的技术手段。 容器在运⾏期间, 动态的为应⽤程序提供运⾏时所依赖的资源,称之为依赖注⼊。 可以这样理解:IOC是一种思想,而DI则是具体实现

acm_pn的博客 4112
上一篇: 笔记
下一篇: 【转】10款流程图软件
view1221
博客等级 码龄19年 4粉丝 2原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值