xml转map 通用

import java.io.ByteArrayInputStream;
import java.util.*;
import org.dom4j.*;
import com.newland.crm.common.util.BusinessExceptionFactory;
import com.newland.csf.common.exception.BusinessException;
import com.newland.csf.frame.util.XmlUtils;
import org.dom4j.io.SAXReader;

/**
 * @author
 * @Description xml解析
 */
public class XmlParseUtils {

   private static final String SPLIT = "/";
   private Map<String, Object> cache ;
   private String root = "";

   /**
    * 解析xml
    * 
    * @param xml
    *            输入的xml
    * @return Map<String,Object> 解析后的map信息
    * @throws BusinessException
    */
   public Map<String, Object> parseXml(String xml) throws BusinessException {
      try {
         /*if(cache != null || !cache.isEmpty()){
            cache.clear();
         }*/
         Document doc = DocumentHelper.parseText(xml);
         cache = XmlUtils.Dom2Map(doc);
         return cache;
      } catch (DocumentException e) {
         // TODO Auto-generated catch block
         throw BusinessExceptionFactory.getBusinessEx(60000054, "");
      }
   }
   /**
    * 解析xml
    *
    * @param xml
    *            输入的xml
    * @return Map<String,Object> 解析后的map信息
    * @throws BusinessException
    */
   public Map<String, Object> parseXml2Map(String xml) throws BusinessException {
      try {
         Document doc = DocumentHelper.parseText(xml);
         return XmlUtils.Dom2Map(doc);
      } catch (DocumentException e) {
         throw BusinessExceptionFactory.getBusinessEx(60000054, "");
      }
   }

   /**获取xml多层次节点
    * @param map 已解析的map对象
    * @param name 节点名称 多层次节点用  "/"分割，exp：root/ch 即root下的ch节点
    * @return list
    */
   public List getNodeList(Map map, String name) {
      String path = getNodePath(name);
      String key = getNodeName(name);
      // log("path="+path+",key="+key);
      Map map1 = getNodeMap(map, path);
      Object obj = map1.get(key);
      return getNodeAsList(obj, key);
   }

   /**获取xml多层次节点
    * @param name 节点名称 多层次节点用  "/"分割，exp：root/ch 即root下的ch节点
    * @return
    */
   public List getNodeList(String name){
      return getNodeList(cache, name);
   }
   private boolean isNVL(String str) {
      return str == null || str.equalsIgnoreCase("");
   }

   /**获取对应节点下的map对象
    * @param name  节点名称 多层次节点用  "/"分割，exp：message/ch 即message下的ch节点
    * @return map
    */
   public Map getNodeMap(String name){
      return getNodeMap(cache,name);
   }
   /**根据对应map对象获取对应节点下的map对象
    * @param map 已存在map对象
    * @param name 节点名称 多层次节点用  "/"分割，exp：root/ch 即root下的ch节点
    * @return map  
    */
   public Map getNodeMap(Map map, String name) {
      if (isNVL(name))
         return map;
      String[] node = splitNode(name);
      String value = "";
      Map map1 = new HashMap();
      for (int i = 0; node != null && i < node.length; i++) {
         String temp = node[i];
         if (isNVL(temp))
            continue;
         if (i == 0)
            map1 = getNodeAsMap(map.get(temp));
         else
            map1 = getNodeAsMap(map1.get(temp));
         // log("temp="+temp+",map1="+map1.size());
         if (map1 == null || map1.size() == 0)
            return new HashMap();
      }
      return map1;
   }

   private String getNodePath(String path) {
      int d = path.lastIndexOf(SPLIT);
      if (d == -1)
         return "";
      return path.substring(0, d);
   }

   private String getNodeName(String path) {
      int d = path.lastIndexOf(SPLIT);
      if (d == -1)
         return path;
      return path.substring(d + 1);
   }

