文章目录
- IOC定义
- 理解IOC
- 不使用IOC：
- 使用IOC：
- 使用IOC的好处
- IOC提供被依赖对象的方式
- 构造器注入
- setter 方法注入
- 接口方式注入
- 简单模拟IOC
- 总结
IOC定义
IoC 全称为 Inversion of Control，翻译为 “控制反转”，它还有一个别名为 DI（Dependency Injection）,即依赖注入。
DI—Dependency Injection，即“依赖注入”：组件之间依赖关系由容器在运行期决定，形象的说，即由容器动态的将某个依赖关系注入到组件之中。
依赖注入的目的并非为软件系统带来更多功能，而是为了提升组件重用的频率，并为系统搭建一个灵活、可扩展的平台。
通过依赖注入机制，我们只需要通过简单的配置，而无需任何代码就可指定目标需要的资源，完成自身的业务逻辑，而不需要关心具体的资源来自何处，由谁实现。
Spring IOC容器通过xml,注解等其它方式配置类及类之间的依赖关系，完成了对象的创建和依赖的管理注入。实现IOC的主要设计模式是工厂模式。
如何理解“控制反转”好呢？理解好它的关键在于我们需要回答如下四个问题：
- 谁控制谁
- 控制什么
- 为何是反转
- 哪些方面反转了
IoC和DI由什么关系呢？其实它们是同一个概念的不同角度描述，由于控制反转概念比较含糊（可能只是理解为容器控制对象这一个层面，很难让人想到谁来维护对象关系），所以2004年大师级人物Martin Fowler又给出了一个新的名字：“依赖注入”，相对IoC 而言，“依赖注入”明确描述了“被注入对象依赖IoC容器配置依赖对象”。
理解IOC
以年轻小伙子找女朋友为例子来说明IOC的作用:
/**
* 年轻小伙子
*/
public class YoungMan {
private BeautifulGirl beautifulGirl;
YoungMan(){
// 可能你比较牛逼，指腹为婚
// beautifulGirl = new BeautifulGirl();
}
public void setBeautifulGirl(BeautifulGirl beautifulGirl) {
this.beautifulGirl = beautifulGirl;
}
public static void main(String[] args){
YoungMan you = new YoungMan();
BeautifulGirl beautifulGirl = new BeautifulGirl("你的各种条件");
beautifulGirl.setxxx("各种投其所好");
// 然后你有女票了
you.setBeautifulGirl(beautifulGirl);
}
}
不使用IOC：
小伙子需要： new BeautifulGirl() ，也就是自己去创建一个女朋友对象。这个过程复杂而又繁琐，而且我们必须要面对每个环节，同时使用完成之后我们还要负责销毁它。
使用IOC：
小伙子自己不用去找女朋友，反过来找IOC，IOC就相当于一个婚介公司，它管理着很多男男女女的资料，小伙子直接跟婚介公司提出需求，婚介公司则会根据需求提供一个妹子给我们，我们只需要负责使用它就行了。
所以，简单点说，IoC 的理念就是让别人为你服务
可以理解为： IOC主动把妹子注入给想使用它的小伙子。 （调用的时候使用Autowied ，这个对象就是前文说的bean， 通过注册进入IOC容器，被实例化之后再进入IOC容器的bean缓存池，就可以供程序调用了，这就和bean的生命周期连了起来。）
-
通过IOC的注册机制可以保证对象的安全性和合规性；
-
实例化对象只需要实例化一次，即可进入IOC容器的bean缓存池，降低了对象的创建开销，提高了程序的性能（有点类似单例）；
-
应用程序调用对象从bean缓存池获取，这样是秒获取对象，提高了调用对象的速度。
现在来回答上面那四个问题，答案就显得非常明显了:
- 谁控制谁：在传统的开发模式下，我们都是采用直接 new 一个对象的方式来创建对象，也就是说你依赖的对象直接由你自己控制，但是有了 IOC 容器后，则直接由 IoC 容器来控制。所以“谁控制谁”，当然是 IoC 容器控制对象。
- 控制什么：控制对象。
- 为何是反转：没有 IoC 的时候我们都是在自己对象中主动去创建被依赖的对象，这是正转。但是有了 IoC 后，所依赖的对象直接由 IoC 容器创建后注入到被注入的对象中，依赖的对象由原来的主动获取变成被动接受，所以是反转。
- 哪些方面反转了：所依赖对象的获取被反转了。
使用IOC的好处
- 集中管理，实现类的可配置和易管理。
- 降低了类与类之间的耦合度。
IOC提供被依赖对象的方式
IOC Service Provider 为被注入对象提供被依赖对象也有如下几种方式：构造方法注入、stter方法注入、接口注入。
构造器注入
构造器注入，顾名思义就是被注入的对象通过在其构造方法中声明依赖对象的参数列表，让外部知道它需要哪些依赖对象。
YoungMan(BeautifulGirl beautifulGirl){
this.beautifulGirl = beautifulGirl; //这里可以定义很多女孩的条件
}
构造器注入方式比较直观，对象构造完毕后就可以直接使用，这就好比你出生你家里就给你指定了你媳妇。
setter 方法注入
对于 JavaBean 对象而言，我们一般都是通过 getter 和 setter 方法来访问和设置对象的属性。所以，当前对象只需要为其所依赖的对象提供相对应的 setter 方法，就可以通过该方法将相应的依赖对象设置到被注入对象中。如下：
public class YoungMan {
private BeautifulGirl beautifulGirl;
public void setBeautifulGirl(BeautifulGirl beautifulGirl) {
this.beautifulGirl = beautifulGirl;
}
}
相比于构造器注入，setter 方式注入会显得比较宽松灵活些，它可以在任何时候进行注入（当然是在使用依赖对象之前），这就好比你可以先把自己想要的妹子想好了，然后再跟婚介公司打招呼，随意性较强。
一般程序中会使用这种方法进行实例化。
接口方式注入
接口方式注入显得比较霸道，因为它需要被依赖的对象实现不必要的接口，带有侵入性。一般都不推荐这种方式。
简单模拟IOC
public interface BeanFactory {
Object getBean(String id);
}
public class ClassPathXmlApplicationContext implements BeanFactory {
//容器，用来存放注入的Bean
private Map<String, Object> container = new HashMap<String, Object>();
//解析xml文件，通过反射将配置的bean放到container中
public ClassPathXmlApplicationContext(String fileName) throws Exception{
SAXBuilder sb = new SAXBuilder();
Document doc
=sb.build(ClassPathXmlApplicationContext.class.getResource("/"+fileName));
Element root = doc.getRootElement();
List<Element> list = XPath.selectNodes(root, "/beans/bean");
for (int i = 0; i < list.size(); i++) {
Element bean = list.get(i);
String id = bean.getAttributeValue("id");
String clazz = bean.getAttributeValue("class");
Object o = Class.forName(clazz).newInstance();
container.put(id, o);
}
}
@Override
public Object getBean(String id) {
return container.get(id);
}
}
需要导入 jdom.jar包。
<?xml version="1.0" encoding="UTF-8"?>
<beans>
<bean id="people" class="com.ioc.People" />
<bean id="chicken" class="com.ioc.Chicken" />
<bean id="dog" class="com.ioc.Dog" />
</beans>
public interface Animal {
void say();
}
public class Dog implements Animal {
@Override
public void say() {
System.out.println("汪汪");
}
}
public class Chicken implements Animal {
@Override
public void say() {
System.out.println("鸡你很美");
}
}
public class People {
public void info(){
System.out.println("小明-23岁");
}
}
public static void main(String[] args) throws Exception {
//加载配置文件
BeanFactory f = new ClassPathXmlApplicationContext("applicationContext.xml");
Object os = f.getBean("dog");
Animal dog = (Animal)os;
dog.say();
Object op = f.getBean("chicken");
Animal chicken = (Animal)op;
chicken.say();
Object p = f.getBean("people");
People people= (Animal)p;
people.info();
}
总结
A对象需要使用合作对象B来共同完成一件事，A要使用B，那么A就对B产生了依赖，也就是A和B之间存在一种耦合关系，并且是紧密耦合在一起。
而使用了Spring之后就不一样了，创建合作对象B的工作是由Spring来做的，Spring创建好B对象，然后存储到一个容器里面，当A对象需要使用B对象时，Spring就从存放对象的那个容器里面取出A要使用的那个B对象，然后交给A对象使用，至于Spring是如何创建那个对象，以及什么时候创建好对象的，A对象不需要关心这些细节问题(你是什么时候生的，怎么生出来的我可不关心，能帮我干活就行)，A得到Spring给我们的对象之后，两个人一起协作完成要完成的工作即可。
所以控制反转IoC(Inversion of Control)是说创建对象的控制权进行转移，以前创建对象的主动权和创建时机是由自己把控的，而现在这种权力转移到第三方，比如转移交给了IoC容器，它就是一个专门用来创建对象的工厂，你要什么对象，它就给你什么对象，有了 IoC容器，依赖关系就变了，原先的依赖关系就没了，它们都依赖IoC容器了，通过IoC容器来建立它们之间的关系。
