IOC介绍及其简单实现

预备知识： Java反射原理，XML及其解析

IOC：Inversion of Control，控制反转，它最主要反映的是与传统面向对象（OO）编程的不同。通常我们编程实现某种功能都需要几个对象相互作用，从编程的角度出发，也就是一个主对象要保存其他类型对象的引用，通过调用这些引用的方法来完成任务。如何获得其他类型的对象引用呢？一种方式是主对象内部主动获得所需引用；另一种方式是在主对象中设置setter 方法，通过调用setter方法或构造方法传入所需引用。后一种方式就叫IOC，也是我们常常所说的依赖注入。以下我们用一个简单的例子来说明传统OO编程与IOC编程的差别。

这个例子的目的是根据时间不同返回不同的问候字符串， 比如Good Morning, world或Good afternoon, World。

服务接口：

package com.kettas.springdev.ioc;

public interface HelloIF {

String sayHello();

}

传统实现：

package com.kettas.springdev.ioc;

import java.util.Calendar;

public class HelloIFImpl implements HelloIF{

private Calendar cal; //我们需要的引用

public HelloIFImpl(){

cal =Calendar.getInstance(); //主动获取

}

public String sayHello(){

if(cal.get(Calendar.AM_PM) == Calendar.AM) return “Good morning, World”;

else return “Good afternoon, World”;

}

}

采用IOC方式：

package com.kettas.springdev.ioc;

import java.util.Calendar;

public class HelloIFImpl implements HelloIF{

private Calendar cal;//我们需要的引用

public void setCal(Calendar cal){ this.cal = cal;} //依赖注入

public String sayHello(){

if(cal.get(Calendar.AM_PM) == Calendar.AM) return “Good morning, World”;

else return “Good afternoon, World”;

}

}

在这里你也许会问：我看不出有太大差别，并且依赖注入还需要我先创建外部的Calendar对象，然后再传到HelloIFImpl对象中。

是的，如果我们直接创建HelloIFImpl对象没有任何的优势。如果我们让一个Bean工厂来帮我们创建HelloIF类型的引用就有优势了，当然要在这样的前提下： 1. Bean工厂可以随时改变HelloIF实现的类型；2. Bean工厂在创建好对象后主动调用依赖注入的方法。所以离开Bean工厂谈IOC是没有什么意义的, 开源框架Spring就提供了灵活多样的Bean工厂。以上例子可以通过如下XML片段来告诉Bean工厂如何创建对象并注入依赖：

<beans>

<bean id=”hello” class=”com.kettas.springdev.ioc.HelloIFImpl”> <!—调用构造方法产生对象à

<property name=”cal” > <!—注入下面定义的Calendar引用-->

<ref local=”calendar”/>

</property>

</bean>

<bean id=”calendar” class=”java.util.GregorianCalendar” /> <!—产生calendar对象à

</beans>

Bean工厂通过解析以上的配置就知道如何创建对象，如何注入依赖。

那Bean工厂到底如何实现所说的功能呢？从以上的XML配置片段我们可以看出

有两种数据类型：一个是Bean的定义（BeanDefinition）；一个是对Bean的属性(Property)的定义(PropertyDefinition)，嵌套在Bean定义中。Bean的定义包括：id, 类名（clazz）和一到多个PropertyDefinition; Property的定义包括： name, refName(如果是引用，指向另一个Bean), value(如果是基本数据类型), ifRef(是否是引用)。Java通过反射机制可以调用构造方法创建对象，也可以调用该实例上的方法。Bean工厂通过递归调用创建配置文件里定义的Bean对象，并调用这些对象的setter方法来实现依赖注入。而依赖注入都使用的是Bean的id, 所以我们在Bean工厂里用一个Map来保存Bean的定义，该Map的key是Bean的id。创建的Bean对象都是单例的，所以我们要保存Bean对象；而客户是通过id来获取Bean对象，所以我们也用Map来缓存。以下的代码提供了上述问题的解决方案（当然这是最简单的一种：只调用没有参数的构造方法，只实现基于setter的依赖注入，注入的依赖只能是基本数据类型或引用， xml解析没有做合法性检测等）

