我的IOC（一）

 

题外话

重复造轮子并不是件不好的事，作为学习我觉得造几个轮子还是很有必要的，光看不练假把式，况且看完后容易忘掉，又要重新看，还不如动手写几行，一来加深印象，二来在coding过程中还能学到不少相关的知识，比如在实现自己IOC的时候，除了深入理解其原理，还能了解诸如xml解析，编写dtd文档保证xml格式的有效性等等。最后写篇博文总结并梳理一下思绪，好了下面正式开始。

 

首先新建一个Person类

 

public class Person {
	private String name;
	private Integer age;
	
   //省略setter,getter方法
}

 

然后再建一个PersonService

 

public class PersonService {
	private Person person;

	public void info(){
		System.out.println("My name's "+person.getName()+" , I'm "+person.getAge()+" years old!");
	}

	public void setPerson(Person person) {
		this.person = person;
	}
}

 

 

和Spring一样，这里采用setter方法实现依赖注入，使用XML文件来保存对象之间的依赖关系

 

 

配置文件

 

<?xml version="1.0" encoding="UTF-8"?>
<beans>
	<bean id="person" class="com.firefly.core.Person">
		<property name="name" value="Jack"/>
		<property name="age" value="12"/>
	</bean>
	<bean id="personService" class="com.firefly.core.PersonService">
		<property name="person" ref="person"/>
	</bean>
</beans>

 

一开始只实现最最基础的部分， 即读取、解析配置文件，然后利用反射实现对象的依赖注入。

 

我们先不管怎么实现解析xml，也不管怎么依赖注入。首先回顾一下Spring当中配置好xml后怎么来使用，一般都是这样

 

ApplicationContext applicationContext = new FileSystemXmlApplicationContext("firefly.xml");

PersonService personService = (PersonService)applicationContext.getBean("personService");

ok,那么我们也新建一个ApplicationContext接口，里面有个getBean方法，然后新建一个FileSystemXmlApplicationContext来实现这个接口

 

/**
 * IOC容器基本接口
 * @author 杰然不同
 * @date 2010-11-26
 * @Description: 定义IOC容器基本规范
 * @Version 1.0
 */
public interface ApplicationContext {
	public Object getBean(String name);
}

 

 

/**
 * 容器接口实现
 * @author 杰然不同
 * @date 2010-11-29
 * @Version 1.0
 */
public class FileSystemXmlApplicationContext extends AbstractApplicationContext{
	
	public FileSystemXmlApplicationContext(String fileName) {
		super.reader = new XmlBeanDefinitionReader(fileName);
		
		// 启动容器初始化
		refresh();
	}
}

 

细心的朋友会看到FileSystemXmlApplicationContext并没有直接实现ApplicationContext，而是继承了名为AbstractApplicationContext

的抽象类，我们先来看下这是个什么类

 

/**
 * IOC容器的具体实现
 * @author 杰然不同
 * @date 2010-12-5
 * @Version 1.0
 */
public abstract class AbstractApplicationContext implements ApplicationContext {
	
	protected Map<String,BeanDefinition> beansDefinitionMap = new HashMap<String, BeanDefinition>();
	
	protected Map<String, Object> beansMap = new HashMap<String, Object>();
	
	protected BeanDefinitionReader reader;
	
	/**
	 * 创建Bean
	 * @Date 2010-11-30
	 * @param beanName
	 * @return 具体Bean实例
	 */
	protected Object createBean(String beanName) {
		Object beanobj = this.beansMap.get(beanName);
		if(beanobj != null)
			return beanobj;
		
		Class<?> clazz = null;
		Object obj = null;
		BeanDefinition beanDefinitionan = (BeanDefinition)beansDefinitionMap.get(beanName);
		if(beanDefinitionan != null){
			try {
				clazz = Class.forName(beanDefinitionan.getClassName());
				obj = clazz.newInstance();
			} catch (ClassNotFoundException e) {
				throw new RuntimeException(e);
			} catch (InstantiationException e) {
				throw new RuntimeException(e);
			} catch (IllegalAccessException e) {
				throw new RuntimeException(e);
			}
		}else{
			
		}
		
		// 依赖注入
		setProperties(obj, beanDefinitionan.getProperties());
		beansMap.put(beanName, obj);
		return obj;
	}
	
