利用xml解析完成依赖注入

以下代码是本人所做的一个简单测试，现在将其公布出来，只是希望那些学习Java的同胞不要在为某些框架感到头痛。该压缩文件已上传，可免费下载

 

声明：以下代码系个人所做，并非转载，如有需要，可转载（禁止用作商业用途）

 

1）Dao类接口

package xmlparse_Ioc;

public interface UserDao {
 
 public void say() ;
}

3）Dao类实现

package xmlparse_Ioc;

public class UserDaoImpl implements UserDao{

 public void say() {
  System.out.println("测试成功...");
 }

}

 

3）BIZ类接口

package xmlparse_Ioc;

public interface UserService {
 
 public void sayHello() ;
}

4）BIZ类实现

package xmlparse_Ioc;

public class UserServiceImpl implements UserService {
 
 private UserDao userDao ;

 public void sayHello() {
  System.out.println("userDao.say:");
  userDao.say() ;
 }

 public UserDao getUserDao() {
  return userDao;
 }
 
 public void setUserDao(UserDao userDao) {
  this.userDao = userDao;
 }

}

5）proxyBean，用于创建对象实例

package xmlparse_Ioc;

public class ProxyBean {

 public static Object newInstance(String className)
   throws Exception {
  return Class.forName(className).newInstance();

 }
}

6）Persist  用于完成注入

 package xmlparse_Ioc;

import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;

public class Persist {

 /**
  * 向目标类target中注入persistClass类对象
  */
 public static Object persist(String target, String persistClass)
   throws Exception {
  Object obj1 = ProxyBean.newInstance (target);
  Object obj2 = ProxyBean.newInstance (persistClass);
  Method method = getSetterMethod(obj1, obj2);
  method.invoke(obj1, obj2);
  return obj1 ;
 }

 public static Object persist(String target, String persistClass,
   String paramName) throws Exception {
  System.out.println("---------创建各对象实例，开始注入-----------");
  System.out.println("target:"+target);
  System.out.println("persistClass:"+persistClass);
  System.out.println("paramName:"+paramName);
  Object obj1 = ProxyBean.newInstance (target);
  Object obj2 = ProxyBean.newInstance (persistClass);
  Method method = getSetterMethod(obj1, obj2, paramName);
  System.out.println("method:"+method.getName());
  method.invoke(obj1, obj2);
  System.out.println("---------注入完毕-----------");
  return obj1 ;
 }

 /**
  * 通过索引目标类（target）的参数类型满足注入类（persistClass）类型，索引成功， 则返回该类型变量的setter方法
  *
  * @param target
  * @param persistClass
  * @return
  */
 private static Method getSetterMethod(Object target, Object persistClass) {
  try {
   BeanInfo info = Introspector.getBeanInfo(target.getClass());
   PropertyDescriptor[] props = info.getPropertyDescriptors();
   for (PropertyDescriptor prop : props) {
    if (prop.getPropertyType() == persistClass.getClass())
     return prop.getWriteMethod();
   }
  } catch (Exception e) {
   e.printStackTrace();
  }
  return null;
 }

 /**
  * 如果目标类（target）中存在名为paramName的变量，则将注入类（persistClass）实例赋值给该变量
  * 该方法仅返回变量paramName的setter方法
  */
 private static Method getSetterMethod(Object target, Object persistClass,
   String paramName) {
  try {
   BeanInfo info = Introspector.getBeanInfo(target.getClass());
   PropertyDescriptor[] props = info.getPropertyDescriptors();
   for (PropertyDescriptor prop : props) {
    if (prop.getName().equals(paramName))
     return prop.getWriteMethod();
   }
  } catch (Exception e) {
   e.printStackTrace();
  }
  return null;
 }
}

7）xml文档

<?xml version="1.0" encoding="UTF-8"?>
<descriptor>
 <bean name="userDao" class="xmlparse_Ioc.UserDaoImpl" />

 <bean name="userService" class="xmlparse_Ioc.UserServiceImpl">
  <property name="userDao" ref="userDao" />
 </bean>
</descriptor>

 

8)xml解析，采用的是DOM树解析

package xmlparse_Ioc;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

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;

import sun.text.CompactShortArray.Iterator;

public class MyXMLParser {

 /**
  * 该方法返回DOM树的首节点
  *
  * @param url :
  *            String xml文件存放路径
  * @return Element
  * @throws Exception
  */
 public static Element getRoot() throws Exception {

  String url = "xmlparse_Ioc/NewFile.xml";
  DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
  DocumentBuilder builder = factory.newDocumentBuilder();
  Document dom = builder.parse(url);
  return dom.getDocumentElement();
 }