Bean的定义：BeanDefinition,java:

package com.kettas.springdev.ioc.bf;

import java.util.HashSet;

import java.util.Set;

public class BeanDefinition {//对应<bean>元素

private String clazz; //Bean类名全路径, 对应<bean>的attribute: class

private String id; //唯一属性, 对应<bean>的attribute: id

private Set<PropertyDefinition> propertyDefinitions //依赖描述, 对应<property>元素

= new HashSet<PropertyDefinition>();

public String getId() {

return id;

}

public void setId(String id) {

this.id = id;

}

public String getClazz() {

return clazz;

}

public void setClazz(String clazz) {

this.clazz = clazz;

}

public Set<PropertyDefinition> getPropertyDefinitions() {

return propertyDefinitions;

}

public void setPropertyDefinitions(Set<PropertyDefinition> propertyDefinitions) {

this.propertyDefinitions = propertyDefinitions;

}

public void addPropertyDefinition(PropertyDefinition pd){

this.propertyDefinitions.add(pd);

}

}

Bean的属性的定义：PropertyDefinition.java:

package com.kettas.springdev.ioc.bf;

public class PropertyDefinition {//对应<property>元素

private String name; // <property> attribute: name

private String refName; // <property>子元素<ref>的attribute(如local, bean等)的值

private String value; //<property>子元素<value>的字符串子元素

private boolean isRef; //是否为引用

public boolean isRef() {

return isRef;

}

public void setRef(boolean isRef) {

this.isRef = isRef;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public String getRefName() {

return refName;

}

public void setRefName(String refName) {

this.refName = refName;

}

public String getValue() {

return value;

}

public void setValue(String value) {

this.value = value;

}

}

Bean工厂接口： BeanFactory.java:

package com.kettas.springdev.ioc.bf;

public interface BeanFactory {

Object getBean(String id);

}

BeanFactory的一个实现：XmlBeanFactory.java:

package com.kettas.springdev.ioc.bf;

import java.lang.reflect.Method;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Map;

import java.util.Set;

public class XmlBeanFactory implements BeanFactory{

private Map<String, Object> beans

= new HashMap<String, Object>();//Bean对象缓存

private Set<BeanDefinition> beanDefinitions

= new HashSet<BeanDefinition>();//Bean的定义

public XmlBeanFactory(String xmlFileClassPath){

new BeanFactoryConfiguration(beanDefinitions, xmlFileClassPath);

}

public Object getBean(String id){

if(beans.containsKey(id)) return beans.get(id);

Object bean = null;

BeanDefinition bd = getBeanDefintion(id);

try{

Class beanClass = Class.forName(bd.getClazz());

bean = beanClass.newInstance();

for(PropertyDefinition pd : bd.getPropertyDefinitions()){

String property = pd.getName();

Method m = getSetter(beanClass,property);

//System.out.println(property + " : " + pd.isRef());

if(pd.isRef()){

m.invoke(bean, getBean(pd.getRefName()));

}else{

setValue(m, bean, pd.getValue());

}

}

beans.put(id, bean);

}catch(Exception e){

throw new RuntimeException("Can't create bean " + id, e);

}

return bean;

}

private void setValue(Method m, Object bean, String value) throws Exception {

// TODO Auto-generated method stub

Class paramType = m.getParameterTypes()[0];

//System.out.println(paramType.getName());

if(paramType == byte.class || paramType == Byte.class){

Byte b = new Byte(value);

m.invoke(bean, b);

}else if(paramType == short.class || paramType == Short.class){

Short s = new Short(value);

m.invoke(bean, s);

}else if(paramType == char.class || paramType == Character.class){

Character c = new Character(value.charAt(0));

m.invoke(bean, c);

}else if(paramType == int.class || paramType == Integer.class){

Integer i = new Integer(value);

m.invoke(bean, i);

}else if(paramType == float.class || paramType == Float.class){

Float f = new Float(value);

m.invoke(bean, f);

}else if(paramType == double.class || paramType == Double.class){

Double d = new Double(value);

m.invoke(bean, d);

}else{

m.invoke(bean, value);

}

}

private Method getSetter(Class beanClass, String property) throws Exception {

// TODO Auto-generated method stub

StringBuilder sb = new StringBuilder("set");

char c = property.charAt(0);

if(c >= 'a' && c <= 'z') c -= 32;

sb.append(c).append(property.substring(1));

Method[] methods = beanClass.getMethods();

for(Method m : methods){

if(m.getName().equals(sb.toString()))

return m;

}

throw new RuntimeException("No such property: " + property);

}

private BeanDefinition getBeanDefintion(String id){

for(BeanDefinition bd : beanDefinitions){

if(bd.getId().equals(id))

return bd;

}

throw new RuntimeException("There is not [id="

+ id + "] in the xml configuration file");

}

}

解析Xml文件，生成BeanDefintion和PropertyDefinition: BeanFactoryConfiguration.java

package com.kettas.springdev.ioc.bf;

import java.util.Set;

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import javax.xml.parsers.ParserConfigurationException;

import org.w3c.dom.Document;

import org.w3c.dom.Element;

import org.w3c.dom.NamedNodeMap;

import org.w3c.dom.Node;

import org.w3c.dom.NodeList;

public class BeanFactoryConfiguration {

public BeanFactoryConfiguration(Set<BeanDefinition> beanDefinitions, String xmlFileClassPath) {

// TODO Auto-generated constructor stub

DocumentBuilderFactory dbf =

DocumentBuilderFactory.newInstance();

try {

DocumentBuilder db = dbf.newDocumentBuilder();

Document doc = db.parse(

this.getClass().getResourceAsStream(xmlFileClassPath)

);

parse(doc, beanDefinitions);

} catch (Exception e) {

// TODO Auto-generated catch block

throw new RuntimeException("can't parse the configuration file : " + xmlFileClassPath, e);

}

}

private void parse(Document doc, Set<BeanDefinition> beanDefinitions) {

// TODO Auto-generated method stub

NodeList beans = doc.getElementsByTagName("bean");

int len = beans.getLength();

for(int i = 0; i < len; i++){

BeanDefinition bd = new BeanDefinition();

Element n = (Element)beans.item(i);

NamedNodeMap nnm = n.getAttributes();

for(int j = 0; j < nnm.getLength(); j++){

Node attr = nnm.item(j);

//System.out.println(attr.getNodeName() + " " + attr.getNodeValue());

if(attr.getNodeName().equals("id"))

bd.setId(attr.getNodeValue());

else

bd.setClazz(attr.getNodeValue());

}

NodeList pros = n.getElementsByTagName("property");

for(int j = 0; j < pros.getLength(); j++){

bd.addPropertyDefinition(createPropertyDefinition(pros.item(j)));

}

beanDefinitions.add(bd);

}

}

private PropertyDefinition createPropertyDefinition(Node node) {

// TODO Auto-generated method stub

PropertyDefinition pd = new PropertyDefinition();

NamedNodeMap nnm = node.getAttributes();

pd.setName(nnm.item(0).getNodeValue());

NodeList nl = ((Element)node).getElementsByTagName("value");

if(nl != null && nl.getLength() > 0){

pd.setValue(nl.item(0).getFirstChild().getNodeValue());

}else{

pd.setRef(true);

nl = ((Element)node).getElementsByTagName("ref");

Node ref = nl.item(0);

pd.setRefName(ref.getAttributes().item(0).getNodeValue());

}

return pd;

}

}

测试程序：

package com.kettas.springdev.ioc.bf;

import springdev.ioc.day1.HelloIF;

public class TestMyBeanFactory {

/**

* @param args

*/

public static void main(String[] args) {

// TODO Auto-generated method stub

BeanFactory bf = new XmlBeanFactory(

"/com/kettas/springdev/ioc/beans.xml"

);

HelloIF hello = (HelloIF)bf.getBean("hello");

System.out.println(hello.sayHello());

}

}