控制反转的理解 - 360文档中心

ioc的实现原理

IoC（控制反转）的实现原理1. 什么是IoC控制反转（Inversion of Control，简称IoC）是一种设计思想或模式，它的核心思想是将对象的创建和依赖关系的管理交给容器来完成，从而实现了对象之间的解耦。

IoC的目的是降低组件之间的耦合度，提升系统的可维护性和可测试性。

在传统的编程模式中，对象的创建和依赖关系的管理通常由程序员手动创建和维护，而在IoC容器的帮助下，这一过程被自动化地处理了。

2. IoC的基本原理IoC的实现原理主要包括两个核心概念：依赖注入（Dependency Injection，简称DI）和依赖查找（Dependency Lookup）。

2.1 依赖注入（DI）依赖注入是一种机制，它通过容器将一个对象的依赖关系注入到该对象中，使得对象只需要关注自身的业务逻辑，而不需要关心依赖对象的创建和管理。

通常，依赖注入可以通过构造函数注入、属性注入和方法注入来实现： - 构造函数注入：通过对象的构造函数接收依赖对象。

- 属性注入：通过对象的属性接收依赖对象。

- 方法注入：通过对象的方法接收依赖对象。

依赖注入的核心思想是：将对象之间的依赖关系从代码中解耦出来，交给容器来管理，对象只需要声明自己需要哪些依赖对象，由容器来负责注入。

2.2 依赖查找（DL）依赖查找是指通过容器查找依赖对象的过程。

当一个对象需要获取某个依赖对象时，它可以通过容器来进行查找。

容器将使用一种查找策略来查找对象并返回给请求者。

依赖查找的方式有两种：主动查找和被动查找。

- 主动查找：对象主动向容器请求依赖对象。

- 被动查找：对象被动地等待容器将依赖对象注入。

无论是哪种方式，依赖查找的核心思想是：将对象获取依赖对象的逻辑从对象中解耦出来，由容器统一管理。

2.3 IoC容器IoC容器是IoC模式的核心，它负责创建对象、管理对象和处理对象之间的依赖关系。

在Spring框架中，容器是由BeanFactory和ApplicationContext两个核心接口实现的。

依赖倒置原则（DIP）、控制反转（IoC）、依赖注入（DI）（C#）

依赖倒置原则（DIP）、控制反转（IoC）、依赖注⼊（DI）（C#）理解：依赖倒置原则（DIP）主程序要依赖于抽象接⼝，不要依赖于具体实现。

⾼层模块不应该依赖底层模块，两个都应该以来抽象。

抽象不应该依赖细节，细节应该依赖抽象。

（）依赖倒置原则是六⼤设计原则中的⼀种，它的⼤致意思是所有模块都应该依赖于抽象，⽽不是直接依赖于另⼀个模块。

依赖倒置原则仅仅只是⼀个原则⽽已，它只是告诉了你程序应该要变成什么样⼦（模块之间依赖抽象），⽽并没有具体告诉你应该怎么做。

就像是在学校，⽼师告诉你教室要⼲净，不要有垃圾，⽽具体打扫垃圾的动作⽼师却并没有告诉你，你可以选择⽤扫把打扫，也可以选择⽤⼿捡，但是最终教室要⼲净（当然，你也可以不遵守）。

控制反转（IoC）就是遵循了依赖倒置原则的⼀个思想。

什么是控制？控制就是对对象进⾏创建、操作、销毁。

什么是“反转”（叫“转移”更为贴切）？“反转”的意思就是将“控制”的操作交由外部来处理，⾃⼰只管⽤，只管要，其他的都不管。

为什么说控制反转遵循了依赖倒置原则？虽然A模块需要B模块，但是A模块中并不是声明了B模块对象的引⽤，⽽是声明了对IB（B模块抽象）的引⽤，A模块真正需要的是实现了IB抽象的⼦类，所以A模块并不依赖于B模块，⽽是依赖于IB抽象。

控制反转的⼤意为：如果模块A需要模块B，模块A中并不是直接控制创建模块B，⽽是从外部控制如何创建。

例如我们将创建何种对象的控制权交由配置⽂件控制，然后根据配置⽂件中的信息（程序集+类型），通过反射来获取对象，⽽不是直接new对象，这也是控制反转的⼀种体现。

IoC容器会连接程序中的所有模块，模块将所需对象的控制权都交由IoC容器控制，IoC容器会根据⽤户配置的信息将各个模块所需要的对象事先创建完成，然后IoC容器可以通过依赖注⼊（DI）的⽅式为模块注⼊所需对象（还有依赖查找（DL）），依赖注⼊就是⼀种具体实现的⼿段。

依赖倒置原则、控制反转和依赖注⼊并不是为程序带来新的功能，⽽是使得程序中模块的耦合性降低，提⾼每个模块的复⽤性。

理论五：控制反转、依赖反转、依赖注入，这三者有何区别和联系？

理论五：控制反转、依赖反转、依赖注⼊，这三者有何区别和联系？关于 SOLID 原则，我们已经学过单⼀职责、开闭、⾥式替换、接⼝隔离这四个原则。

