java进阶（一）--控制反转IoC

控制反转（Inversion of Control，英文缩写为IoC），亦称为 “依赖倒置原理”("Dependency Inversion Principle")，是一个重要的面向对象编程的法则来削减计算机程序的耦合问题，也是轻量级的Spring框架的核心。 控制反转一般分为两种类型，依赖注入（Dependency Injection，简称DI）和依赖查找（Dependency Lookup）。依赖注入应用比较广泛，依赖注入之所以更流行是因为它是一种更可取的方式：让容器全权负责依赖查

询，受管组件只需要暴露JavaBean的setter方法或者带参数的构造子或者接口，使容器可以在初始化时组装对象的依赖关系。其与

依赖查找方式相比，主要优势为：

<1>查找定位操作与应用代码完全无关。

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

<3>不需要特殊的接口，绝大多数对象可以做到完全不必依赖容器。。

许多非凡的应用（企业级的大型软件）都是由两个或是更多的类通过彼此的合作来实现业务逻辑，这使得每个对象都需要，与其合作的对象（也

就是它所依赖的对象）的引用。如果这个获取过程要靠自身实现，那么如你所见，这将导致代码高度耦合并且难以测试。应用控制反转，对象在被创

建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。所以，控制反转是，关于一

个对象如何获取他所依赖的对象的引用，这个责任的反转。

IoC个人认为是已经是一种全新的设计模式，本来我也想把这篇文章放到java设计模式分类目录下，但是想想又觉得不合适，因为其理论和时间

成熟相对较晚，所以在GoF中并没有包含该设计模式，同时大家普遍认同的23种设计模式中（如果还不知道23种设计模式包含哪些，请猛戳这里->

java设计模式），也没有该设计模式，所以我就干脆重新开了个分类--java进阶

废话不多说，看代码，在还没有IoC之前，我们的代码是，如果需要在A对象里面，使用到B对象的相关方法，就需要new出一个B对象来，如下

所示：

class B
{
	public void print()
	{
		System.out.println("B print");
	}
}
public class A 
{
	public static void main(String[] args) 
	{
		B b= new B(); // 对象A和对象B高度耦合
		b.print();

	}

}

聪明的人类总是一直在不断的进步，工业革命来啦，工厂模式的出现，我们就把构造对象实例的工作交给工厂来处理啦：

FactoryImpl
	{
	   B create(Object condition)
	   {
	      if(condition = condA)
	      {
	          return new B1();
	      }
	      else if(condition = condB)
	      {
	          return new B2();
	      }
	      else
	      {
	          return new B();
	      }
	    }
	}

表面上工厂模式是在一定程度上缓解了第一个程序的问题，但实质上这种代码耦合并没有改变。通过IoC模式可以彻底解决这种耦合，它把耦合从代码中移出去，放到统一的XML 文件中，通过一个容器在需要的时候把这个依赖关系形成，即把需要的接口实现注入到需要它的类中，这可能就是“依赖注入”说法的来源了。

IoC模式，系统中通过引入实现了IoC模式的IoC容器，即可由IoC容器来管理对象的生命周期、依赖关系等，从而使得应用程序的配置和依赖性规范与实际的应用程序代码分开。其中一个特点就是通过文本的配置文件进行应用程序组件间相互关系的配置，而不用重新修改并编译具体的代码，下面以运用了Spring的代码为例：

对象HelloWorld：

package com.helloWorld ;
public class HelloWorld {
 
    private String message;
 
    public void setMessage(String message){
        this.message  = message;
    }
 
    public String getMessage(){
        return this.message;
    }
 
    public void printMessage(){
        System.out.println("Your Message : " + message);
    }
}

对象Main：

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.importnew.HelloWorld;
 
public class Main {
    public static void main(String[] args) {
 
        ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
 
        HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
 
        obj.printMessage();
    }
}

Bean文件：

<?xml version="1.0" encoding="UTF-8"?>
 
    <beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
 
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
 
       <bean id="helloWorld" class="com.helloWorld.HelloWorld">
           <property name="message" value="Hello World!"/>
       </bean>
 
    </beans>

从上面两个程序可以看出， IoC模式看做是工厂模式的升华，可以把IoC看作是一个大工厂，只不过这个大工厂里要生成的对象都是在XML文件中给出定义的，然后利用Java 的“反射”编程，根据XML中给出的类名生成相应的对象。从实现来看，IoC是把以前在工厂方法里写死的对象生成代码，改变为由XML文件来定义，也就是把工厂和对象生成这两者独立分隔开来，目的就是提高灵活性和可维护性。