Collection与XMLDoc相互转换

生成XMLDoc的公共方法
1：产生XMLDOC
import java.io.IOException;
import java.io.OutputStream;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.jdom.Attribute;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.output.XMLOutputter;

public class AJAXXMLDocument
{
  Element root;
  private final String _ROOT_TAG = "ajax-result";
  private final String _LIST_TAG = "l";
  private final String _MAP_TAG = "m";
  private final String _VALUE_TAG = "v";
  private final String _RETURN_FLAG_TAG = "flag";
  private final String _RETURN_MESSAGE_TAG = "message";
  private final String _ATTR_NAME = "n";
  private final String _VALUE_KEY = "k";

  public AJAXXMLDocument()
  {
    this.root = new Element("ajax-result");
  }

  /**
   * @deprecated
   */
  public Document getICSsXMLDocument()
  {
    return new Document(this.root);
  }

  public Document getAJAXXMLDocument()
  {
    return new Document(this.root);
  }

  public void setReturnFlag(String flag)
  {
    Element cell = new Element("flag");
    cell.addContent(flag);
    this.root.addContent(cell);
  }

  public void setReturnMessage(String message)
  {
    Element cell = new Element("message");
    cell.addContent(message);
    this.root.addContent(cell);
  }

  public void addObject(String name, Object o)
  {
    List els;
    int i;
    Element el;
    if (o instanceof List) {
      els = this.root.getChildren("l");
      for (i = 0; (els != null) && (i < els.size()); ++i) {
        el = (Element)els.get(i);
        if ((el.getAttribute("n") != null) && (el.getAttribute("n").getValue().equals(name)))
        {
          this.root.removeContent(el);
          break;
        }
      }
      addListObject((List)o, name);
    } else if (o instanceof Map) {
      els = this.root.getChildren("m");
      for (i = 0; (els != null) && (i < els.size()); ++i) {
        el = (Element)els.get(i);
        if ((el.getAttribute("n") != null) && (el.getAttribute("n").getValue().equals(name)))
        {
          this.root.removeContent(el);
          break;
        }
      }
      addMapObject((Map)o, name);
    } else {
      els = this.root.getChildren("v");
      for (i = 0; (els != null) && (i < els.size()); ++i) {
        el = (Element)els.get(i);
        if ((el.getAttribute("k") != null) && (el.getAttribute("k").getValue().equals(name)))
        {
          this.root.removeContent(el);
          break;
        }
      }
      Element cell = new Element("v");
      cell.setAttribute("k", name);
      cell.addContent("null");
      this.root.addContent(cell);
    }
  }

  private void addMapObject(Map paramMap, String paramName)
  {
    this.root.addContent(toXMLForMap(paramMap, paramName));
  }

  private void addListObject(List paramList, String paramName)
  {
    this.root.addContent(toXMLForList(paramList, paramName));
  }

  private Element toXMLForObject(Object o, String name)
  {
    Element cell = new Element("v");
    if ((name != null) && (name.length() > 0))
      cell.setAttribute("k", name);
    if (o instanceof Date) {
      Date d = (Date)o;
      Calendar c = Calendar.getInstance();
      c.setTime(d);
      SimpleDateFormat vFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

      if ((c.get(13) == 0) && (c.get(12) == 0) && (c.get(10) == 0))
      {
        vFormat = new SimpleDateFormat("yyyy-MM-dd");
      } else if (c.get(13) == 0)
        vFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm");

      cell.addContent(vFormat.format(o));
    } else {
      cell.addContent("null");
    }
    return cell;
  }

  private Element toXMLForMap(Map paramMap, String mapName)
  {
    Element map = new Element("m");
    if ((mapName != null) && (mapName.length() > 0))
      map.setAttribute("n", mapName);
    if (paramMap != null)
      for (Iterator it = paramMap.keySet().iterator(); it.hasNext(); ) {
        String key = (String)it.next();
        if (paramMap.get(key) instanceof Map)
          map.addContent(toXMLForMap((Map)paramMap.get(key), key));
        else if (paramMap.get(key) instanceof List)
          map.addContent(toXMLForList((List)paramMap.get(key), key));
        else
          map.addContent(toXMLForObject(paramMap.get(key), key));
      }


    return map;
  }

