Java读取多层级xml文件

た 入场券 2022-07-14 09:29 305阅读 0赞

最近在做国际客服北京职场的项目，需要提供一个接口服务端的能力，也就是需要开发一个http+xml的协议，入参和出参均为Map格式，各系统间的请求或应答是以xml格式封装的。在将返回报文（xml）解析为Map输出时遇到一个难点：Java对于多层级xml的解析。现以一个客户资料查询接口为例将解析过程记录如下：

返回xml报文的简化形式：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <ROOT>
  3.       <HEAD>
  4.             <ORIGIN_DOMAIN>kefuxitongbianma</ORIGIN_DOMAIN>
  5.             <HOME_DOMAIN>CUGCRM</HOME_DOMAIN>
  6.             <ACTION_CODE>1</ACTION_CODE>
  7.             <BUSI_CODE>QUERYCUST</BUSI_CODE>
  8.             <TRANS_ID>20160220160635123456</TRANS_ID>
  9.             <RET_CODE>0000</RET_CODE>
  10.             <RET_MSG>success</RET_MSG>
  11.       </HEAD>
  12.       <BODY>
  13.             <TOTAL_RECORDS>20</TOTAL_RECORDS>
  14.             <TOTAL_PAGE>10</TOTAL_PAGE>
  15.             <CURRENT_PAGE>1</CURRENT_PAGE>
  16.             <CUSTINFOLIST>
  17.                   <CUSTINFO>
  18.                         <CUST_TYPE>001</CUST_TYPE>
  19.                         <VIP_FLAG>true</VIP_FLAG>
  20.                   </CUSTINFO>
  21.                   <CUSTINFO>
  22.                         <CUST_TYPE>002</CUST_TYPE>
  23.                         <VIP_FLAG>false</VIP_FLAG>
  24.                   </CUSTINFO>
  25.                   <CUSTINFO>
  26.                         <CUST_TYPE>003</CUST_TYPE>
  27.                         <VIP_FLAG>false</VIP_FLAG>
  28.                   </CUSTINFO>
  29.             </CUSTINFOLIST>
  30.       </BODY>
  31. </ROOT>
  36. import java.util.ArrayList;
  37. import java.util.HashMap;
  38. import java.util.List;
  39. import java.util.Map;
  40. import java.util.Set;
  41. import net.sf.json.JSONObject;
  42. import org.apache.log4j.Logger;
  43. import org.dom4j.Document;
  44. import org.dom4j.DocumentException;
  45. import org.dom4j.DocumentHelper;
  46. import org.dom4j.Element;
  47. import org.dom4j.Namespace;
  48. import org.dom4j.QName;
  49. /**
  50.  * 解析xml的工具类
  51.  * 1、将多层级xml解析为Map
  52.  * 2、将多层级xml解析为Json
  53.  *
  54.  * @author lmb
  55.  *
  56.  */
  57. public class ParseXmlUtil {
  59.       public static Logger logger = Logger.getLogger(ParseXmlUtil.class);
  60.       public static void main(String[] args) { 
  61.               // 获取一个xml文件 
  62.               String textFromFile = MyXmlUtil.XmlToString();
  63.               //将xml解析为Map
  64.               Map resultMap = xml2map(textFromFile);
  65.               //将xml解析为Json
  66.               String resultJson = xml2Json(textFromFile);
  67.       } 
  70.       /**
  71.        * 将xml格式响应报文解析为Json格式
  72.        * @param responseXmlTemp
  73.        * @return
  74.        */
  75.       public static String xml2Json(String responseXmlTemp) {
  76.             Document doc = null;
  77.             try {
  78.                   doc = DocumentHelper.parseText(responseXmlTemp);
  79.             } catch (DocumentException e) {
  80.                   logger.error("parse text error : " + e);
  81.             }
  82.             Element rootElement = doc.getRootElement();
  83.             Map<String,Object> mapXml = new HashMap<String,Object>();
  84.             element2Map(mapXml,rootElement);
  85.             String jsonXml = JSONObject.fromObject(mapXml).toString();
  86.             System.out.println("Json >>> " + jsonXml);
  87.             return jsonXml;
  88.       }
  89.       /**
  90.        * 将xml格式响应报文解析为Map格式
  91.        * @param responseXmlTemp
  92.        * @param thirdXmlServiceBean
  93.        * @return
  94.        * @throws DocumentException
  95.        */
  96.       public static Map<String, Object> xml2map(String responseXmlTemp) {
  97.             Document doc = null;
  98.             try {
  99.                   doc = DocumentHelper.parseText(responseXmlTemp);
  100.             } catch (DocumentException e) {
  101.                   logger.error("parse text error : " + e);
  102.             }
  103.             Element rootElement = doc.getRootElement();
  104.             Map<String,Object> mapXml = new HashMap<String,Object>();
  105.             element2Map(mapXml,rootElement);
  106.             System.out.println("Map >>> " + mapXml);
  107.             return mapXml;
  108.       }
  109.       /**
  110.        * 使用递归调用将多层级xml转为map
  111.        * @param map
  112.        * @param rootElement
  113.        */
  114.       public static void element2Map(Map<String, Object> map, Element rootElement) {
  116.             //获得当前节点的子节点
  117.             List<Element> elements = rootElement.elements();
  118.             if (elements.size() == 0) {
  119.                   //没有子节点说明当前节点是叶子节点，直接取值
  120.                   map.put(rootElement.getName(),rootElement.getText());
  121.             }else if (elements.size() == 1) {
  122.                   //只有一个子节点说明不用考虑list的情况，继续递归
  123.                   Map<String,Object> tempMap = new HashMap<String,Object>();
  124.                   element2Map(tempMap,elements.get(0));
  125.                   map.put(rootElement.getName(),tempMap);
  126.             }else {
  127.                   //多个子节点的话就要考虑list的情况了，特别是当多个子节点有名称相同的字段时
  128.                   Map<String,Object> tempMap = new HashMap<String,Object>();
  129.                   for (Element element : elements) {
  130.                         tempMap.put(element.getName(),null);
  131.                   }
  132.                   Set<String> keySet = tempMap.keySet();
  133.                   for (String string : keySet) {
  134.                         Namespace namespace = elements.get(0).getNamespace();
  135.                         List<Element> sameElements = rootElement.elements(new QName(string,namespace));
  136.                         //如果同名的数目大于1则表示要构建list
  137.                         if (sameElements.size() > 1) {
  138.                               List<Map> list = new ArrayList<Map>();
  139.                               for(Element element : sameElements){
  140.                                     Map<String,Object> sameTempMap = new HashMap<String,Object>();
  141.                                     element2Map(sameTempMap,element);
  142.                                     list.add(sameTempMap);
  143.                               }
  144.                               map.put(string,list);
  145.                         }else {
  146.                               //同名的数量不大于1直接递归
  147.                               Map<String,Object> sameTempMap = new HashMap<String,Object>();
  148.                               element2Map(sameTempMap,sameElements.get(0));
  149.                               map.put(string,sameTempMap);
  150.                         }
  151.                   }
  152.             }
  153.       }
  154. }

