Spring IOC

在Java中，其反射和动态代理机制极其强大，我们可以通过其反射机制在运行时获取信息。而代理是一种基本的设计模式，它是一种为了提供额外的或不同的操作而插入到真实对象中的某个对象。而Java的动态代理在代理上更进一步，既能动态的创建代理对象，又能动态的调用代理方法。Java的反射和动态代理机制，使Java变得更加强大。

Spring框架这几年风头正劲，虽然使用者众多，但真正了解其内部实现原理的朋友却并不是很多。其实，了解它的内部实现机制和设计思想是很有必要的大家都知道，Spring框架的IOC和AOP部分功能强大，很值得我们学习。那么让我们在这两篇文章中分别详细的学习IOC和AOP的实现吧。

传统方式和Spring方式对比：

传统方式：决定使用哪一个具体实现是由应用程序负责的，在编译阶段就确定了。

Spring方式：调用类只依赖接口，而不依赖具体的实现类，减少了耦合。控制权交给了容器，在运行期才由容器决定将具体的实现动态的“注入”到调用类的对象中。这也是使用IoC的根本原因。

现在我们对IoC有了基本认识，我们再理解一下IoC的概念。

IoC

IoC（Inversion of Control），控制反转，用白话来讲，就是由容器控制程序之间的关系，而非传统实现中，由程序代码直接控制。这也就是所谓“控制反转”的概念所在：控制权由应用代码中转到了外部容器，控制权的转移，就是所谓反转。

IoC的优缺点

优点：

1、把对象的创建和依赖关系定义在了XML文件中，我们改变子类的实现变得异常简单。

2、控制反转减轻了对象之间的耦合度，减轻了对象之间的依赖关系，增加了系统的灵活性，可维护性，以及可移植性等等。

缺点：

1、生成对象的方式变复杂了（事实上操作还是挺简单的），对于不习惯这种方式的人，会觉得有些别扭和不直观。

2、创建对象因为使用了反射技术，在效率上有些损耗。但相对于IoC提高的维护性和灵活性来说，这点损耗是微不足道的，除非某对象的生成对效率要求特别高。

一． Java反射机制概述与初探

Java的反射机制是Java语言的一个重要特性，Java具有的比较突出的动态机制就是反射（reflection）。通过它，我们可以获取如下信息：

1）在运行时判断任意一个对象所属的类；

2）在运行时获取类的对象；

3）在运行时获得类所具有的成员变量和方法等。

下面让我们通过调用一个Java Reflection API的演示实例来见识一下反射机制的强大。

首先在IDE中建立名为reflection_proxy的Java工程，并建立存放源文件的目录src，并在src目录下分别建立org.amigo. reflection目录和org.amigo.proxy目录来分别存放代理和反射的实例。我们在reflection目录下建立ReflectionTest.java文件，在该文件中编写代码来演示Java Reflection API的使用。该类的代码如下所示：

package org.amigo.reflection;

import java.awt.Button;

import java.lang.reflect.Method;

import java.util.Hashtable;

