基于dom4j编写的xml数据源操作类

这个是以前写的简单例子，后来发现 xstream 的做法跟我想到一起去了，不过人家做的相当完善。简单的小的文件适合用xstream来操作（xstream的 osgi版本用的时候有些问题，在bundle相互调用的时候出错，换成jar版的就可以）。
代码留作纪念：

package test;

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;

/**
 * 基于dom4j编写的xml数据源操作类，可以将一个对象组织到xml文件中，
 * 如: outputDocUTF8ToFile(CreateXmlBaseObjectArray(person),"test.xml");

 * 也可以将该xml中的内容读出来，并根据其中内容生成相应的对象，
 * 如: Object[] personFromXml = getObjectFromXml("test.xml");

 * @author qihigh 2010.12.17
 *
 */
public class XmlMethodByDom4j {
	
	public static void main(String args[]) throws Throwable{
		Student[] person = {new Student("用户名",20,"爷们","春哥纯爷们","扩展"),
				   new Student("第二",25,"爷们c","春哥纯爷们","扩展2")};
		outputDocUTF8ToFile(CreateXmlBaseObjectArray(person),"test.xml");
		
		Object[] personFromXml = getObjectFromXml("test.xml");
		for(Object personXml : personFromXml){
			System.out.println(((Student) personXml).getUserName()+personXml);
		}
		
	}
	/**
	 * 把一个object数组写成xml形式
	 * @param objs
	 * @return objcet构造的xml整体的document
	 */
	public static Document CreateXmlBaseObjectArray(Object[] objs){
		if(objs.length == 0 || objs == null){
			return null;
		}
		Document doc = DocumentHelper.createDocument();
		//根节点 采用的第一个对象的class的name（其实所有的都一样）
		//当用objs.getClass()时候节点为 <[Ltest.Person;s>
		Element root = doc.addElement(objs[0].getClass().getName()+"s");
		for(Object o : objs){
			CreateXmlNode(o,root);
		}
		return doc;
	}
	/**
	 * 在给定的root 下构造整个obj xml树。
	 * @param 构建xml基于的obj
	 * @param 要构建的root
	 */
	private static void CreateXmlNode(Object obj,Element root){
		if(obj != null && !"".equals(obj)){
			//获取这个对象的所有属性(person 的所有属性)
			Map<String,String> attMap = getAttributeMap(obj);
			//节点属性
			String nodeClassName = obj.getClass().getName();//类的全称test.student
			String[] nodeNameDetail = nodeClassName.split("[.]");//类的全称详细描述数组.用的正则表达式
			String nodeName = nodeNameDetail[nodeNameDetail.length-1];//类的名字,比如student
			//节点的名字为类的名字，紧跟属性为类的全称
			Element studentName = root.addElement(nodeName).addAttribute("class", nodeClassName);
			//节点内部属性
			for(String key:attMap.keySet()){
				String value = attMap.get(key);
				Element tempEle = studentName.addElement(key);
				tempEle.setText(value);
			}
		}
	}
	/** 输出doc到标准输出流GBK,不好用 还是utf8 */
	public static void outputDocGBK(Document doc){
		if(doc == null || "".equals(doc)) 
			throw new NullPointerException("doc内容不能为空");
		outputDoc(doc,"GBK");
	}
	/** 输出doc到标准输出流UTF8 */
	public static void outputDocUTF8(Document doc){
		if(doc == null || "".equals(doc)) 
			throw new NullPointerException("doc内容不能为空");
		outputDoc(doc,"UTF-8");
	}
	/** 输出doc到标准输出流UTF8到文件 */
	public static void outputDocUTF8ToFile(Document doc,String fileName){
		if(doc == null || "".equals(doc)) 
			throw new NullPointerException("doc内容不能为空");
		outputDocToFile(doc,"UTF-8",fileName);
	}
	/** 输出doc到标准输出流 */
	private static void outputDoc(Document doc,String formatWay){
		  try{
			  OutputFormat format = new OutputFormat("	",true);
			  format.setEncoding(formatWay);
			  
			  XMLWriter xmlWriter = new XMLWriter(new PrintWriter(System.out),format);
			  xmlWriter.write(doc);
			  xmlWriter.close();
		  }catch (IOException e) {
			e.printStackTrace();
		  }
	}
	/**
	 * 输出到文件
	 */
	private static void outputDocToFile(Document doc,String formatWay,String fileName){
		  try{
			  OutputFormat format = new OutputFormat("	",true);
			  format.setEncoding(formatWay);
			  
			  BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(new File(fileName)));
			  
			  XMLWriter xmlWriter = new XMLWriter(new PrintWriter(bos),format);
			  xmlWriter.write(doc);
			  xmlWriter.close();
		  }catch (IOException e) {
			e.printStackTrace();
		  }
	}
	/**
	 * 判断一个对象是否实现了某个特定的接口
	 * @param theClass Class
	 * @param theInterface String
	 * @return 实现了这个接口返回true
	 */
	public static boolean isRealizeInterface(Class theClass,String theInterface){
		Class<?>[] classes = theClass.getInterfaces();
		for(Class c : classes){
			if(c.getName().equals(theInterface)){
				return true;
			}
		}
		return false;
	}
	/**
	 * 获取给定obj的所有的变量和变量的名称
	 * @param obj
	 * @return Map<变量名，变量值>
	 */
	public static Map<String,String> getAttributeMap(Object obj) {
		if(obj == null || "".equals(obj)) return null;
		Map<String,String> attributeMap = new HashMap<String, String>();
		Field[] fields = obj.getClass().getDeclaredFields();
		for(Field field:fields){
			 // 对于每个属性，获取属性名
			String varName = field.getName();
			try{
				//获取原来的访问控制权限 
				boolean accessFlag = field.isAccessible();
				//修改之
				field.setAccessible(true);
				//获取对象field 中varName 属性的值
				Object value = field.get(obj); 
//				System.out.println("对象中包含的变量：" + varName +  " = " + value);
				//恢复访问权限
				field.setAccessible(accessFlag);
				attributeMap.put(varName, String.valueOf(value));//将任意可转换的类型转换为String
			}catch (Exception e) {
				e.printStackTrace();
			}
		}
		return attributeMap;
	}
	
	/**
	 * 	获取xml文件的根节点
	 * @param xmlFileName
	 * @return xml文件的根节点
	 * @throws Throwableo
	 */
	public static Element getRootFromXml(String xmlFileName) throws Throwable{
		SAXReader reader = new SAXReader();
		Document doc = reader.read(new File(xmlFileName));
		Element elementRoot = doc.getRootElement();//获取根元素
		return elementRoot;
	}
	
	/**
	 * 读取一个xml下的属性和节点的方法
	 * @throws Throwable
	 */
	public static Map<String,ElementAtt> readInfo(String fileName) throws Throwable{
		if(fileName == null || "".equals(fileName)){
			throw new FileNotFoundException("文件名不能为空"); 
		}
		SAXReader reader = new SAXReader();
		Document doc = reader.read(new File(fileName));
		Element elementRoot = doc.getRootElement();//获取根元素 最底层的元素
		
		Map<String,ElementAtt> rootMap = new HashMap<String, ElementAtt>();
		//迭代器：取根元素下的子元素名称
		Iterator<Element> iter = elementRoot.elementIterator();
		System.out.println("取根元素下的子元素名称");
		int eleBaseCount = 0;
		Element elebase = null;
		while(iter.hasNext()){
			elebase = iter.next();
			eleBaseCount++;
			String eleName  = elebase.getName();//获取元素名称
			String eleValue = elebase.attributeValue("class");//获取元素某项属性 这里指定为class属性
			System.out.println(eleName + "=" + eleValue);
			Map<String, String> eleMap = getInfo(elebase);
			//节点名字可能相同，比如都是student，加个count区别
			rootMap.put(eleName+eleBaseCount,new ElementAtt(eleValue,eleMap));//将一个节点包装起来，Map中每一项都是一个完整类的全部属性
		}
		return rootMap;
	}
	/**
	 * 通过一个root 获取所有的 递归调用
	 * 	并添加到map中
	 * @param root
	 */
	public static Map<String,String> getInfo(Element root){
		Map<String,String> infoMap = new HashMap<String, String>();//用来存贮所有当前节点的子属性以及子属性的map
		Iterator<Element> iter = root.elementIterator();//遍历root的element
		int childCount = 0;//用来指明子属性的map并计数
		while(iter.hasNext()){
			Element element = iter.next();
			String eleName = element.getName();//获取元素名称
			String eleValue = element.getText();//获取元素值
//			System.out.println(eleName + " " + eleValue);
			infoMap.put(eleName, eleValue);
			/** 对于有特殊属性的节点（将属性写成<student class="test" >）时要获取class会用到的操作 */
//			Iterator<Attribute> iter1 = element.attributeIterator();
//			System.out.println("获取属性名称、值");
//			while (iter1.hasNext()) {
//				Attribute elAtt = iter1.next();
//				String elAttName = elAtt.getName();
//				String elAttValue = elAtt.getValue();//获取属性名称和值
//				System.out.println(elAttName+" "+elAttValue);
//			}
			/** 没有实现,对于当前需求来说, 也没有什么用 目前只需要一层结构 
			 * (The method put(String, String) in the type Map<String,String> is not applicable for the arguments (String, Map<String,String>))
			 */
//			Map<String,String> childMap = getInfo(element);//自己调用自己 递归方法
//			if(childMap != null){
//				infoMap.put("child"+childCount, childMap);
//			}
		}
		return infoMap;
	}
	/**
	 * 从xml文件中读出内容并对其进行实例化，返回实例化之后的数组(该类必须存在才行)
	 * @throws Throwable
	 */
	public static Object[] getObjectFromXml(String fileName) throws Throwable{
		/** 从文件读取一个xml下的属性和节点的方法 */
		Map<String,ElementAtt> xmlMap = readInfo(fileName);
		Object[] objectFromXml = new Object[xmlMap.keySet().size()];
		int index = 0;
		for(String eleBase : xmlMap.keySet()){
			ElementAtt elementAtt = xmlMap.get(eleBase);
			String className = elementAtt.getEleValue();
			objectFromXml[index] = (Object) createObjectByMap(elementAtt.getEleMap(),Class.forName(className).newInstance());
			index++;
		}
		return objectFromXml;
	}
	/**
	 * 对一个对象中的各个属性进行赋值，值的来源来自于attributeMap
	 * @throws NoSuchFieldException 
	 * @throws SecurityException 
	 * @throws IllegalAccessException 
	 * @throws IllegalArgumentException 
	 */
	public static Object createObjectByMap(Map<String,String> aMap,Object aObj) throws SecurityException, NoSuchFieldException, IllegalArgumentException, IllegalAccessException{
//		Field[] fields = aObj.getClass().getDeclaredFields();
		for(String attName : aMap.keySet()){
			Field field = aObj.getClass().getDeclaredField(attName);
			//获取原来的访问控制权限 
			boolean accessFlag = field.isAccessible();
			//修改之
			field.setAccessible(true);
			//根据不同的类型注入值
			if(field.getType().getName().equals("int")){
				//System.out.println("如果是int类型");
				field.set(aObj, Integer.valueOf(aMap.get(attName)));
			}else{
				field.set(aObj, aMap.get(attName));
			}
			//恢复访问权限
			field.setAccessible(accessFlag);
		}
		return aObj;
	}
}