  private Element toXMLForList(List paramList, String listName)
  {
    Element list = new Element("l");
    if ((listName != null) && (listName.length() > 0))
      list.setAttribute("n", listName);
    if (paramList != null)
      for (int i = 0; i < paramList.size(); ++i) {
        Object o = paramList.get(i);
        if ((o != null) && (o instanceof Map))
          list.addContent(toXMLForMap((Map)o, ""));
        else if (o instanceof List)
          list.addContent(toXMLForList((List)o, ""));
        else
          list.addContent(toXMLForObject(o, ""));
      }


    return list;
  }

  public static void main(String[] args) {
    OutputStream out = System.out;
    XMLOutputter outputter = new XMLOutputter();
    AJAXXMLDocument icssdoc = new AJAXXMLDocument();
    ArrayList l = new ArrayList();
    Map m = new HashMap();
    m.put("description", null);
    m.put("value", "01");
    m.put("other", "测试");
    l.add(m);
    m = new HashMap();
    m.put("description", "驾驶证");
    m.put("value", "02");
    l.add(m);
    m = new HashMap();
    m.put("description", "军官证");
    m.put("value", "03");
    l.add(m);
    icssdoc.addObject("IDTYPE", l);
    icssdoc.addObject("IDNO", "430**");
    icssdoc.addObject("IDNO", "430**12312");
    try {
      outputter.setEncoding("GBK");
      outputter.output(icssdoc.getAJAXXMLDocument(), out);
    }
    catch (IOException e) {
      e.printStackTrace();
    }
  }
}

2：产生XMLDOC、XMLDOC转换Collection
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;

/*
*  应用Dom4j： 1.解析XML字符串存入map中;
*             2.解析XML文件存入map中;
*             3.解析XMLmap存入String中; 
*             4.XML字符串生成xml文件
*             以上都不支持xml的Attribute属性的解析
*/