/**

*初探Java的反射机制.

*@author<a href="mailto:xiexingxing1121@126.com">AmigoXie</a>

*Creationdate:2007-10-2-上午10:13:48

publicclass ReflectionTest {

/**

*@paramargs

publicstaticvoid main(String[] args) throws Exception {

ReflectionTest reflection = new ReflectionTest();

reflection.getNameTest();

System.out.println("");

reflection.getMethodTest();

}

/**

*Class的getName()方法测试.

*@throwsException

publicvoid getNameTest() throws Exception {

System.out.println("===========begin getNameTest============");

String name = "xxxxx";

Class cls = name.getClass();

System.out.println("String类名: " + cls.getName());

Button btn = new Button();

Class btnClass = btn.getClass();

System.out.println("Button类名: " + btnClass.getName());

Class superBtnClass = btnClass.getSuperclass();

System.out.println("Button的父类名: " + superBtnClass.getName());

Class clsTest = Class.forName("java.awt.Button");

System.out.println("clsTest name: " + clsTest.getName());

System.out.println("===========end getNameTest============");

}

/**

*Class的getMethod()方法测试.

*@throwsException

publicvoid getMethodTest() throws Exception {

System.out.println("===========begin getMethodTest==========");

Class cls = Class.forName("org.amigo.reflection.ReflectionTest");

Class ptypes[] = new Class[2];

ptypes[0] = Class.forName("java.lang.String");

ptypes[1] = Class.forName("java.util.Hashtable");

Method method = cls.getMethod("testMethod", ptypes);

Object args[] = new Object[2];

args[0] = "hello, my dear!";

Hashtable<String, String> ht = new Hashtable<String, String>();

ht.put("name", "xxxxx");

args[1] = ht;

String returnStr = (String) method.invoke(new ReflectionTest(), args);

System.out.println("returnStr= " + returnStr);

System.out.println("===========end getMethodTest=========="); } public String testMethod(String str, Hashtable ht) throws Exception { String returnStr = "返回值"; System.out.println("测试testMethod()方法调用"); System.out.println("str= " + str); System.out.println("名字= " + (String) ht.get("name")); System.out.println("结束testMethod()方法调用"); return returnStr; } }

运行该例，可在控制台看到如下内容：

===========begin getNameTest============

String类名: java.lang.String

Button类名: java.awt.Button

Button的父类名: java.awt.Component

clsTest name: java.awt.Button

===========end getNameTest============

===========begin getMethodTest==========

测试testMethod()方法调用

str= hello, my dear!

名字= xxxxxx

结束testMethod()方法调用

returnStr= 返回值

===========end getMethodTest==========

分析运行结果，我们可以发现，Java的反射机制使得我们在运行时能够判断一个对象所属的类，获取对象的方法并得其进行调用，并获取方法的返回结果等功能。

二． IOC使用的背景

在我们日常的设计中，类与类之间存在着千丝万缕的关系，如果两个类存在着强耦合关系，那么在维护时，一个类的修改很可能会牵动另一个类的关联修改，从而使得我们的维护工作步履维艰。下面让我们来看这样的一个强耦合反面例子。

首先我们建立一个Chinese.java类，该类的sayHelloWorld(String name)方法，用中文对名为name的人问好，其内容如下：

package org.amigo.reflection;

/**

*中国人类.

*@author<a href="mailto:xiexingxing1121@126.com">AmigoXie</a>

*Creationdate:2007-10-2-上午10:37:17

publicclass Chinese {

/**

*用中文对某人问好.

*@paramname姓名

publicvoid sayHelloWorld(String name) {

String helloWorld = "你好，" + name;

System.out.println(helloWorld);

}

下面我们接着建立一个American.java类，该类的sayHelloWorld(String name)方法，用英文对名为name的人问好，其内容如下：

package org.amigo.reflection;

/**

*美国人类.

*@author<a href="mailto:xiexingxing1121@126.com">AmigoXie</a>

*@version1.0

*Creationdate:2007-10-2-上午10:41:27

publicclass American {

/**

*用英文对某人问好.

*@paramname姓名

publicvoid sayHelloWorld(String name) {

String helloWorld = "Hello，" + name;

System.out.println(helloWorld);

}

最后我们编写一个测试类对这两个类的sayHelloWorld(String name)方法进行测试，下面是该类的内容：

package org.amigo.reflection;

/**

*HelloWorld测试.

*@author<a href="mailto:xiexingxing1121@126.com">AmigoXie</a>

*Creationdate:2007-10-2-上午10:45:13

publicclass HelloWorldTest {

/**

*测试Chinese和American的sayHelloWorld()方法.

*@paramargs

*@author<a href="mailto:xiexingxing1121@126.com">AmigoXie</a>

*Creationdate:2007-10-2-上午10:43:51

publicstaticvoid main(String[] args) {

Chinese chinese = new Chinese();

chinese.sayHelloWorld("xxxxxx");

American american = new American();

american.sayHelloWorld("Amigo");

}

观察HelloWorldTest我们可以很清楚的看到，该类与Chinese.java类和American.java类都存在强耦合关系。

上面的例子让我们想到的是在N年以前，当我们需要某个东西时，我们一般是自己制造。但是当发展到了一定的阶段后，工厂出现了，我们可以工厂中购买我们需要的东西，这极大的方便了我们。在上例中，我们都是通过new来创建新的对象，在开发中，这种强耦合关系是我们所不提倡的，那么我们应该如何来实现这个例子的解耦呢？我们接着想到了使用工厂模式，我们需要新建一个工厂类来完成对象的创建，并采用依赖接口的方式，此时需要对代码进行如下修改：

首先建立接口类Human.java，其内容如下：

package org.amigo.reflection;

/**

* 人类接口类.

* @author <a href="mailto:xiexingxing1121@126.com">AmigoXie</a>

* Creation date: 2007-10-2 - 上午11:04:56

public interface Human {

/**

* 对某人问好.

* @param name 姓名

public void sayHelloWorld(String name);

}

并将American.java类和Chinese.java类改为实现该接口，即类头分别改成：public class American implements Human和public class Chinese implements Human。

接着编写HumanFactory.java工厂类，其内容为：

package org.amigo.reflection;

/**

* 工厂类.

* @author <a href="mailto:xiexingxing1121@126.com">AmigoXie</a>

* Creation date: 2007-10-2 - 上午11:09:30

public class HumanFactory {

/**

* 通过类型字段获取人的相应实例

* @param type 类型

* @return 返回相应实例

public Human getHuman(String type) {

if ("chinese".equals(type)) {

return new Chinese();

} else {

return new American();

}

最后我们还需要修改测试类HelloWorld.java类，修改后的内容如下：

package org.amigo.reflection;

/**

* HelloWorld测试.

* @author <a href="mailto:xiexingxing1121@126.com">AmigoXie</a>

* Creation date: 2007-10-2 - 上午10:45:13

public class HelloWorldTest {

/**

* 测试sayHelloWorld()方法.

* @param args

* @author <a href="mailto:xiexingxing1121@126.com">AmigoXie</a>

* Creation date: 2007-10-2 - 上午10:43:51

public static void main(String[] args) {

HumanFactory factory = new HumanFactory();

Human human1 = factory.getHuman("chinese");

human1.sayHelloWorld("xxxxx");

Human human2 = factory.getHuman("american");

human2.sayHelloWorld("Amigo");

}

观察此例我们可以看到，该类不再与具体的实现类Chinese和American存在耦合关系，而只是与它们的接口类Human存在耦合关系，具体对象的获取只是通过传入字符串来获取，很大程度上降低了类与类之间的耦合性。

但是我们还是不太满足，因为还需要通过chinese和american在类中获取实例，那么当我们需要修改时实现时，我们还需要在类中修改这些字符串，那么还有没有更好的办法呢？让我们在下节中进行继续探讨。

三． IOC粉墨登场

IOC（Inverse of Control）可翻译为“控制反转”，但大多数人都习惯将它称为“依赖注入”。在Spring中，通过IOC可以将实现类、参数信息等配置在其对应的配置文件中，那么当需要更改实现类或参数信息时，只需要修改配置文件即可，这种方法在上例的基础上更进一步的降低了类与类之间的耦合。我们还可以对某对象所需要的其它对象进行注入，这种注入都是在配置文件中做的，Spring的IOC的实现原理利用的就是Java的反射机制， Spring还充当了工厂的角色，我们不需要自己建立工厂类。Spring的工厂类会帮我们完成配置文件的读取、利用反射机制注入对象等工作，我们可以通过bean的名称获取对应的对象。

下面让我们看看如下的模拟Spring的bean工厂类：

package org.amigo.reflection;

import java.io.InputStream;

import java.lang.reflect.Method;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import org.dom4j.Attribute;

import org.dom4j.Document;

import org.dom4j.Element;

import org.dom4j.io.SAXReader;

/**

* bean工厂类.

* @author <a href="mailto:xiexingxing1121@126.com">AmigoXie</a>

* Creation date: 2007-10-6 - 上午10:04:41

public class BeanFactory {

private Map<String, Object> beanMap = new HashMap<String, Object>();

/**

* bean工厂的初始化.

* @param xml xml配置文件

public void init(String xml) {

try {

//读取指定的配置文件

SAXReader reader = new SAXReader();

ClassLoader classLoader = Thread.currentThread().getContextClassLoader();

//从class目录下获取指定的xml文件

InputStream ins = classLoader.getResourceAsStream(xml);

Document doc = reader.read(ins);

Element root = doc.getRootElement();

Element foo;

//遍历bean

for (Iterator i = root.elementIterator("bean"); i.hasNext();) {

foo = (Element) i.next();

//获取bean的属性id和class

Attribute id = foo.attribute("id");

Attribute cls = foo.attribute("class");

//利用Java反射机制，通过class的名称获取Class对象

Class bean = Class.forName(cls.getText());

//获取对应class的信息

java.beans.BeanInfo info = java.beans.Introspector.getBeanInfo(bean);

//获取其属性描述

java.beans.PropertyDescriptor pd[] = info.getPropertyDescriptors();

//设置值的方法

Method mSet = null;

//创建一个对象

Object obj = bean.newInstance();

//遍历该bean的property属性

for (Iterator ite = foo.elementIterator("property"); ite.hasNext();) {

Element foo2 = (Element) ite.next();

//获取该property的name属性

Attribute name = foo2.attribute("name");

String value = null;

//获取该property的子元素value的值

for(Iterator ite1 = foo2.elementIterator("value"); ite1.hasNext();) {

Element node = (Element) ite1.next(); value = node.getText(); break; } for (int k = 0; k < pd.length; k++) { if (pd[k].getName().equalsIgnoreCase(name.getText())) { mSet = pd[k].getWriteMethod(); //利用Java的反射极致调用对象的某个set方法，并将值设置进去 mSet.invoke(obj, value); } } } //将对象放入beanMap中，其中key为id值，value为对象 beanMap.put(id.getText(), obj); } } catch (Exception e) { System.out.println(e.toString()); } } /** * 通过bean的id获取bean的对象. * @param beanName bean的id * @return 返回对应对象 */ public Object getBean(String beanName) { Object obj = beanMap.get(beanName); return obj; } /** * 测试方法. * @param args * @author <a href="mailto:xiexingxing1121@126.com">AmigoXie</a> * Creation date: 2007-10-6 - 上午11:21:14 */ public static void main(String[] args) { BeanFactory factory = new BeanFactory(); factory.init("config.xml"); JavaBean javaBean = (JavaBean) factory.getBean("javaBean"); System.out.println("userName=" + javaBean.getUserName()); System.out.println("password=" + javaBean.getPassword()); } }