今天，我们再来学习最后⼀个原则：依赖反转原则。

在前⾯⼏节课中，我们讲到，单⼀职责原则和开闭原则的原理⽐较简单，但是，想要在实践中⽤好却⽐较难。

⽽今天我们要讲到的依赖反转原则正好相反。

这个原则⽤起来⽐较简单，但概念理解起来⽐较难。

⽐如，下⾯这⼏个问题，你看看能否清晰地回答出来：“依赖反转”这个概念指的是“谁跟谁”的“什么依赖”被反转了？“反转”两个字该如何理解？我们还经常听到另外两个概念：“控制反转”和“依赖注⼊”。

这两个概念跟“依赖反转”有什么区别和联系呢？它们说的是同⼀个事情吗？如果你熟悉 Java 语⾔，那 Spring 框架中的 IOC 跟这些概念⼜有什么关系呢？看了刚刚这些问题，你是不是有点懵？别担⼼，今天我会带你将这些问题彻底搞个清楚。

之后再有⼈问你，你就能轻松应对。

话不多说，现在就让我们带着这些问题，正式开始今天的学习吧！控制反转（IOC）在讲“依赖反转原则”之前，我们先讲⼀讲“控制反转”。

控制反转的英⽂翻译是 Inversion Of Control，缩写为 IOC。

此处我要强调⼀下，如果你是 Java ⼯程师的话，暂时别把这个“IOC”跟 Spring 框架的 IOC 联系在⼀起。

关于 Spring 的 IOC，我们待会⼉还会讲到。

我们先通过⼀个例⼦来看⼀下，什么是控制反转。

