预备知识： 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());
}
}