 /**
  * 在DOM树的根节点下寻找满足要求的子节点
  *
  * @param root :
  *            Element DOM的根节点
  * @param tagName :
  *            String 所要查找的节点名
  * @return NodeList
  */
 public static NodeList getNodeList(Element root, String tagName) {
  return root.getElementsByTagName(tagName);
 }

 /**
  * 返回节点下满足条件的子节点
  *
  * @param node
  * @param tagName
  * @return
  */
 private static List<Node> getNodeList(Node node, String tagName) {
  System.out.println("-----------开始读取节点"+node.getNodeName()+"下满足条件："+tagName+"的节点---------");
  List<Node> list = new ArrayList<Node>();
  if (node.hasChildNodes()) {
   NodeList nodeList = node.getChildNodes();
   for (int i = 0; i < nodeList.getLength(); i++) {
    if (nodeList.item(i).getNodeName().equals(tagName)) {
     list.add(nodeList.item(i));
    }
   }
  }
  System.out.println("------满足条件的节点数："+list.size()+"---------");
  return list;
 }

 /**
  * 根据需要，将某些信息存放于Map中
  *
  * @param root
  * @param tagName
  * @return
  */
 public static Map<String, String> createMap(Element root, String tagName) {
  System.out.println("---------开始创建'键-值'对-----------");
  Map<String, String> map = new HashMap<String, String>();
  NodeList list = getNodeList(root, tagName);
  for (int i = 0; i < list.getLength(); i++) {
   Node node = list.item(i);
   if (node.hasAttributes()) {
    NamedNodeMap namedNodeMap = node.getAttributes();
    Node keyNode = namedNodeMap.getNamedItem("name");
    System.out.println("name:" + keyNode.getNodeValue());
    Node valueNode = namedNodeMap.getNamedItem("class");
    System.out.println("class:" + valueNode.getNodeValue());
    map.put(keyNode.getNodeValue(), valueNode.getNodeValue());
   }
  }
  System.out.println("---------'键-值'对创建结束-----------");
  return map;
 }

 public static List<?> persist(Element root) throws Exception {
  if (root.hasChildNodes()) {
   return persist(getNodeList(root, "bean"));
  }
  return null;
 }

 /**
  * 返回一组完成依赖注入的目标类实例
  *
  * @param nodeList
  * @return
  * @throws Exception
  */
 private static List<?> persist(NodeList nodeList) throws Exception {
  List<Object> list = new ArrayList<Object>();
  Map<String, String> map = createMap(getRoot(), "bean");
  for (int i = 0; i < nodeList.getLength(); i++) {
   Node node = nodeList.item(i);
   if (node.hasChildNodes()) {
    List<?> demo = getNodeList(node, "property");
    for (int j = 0; j < demo.size(); j++) {
     Node arg = (Node) demo.get(j);
     Object obj = persist(arg, map);
     if (obj != null)
      list.add(obj);
    }
   }

  }
  return list;
 }

 private static Object persist(Node node, Map<String, String> map)
   throws Exception {
  System.out.println("--------获取注入的各要数，其中节点为"+node.getNodeName()+"-------");
  if (node.hasAttributes()) {
   // ****这里map应作为一个参数传递进来
   NamedNodeMap namedNodeMap = node.getAttributes();
   // arg1 name="name" value=null
   Node arg1 = namedNodeMap.getNamedItem("name");
   System.out.println("name:"+arg1);
   // arg2 null
   Node arg2 = namedNodeMap.getNamedItem("ref");
   System.out.println("ref:"+arg2);
   // arg3 name="class" value=null
   Node arg3 = node.getParentNode().getAttributes().getNamedItem("class");
   System.out.println("target:"+arg3);
//   System.out.println("是否存在引用：" + arg2);
   if (arg2 != null) {
    String value = map.get(arg2.getNodeValue());
    System.out.println("ref-value:" + value);
    return Persist.persist(arg3.getNodeValue(), value, arg1
      .getNodeValue());
   }
  }
  return null;
 }

 public static void main(String[] args) {
  try {
   Element root = MyXMLParser.getRoot();
   List<?> list = MyXMLParser.persist(root);
//   System.out.println("---------" + list.size() + "---------------");
   for (int i = 0; i < list.size(); i++) {
    Object obj = list.get(i) ;
    if(obj instanceof UserService) {
     UserService service = (UserService) obj;
     service.sayHello() ;
    }
    
   }
  } catch (Exception e) {
   e.printStackTrace();
  }
 }
}

希望各位高手也能共享一些实际，但简单的例子供大家学习交流之用