该类的init(xml)方法，通过指定的xml来给对象注入属性，为了对该类进行测试，我还需要新建一个JavaBean和在src目录下新建一个名为config.xml的配置文件。JavaBean的内容如下：

package org.amigo.reflection;

/**

* 简单的bean，用于测试

* @author <a href="mailto:xiexingxing1121@126.com">AmigoXie</a>

* Creation date: 2007-10-6 - 上午11:24:30

public class JavaBean {

private String userName;

private String password;

public String getPassword() {

return password;

}

public String getUserName() {

return userName;

}

public void setUserName(String userName) {

this.userName = userName;

}

public void setPassword(String password) {

this.password = password;

}

这个简单bean对象中有两个属性，分别为userName和password，下面我们在配置文件config.xml中对其属性注入对应的属性值。配置文件内容如下：

xml version="1.0" encoding="UTF-8"?>

<beans>

</property>

</property>

</bean>

</beans>

类与配置文件都完成后，可以运行BeanFactory.java文件，控制台显示内容为：

userName=xxxxx

password=12345678

可以看到，虽然在main()方法中没有对属性赋值，但属性值已经被注入，在BeanFactory类中的Class bean = Class.forName(cls.getText());通过类名来获取对应的类，mSet.invoke(obj, value);通过invoke方法来调用特定对象的特定方法，实现的原理都是基于Java的反射机制，在此我们有一次见证了Java反射机制的强大。

当然，这只是对IOC的一个简单演示，在Spring中，情况要复杂得多，例如，可以一个bean引用另一个bean，还可以有多个配置文件、通过多种方式载入配置文件等等。不过原理还是采用Java的反射机制来实现IOC的。