Spring记录之模拟IoC(一)

模拟Spring IoC容器

先回顾一下前文。前文说过，Spring的容器，通过读取配置文件，利用反射机制，实现了对象的创建，这是核心。

模拟步骤

1.准备一个xml文件，配置好对象的关系

2.根据配置文件初始化容器

3.容器根据配置文件创建对象

目录结构

1.bean.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans>
<bean id="chinese" class="spring.beans.Chinese"></bean>

<bean id="english" class="spring.beans.English"></bean>
</beans>

2.准备容器

一个定义容器标准的接口

package spring.container;

/**
* @author Administrator
*
*/
public interface BeanFactory {

public Object getBean(String id);
}

3. 两种解析xml方法

Spring容器初始化的同时，会解析xml配置文件，所以在容器的构造方法里解析xml文件.

package spring.container;

import java.util.HashMap;
import java.util.Map;
import spring.parser.ConfigParser;

/**
* @author Administrator
*
*/
public class DomClassPathXMLApplicationContext implements BeanFactory {

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

//parse xml file instantly this class is initializing
public DomClassPathXMLApplicationContext(String path) {
beans = ConfigParser.domParser(path);
}

@Override
public Object getBean(String id) {
return beans.get(id);
}
}

package spring.container;

import java.util.HashMap;
import java.util.Map;

import spring.parser.ConfigParser;

/**
* @author Administrator
*
*/
public class Dom4jClassPathXmlApplicationContext implements BeanFactory{

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

//parse xml file instantly this class is initializing
public Dom4jClassPathXmlApplicationContext(String path) {
beans = ConfigParser.dom4jParser(path);
}

@Override
public Object getBean(String id) {
return beans.get(id);
}

}

解析xml配置文件的核心方法(1.0)

public class ConfigParser {

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

/**
* dom parse xml file
* @param path
* @return
*/
public static Map<String, Object> domParser(String path) {
org.w3c.dom.Document document = null;
try {

DocumentBuilderFactory factory = DocumentBuilderFactory
.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
document = builder.parse(DomClassPathXMLApplicationContext.class
.getResourceAsStream(path));

} catch (SAXException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
throw new RuntimeException(
"please check your configuration file. Make sure it is correct.");
} catch (ParserConfigurationException e) {
e.printStackTrace();
}

// 获取所有<bean>节点
NodeList beanList = document.getElementsByTagName("bean");

for (int i = 0; i < beanList.getLength(); i++) {

Node node = beanList.item(i);
NamedNodeMap namedNodeMap = node.getAttributes();
// dom解析属性是倒着来的，先class，再id,<bean id="" class=""></bean>
String clazz = namedNodeMap.item(0).getNodeValue();
String id = namedNodeMap.item(1).getNodeValue();
Object object;
try {

object = Class.forName(clazz).newInstance();
beans.put(id, object);

} catch (InstantiationException | IllegalAccessException
| ClassNotFoundException e) {
e.printStackTrace();
}

}
return beans;
}

/**
* dom4j parse xml file
* @param path
* @return
*/
public static Map<String, Object> dom4jParser(String path) {

// 1.parse xml configuration

SAXReader reader = new SAXReader();
org.dom4j.Document document = null;
try {
document = reader.read(Dom4jClassPathXmlApplicationContext.class
.getResourceAsStream(path));
} catch (DocumentException e) {
e.printStackTrace();
throw new RuntimeException(
"please check your configuration file. Make sure it is correct.");
}
// 2. define xPath to fetch all <bean>
String xpath = "//bean";
List<Element> list = document.selectNodes(xpath);

if (list.size() > 0) {
for (Element beanEle : list) {

String id = beanEle.attributeValue("id");
String clazz = beanEle.attributeValue("class");

try {
// use reflection to generate object
Object object = Class.forName(clazz).newInstance();
// put id and obj into a map
beans.put(id, object);

} catch (InstantiationException | IllegalAccessException
| ClassNotFoundException e) {
e.printStackTrace();
throw new RuntimeException(
"please check your configuration file." + id
+ "not found!");
} catch (SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
return beans;
}
}

4. 测试用的bean类

定义了一个Human接口

public interface Human {
public void speak();
}
.......
public class English implements Human{
private String name = "British";

@Override
public void speak() {
System.out.println(name + " speaks in English.");
}
}

......

public class Chinese implements Human{

private String name = "中国人";

@Override
public void speak() {
System.out.println(name + "说中文。");
}

}

5. 测试

public class ContainerTest {

@Test
public void testContainer(){
Dom4jClassPathXmlApplicationContext context = new Dom4jClassPathXmlApplicationContext("/bean.xml");
//      DomClassPathXMLApplicationContext context = new DomClassPathXMLApplicationContext("/bean.xml");
Chinese chinese = (Chinese) context.getBean("chinese");
English english = (English)context.getBean("english");
chinese.speak();
english.speak();

}
}

结果如下



至此，一个简单的Spring IoC模拟1.0就实现完毕了，对象创建不是new出来的，而是通过配置文件解析，由容器创建的。