   private Map getNodeAsMap(Object obj) {
      if (obj == null)
         return new HashMap();
      if (obj.getClass().getName().equals("java.util.HashMap"))
         return (Map) obj;
      return new HashMap();
   }

   private List getNodeAsList(Object obj, String key) {
      List list = new ArrayList();
      if (obj == null)
         return list;
      // log("obj="+obj.getClass().getName());
      String clsname = obj.getClass().getName();
      if (clsname.equals("java.util.HashMap")) {
         list.add(obj);
      }
      else if (clsname.equals("java.util.ArrayList"))
         return (List) obj;
      else if (clsname.equals("java.lang.String")) {
         Map map = new HashMap();
         map.put(key, obj);
         list.add(map);
      }
      return list;
   }
   /**
    *
    * 通过XML转换为Map<String,Object>
    *
    * @param xml 为String类型的Xml
    * @return 第一个为Root节点，Root节点之后为Root的元素，如果为多层，可以通过key获取下一层Map
    */
   public static Map<String, Object> createMapByXml(String xml) {
      Document doc = null;
      try {
         doc = DocumentHelper.parseText(xml);
      } catch (DocumentException e) {
         e.printStackTrace();
      }
      Map<String, Object> map = new HashMap<String, Object>();
      if (doc == null)
         return map;
      Element rootElement = doc.getRootElement();
      elementTomap(rootElement,map);
      return map;
   }

   /***
    *
    * XmlToMap核心方法，里面有递归调用
    *
    * @param outmap
    * @param outele
    */
   @SuppressWarnings("unchecked")
   public static Map<String, Object> elementTomap (Element outele,Map<String,Object> outmap) {
      List<Element> list = outele.elements();
      int size = list.size();
      if(size == 0){
         outmap.put(outele.getName(), outele.getTextTrim());
      }else{
         Map<String, Object> innermap = new HashMap<String, Object>();
         for(Element ele1 : list){
            String eleName = ele1.getName();
            Object obj =  innermap.get(eleName);
            if(obj == null){
               elementTomap(ele1,innermap);
            }else{
               if(obj instanceof java.util.Map){
                  List<Map<String, Object>> list1 = new ArrayList<Map<String, Object>>();
                  list1.add((Map<String, Object>) innermap.remove(eleName));
                  elementTomap(ele1,innermap);
                  list1.add((Map<String, Object>) innermap.remove(eleName));
                  innermap.put(eleName, list1);
               }else{
                  elementTomap(ele1,innermap);
                  ((List<Map<String, Object>>)obj).add(innermap);
               }
            }
         }
         outmap.put(outele.getName(), innermap);
      }
      return outmap;
   }
   private String[] splitNode(String name) {
      return name.split(SPLIT);
   }


   /**
    * 取出xml数据  仅限2层数据
    * @param xml
    * @return
    */
   public static List<Map<String, Object>> xml2list(String xml) {
      xml =xml.replace("\n","").replace(" ","");
      List<Map<String, Object>> resList = new ArrayList();
      SAXReader reader = new SAXReader();
      Document document = null;
      try {
         document = reader.read(new ByteArrayInputStream(xml.getBytes("UTF-8")));
         Element root = document.getRootElement();
         List<Element> childElements = root.elements();//获取当前元素下的全部子元素
         for (Element child : childElements) {//循环输出全部信息
            Map<String, Object> map = new HashMap();//每个实体
            List<Element> infos = child.elements();//每个对象信息
            for (Element info : infos) {
               String name = info.getName();//获取当前元素名
               String text = info.getText();//获取当前元素值
               map.put(name,text);
            }
            resList.add(map);
            map=null;//回收map
         }
      } catch (Exception e) {
         e.printStackTrace();
      }
      return resList;
   }