	/**
	 * 获取Bean
	 */
	public Object getBean(String name){
		return createBean(name);
	}
	
	
	/**
	 * 使用set方法注入值
	 */
	private Object setProperties(Object obj, Map<String, Object> properties) {
		Class<?> clazz = obj.getClass();
		try {
			Method[] methods = clazz.getMethods(); 
			for(Entry<String, Object> entry : properties.entrySet()){
				String key = entry.getKey();
				Object value = entry.getValue();

				for(Method m : methods){
					// 取出所有set方法并且只有一个参数
					String methodName = m.getName();
					Class<?>[] argsType = m.getParameterTypes();
					if(methodName.startsWith("set") && argsType.length == 1){
						String tempName = methodName.substring(3, methodName.length()).toLowerCase();
						if(tempName.equals(key)){
							setFieldValue(argsType[0].getName(),(String)value,m,obj);
						}
					}
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		return obj;
	}
	
	private void setFieldValue(String className, String value, Method m,
			Object obj) throws IllegalArgumentException,
			IllegalAccessException, InvocationTargetException {
		
		if (className.equals("byte"))
			m.invoke(obj, Byte.parseByte(value));
		else if (className.equals("short"))
			m.invoke(obj, Short.parseShort(value));
		else if (className.equals("int"))
			m.invoke(obj, Integer.parseInt(value));
		else if (className.equals("long"))
			m.invoke(obj, Long.parseLong(value));
		else if (className.equals("float"))
			m.invoke(obj, Float.parseFloat(value));
		else if (className.equals("double"))
			m.invoke(obj, Double.parseDouble(value));
		else if (className.equals("boolean"))
			m.invoke(obj, Boolean.parseBoolean(value));
		else if (className.equals("java.lang.Byte"))
			m.invoke(obj, new Byte(value));
		else if (className.equals("java.lang.Short"))
			m.invoke(obj, new Short(value));
		else if (className.equals("java.lang.Integer"))
			m.invoke(obj, new Integer(value));
		else if (className.equals("java.lang.Long"))
			m.invoke(obj, new Long(value));
		else if (className.equals("java.lang.Float"))
			m.invoke(obj, new Float(value));
		else if (className.equals("java.lang.Double"))
			m.invoke(obj, new Double(value));
		else if (className.equals("java.lang.String"))
			m.invoke(obj, new String(value));
		else if (className.equals("java.lang.Boolean"))
			m.invoke(obj, new Boolean(value));
		else
			m.invoke(obj, createBean(value));
	}
	
	/**
	 * IOC容器初始化入口
	 * @Date 2010-11-29
	 */
	public void refresh(){
		beansDefinitionMap = reader.loadBeanDefinitions();
	}
}

 

原来IOC的具体实现是在这个类中，之所以这么做也是为了能有更好的扩展性。在这里我有必要说一下springioc工作的流程。IOC容器需要进行初始化，粗略的说就是解析配置文件将bean信息缓存到一个HashMap中，在这个过程中有专门的读取器对资源进行定位、解析、注册，这也是解耦的一种体现。于是在AbstractApplicationContext 中声明一个读取器BeanDefinitionReader，然后在其子类指明是由哪种读取器来读取，

此处自然我们需要一个解析xml的读取器super.reader = new XmlBeanDefinitionReader(fileName);

 

在FileSystemXmlApplicationContext中只做两件事，一个是将配置文件名给读取器，配置文件放在classpath下面，

然后调用refresh()启动IOC的初始化

 

我们顺着refresh()看下去，读取器调用loadBeanDefinitions()方法开始处理配置文件，下面是读取器的相关内容

 

 

BeanDefinition用来表示单个Bean

 

public class BeanDefinition {
	
	// Bean的id
	private String id;
	
	// Bean的class
	private String className;
	
	// Bean的属性集合
	private Map<String, Object> properties = new HashMap<String, Object>();

       // 省略getter,setter方法
}

 

读取、解析配置文件

 

1.创建读取配置文件通用接口BeanDefinitionReader

 

/**
 * 加载配置文件接口
 * @author 杰然不同
 * @date 2010-11-28
 * @Version 1.0
 */
public interface BeanDefinitionReader {

	/**
	 * 读取配置文件中的信息
	 * @Date 2010-11-29
	 * @param fileName 文件名
	 * @return map
	 */
	public abstract Map<String, Bean> loadBeanDefinitions();
	
}

 

2.创建XmlBeanDefinitionReader实现以上接口，看名字很容易知道是读取XML形式的配置文件，今后可以扩展其他形式，只需实现上面的接口即可。

 

public class XmlBeanDefinitionReader implements BeanDefinitionReader {

	private final String fileName;
	
	protected static Logger log = Logger.getLogger(XmlBeanDefinitionReader.class.getName());
	
	public XmlBeanDefinitionReader(String fileName) {
		this.fileName = fileName;
	}
	
	/**
	 * 读取配置文件,将Bean信息存入HashMap中
	 * @Date 2010-12-5
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public Map<String, BeanDefinition> loadBeanDefinitions(){
		
		Map<String, BeanDefinition> beanDefinitionsMap = new HashMap<String, BeanDefinition>();
		
		Document doc = null;
		
		// 获得Xml文档对象
		try {
			log.info("Get XML Document");
			doc = readDocument(this.fileName);
		} catch (DocumentException e) {
			e.printStackTrace();
			return null;
		}
		
		// 获得根节点
		List<Element> beans = doc.getRootElement().elements("bean");
		
		// 遍历所有跟节点
		for(Element e : beans){
			
			BeanDefinition beanDefinitionan = new BeanDefinition();
			String id = e.attributeValue("id");
			String className = e.attributeValue("class");
			beanDefinitionan.setId(id);
			beanDefinitionan.setClassName(className);
			
			// 获得Bean中所有property
			List<Element> propertiesList = e.elements("property");
			
			// 遍历所有property
			for(Element e1 : propertiesList){
				String name = e1.attributeValue("name");
		
				// 如果是普通赋值形式
				if(e1.attribute("value") != null)
					beanDefinitionan.getProperties().put(name, e1.attributeValue("value"));
				
				// 如果是引用另一个Bean形式
				if(e1.attribute("ref") != null)
					beanDefinitionan.getProperties().put(name, e1.attributeValue("ref"));
			}
			
			beanDefinitionsMap.put(id, beanDefinitionan);
		}
		return beanDefinitionsMap;
	}
	
	/**
	 * 根据文件读取Document
	 * @Date 2010-11-28
	 * @param filePath
	 * @return 文档对象
	 * @throws DocumentException 
	 */
	private Document readDocument(String filePath) throws DocumentException{
		// 获得带上classpath路径的文件路径
		filePath = Thread.currentThread().getContextClassLoader().getResource(
				filePath).getPath().substring(1);

		log.info("Loading XML bean definitions from file [" + filePath + "]");
		
		//使用SAXReader来读取xml文件
		SAXReader reader = new SAXReader();
		Document doc = null;
		doc = reader.read(new File(filePath));
		return doc;
	}
}

 

读取器经过一系列处理后，将xml中所有的内容缓存到Map<String, BeanDefinition>中，到此为止IOC容器初始化完毕。Bean的依赖注入在第一次getBean的时候触发。

 

我们回到AbstractApplicationContext中看getBean方法，它直接调用了createBean新建Bean，顺着方法看下去，可以看到是利用了java反射机制来实例化Bean对象和它的属性对象，然后同样缓存到HashMap中。

 

到这里一个简单IOC完成了，我们写一个测试

 

public class ApplicationContextTest extends TestCase {

	@Test
	public void testGetBean(){
		ApplicationContext applicationContext = new FileSystemXmlApplicationContext("firefly.xml");
		
		PersonService personService = (PersonService)applicationContext.getBean("personService");
		personService.info();
		Person person = (Person)applicationContext.getBean("person");
		System.out.println(person.getName());
	}
}

 输出：

My name's Jack , I'm 12 years old!

Jack

 

下一节我们进行第一次重构！！！

 

ps:附件是重构前的源码，用maven构建的