public class UserServiceTest {public static boolean doTest() {// ...}public static void main(String[] args) {//这部分逻辑可以放到框架中if (doTest()) {System.out.println("Test succeed.");} else {System.out.println("Test failed.");}}}在上⾯的代码中，所有的流程都由程序员来控制。

控制反转的实现方式

控制反转的实现方式什么是控制反转控制反转（Inversion of Control，简称IoC）是一种软件设计原则，用于解耦和增强代码的可维护性和可测试性。

它将对象的创建、依赖关系的管理和控制权的转移从应用程序代码中转移到外部容器中。

在传统的编程模型中，应用程序代码通常负责创建和管理对象，以及处理它们之间的依赖关系。

这种方式会导致代码紧耦合、难以维护和测试。

而控制反转通过将对象的创建和依赖关系的管理交给外部容器，使得应用程序代码只需要关注核心的业务逻辑，而不需要关心对象的创建和管理。

控制反转的实现方式控制反转有多种实现方式，下面介绍几种常用的方式：1. 依赖注入（Dependency Injection，简称DI）依赖注入是控制反转的一种实现方式。

它通过将依赖关系从应用程序代码中移除，由外部容器负责创建和提供依赖的对象。

依赖注入可以通过构造函数、属性或方法来实现。

构造函数注入构造函数注入是一种常见的依赖注入方式，它通过在类的构造函数中声明依赖的参数，由外部容器负责创建和传递依赖的对象。

public class UserService {private UserRepository userRepository;public UserService(UserRepository userRepository) {erRepository = userRepository;}// ...}在上面的例子中，UserService类依赖于UserRepository类，通过构造函数注入UserRepository对象。

属性注入属性注入是另一种常见的依赖注入方式，它通过在类的属性上使用注解或配置文件来声明依赖的对象，由外部容器负责创建和注入依赖的对象。

public class UserService {@Autowiredprivate UserRepository userRepository;// ...}在上面的例子中，UserService类依赖于UserRepository类，通过属性注入UserRepository对象。

ioc(di)与aop概念的理解

ioc(di)与aop概念的理解
IOC（Inversion of Control，控制反转）和AOP（Aspect-Oriented Programming，面向切面编程）是面向对象编程中的两个重要概念。

1. IOC（控制反转）：
IOC 是一种设计原则，它将程序控制的权力从应用程序代码中反转到框架或容器中。

通常情况下，应用程序代码负责创建和管理对象之间的依赖关系，而在IOC 容器中，对象的创建和管理由容器负责。

典型的IOC 容器有Spring 容器。

在Spring 中，通过XML 配置文件或者注解，我们可以描述对象之间的依赖关系，Spring 容器负责根据这些描述来创建和管理对象，从而实现了控制反转。

2. AOP（面向切面编程）：
AOP 是一种编程范式，它的主要目的是解耦系统中的横切关注点（cross-cutting concerns）。

横切关注点是那些存在于应用程序各个模块中、影响多个模块的功能，比如日志记录、事务管理、安全控制等。

AOP 通过将这些横切关注点从业务逻辑中抽取出来，然后通过“切面”将它们模块化，从而实现了系统中各个模块和横切关注点的解耦。

在Java 中，AOP 可以通过Spring AOP 或者AspectJ 等框架来实现。

简而言之，IOC 是一种设计原则，它将对象的创建和管理权利交给了容器；而AOP 则是一种编程范式，通过将横切关注点从业务逻辑中分离出来，实现了系统模块和横切关注点的解耦。

在实际应用中，IOC 和AOP 经常结合使用，比如Spring 框架就同时支持IOC 和AOP。

对ioc的理解

对IOC的理解一、什么是IOC1.1 控制反转的概念控制反转（Inversion of Control，简称IOC）是一种软件设计原则，它将程序的控制权从应用程序代码中转移给了外部的容器。

在传统的编程模型中，应用程序代码负责管理和控制对象的创建、依赖和生命周期，导致代码之间紧密耦合，可维护性差。

而通过IOC，对象的创建和依赖交由外部容器负责，应用程序代码只需声明对象的依赖关系，可以更加灵活、高内聚低耦合地组织代码。

1.2 IOC的优点和作用•解耦–通过IOC容器管理对象的创建和依赖，减少代码之间的依赖关系，降低耦合性。

•可测试性–通过IOC容器可以轻松替换依赖的对象，方便进行单元测试和集成测试。

•高内聚低耦合–通过IOC容器实现代码的解耦，使得代码更加模块化、可维护性更好。

二、IOC的实现方式2.1 依赖注入（Dependency Injection，简称DI）依赖注入是IOC的一种常见实现方式，它通过构造函数注入、属性注入或接口注入等方式，将对象的依赖关系注入到目标对象中。

2.1.1 构造函数注入在构造函数注入中，依赖的对象通过对象的构造函数进行注入。

例如：public class UserServiceImpl {private UserDao userDao;public UserServiceImpl(UserDao userDao) {erDao = userDao;}}2.1.2 属性注入在属性注入中，依赖的对象通过对象的属性进行注入。

例如：public class UserServiceImpl {@Autowiredprivate UserDao userDao;}2.1.3 接口注入在接口注入中，依赖的对象通过实现接口的方式进行注入。

例如：public interface UserRepository {// ...}public class UserRepositoryImpl implements UserRepository {// ...}public class UserServiceImpl implements UserService {private UserRepository userRepository;@Autowiredpublic void setUserRepository(UserRepository userRepository) {erRepository = userRepository;}}2.2 依赖查找（Dependency Lookup）依赖查找是IOC的另一种实现方式，它通过在IOC容器中查找依赖的对象来进行注入。

SpringIOC（控制反转）详解及示例

SpringIOC（控制反转）详解及⽰例控制反转——Spring通过⼀种称作控制反转（）的技术促进了低耦合。

当应⽤了IoC，⼀个对象依赖的其它对象会通过被动的⽅式传递进来，⽽不是这个对象⾃⼰创建或者查找依赖对象。

你可以认为IoC与JNDI相反——不是对象从容器中查找依赖，⽽是容器在对象初始化时不等对象请求就主动将依赖传递给它。

下⾯简单通过实例来看⼀下控制反转的好处：⾸先先定义⼀个Cat.java类package com.model;public class Cat {private String name="kitty";private int age=2;public void sleep(){System.out.println(name+"猫睡了");}}再定义⼀个main函数的类调⽤Catpublic class Test {public static void main(String[] args) {Cat p = new Cat();p.sleep();} 这样会输出 kitty猫睡了这句话。

⾸先我们来分析⼀下代码：在main中new ⼀个Cat，其实这样Cat的名字和年龄就已经固定了重点来了：如果我要换个猫呢？那么new的对象就要从Cat⾥⾯修改。

这岂不是⾮常⿇烦的事⽽且破环了项⽬的⼀体性。

实际上现在⼯作的控制权并不在main中⽽是在JavaWork中，⽽正确的解决⽅法是将控制权交到mian中！要想实现控制反转：⾸先定义⼀个接⼝，让所有的宠物都通过这个接⼝package com.model;public interface IPet {public String getName();public void setName(String name);public void sleep();} 再将Cat类添加实现⽅法package com.model;public class Cat implements IPet {private String name;private int age;public String getName() {return name;}public void setName(String name) { = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public void sleep(){System.out.println(name+"猫睡了");}} 再造⼀个Dog类实现IPet接⼝package com.model;public class Dog implements IPet {private String name;private int age;public String getName() {return name;}public void setName(String name) { = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public Dog(String name, int age) {super(); = name;this.age = age;}public void sleep(){System.out.println(name+"狗睡了");}} 再做⼀个Human类添加另外⼀个⽅法，其中包含了IPet这个接⼝实现的Cat和Dog类的feed⽅法package com.model;public class Human {private IPet pet;public IPet getPet() {return pet;}public void setPet(IPet pet) {this.pet = pet;}public void feed(){System.out.println("正在喂养"+pet.getName());pet.sleep();}} 在这⾥，我们采⽤Spring的xml配置来实现控制反转(beans.xml)<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans.xsd"><bean id="pet1" class="com.model.Dog"><constructor-arg name="name" value="wang"></constructor-arg><constructor-arg name="age" value="2"></constructor-arg></bean><bean id="pet2" class="com.model.Cat"><property name="name" value="miao"></property><property name="age" value="3"></property></bean><bean id="pet3" class="com.model.Mouse" init-method="born"></bean><bean id="human" class="com.model.Human"><property name="pet" ref="pet1"></property></bean></beans> 最后做⼀个带有main函数的测试类package com.model;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;public class Test {public static void main(String[] args) {// IPet p = new Dog();// p.sleep();ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");IPet p1=(IPet)context.getBean("pet1");IPet p2=(IPet)context.getBean("pet2");IPet p3=(IPet)context.getBean("pet3");p1.sleep();p2.sleep();p3.sleep();Human h = (Human)context.getBean("human");h.feed();}} 此时的输出结果为wang狗睡了miao猫睡了laoshu⿏睡了正在喂养wangwang狗睡了因为在beans.xml中定义的pet1狗叫wang年龄2，pet2猫叫miao年龄3，human只喂养了pet1狗，再调⽤pet1的sleep，然后可以发现，我定义了⼀个pet3的⽼⿏，但是我并没有给它名字和年龄，依然能出来结果，是因为调⽤了init-method="born"⽅法，这个写法的意思是调⽤此类内部的⽅法born，看⼀下Mouse.java类的写法：package com.model;public class Mouse implements IPet{private String name;private int age;public String getName() {return name;}public void setName(String name) { = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public void born(){name="laoshu";age=1;}public void sleep(){System.out.println(name+"⿏睡了");}} 是不是⼀⽬了然。

控制反转的概念

控制反转的概念
控制反转（Inversion of Control，缩写为IoC）是一种软件设计模式，它可以将对象之间的依赖关系转移到容器或框架中，从而实现更加灵活的应用程序设计。

在传统的编程模型中，程序员通常需要自己管理对象之间的依赖关系，这往往会导致代码的复杂性增加，而IoC模式则通过将控制权转移到框架或容器中，使得对象之间的依赖关系可以更加灵活地管理和维护。

具体来说，IoC模式通常涉及到两个角色：容器和组件。

容器负责管理组件之间的依赖关系，同时也负责实例化和初始化这些组件。

而组件则是应用程序中的各个独立部分，它们通过容器来获取所需的资源和服务，而不需要直接依赖其他组件。

IoC模式的应用范围非常广泛，如Spring框架就是一个IoC容器，它可以管理Java应用程序中的组件之间的依赖关系，从而提高开发效率和代码可维护性。

在实践中，程序员可以使用不同的IoC容器和框架来满足自己的需求，从而实现更加灵活和可扩展的应用程序设计。

控制反转和依赖注入的理解(通俗易懂)

控制反转和依赖注入的理解(通俗易懂)控制反转（IoC）和依赖注入（DI）是软件开发中常用的编程范式，它们极大地提高了代码可维护性和可复用性，简化了代码结构。

一. 什么是控制反转（IoC）控制反转是一种编程模式，它将应用程序中的控制权转移到容器，通过使用者给容器指定它需要的资源，容器来完成具体的对象创建和外部调用资源的分配工作。

在控制反转模式下，对象的依赖关系由第三方容器（如Spring框架）来管理，而不是由程序本身控制。

二. 什么是依赖注入（DI）依赖注入是另一种编程范式，它将需要通过调用来实现的资源，替换成注入的依赖（通常称为参数）。

这些依赖通常由具体实现对象的对象提供。

依赖注入的思路是，将依赖的调用和实现解耦，以达到解耦和可维护的目的。

当使用依赖注入时，需要提供一种方式，将实例注入。

三. 控制反转和依赖注入的优势控制反转和依赖注入有以下优势：（1）简化编码。

控制反转和依赖注入模式，可以将资源和对象的引用分别移交给三方容器和依赖参数，从而节省了用于实例 building 的代码，避免编写大量重复的代码。

（2）提高可复用性。

控制反转和依赖注入模式，可以将对象和资源的创建和依赖解耦，这样做将会提升代码的可复用性。

（3）提供可测试性。

使用控制反转和依赖注入模式，可以有效管理接口和实现，简化测试套件的编写，当接口的实现变更的时候，可以修改对应的依赖，而不需要修改已编写的测试代码。

四. 总结控制反转和依赖注入是软件开发中常用的编程模式，它们可以简化代码结构、提高代码可维护性和可复用性、以及提供可测试性，是软件开发的重要概念，被广泛应用。

.net core aop与ioc原理

一、概述.NET Core是一个开源的跨评台框架，支持在Windows、Linux和macOS上进行开发。

它提供了一种更加灵活和高效的方式来构建应用程序，同时也拥有丰富的生态系统和强大的性能。

在.NET Core中，AOP（Aspect Oriented Programming，面向切面编程）和IoC （Inversion of Control，控制反转）是两个重要的概念，它们可以帮助开发者更好地组织和管理代码。

二、AOP原理1. 什么是AOPAOP是一种编程范式，它的核心思想是将跨越多个类并且具有共同关注点的代码进行集中管理，从而提高代码的重用性和可维护性。

AOP 可以分离横切关注点，使得程序的模块化更加清晰，同时也能减少代码的重复性。

2. AOP的实现原理在.NET Core中，AOP通常是通过使用代理技术实现的。

在AOP编程中，开发者可以使用代理来将横切关注点（如日志记录、性能监控等）与业务逻辑代码分离开来。

通过代理，可以在方法调用前后进行特定逻辑的执行，而不需要修改原有的业务逻辑代码。

三、IoC原理1. 什么是IoCIoC是一种设计模式，它的核心思想是将应用程序的控制权从应用程序代码中解耦出来，从而实现松耦合的设计。

在IoC中，对象的创建和管理通常由容器来完成，开发者只需要关注对象之间的依赖关系，而不需要关注对象的创建和生命周期管理。

2. IoC的实现原理在.NET Core中，IoC通常是通过依赖注入（DI）来实现的。

依赖注入是一种将对象的依赖关系通过构造函数、属性或者方法参数传递的方式注入到对象中的技术。

通过依赖注入，开发者可以将对象的创建和管理交给IoC容器来完成，从而实现松耦合的设计。

四、AOP与IoC在.NET Core中的应用1. AOP的应用在.NET Core中，AOP通常是通过使用第三方库（如Castle DynamicProxy、PostSharp等）来实现的。

开发者可以通过使用这些库来在方法调用前后执行特定逻辑，从而实现日志记录、事务管理、权限控制等横切关注点的管理。

Ioc控制反转详解

Ioc--控制反转详解本文转载与百度知道,简单例子让初学者很快对IoC有一个全面的了解....首先想说说IoC（Inversion of Control，控制倒转）。

这是spring的核心，贯穿始终。

所谓IoC，对于spring框架来说，就是由spring来负责控制对象的生命周期和对象间的关系。

这是什么意思呢，举个简单的例子，我们是如何找女朋友的？常见的情况是，我们到处去看哪里有长得漂亮身材又好的mm，然后打听她们的兴趣爱好、qq号、电话号、ip号、iq号………，想办法认识她们，投其所好送其所要，然后嘿嘿……这个过程是复杂深奥的，我们必须自己设计和面对每个环节。

传统的程序开发也是如此，在一个对象中，如果要使用另外的对象，就必须得到它（自己new一个，或者从JNDI中查询一个），使用完之后还要将对象销毁（比如Connection 等），对象始终会和其他的接口或类藕合起来。

那么IoC是如何做的呢？有点像通过婚介找女朋友，在我和女朋友之间引入了一个第三者：婚姻介绍所。

婚介管理了很多男男女女的资料，我可以向婚介提出一个列表，告诉它我想找个什么样的女朋友，比如长得像李嘉欣，身材像林熙雷，唱歌像周杰伦，速度像卡洛斯，技术像齐达内之类的，然后婚介就会按照我们的要求，提供一个mm，我们只需要去和她谈恋爱、结婚就行了。

简单明了，如果婚介给我们的人选不符合要求，我们就会抛出异常。

整个过程不再由我自己控制，而是有婚介这样一个类似容器的机构来控制。

Spring所倡导的开发方式就是如此，所有的类都会在spring容器中登记，告诉spring你是个什么东西，你需要什么东西，然后spring 会在系统运行到适当的时候，把你要的东西主动给你，同时也把你交给其他需要你的东西。

所有的类的创建、销毁都由spring来控制，也就是说控制对象生存周期的不再是引用它的对象，而是spring。

对于某个具体的对象而言，以前是它控制其他对象，现在是所有对象都被spring控制，所以这叫控制反转。

控制反转

控制反转(IoC)与依赖注入(DI)1.控制反转(Inversion of Control)与依赖注入(Dependency Injection) 控制反转即IoC (Inversion of Control)，它把传统上由程序代码直接操控的对象的调用权交给容器，通过容器来实现对象组件的装配和管理。

所谓的“控制反转”概念就是对组件对象控制权的转移，从1.控制反转(Inversion of Control)与依赖注入(Dependency Injection)控制反转即IoC (Inversion of Control)，它把传统上由程序代码直接操控的对象的调用权交给容器，通过容器来实现对象组件的装配和管理。

所谓的“控制反转”概念就是对组件对象控制权的转移，从程序代码本身转移到了外部容器。

IoC是一个很大的概念，可以用不同的方式来实现。

其主要实现方式有两种：<1>依赖查找（Dependency Lookup）：容器提供回调接口和上下文环境给组件。

EJB和Apache Avalon 都使用这种方式。

<2>依赖注入（Dependency Injection）：组件不做定位查询，只提供普通的Java方法让容器去决定依赖关系。

后者是时下最流行的IoC类型，其又有接口注入（Interface Injection），设值注入（Setter Injection）和构造子注入（Constructor Injection）三种方式。

图1 控制反转概念结构依赖注入之所以更流行是因为它是一种更可取的方式：让容器全权负责依赖查询，受管组件只需要暴露JavaBean的setter方法或者带参数的构造子或者接口，使容器可以在初始化时组装对象的依赖关系。

其与依赖查找方式相比，主要优势为：<1>查找定位操作与应用代码完全无关。

<2>不依赖于容器的API，可以很容易地在任何容器以外使用应用对象。

设计模式—控制反转（Ioc）

设计模式—控制反转（Ioc）本篇⽬录：好长时间没有更新设计模式系列了，不是不想写，奈何⼩菜功⼒有限，这段时间也在给⾃⼰充电，毕竟路要⼀步⼀步⾛，急不得。

控制反转（Inversion of Control）是解决程序耦合问题的⼀种⽅案，还有种叫法是依赖注⼊（Dependency Injection），但我感觉Ioc（控制反转）是⼀种思想，DI（依赖注⼊）是实现这种思想的⼀种⽅式，或者说Ioc是⼀种概念，DI是这种概念的思想，不知道我这样理解的对不对。

可能⼀开始接触这些东西有点莫名其妙，园友们写的⼀些东西也看得头疼，⾄少我当时是这样，如果你是像我⼀样的菜鸟，请跟我⼀起学习下，不看代码，我们先看⼀个⽣活中的例⼦-压⽔井和⾃来⽔⼚的故事。

内容有点多，请坚持往下看哦！压⽔井⼩时候在农村喝⽔都是⾃家打井或是⽤电⽔泵取⽔，想什么时候喝就什么时候喝，想喝多少就喝多少，很⽅便，⽽且不⽤花钱。

但是有个问题是，家⾥⾯的房⼦要装修或是重建，原来打的井已经不适合新建的房⼦了，也就是说需要重新打井，这就很⿇烦，建多少次房⼦，需要打多少次的井（当然⼟豪才这样）。

我们先看这个⼩⽰例，其实如果抽象⼀点的话，有点类似⼯⼚模式，为什么？我们分析下：上⾯例⼦中的⽔可以看成⼀个产品，每家的井或是电⽔泵可以看成⼀个⼯⼚，⾃⼰根据⾃家的情况来“⽣产”出来⽔，只有⼀家有井或是电⽔泵还好（其他家去他家取⽔，但不现实），如果每家都有⼀个井或是电⽔泵，就有点⼯⼚泛滥的情况发⽣了，可能会出现：⽔污染：每家都吃不上⽔，这⾥⾯的⽔出现问题就是产品出现问题，这样我们就需要在每个⼯⼚⾥⾯进⾏处理，就⽐如需要在每家的井或电⽔泵上安装⼀个净⽔器，显然代价⽐较⼤，也不太现实。

整体搬迁：原来的井或电⽔泵⽤不了了，每家的井或电⽔泵就需要重新搞，可能不太现实，当然只是做个假设，细想⼀下，这个问题的根源其实就是井或电⽔泵太多了，也就是⼯⼚泛滥。

上⾯所说的问题为什么会出现？其实就是依赖关系作祟，每⼀家都要依赖⾃家的井或电⽔泵，也没办法，毕竟⼈要喝⽔，总不能跑到地下暗河去喝吧，只能通过井或电⽔泵（⼯⼚）来取⽔（调⽤），这个问题在编程中就是依赖倒置原则的反例，何为依赖倒置原则：⾼层次的模块不应该依赖于低层次的模块，他们都应该依赖于抽象。

用最简单的方式理解IoC控制反转

⽤最简单的⽅式理解IoC控制反转思想引⼊假设⼀个系统原先只设定有⼀个默认的⽅法去完成业务，这⾥举例这个原先设定开发的是 UserDaoImpl（可能有些牵强，但是不影响我们对逻辑的理解）这样⼀个业务。

后来有⼀天，需求变了，业务流程⼤改，这⾥举例改为UerDaoOracleImpl，这时候我们可能需要修改UserService中对Dao层的引⽤，即修改原理的UserDaoImpl为UerDaoOracleImpl。

再后来，⽤户需求⼜变了，⽐如来了个 UserDaoMysqlImpl，这时候可能有得修改代码了吧。

好吧，那改吧，但是呢⼜有⼀天产品经理跑过来说改回原来的第⼀种，emmmm⽰意图如下：既然这样，和不把这个修改权丢给⽤户呢？要是能把这个修改权交给⽤户⾃由适⽤，那我们是不是可以把节省下来的时间拿去学新的技术了呢？是不是让⽤户感觉更好了呢？就这样IOC思想来了！IOC思想IoC，Inversion of Control，控制反转，是⼀种设计思想。

即把对象的创建，从原来的由原来的程序⾃⼰控制，变成了向外转给第三⽅/⽤户/容器来根据需要⾃定义管理创建。

举个和代码不是很相关的例⼦，例如以前的⽹站⼏乎都是只有⼀种风格，⽹站管理者设计的是什么样⽤户看到的就是什么样，但是现在不⼀样了，不少⽹站⽀持⽤户根据⾃⼰的喜好随意切换风格、⽪肤，这也是控制反转思想的⼀种应⽤吧。

IOC简单应⽤好，现在就简单的应⽤ IoC 这种思想来改变上图这的逻辑吧。

假设我们这⾥的 UserController就是对外（⽤户）的接⼝，即别的⼈/系统回从这⾥开始调⽤我们的业务逻辑。

现在我们就在这⾥直接接⼊⽤户需求，例如接⼝使⽤⽅说⽤ UserDaoMysqlImpl，好，那你就⾃⼰new⼀个UserDaoMysqlImpl对象传⼊我的预留的接⼝就⾏呗。

再过两天接⼝调⽤者⼜想⽤ UerDaoOracleImpl 这套了，也⾏，你⾃⼰set进去⼀个UerDaoOracleImpl就能调⽤我对UerDaoOracleImpl这套业务的⽀持了。

控制反转和依赖注入的理解

控制反转和依赖注入的理解嘿，朋友们！今天咱来唠唠控制反转和依赖注入这俩玩意儿。

你看啊，咱平常过日子，是不是有时候得依靠别人呀？比如说你想修个东西，自己不会，就得找个懂行的师傅来帮忙。

这就好比程序里的各个模块，它们有时候也得依靠别的模块来完成一些任务。

控制反转呢，就像是你本来自己掌握着一切，突然有一天，你说：“哎呀，我不管啦，让别人来操心吧！”在程序里，就是原本由程序自己控制流程，现在把这个控制权交出去了。

那依赖注入呢，就更好理解啦。

就好像你想吃蛋糕，你不用自己去做，而是有人直接把做好的蛋糕给你送过来。

在程序里，就是把一个模块所需要的依赖，直接给它注入进去，不用它自己费劲去找啦。

比如说，一个模块就像个挑食的小孩，它只喜欢吃特定的东西。

那我们就直接把它喜欢吃的东西给它，让它开开心心地“吃”下去，然后好好干活。

你想想，如果每个模块都自己去到处找它需要的东西，那得多乱呀！就像你要做饭，还得自己去种粮食、养牛羊，那得累成啥样啊。

但是有了依赖注入，就方便多啦，直接给它准备好，它就能高效工作啦。

这控制反转和依赖注入，不就像是给程序世界带来了一场革命嘛！让程序们的生活变得更加轻松、有序。

它们就像是一对好搭档，一起让程序的世界变得更加美好。

有了它们，程序的构建和维护都变得简单多啦。

咱再想想，要是没有这俩宝贝，那程序得多难写呀！每个模块都得自己去搞定一切，那得费多大的劲。

所以说呀，控制反转和依赖注入可真是好东西呀，咱可得好好利用它们，让我们的程序变得更强大、更厉害！它们让程序的开发变得更有趣、更有挑战性，也让我们这些开发者能更好地发挥自己的才能呀！这难道不是一件很棒的事情吗？反正我是这么觉得的！你们说呢？。

我想这下你应该知道什么叫控制反转

什么叫控制反转（IoC ）IOC（Inversion of Control）控制反转模式，意味着去除所有有该类产生但不由该类直接负责的对象实例，而改由外界传入。

由简单的对象开发模式到IOC（控制翻转）1. 依赖注入（Dependency Injection）组件之间的依赖关系有容器在运行时期决定。

2. 控制反转（IoC. Inversion of Control Containers）控制权由应用代码中转移到外部容器，控制权的转移。

IoC，翻译成中文有人叫控制反转，听起来很别别扭，其实就是依赖关系的转移，通过XML配置文件由容器来管理类，而不是在类中直接生成Bean的实例。

网上一个大牛人对IoC的形象比喻：套用好莱坞的一句名言就是：你呆着别动，到时我会找你。

什么意思呢？就好比一个皇帝和太监有一天皇帝想幸某个美女，于是跟太监说，今夜我要宠幸美女皇帝往往不会告诉太监，今晚几点会回宫，会回哪张龙床，他只会告诉太监他要哪位美女其它一切都交由太监去安排，到了晚上皇帝回宫时，自然会有美女出现在皇帝的龙床上这就是控制反转(IoC Inversion of Control)，而把美女送到皇帝的寝宫里面去就是注射(DI dependence Inversion)太监就是是框架里面的注射控制器类BeanFactory，负责找到美女并送到龙床上去整个后宫可以看成是Spring框架，美女就是Spring控制下的JavaBean而传统的模式就是一个饥渴男去找小姐出台找领班，帮助给介绍一个云云，于是领班就开始给他张罗介绍一个合适的给他，完事后，再把小姐还给领班，下次再来这个过程中，领班就是查询上下文Context，领班的一个职能就是给客户找到他们所要的小姐这就是lookup()方法，领班手中的小姐名录就是JNDI//Java Naming and Directory Interface小姐就是EJB，饥渴男是客户端，青楼是EJB容器看到区别了么？饥渴男去找小姐出台很麻烦，不仅得找，用完后还得把小姐给还回去而皇帝爽翻了，什么都不用管，交给太监去处理，控制权转移到太监手中去了而不是皇帝，必要时候由太监给注射进去就可以了看到Spring的美妙了吧，Spring还提供了与多个主流框架的支持可以和其它开源框架集成－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－控制反转模式是当今J2EE架构中常用到的模式之一，它符合好莱坞法则:不要调用我，我会调用你。

什么是控制反转

什么是控制反转控制反转就是关于⼀个对象如何获取他所依赖的对象的引⽤，这个责任的反转。

这也是多态的体现。

好⽐去超市买东西，从我⾃⼰拿需要的物品变成了服务员给我。

控制反转包括依赖注⼊和依赖查找，这次我先理解⼀下依赖注⼊：1using System;23namespace多态4 {5class MainClass6 {7public static void Main (string[] args)8 {9 IPerson student = new Student ();10 student.run ();11 IPerson teacher = new Teacher();12 teacher.run ();13 Console.Read ();14 }15 }1617public interface IPerson18 {19void run();20 }2122public class Student:IPerson23 {24public void run()25 {26 Console.WriteLine ("Student Write!");27 }28 }2930public class Teacher:IPerson31 {32public void run()33 {34 Console.WriteLine ("Teacher Write!");35 }36 }37 }如代码所⽰：IPerson接⼝可以实例Student类或者Teacher类,⽽不像以前那样Student s = new Student();这样，如果下次想要实例Teacher还要去代码中修改，再编译，太⿇烦，这样IPerson p = new *** 这个***是从配置⽂件(xml⼀类的⽂件)中读取出来，然后运⽤反射的⽅法动态取到要调⽤的类(或DLL⽂件)，打到⽅便的⽬的。

憋了很久,终于弄懂什么是IOC（控制反转）

憋了很久,终于弄懂什么是IOC（控制反转）导航共享充电宝IOC思想复杂的依赖关系IOC定义Spring中的IOCIOC与⼯⼚模式IOC容器的技术剖析结语参考本节是摘⾃的第13篇,感谢您的阅读,预计阅读时长3min。

将对象⾃⾝从其依赖关系的管理中解放出来，将这个管理⼯作的责任交给第三⽅来完成。

共享充电宝尴尬往事⼿机早已成为我们⽣活中不可或缺的⼀部分,但是伴随⽽来的便是⼿机的充电问题。

⼤概在2011年,笔者和同学买好了回学校的⽕车票。

因为是晚上6点半的⽕车票,所以笔者就想时间还早,正好⾃⼰也要去商场买点东西,便和同学约定晚上六点在⽕车站候车室会合,并将车票交给了同学。

下午五点半的时候,笔者便早早地出发前往⽕车站,⼤概⼆⼗分钟左右便到了车站。

到站之后正好赶上排队检票(⼀般都是提前⼀个⼩时检票),但是尴尬地⼀幕发⽣了——⼿机没电了。

眼看就要轮到我检票了,可车票还在我同学那⾥,我同学已经进站,在⼆楼候车室。

我礼貌地请检票员想跳过我,先去检查后⾯的票,同时也在想办法联系我的同学。

我也想起来借⼀个电话或者打公⽤电话,但⽆奈没有记住同学的⼿机号码...眼看着排队检票的队伍都进站了,检查通道也开始准备关闭了。

这时多么希望⾃⼰带了充电线或者充电宝啊...就在这时,我那同学突然从楼上冲下来,把车票给我,化解了这场尴尬。

因为⼿机没电且未带⼿机充电线出现的糗事其实不⽌这⼀件,我想⽣活中很多⼈都有过这样的经历。

时隔多年,可能很多同学会觉得这个很荒唐,为啥不⽤共享充电宝呢。

因为,那个时候没有。

共享充电宝尽管这样的事情屡见不鲜,但是依然没有引起⼿机⼚商的重视(直到今天⼿机电池的续航能⼒依然是个问题),通常我们在出门前会做⼀些准备避免这种事情的发⽣:多带⼀个⼿机换⼀个⼤容量电池带上电话本(以备不时之需)带上充电宝但是以上⼏种⽅式依然是成本较⾼的,所以通常⼿机没电你⼤概率只能通过以下但是充电:找路⼈借充电宝在饭店吃饭时，让店家帮忙充电去住酒店充电...另外,因为⼿机⼚商不同,充电线接⼝不⼀致,你可能还需要再去买⼀根充电线...⽽以上这些不仅你的增加时间和⾦钱成本,还会增加新沟通成本。

依赖注入和控制反转的理解

依赖注⼊和控制反转的理解
依赖注⼊：DI—Dependency Injection
控制反转：IoC—Inversion of Control
其实这个概念⼀直也没有很好的理解，开始只知道拿来主义，拿来就⽤，但是不知道到底为什么要这么⽤。

⾸先依赖注⼊和控制反转是同⼀个概念，只是针对不同的对象的说法。

通俗理解：
在没有这个概念之前，假如你是⼀个单⾝狗，那么你需要找⼀个⼥朋友，在没有任何⼈帮助的情况下，你只能按照⾃⼰的想法⾃⼰主动去寻求。

假设你喜欢萝莉，那么你需要
Girl girl=new Girl("萝莉");
但是有了这个概念之后，你喜欢什么样的⼥孩，那么你可以通过婚介（容器）去帮你找，你只要和婚介说清楚你喜欢什么样的⼥孩，婚介就会把合适的⼥孩介绍给你，不需要你⾃⼰苦苦寻找。

Girl girl; ⾄于具体是哪个girl就由容器分配给你，不需要你⾃⼰new
依赖注⼊就针对于应⽤程序⽽⾔，它依赖容器给他注⼊具体的实例，就像你依赖婚介给你找合适的⼥朋友。

控制反转就是针对容器⽽⾔，它控制应⽤程序的实例
仅是简单通俗⽽⾔，有些词不达意，只是写下来便于⾃⼰后续记忆。