public class Dom4jXmlProcessor {

private Element documentRoot; //xml根结点

private LinkedHashMap xmlElementsMap = new LinkedHashMap(); //存放xml的map

private StringBuffer sb = new StringBuffer(); //解析map放入StringBuffer

/*
* 解析XML字符串,存入map中,不支持属性的解析
*
*/
public synchronized LinkedHashMap parseXmlString(String xmlStr) {

LinkedHashMap recursiveMap = new LinkedHashMap();
try {
Document document = DocumentHelper.parseText(xmlStr);
Element docRoot = document.getRootElement();//获取根结点       
// documentRoot = docRoot;
LinkedHashMap rootMap=new LinkedHashMap();
recursiveMap.put(docRoot.getName(),rootMap);
//调用遍历解析xml的函数
ergodicXmlElement(docRoot, rootMap);
System.out.println("========xml字符串解析为map==========="+recursiveMap);
} catch (Exception e) {
e.printStackTrace();
System.out.println("解析xml字符串时出现异常！" + e.getMessage());
}
return recursiveMap;
}

/*
* 直接解析XML文件,存入map中,不支持属性的解析
*
*/
public synchronized LinkedHashMap parseXmlFile(String fileName) {

File inputXml = new File(fileName);
SAXReader saxReader = new SAXReader();
LinkedHashMap recursiveMap = new LinkedHashMap();
try {
Document document = saxReader.read(inputXml);
Element docRoot = document.getRootElement();//获取根结点
documentRoot = docRoot;
//调用遍历解析xml的函数
ergodicXmlElement(docRoot, recursiveMap);
// System.out.println("========xml文件解析为map==========="+this.xmlElementsMap);
} catch (DocumentException e) {
System.out.println("解析xml文件时出现异常！" + e.getMessage());
}
return this.xmlElementsMap;
}

/*
* 解析XMLmap,存入String中,不支持属性的解析
*
*/
public String parseXmlMap(LinkedHashMap xmlMap) {

try {
//调用解析xmlMap的函数
sb.append("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>");
ergodicXmlMap(xmlMap);
} catch (Exception e) {
System.out.println("生成XML String时出现异常！" + e.getMessage());
}
return this.sb.toString();
}

/*
* xml字符串生成XML文件
*
*/
public void createXmlFile(String xmlString, String fileName) {
try {
OutputFormat format = OutputFormat.createPrettyPrint();
format.setEncoding("UTF-8");
XMLWriter xmlWriter = new XMLWriter(new FileOutputStream(fileName), format);
Document doc = DocumentHelper.parseText(xmlString);
xmlWriter.write(doc);
xmlWriter.close();
} catch (Exception e) {
System.out.println("xml字符串生成XML文件时出现异常！" + e.getMessage());
}
}

/*
* 遍历解析XmlElement
* 在没有子结点时才存入map<key,String>,否则存入map<key,List>
*
* */
public synchronized void ergodicXmlElement(Element elem, LinkedHashMap loopMap) {
Iterator childElemsIter = elem.elementIterator();
while (childElemsIter.hasNext()) {
Element childElem = (Element) childElemsIter.next();
String name = childElem.getName();
List sameChildElems = elem.elements(name);
if (!sameChildElems.isEmpty() && sameChildElems.size() > 1) {
if (loopMap.get(name) == null)
loopMap.put(name, new LinkedList());
}
List childElems = childElem.elements();
if (!childElems.isEmpty()) {
LinkedHashMap elemMap = new LinkedHashMap();
if (loopMap.get(name) != null && loopMap.get(name) instanceof List) {
((List) loopMap.get(name)).add(elemMap);
} else {
if (loopMap.get(name) == null)
loopMap.put(name, new LinkedList());
((List) loopMap.get(name)).add(elemMap);
}
ergodicXmlElement(childElem, elemMap);
} else {
if (loopMap.get(name) != null && loopMap.get(name) instanceof List) {
((List) loopMap.get(name)).add(childElem.getStringValue());
} else {
loopMap.put(name, childElem.getStringValue());
}
}
}
}

/*
* 遍历解析xmlMap
* 适用范围：本方法只适合 xmlMap的value 为String 或 list类型,而其中的list只能存放map的情况
*
* */
public synchronized void ergodicXmlMap(LinkedHashMap xmlMap) {
try {
if (xmlMap != null) {
Iterator it = xmlMap.entrySet().iterator();
while (it.hasNext()) {
Map.Entry entry = (Map.Entry) it.next();
Object key = entry.getKey();
Object value = entry.getValue();
if (value instanceof java.lang.String) {
sb.append("<" + key + ">");
sb.append(value);
sb.append("</" + key + ">");
} else if (value instanceof java.util.LinkedList) {
for (Iterator it1 = ((LinkedList) value).iterator(); it1.hasNext();) {
Object obj = it1.next();
sb.append("<" + key + ">");
ergodicXmlMap((LinkedHashMap) obj);//value为List则递归，直到value为String
sb.append("</" + key + ">");
}
} else if(value == null) { // 如果是null
sb.append("<" + key + ">");
sb.append("</" + key + ">");
}
}
}
} catch (Exception e) {
System.out.println("将存放xml元素的map转化为String时出现异常！" + e.getMessage());
}
}

//测试
/*public static void main(String[] args) {

String fileName = "d:\\demo.xml";
Dom4jXmlProcessor dxp = new Dom4jXmlProcessor();
LinkedHashMap xmlMap = new LinkedHashMap();
// //解析xml文件为map
xmlMap = dxp.parseXmlFile(fileName);
System.out.println("====解析xml文件为map======" + xmlMap);
//解析xmlMap 为xmlString
//     String xmlString = dxp.parseXmlMap(xmlMap);
//     System.out.println("====解析xmlMap 为xmlString======"+xmlString); 
//    //由xmlString 生成xml文件
//    dxp.createXmlFile(xmlString, "d:\\createdemo.xml");
//    //解析xmlString为xmlMap
//    xmlMap = dxp.parseXmlString(xmlString);

}*/

public static void main(String[] args) {
       try {
           String fileName = "d:\\demo.xml";
           File file = new File(fileName);
           InputStream inputStream;
           inputStream = new FileInputStream(file);
           InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
           BufferedReader reader = new BufferedReader(inputStreamReader);
           StringBuffer stringBuffer = new StringBuffer("");
           String line = reader.readLine();
           while (line != null) {
              stringBuffer.append(line);
              line = reader.readLine();
           }
           reader.close();
           Dom4jXmlProcessor dxp = new Dom4jXmlProcessor();
           System.out.println(stringBuffer.toString());
           dxp.parseXmlString(stringBuffer.toString());
          
       } catch (FileNotFoundException e) {

           e.printStackTrace();

       } catch (IOException e) {

           // TODO Auto-generated catch block

           e.printStackTrace();

       }



    }



public Element getDocumentRoot() {
return documentRoot;
}

public void setDocumentRoot(Element documentRoot) {
this.documentRoot = documentRoot;
}

public LinkedHashMap getXmlElementsMap() {
return xmlElementsMap;
}

public void setXmlElementsMap(LinkedHashMap xmlElementsMap) {
this.xmlElementsMap = xmlElementsMap;
}

public StringBuffer getSb() {
return sb;
}

public void setSb(StringBuffer sb) {
this.sb = sb;
}

}