2. 程式人生 > >java xml與json 相互轉換

java xml與json 相互轉換

阿新 • • 發佈：2019-01-23

需要json-lib-2.1-jdk15.jar和xom-1.2.5.jar，maven pom.xml如下：

Xml程式碼  收藏程式碼
  1. <dependency>
  2.     <groupId>net.sf.json-lib</groupId>
  3.     <artifactId>json-lib</artifactId>
  4.     <version>2.1</version>
  5.     <classifier>jdk15</classifier>
  6. </dependency>
  7. <dependency>
  8.     <groupId>xom</groupId>
  9.     <artifactId>xom</artifactId>
  10.     <version>1.2.5</version>
  11.     <type>jar</type>
  12.     <scope>compile</scope>
  13. </dependency>
  Java程式碼  收藏程式碼
  1. <p>package com.shine.framework.core.util;</p>  
  2. import java.io.ByteArrayOutputStream;  
  3. import java.util.ArrayList;  
  4. import java.util.HashMap;  
  5. import java.util.Iterator;  
  6. import java.util.List;  
  7. import java.util.Map;  
  8. import net.sf.json.JSON;  
  9. import net.sf.json.JSONSerializer;  
  10. import net.sf.json.xml.XMLSerializer;  
  11. import org.dom4j.Document;  
  12. import org.dom4j.DocumentHelper;  
  13. import
     org.dom4j.Element;  
  14. import org.dom4j.io.OutputFormat;  
  15. import org.dom4j.io.XMLWriter;  
  16. /** 
  17.  * common xml conver utility 
  18.  *  
  19.  * @author [email protected] 
  20.  * @version Framework 2010.10.26 
  21.  * @url http://blog.csdn.net/arjick/article/details/6251777 
  22.  */
  23. publicclass XmlConverUtil {  
  24.     /** 
  25.      * map to xml xml <node><key label="key1">value1</key><key 
  26.      * label="key2">value2</key>......</node> 
  27.      *  
  28.      * @param map 
  29.      * @return 
  30.      */
  31.     publicstatic String maptoXml(Map map) {  
  32.         Document document = DocumentHelper.createDocument();  
  33.         Element nodeElement = document.addElement("node");  
  34.         for (Object obj : map.keySet()) {  
  35.             Element keyElement = nodeElement.addElement("key");  
  36.             keyElement.addAttribute("label", String.valueOf(obj));  
  37.             keyElement.setText(String.valueOf(map.get(obj)));  
  38.         }  
  39.         return doc2String(document);  
  40.     }  
  41.     /** 
  42.      * list to xml xml <nodes><node><key label="key1">value1</key><key 
  43.      * label="key2">value2</key>......</node><node><key 
  44.      * label="key1">value1</key><key 
  45.      * label="key2">value2</key>......</node></nodes> 
  46.      *  
  47.      * @param list 
  48.      * @return 
  49.      */
  50.     publicstatic String listtoXml(List list) throws Exception {  
  51.         Document document = DocumentHelper.createDocument();  
  52.         Element nodesElement = document.addElement("nodes");  
  53.         int i = 0;  
  54.         for (Object o : list) {  
  55.             Element nodeElement = nodesElement.addElement("node");  
  56.             if (o instanceof Map) {  
  57.                 for (Object obj : ((Map) o).keySet()) {  
  58.                     Element keyElement = nodeElement.addElement("key");  
  59.                     keyElement.addAttribute("label", String.valueOf(obj));  
  60.                     keyElement.setText(String.valueOf(((Map) o).get(obj)));  
  61.                 }  
  62.             } else {  
  63.                 Element keyElement = nodeElement.addElement("key");  
  64.                 keyElement.addAttribute("label", String.valueOf(i));  
  65.                 keyElement.setText(String.valueOf(o));  
  66.             }  
  67.             i++;  
  68.         }  
  69.         return doc2String(document);  
  70.     }  
  71.     /** 
  72.      * json to xml {"node":{"key":{"@label":"key1","#text":"value1"}}} conver 
  73.      * <o><node class="object"><key class="object" 
  74.      * label="key1">value1</key></node></o> 
  75.      *  
  76.      * @param json 
  77.      * @return 
  78.      */
  79.     publicstatic String jsontoXml(String json) {  
  80.         try {  
  81.             XMLSerializer serializer = new XMLSerializer();  
  82.             JSON jsonObject = JSONSerializer.toJSON(json);  
  83.             return serializer.write(jsonObject);  
  84.         } catch (Exception e) {  
  85.             e.printStackTrace();  
  86.         }  
  87.         returnnull;  
  88.     }  
  89.     /** 
  90.      * xml to map xml <node><key label="key1">value1</key><key 
  91.      * label="key2">value2</key>......</node> 
  92.      *  
  93.      * @param xml 
  94.      * @return 
  95.      */
  96.     publicstatic Map xmltoMap(String xml) {  
  97.         try {  
  98.             Map map = new HashMap();  
  99.             Document document = DocumentHelper.parseText(xml);  
  100.             Element nodeElement = document.getRootElement();  
  101.             List node = nodeElement.elements();  
  102.             for (Iterator it = node.iterator(); it.hasNext();) {  
  103.                 Element elm = (Element) it.next();  
  104.                 map.put(elm.attributeValue("label"), elm.getText());  
  105.                 elm = null;  
  106.             }  
  107.             node = null;  
  108.             nodeElement = null;  
  109.             document = null;  
  110.             return map;  
  111.         } catch (Exception e) {  
  112.             e.printStackTrace();  
  113.         }  
  114.         returnnull;  
  115.     }  
  116.     /** 
  117.      * xml to list xml <nodes><node><key label="key1">value1</key><key 
  118.      * label="key2">value2</key>......</node><node><key 
  119.      * label="key1">value1</key><key 
  120.      * label="key2">value2</key>......</node></nodes> 
  121.      *  
  122.      * @param xml 
  123.      * @return 
  124.      */
  125.     publicstatic List xmltoList(String xml) {  
  126.         try {  
  127.             List<Map> list = new ArrayList<Map>();  
  128.             Document document = DocumentHelper.parseText(xml);  
  129.             Element nodesElement = document.getRootElement();  
  130.             List nodes = nodesElement.elements();  
  131.             for (Iterator its = nodes.iterator(); its.hasNext();) {  
  132.                 Element nodeElement = (Element) its.next();  
  133.                 Map map = xmltoMap(nodeElement.asXML());  
  134.                 list.add(map);  
  135.                 map = null;  
  136.             }  
  137.             nodes = null;  
  138.             nodesElement = null;  
  139.             document = null;  
  140.             return list;  
  141.         } catch (Exception e) {  
  142.             e.printStackTrace();  
  143.         }  
  144.         returnnull;  
  145.     }  
  146.     /** 
  147.      * xml to json <node><key label="key1">value1</key></node> 轉化為 
  148.      * {"key":{"@label":"key1","#text":"value1"}} 
  149.      *  
  150.      * @param xml 
  151.      * @return 
  152.      */
  153.     publicstatic String xmltoJson(String xml) {  
  154.         XMLSerializer xmlSerializer = new XMLSerializer();  
  155.         return xmlSerializer.read(xml).toString();  
  156.     }  
  157.     /** 
  158.      *  
  159.      * @param document 
  160.      * @return 
  161.      */
  162.     publicstatic String doc2String(Document document) {  
  163.         String s = "";  
  164.         try {  
  165.             // 使用輸出流來進行轉化
  166.             ByteArrayOutputStream out = new ByteArrayOutputStream();  
  167.             // 使用UTF-8編碼
  168.             OutputFormat format = new OutputFormat("   ", true, "UTF-8");  
  169.             XMLWriter writer = new XMLWriter(out, format);  
  170.             writer.write(document);  
  171.             s = out.toString("UTF-8");  
  172.         } catch (Exception ex) {  
  173.             ex.printStackTrace();  
  174.         }  
  175.         return s;  
  176.     }  
  177. } 