xml文件读取工具类：

  1. import java.io.File;
  2. import java.io.IOException;
  3. import java.io.StringWriter;
  4. import org.jdom.Document;
  5. import org.jdom.input.SAXBuilder;
  6. import org.jdom.output.Format;
  7. import org.jdom.output.XMLOutputter;
  8. /**
  9.  * 读取一个xml文件返回string
  10.  * @author lmb 
  11.  *
  12.  */
  13. public class MyXmlUtil {
  14.       /**
  15.        * 加载xml文件
  16.        * @return Document
  17.        */
  18.       public static Document load(){
  19.             Document document=null; 
  20.         String url="E://2.xml"; 
  21.         try { 
  22.             SAXBuilder reader = new SAXBuilder();  
  23.             document=reader.build(new File(url)); 
  24.        } catch (Exception e) { 
  25.             e.printStackTrace(); 
  26.        } 
  27.         return document;
  28.       }
  30.       /**
  31.        * 将xml文件转换为String串
  32.        * @return
  33.        */
  34.       public static String XmlToString(){
  35.             Document document=null; 
  36.         document=load(); 
  38.         Format format =Format.getPrettyFormat();     
  39.         format.setEncoding("UTF-8");//设置编码格式  
  41.         StringWriter out=null; //输出对象 
  42.         String sReturn =""; //输出字符串 
  43.         XMLOutputter outputter =new XMLOutputter();  
  44.         out=new StringWriter();  
  45.         try { 
  46.            outputter.output(document,out); 
  47.         } catch (IOException e) { 
  48.            e.printStackTrace(); 
  49.         }  
  50.         sReturn=out.toString();  
  51.         return sReturn; 
  52.     } 
  53. }

控制台打印结果：

  1. Map >>> {BODY={TOTAL_RECORDS={TOTAL_RECORDS=20}, CUSTINFOLIST={CUSTINFO=[{CUST_TYPE={CUST_TYPE=001}, VIP_FLAG={VIP_FLAG=true}}, {CUST_TYPE={CUST_TYPE=002}, VIP_FLAG={VIP_FLAG=false}}, {CUST_TYPE={CUST_TYPE=003}, VIP_FLAG={VIP_FLAG=false}}]}, TOTAL_PAGE={TOTAL_PAGE=10}, CURRENT_PAGE={CURRENT_PAGE=1}}, HEAD={ACTION_CODE={ACTION_CODE=1}, ORIGIN_DOMAIN={ORIGIN_DOMAIN=kefuxit}, BUSI_CODE={BUSI_CODE=QUERYCUST}, HOME_DOMAIN={HOME_DOMAIN=CUGCRM}, TRANS_ID={TRANS_ID=20160220160635123456}, RET_MSG={RET_MSG=success}, RET_CODE={RET_CODE=0000}}}
  3. Json >>> {"BODY":{"TOTAL_RECORDS":{"TOTAL_RECORDS":"20"},"CUSTINFOLIST":{"CUSTINFO":[{"CUST_TYPE":{"CUST_TYPE":"001"},"VIP_FLAG":{"VIP_FLAG":"true"}},{"CUST_TYPE":{"CUST_TYPE":"002"},"VIP_FLAG":{"VIP_FLAG":"false"}},{"CUST_TYPE":{"CUST_TYPE":"003"},"VIP_FLAG":{"VIP_FLAG":"false"}}]},"TOTAL_PAGE":{"TOTAL_PAGE":"10"},"CURRENT_PAGE":{"CURRENT_PAGE":"1"}},"HEAD":{"ACTION_CODE":{"ACTION_CODE":"1"},"ORIGIN_DOMAIN":{"ORIGIN_DOMAIN":"kefuxit"},"BUSI_CODE":{"BUSI_CODE":"QUERYCUST"},"HOME_DOMAIN":{"HOME_DOMAIN":"CUGCRM"},"TRANS_ID":{"TRANS_ID":"20160220160635123456"},"RET_MSG":{"RET_MSG":"success"},"RET_CODE":{"RET_CODE":"0000"}}}