/**
 * 存贮base节点的相关属性 eleValue 包含了该节点标识的类名，eleMap是具体的属性
 * @author qihigh
 *
 */
class ElementAtt {
	public ElementAtt(String eleValue, Map<String, String> eleMap) {
		this.eleValue = eleValue;
		this.eleMap = eleMap;
	}
	private String eleValue;
	private Map<String, String> eleMap;
	
	public String getEleValue() {
		return eleValue;
	}
	public void setEleValue(String eleValue) {
		this.eleValue = eleValue;
	}
	public Map<String, String> getEleMap() {
		return eleMap;
	}
	public void setEleMap(Map<String, String> eleMap) {
		this.eleMap = eleMap;
	}
	@Override
	public String toString() {
		return "[eleValue = "+eleValue+" eleMap = "+eleMap+"]";
	}
	
	
}

/**
 * 数据持久化对象
 * @author qihigh
 *
 */

class Student{
	private String userName;
	private int age;
	private String sex;
	private String selfDescription;
	private String extend;
	
	public Student(){}
	public Student(String userName, int age, String sex, String selfDescription,String extend) {
		this.userName = userName;
		this.age = age;
		this.sex = sex;
		this.selfDescription = selfDescription;
		this.extend = extend;
	}
	
	public String getUserName() {
		return userName;
	}
	
	@Override
	public String toString(){
		return "[userName= "+userName+";age="+age+";sex="+sex+";selfDescription="+selfDescription+"]";
	}
}