相關推薦

java xml與json 相互轉換

需要json-lib-2.1-jdk15.jar和xom-1.2.5.jar，maven pom.xml如下： Xml程式碼   <dependency>    <groupId>net.sf.json-lib</groupId

JAVA 實現XML與JSON 相互轉換

tst throws light getc con parent urn In 工作 原文地址https://blog.csdn.net/congcong68/article/details/39029907 在工作中，經常碰到XML轉為JSON或者JSON轉為XML，在這

Java實現xml與json互相轉換

看到別人發的，感覺不錯，待驗證1.第一種方法（個人實現的）使用JSON-JAVA提供的方法，之前一直使用json-lib提供的方法轉json，後來發現了這個開源專案，覺得用起來很不錯，並且可以修改XML.java中的parse方法滿足自己的轉換需要。(1)首先去git下載所需

xml和JSON相互轉換的Java實現

依賴的包: json-lib-2.4-jdk15.jar ezmorph-1.0.6.jar xom-1.2.1.jar commons-lang-2.1.jar commons-io-1.3.2.jar jaxen-1.1.jar 輸入xml檔案,輸出JSON物件 Java程式碼   pa

Json使用，各物件與json相互轉換

Json：一種網路通訊使用的資料格式，因為便於解析，比較流行，物件可以轉為json，同樣json也可以轉物件。 下面介紹下Json工具的簡單使用。 FastJson 　　阿里的開源json工具包，國內比較流行，用的較多。 　　物件轉json字串 　　　　JSON.toJSONString(user)