 /** 
  * 取出xml数据 为map 任意层级结构的
  * @param xml 要转的xml(可以任意格式)
  * @param obj 可以传 null
  * @return */
   public static List<Map<String, Object>> createMapByXml(String xml,Object obj) {
      List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
      Document doc = null;
      try {
         doc = DocumentHelper.parseText(xml);
      } catch (DocumentException e) {
         e.printStackTrace();
      }
      Map<String, Object> map = new HashMap<String, Object>();
      if (doc == null)
         return list;
      Element rootElement = doc.getRootElement();
      Element2Map(rootElement, map);
      list.add(map);
      return list;
   }
   /***
    * XmlToMap核心方法，里面有递归调用
    */
   public   static void  Element2Map(Element elmt, Map<String, Object> map) {
      if (null == elmt) {
         return;
      }
      String name = elmt.getName();
      // 当前元素是最小元素
      if (elmt.isTextOnly()) {
         // 查看map中是否已经有当前节点
         Object f = map.get(name);
         // 用于存放元素属性
         Map<String, Object> m = new HashMap<String, Object>();
         // 遍历元素中的属性
         Iterator ai = elmt.attributeIterator();
         // 用于第一次获取该元素数据
         boolean aiHasNex = false;
         while (ai.hasNext()) {
            aiHasNex = true;
            // 拿到属性值
            Attribute next = (Attribute) ai.next();
            m.put(name + "." + next.getName(), next.getValue());
         }
         // 第一次获取该元素
         if (f == null) {
            // 判断如果有属性
            if (aiHasNex) {
               // 将属性map存入解析map中
               m.put(name, elmt.getText());
               map.put(name, m);
            } else {
               // 没有属性，直接存入相应的值
               map.put(name, elmt.getText());
            }
         } else {
            // 解析map中已经有相同的节点
            // 如果当前值是list
            if (f instanceof List<?>) {
               // list中添加此元素
               m.put(name, elmt.getText());
               ((List) f).add(m);
            } else {
               // 如果不是，说明解析map中只存在一个与此元素名相同的对象
               // 存放元素
               List<Object> listSub = new ArrayList<Object>();
               // 如果解析map中的值为string，说明第一个元素没有属性
               if (f instanceof String) {
                  // 转换为map对象，
                  Map<String, Object> m1 = new HashMap<String, Object>();
                  m1.put(name, f);
                  // 添加到list中
                  listSub.add(m1);
               } else {
                  // 否则直接添加值
                  listSub.add(f);
               }
               // 将当前的值包含的属性值放入list中
               m.put(name, elmt.getText());
               listSub.add(m);
               // 解析map中存入list
               map.put(name, listSub);
            }

         }
      } else {
         // 存放子节点元素
         Map<String, Object> mapSub = new HashMap<String, Object>();
         // 遍历当前元素的属性存入子节点map中
         attributeIterator(elmt, mapSub);
         // 获取所有子节点
         List<Element> elements = (List<Element>) elmt.elements();
         // 遍历子节点
         for (Element elmtSub : elements) {
            // 递归调用转换map
            Element2Map(elmtSub, mapSub);
         }
         // 当前元素没有子节点后 获取当前map中的元素名所对应的值
         Object first = map.get(name);
         if (null == first) {
            // 如果没有将值存入map中
            map.put(name, mapSub);
         } else {
            // 如果有，则为数组对象
            if (first instanceof List<?>) {
               attributeIterator(elmt, mapSub);
               ((List) first).add(mapSub);
            } else {
               List<Object> listSub = new ArrayList<Object>();
               listSub.add(first);
               attributeIterator(elmt, mapSub);
               listSub.add(mapSub);
               map.put(name, listSub);
            }
         }
      }
   }
   /**
    * 遍历元素属性
    *
    * @param elmt
    * @param map
    */
   private static void attributeIterator(Element elmt, Map<String, Object> map) {
      if (elmt != null) {
         Iterator ai = elmt.attributeIterator();
         while (ai.hasNext()) {
            Attribute next = (Attribute) ai.next();
            map.put(elmt.getName() + "." + next.getName(), next.getValue());
         }
      }
   }
}