自行编写BeanFactory，感受Spring核心的核心

Spring的核心是IoC容器，IoC的核心是无须程序员自行完成对象的实例化和对象间关系的装配。Spring中通过BeanFactory或其子接口类型ApplicationContext完成该项工作。Spring中有关对象的实例化可以实现：

1. 构造方法实例化；
2. 静态工厂方法实例化；
3. 实例工厂方法实例化；
4. FactoryBean实例化等；

实例化的对象可以放置于各种不同的作用范围：

1. singleton;
2. prototype;
3. request;
4. session;
5. global session以及甚至可以自行定义作用范围；

对象关系装配时可以装配的对象为：

1. 基本类型;
2. String类型；
3. 数组类型；
4. List类型；
5. Map类型；
6. Properties类型；
7. 自行定义的Bean对象等；

装配时可以采用：

1. setter注入；
2. 构造子注入;

我们也可以不看Spring源码，通过自行编写BeanFactory，感受IoC需要对象，召之即来的痛快。在接下来的BeanFactory源码中，只实现了：

1. 通过构造方法完成对象的实例化，而且均是单个实例；
2. 通过setter注入方式注入String和自行定义的Bean对象；

源码如下：

package common;

import java.lang.reflect.Method;
import java.util.*;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.*;

public class MyBeanFactory {
	private Map<String, Object> map=
		new HashMap<String, Object>();
	
	public MyBeanFactory(String path) {
		DocumentBuilderFactory f=
			DocumentBuilderFactory.newInstance();
		try {
			DocumentBuilder builder=
				f.newDocumentBuilder();
			Document document=builder.parse(path);
			
			//实例化对象
			buildBeanObject(document);
			//建立对象间关系
			buildBeanObjectRelation(document);
		}catch(Exception e) {
			throw new RuntimeException(e);
		}
	}
	
	/**
	 * 1. 读取配置文件<bean>标记中class属性值用以
	 * 实例化成对象存入Map作为Value;
	 * 2. 读取配置文件<bean>标记中id属性值存入
	 * Map作为Key;
	 * 
	 * @param document
	 */
	private void buildBeanObject(Document document) 
		throws Exception{
		Element root=document.getDocumentElement();
		NodeList beans=root.getElementsByTagName("bean");
		for(int i=0;i<beans.getLength();i++) {
			Element bean=(Element)beans.item(i);
			String id=bean.getAttribute("id");
			String className=bean.getAttribute("class");
			
			map.put(id, Class.forName(className).newInstance());
		}
	}
	
	private void buildBeanObjectRelation(Document document) 
		throws Exception{
		Element root=document.getDocumentElement();
		NodeList beans=root.getElementsByTagName("bean");
		
		BeanWrapper wrapper=null;
		for(int i=0;i<beans.getLength();i++) {
			Element bean=(Element)beans.item(i);
			String id=bean.getAttribute("id");
			Object o=map.get(id);
			NodeList properties=bean.getElementsByTagName("property");
			for(int j=0;j<properties.getLength();j++) {
				Element property=(Element)properties.item(j);
				String name=property.getAttribute("name");
				String value=property.getAttribute("value");
				wrapper=new BeanWrapper(o);
				if(value==null||value.trim().length()==0) {
					value=property.getAttribute("ref");
					wrapper.setProperty(name, map.get(value));
				} else {
					try {
						wrapper.setProperty(name, Integer.parseInt(value));
					}catch(Exception e) {
						wrapper.setProperty(name, value);
					}					
				}				
			}			
		}		
	}	
	
	public Object getBean(String id) {
		return map.get(id);
	}
}

class BeanWrapper {
	Object o;
	Map<String, Method> map=
		new HashMap<String,Method>();
	
	public BeanWrapper(Object o) {
		this.o=o;
	}

	public void setProperty(String name,Object value) throws Exception{
		String methodName="set"+name.toUpperCase().charAt(0)+name.substring(1);
		array2Map(o.getClass().getMethods());
		Method m=map.get(methodName);
		//Method m=o.getClass().getMethod(methodName, value.getClass());
		m.invoke(o, value);
	}
	
	private void array2Map(Method[] ma) {
		for(int i=0;i<ma.length;i++) {
			map.put(ma[i].getName(),ma[i]);
		}
	}
}