JsonUtils的實現：物件與json相互轉換

pom.xml依賴 <dependency> <groupId>com.fasterxml.jackson.core</groupId> &

XML與陣列相互轉換

在實際的開發中，可能會經常將XML資料和陣列之間來回的轉換。如果是XML資料轉換為陣列，這樣比較方便讀取；陣列轉換為XML這種應用場景更為多見，如果我們某一天要寫XML的介面，這一步肯定是必須要做的，通常我們從資料庫中查詢到的資料是陣列，我們必須將陣列轉化為XML資料，然後將

字串、陣列、map集合、集合陣列、Java物件與JSON相互轉化

一、需要匯入的jar包 二、相互轉化1.字串與JSON相互轉化        //字串轉化為JSON，取JSON內元素        String jsonStr="{'name':'Jeffrey'}";        JSONObject jo=JSONObject.fr

java unicode與漢字相互轉換（處理特殊符號/表情）

漢字轉unicode： StringEscapeUtils.escapeJava(user.getUserName()) unicode轉漢字： StringEscapeUtils.u

C# 物件與JSON相互轉換

需要新增引用： System.Runtime.Serialization; System.ServiceModel.Web using System; using System.Collections.Generic; using System.IO; using Sy

JSON 與JAVA數據的相互轉換

sse map ini ngs 相互 pro lec ble throw import net.sf.json.JSONArray;import net.sf.json.JSONException;import net.sf.json.JSONObject;import

xml 與 json 在 Newtonsoft 中的相互轉換

1.資料格式 我們平時經常用到的兩種資料格式就是 xml 與 json。這兩種格式的轉換也變成了一個需要了解的操作。 2. xml XML（Extensible Markup Language）是一種用來編碼文件的標記語言，人和機器都能夠 快速理解XML文件的含

java物件與json物件間的相互轉換詳細解釋

1.簡單的解析json字串 首先將json字串轉換為json物件，然後再解析json物件，過程如下。 JSONObject jsonObject = JSONObject.fromObject(jsonStr); <pre></pre>&

java關於物件(javabean)與xml之間的相互轉換

今天我們要探討的一個問題是，如何將xml格式的字串轉換成物件，以及物件轉換成xml字串。 簡介 現如今，雖然資料的傳輸大部分都是用json格式來進行傳輸，但是xml畢竟也會有一些老的專案在進行使用，身為一個萬能的程式設計師。我們又怎能不會使

json字符串與java對象的相互轉換(jackson)

ces color 指定 nproc ast 文件 public 方法 輸出結果 1.java對象轉換為json字符串 package com.chichung.json; import com.fasterxml.jackson.core.JsonProcessing

Java對象與JSON互相轉換jsonlib以及手動創建JSON對象與數組——(二)

ring lnl tft sem mkf ted family sae key 　　　　首先聲明一下，jsonlib轉換與GSON相比太差勁了，操作不是一般的繁瑣。GSON可以直接轉換成各種集合與對象類型。強烈推薦使用GSON。而且GSON一個方法就可以解決，

JSONUtil(JAVA對象/List與json互轉，xml與json互轉)

transpose boolean ngs final span arraylist setname clas pro 1 package com.chauvet.utils.json; 2 3 import java.io.BufferedReader;

java字元陣列與字串相互轉換

1.字串轉化為字元陣列 public class Hello { public static void main(String args[]){ Scanner input = new Scanner(System.in); String str="abc";

java型別 7bit位元組與String 相互轉換

在通訊GSM，俗稱的2G 通常採用的是7bit編碼，是一種7位編碼壓縮演算法，其實原理上來說一個位元組佔8個位元位，一般最高位都是符號運算位 ，通常忽略不計，7bit其實就是運用了最高位將位元組往前移一位 就能空出一個位元位來給下個位元組用，也就是說8個位元組  之前的話 64位位元位來表

Java整型與字串相互轉換

1如何將字串 String 轉換成整數 int? 　　A. 有兩個方法: 　　1). int i = Integer.parseInt([String]); 或 　　i = Integer.parseInt([String],[int radix]); 　　2). int i = I