采用 dom4j 和反射模拟 Spring 框架的依赖注入功能

Spring 的依赖注入是指将对象的创建权交给 Spring 框架, 将对象所依赖的属性注入进来的行为.在学习了 dom4j 后, 其实也可以利用 dom4j 和反射做一个小 Demo 模拟 Spring 框架的这种功能.下面是具体的步骤:

  第一步, 编写配置文件.配置文件的书写, 采用了和 Spring 的配置文件 applicationContext.xml 一样的书写规则:
xml <?xml version="1.0" encoding="UTF-8"?> <beans> <bean id="user1" class="com.itmayiedu.entity.User"> <property name="userId" value="0001"></property> <property name="userName" value="余胜军"></property> </bean> <bean id="user2" class="com.itmayiedu.entity.User"> <property name="userId" value="0002"></property> <property name="userName" value="张三"></property> </bean> </beans>
第二步, 编写 JavaBean 类, 书写了两个 JavaBean, 其中 Student 类中有一个 Teacher 类的引用.

public class User {

	private String userId;
	private String userName;
	public String getUserId() {
		return userId;
	}
	public void setUserId(String userId) {
		this.userId = userId;
	}
	public String getUserName() {
		return userName;
	}
	public void setUserName(String userName) {
		this.userName = userName;
	}
}

第三步, 也是最关键的一步, 编写 MyClassPathXmlApplicationContext 类, 在这个类里面做了如下操作:

  1.利用传入的参数获取 xml 文件的流, 并且利用 dom4j 解析成 Document 对象

  2.对于 Document 对象获取根元素对象后对下面的标签进行遍历, 判断是否有符合的 id.

  3.如果找到对应的 id, 相当于找到了一个 Element 元素, 开始创建对象, 先获取 class 属性, 根据属性值利用反射建立对象.

  4.遍历标签下的 property 标签, 并对属性赋值.注意, 需要单独处理 int,float 类型的属性.因为在 xml 配置中这些属性都是以字符串的形式来配置的, 因此需要额外处理.

  5.如果属性 property 标签有 ref 属性, 说明某个属性的值是一个对象, 那么根据 id(ref 属性的值)去获取 ref 对应的对象, 再给属性赋值.

  6.返回建立的对象, 如果没有对应的 id, 或者下没有子标签都会返回 null

  代码如下:
```java
public class MyClassPathXmlApplicationContext {
private String xmlName;

public MyClassPathXmlApplicationContext(String xmlName) {
    this.xmlName=xmlName;
}

public Object getBean(String id) {
    Object obj=null;            //声明引用.
    //进行xml的解析
    SAXReader reader=new SAXReader();
    try {
        Document document = reader.read(this.getClass().getClassLoader().getResourceAsStream(xmlName));
        Element root=document.getRootElement();
        //遍历.看是否有元素的id为传入的参数.
        List<Element> elements = root.elements();
        if(elements.size()>0) {
            for(Element element:elements ) {
                if(element.attributeValue("id").equals(id)) {//id相同开始创建对象
                    //采用反射创建对象.
                    String className=element.attributeValue("class");
                    Class beanClass=Class.forName(className);
                    obj=beanClass.newInstance();
                    //获取子标签的属性.
                    List<Element> attributes=element.elements();
                    if(attributes.size()>0) {
                        for(Element attribute:attributes) {
                            String name=attribute.attributeValue("name");
                            Field field = beanClass.getDeclaredField(name);
                            field.setAccessible(true);
                            if(attribute.attribute("ref")!=null) {
                                //此属性的值是一个对象.这里由于直接调用getBean方法赋值给对象,返回的对象一定是Bean参数的对象,因此强制转换不会出问题
                                String refid=attribute.attributeValue("ref");
                                field.set(obj, getBean(refid));
                            }
                            else {
                                //此属性值是一个字符串.这里单独处理int,float类型变量.如果不处理,会将String类型直接赋值给int类型,发生ClassCastException
                                String value=attribute.attributeValue("value");
                                //需要对类型进行判断
                                if(value.matches("[0-9]+")) {
                                    //整数
                                    int x=Integer.parseInt(value);
                                    field.set(obj, x);
                                    continue;
                                }
                                if(value.matches("[0-9]*(\\.+)[0-9]*")) {
                                    //浮点数
                                    float y=Float.parseFloat(value);
                                    field.set(obj, y);  //注意double可以接受float类型
                                    continue;
                                }
                                field.set(obj, value);//处理String类型
                            }
                        }
                    }
                }
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
    return obj;
}

}

第四步:测试.

public void testMySpring() {
MyClassPathXmlApplicationContext applicationContext=new MyClassPathXmlApplicationContext(“applicationContext.xml”);
System.out.println(applicationContext.getBean(“student1”));
}
```

总结:

  dom4j 是一个很好的解析 xml 的工具, 而解析 xml 是一个很重要的基本功, 对于理解框架原理有很大的帮助.反射结合 xml 文件的解析, 可以实现在任何类中方便的创建任何对象.