格式化之后的结果如下：

  1. map :
  2. {
  3.     BODY={
  4.         TOTAL_RECORDS={TOTAL_RECORDS=20},
  5.         CUSTINFOLIST={
  6.             CUSTINFO=[
  7.                 {
  8.                     CUST_TYPE={CUST_TYPE=001},
  9.                     VIP_FLAG={VIP_FLAG=true}
  10.                 },
  11.                 {
  12.                     CUST_TYPE={CUST_TYPE=002},
  13.                     VIP_FLAG={VIP_FLAG=false}
  14.                 },
  15.                 {
  16.                     CUST_TYPE={CUST_TYPE=003},
  17.                     VIP_FLAG={VIP_FLAG=false}
  18.                 }
  19.             ]
  20.         },
  21.         TOTAL_PAGE={TOTAL_PAGE=10},
  22.         CURRENT_PAGE={CURRENT_PAGE=1}
  23.     },
  24.     HEAD={
  25.         ACTION_CODE={ACTION_CODE=1},
  26.         ORIGIN_DOMAIN={ORIGIN_DOMAIN=kefuxit},
  27.         BUSI_CODE={BUSI_CODE=QUERYCUST},
  28.         HOME_DOMAIN={HOME_DOMAIN=CUGCRM},
  29.         TRANS_ID={TRANS_ID=20160220160635123456},
  30.         RET_MSG={RET_MSG=success},
  31.         RET_CODE={RET_CODE=0000}
  32.     }
  33. }
  35. Json:
  36. {
  37.     "BODY":{
  38.         "TOTAL_RECORDS":{"TOTAL_RECORDS":"20"},
  39.         "CUSTINFOLIST":{
  40.             "CUSTINFO":[
  41.                 {
  42.                     "CUST_TYPE":{"CUST_TYPE":"001"},
  43.                     "VIP_FLAG":{"VIP_FLAG":"true"}
  44.                 },
  45.                 {
  46.                     "CUST_TYPE":{"CUST_TYPE":"002"},
  47.                     "VIP_FLAG":{"VIP_FLAG":"false"}
  48.                 },
  49.                 {
  50.                     "CUST_TYPE":{"CUST_TYPE":"003"},
  51.                     "VIP_FLAG":{"VIP_FLAG":"false"}
  52.                 }
  53.             ]
  54.         },
  55.         "TOTAL_PAGE":{"TOTAL_PAGE":"10"},
  56.         "CURRENT_PAGE":{"CURRENT_PAGE":"1"}
  57.     },
  58.     "HEAD":{
  59.         "ACTION_CODE":{"ACTION_CODE":"1"},
  60.         "ORIGIN_DOMAIN":{"ORIGIN_DOMAIN":"kefuxit"},
  61.         "BUSI_CODE":{"BUSI_CODE":"QUERYCUST"},
  62.         "HOME_DOMAIN":{"HOME_DOMAIN":"CUGCRM"},
  63.         "TRANS_ID":{"TRANS_ID":"20160220160635123456"},
  64.         "RET_MSG":{"RET_MSG":"success"},
  65.         "RET_CODE":{"RET_CODE":"0000"}
  66.     }
  67. }

发表评论

表情：
评论列表 （有 0 条评论，305人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Java 读取XML文件（DOM）。

    XML文件的一个常用用途是保存数据，例如我们可以将连接数据库的相关信息保存到一个xml文件中，程序通过读取xml文件的内容获取信息。这样当数据库的连接信息改变时，我们只需要修改

    亦凉亦凉/ 0 赞/ 186 阅读

    相关 Java读取多层级xml文件

    最近在做国际客服北京职场的项目，需要提供一个接口服务端的能力，也就是需要开发一个http+xml的协议，入参和出参均为Map格式，各系统间的请求或应答是以xml格式封装的。在将

    た 入场券た 入场券/ 0 赞/ 306 阅读