java实体在xml和json之间相互转换

今天药忘吃喽~ 2023-10-17 21:48 93阅读 0赞

在我们Java开发 接口调试过程中 经常会遇到 实体转换长json、xml 或者json 转换成实体、xml 等多种情况，今天博主给大家详细举例：

  1. 1、原生实体与json 相互转换：
  3. User user = new User();
  5. HashMap<String, Object> paramMap = new HashMap<String,Object>();
  7. String requestString = JSON.toJSONString(paramMap);
  8. ReturnInfo returnInfo = JSON.parseObject(result, ReturnInfo.class);//
  10. result 字符串为json  retrunInfo.class 为实体类

2、

  1. import java.util.ArrayList;
  2. import java.util.HashMap;
  3. import java.util.Iterator;
  4. import java.util.List;
  5. import java.util.Map;
  6. import java.util.StringTokenizer;
  8. import net.sf.json.JSONArray;
  9. import net.sf.json.JSONObject;
  12. /**
  13.  * JSOn工具类
  14.  */
  15. @SuppressWarnings("unchecked")
  16. public class JSONUtils {
  18.     /**
  19.      * 生成json数组
  20.      * @param datasJSON
  21.      * @return
  22.      */
  23.     public static JSONArray createJSONArray(String datasJSON){
  24.         String datas = JSONUtils.json2String(datasJSON, "datas");
  25.         JSONArray results = new JSONArray();;
  26.         JSONArray datasJSONArray = JSONArray.fromObject(datas);
  27.         Iterator<JSONObject> iterator = datasJSONArray.iterator();
  28.         while(iterator.hasNext()){
  29.             JSONObject data = (JSONObject) iterator.next();
  30.             JSONObject eachDataObject = data.getJSONObject("data");
  31.             results.element(eachDataObject);
  32.         }
  33.         return results;
  34.     }
  36.     /**
  37.      * 生成jsonobject 
  38.      * @param datasJSON
  39.      * @return
  40.      */
  41.     @SuppressWarnings("rawtypes")
  42.     public static List<JSONObject> createJSONObjects(String datasJSON){
  43.         List<JSONObject> results = new ArrayList<JSONObject>();
  44.         String datas = JSONUtils.json2String(datasJSON, "datas");
  45.         JSONArray jsonArray = JSONArray.fromObject(datas);
  46.         Iterator iterator = jsonArray.iterator();
  47.         while(iterator.hasNext()){
  48.             JSONObject data = (JSONObject) iterator.next();
  49.             JSONObject eachDataObject = data.getJSONObject("data");
  50.             results.add(eachDataObject);
  51.         }
  52.         return results;
  53.     }
  55.     /**
  56.      * 另一种生成jsonObject 方法
  57.      * @param datasJSON
  58.      * @return
  59.      */
  60.     @SuppressWarnings("rawtypes")
  61.     public static JSONObject createJSONObject(String datasJSON){
  62.         JSONObject result = new JSONObject();
  63.         String datas = JSONUtils.json2String(datasJSON, "datas");
  64.         JSONArray jsonArray = JSONArray.fromObject(datas);
  65.         Iterator iterator = jsonArray.iterator();
  66.         while(iterator.hasNext()){
  67.             JSONObject data = (JSONObject) iterator.next();
  68.             JSONObject eachDataObject = data.getJSONObject("data");
  69.             result = eachDataObject;
  70.         }
  71.         return result;
  72.     }
  75.     /**
  76.      * json转换成list
  77.      * @param json the json
  78.      * @return List<Map>
  79.      * 
  80.      */
  82.     public static  List<Map<String,Object>> jsonToList(String json) {
  83.         List<Map<String,Object>> listMap = new ArrayList<Map<String,Object>>();
  84.         String JSON = json.substring(1, json.length() - 1);
  85.         JSON = JSON.replaceAll("},", "}^");
  86.         StringTokenizer strTokenizer = new StringTokenizer(JSON, "^");
  87.         while (strTokenizer.hasMoreTokens()) {
  88.             String token = strTokenizer.nextToken();
  89.             Map<String,Object> paraMap =getMap4Json(token);
  90.             listMap.add(paraMap);
  91.         }
  93.        return listMap;
  94.     }
  96.     /**
  97.      * map转换成json
  98.      *
  99.      * @param jsonString the json string
  100.      * @return the 4Json
  101.      * 
  102.      */
  103.     public static Map<String,Object> getMapToJson(String jsonString) {
  104.         JSONObject jsonObject = JSONObject.fromObject(jsonString);
  105.         String key;
  106.         Object value;
  107.         Map<String,Object> valueMap = new HashMap<String,Object>();
  108.         Iterator<String> keyIter = jsonObject.keys();
  109.         while (keyIter.hasNext()) {
  110.             key =keyIter.next();
  111.             value = String.valueOf(jsonObject.get(key));
  112.             valueMap.put(key, value);
  113.         }
  114.         return valueMap;
  115.     }
  117.    /**
  118.     * string 转换成json字符串
  119.     *
  120.     * @param key the key
  121.     * @param value the value
  122.     * @return {a:1,b:8}
  123.     * 
  124.     */
  125.    public static String stringTojson(String key, String value) {
  126.         JSONObject object = new JSONObject();
  127.         object.put(key, value);
  128.         return object.toString();
  129.     }
  131.     /**
  132.      * json转换成数组
  133.      * @param json the json
  134.      * @param valueClz the value clz
  135.      * @return  
  136.      * 
  137.      */
  138.     public static Object jsonToArray(String json, Class<?> valueClz) {
  139.         JSONArray jsonArray = JSONArray.fromObject(json);
  140.         return JSONArray.toArray(jsonArray, valueClz);
  141.     }
  143.     /**
  144.      * object转换成json
  145.      *
  146.      * @param object the object
  147.      * @return the string
  148.      * @param:objec
  149.      */
  150.     public static String collectionTojson(Object object) {
  151.         JSONArray jsonArray = JSONArray.fromObject(object);
  152.         return jsonArray.toString();
  153.     }
  155.     /**
  156.      * map转JSON.
  157.      *
  158.      * @param object the object
  159.      * @return the string
  160.      * 
  161.      */
  162.     public static String mapTojson(Map<String,Object> object) {
  163.         JSONObject jsonObject = JSONObject.fromObject(object);
  164.         return jsonObject.toString();
  165.     }
  167.     /**
  168.      * json转map
  169.      *
  170.      */
  171.     @SuppressWarnings("rawtypes")
  172.     public static Map jsonToMap(Object[] keyArray, String json, Class<?> valueClz) {
  173.         JSONObject jsonObject = JSONObject.fromObject(json);
  174.         Map classMap = new HashMap();
  175.         for (int i = 0; i < keyArray.length; i++) {
  176.             classMap.put(keyArray[i], valueClz);
  177.         }
  178.         return (Map) JSONObject.toBean(jsonObject, Map.class, classMap);
  179.     }
  181.     /**
  182.      * 实体转换jSON.
  183.      *
  184.      * @param object the object
  185.      * @return the string
  186.      * 
  187.      */ 
  188.     public static String beanTojson(Object object) {
  189.         JSONObject jsonObject = JSONObject.fromObject(object);
  190.         return jsonObject.toString();
  191.     }
  193.     /**
  194.      * json转object
  195.      * 
  196.      */
  197.     @SuppressWarnings("rawtypes")
  198.     public static Object jsonToObject(String json, Class beanClz) {
  199.         return JSONObject.toBean(JSONObject.fromObject(json), beanClz);
  200.     }
  202.     /**
  203.      * json转string
  204.      */
  205.     public static String jsonToString(String json, String key) {
  206.         JSONObject jsonObject = JSONObject.fromObject(json);
  207.         return jsonObject.get(key).toString();
  208.     }
  210.     /**
  211.      * list转json
  212.      * 
  213.      */
  214.     @SuppressWarnings("rawtypes")
  215.     public static String listTojson(List list){
  216.        JSONArray jsonArray2 = JSONArray.fromObject(list);
  217.        return jsonArray2.toString();
  218.     }
  219. }

日常开发常用json转换 工具类：比如 

  1. Result info = (Result) JSONUtils.jsonToObject(result,Result.class);//json转实体
  2. String bean2json = JSONUtils.beanTojson(map);//实体转json

3、xml转换相关 

  1.  String str=xml+XmlUtils.toXml(packet);
  3. xml工具类:
  4. import java.io.File;
  5. import java.io.InputStream;
  6. import java.text.DateFormat;
  7. import java.text.ParseException;
  8. import java.text.SimpleDateFormat;
  9. import java.util.Date;
  11. import com.jingyou.application.cases.dto.custom.mps.MPSMainInfoDTO;
  12. import com.jingyou.application.cases.dto.custom.mps.QueryConditionDTO;
  13. import com.thoughtworks.xstream.XStream;
  14. import com.thoughtworks.xstream.converters.Converter;
  15. import com.thoughtworks.xstream.converters.MarshallingContext;
  16. import com.thoughtworks.xstream.converters.UnmarshallingContext;
  17. import com.thoughtworks.xstream.io.HierarchicalStreamReader;
  18. import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
  19. import com.thoughtworks.xstream.io.xml.DomDriver;
  21. /**
  22.  * 
  23.  * ClassName:SerializeUtils Reason: 基于xstream的xml序列化工具类
  24.  */
  25. @SuppressWarnings("unchecked")
  26. public class XmlUtils {
  28.     private static XStream getXStream(Class clazz) {
  29.         // dom方式解析
  30.         XStream xstream = new XStream();
  31.         // 开启注解检查，指定注解类
  32.         xstream.processAnnotations(clazz);
  33.         // 注册日期对象的转换器
  34.         xstream.registerConverter(new Converter() {
  35.             // Date → String
  36.             public void marshal(Object arg0, HierarchicalStreamWriter arg1, MarshallingContext arg2) {
  37.                 DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
  38.                 arg1.setValue(dateFormat.format((Date) arg0));
  39.             }
  41.             // String → Date
  42.             public Object unmarshal(HierarchicalStreamReader arg0, UnmarshallingContext arg1) {
  43.                 SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  44.                 if(!"".equals(arg0.getValue())){
  45.                     if(arg0.getValue().length() < 19){
  46.                         dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm");
  47.                     } 
  48.                     if(arg0.getValue().length() < 11){
  49.                         dateFormat = new SimpleDateFormat("yyyy-MM-dd");
  50.                     }
  51.                     try {
  52.                         return dateFormat.parse(arg0.getValue());
  53.                     } catch (ParseException e) {
  54.                         e.printStackTrace();
  55.                         throw new RuntimeException(e.getCause());
  56.                     }
  57.                 }else{
  58.                     return null;
  59.                 }
  60.             }
  62.             // 对Date类型转换
  63.             public boolean canConvert(Class arg0) {
  64.                 return arg0.equals(Date.class);
  65.             }
  67.         });
  69.         return xstream;
  70.     }
  72.     private static XStream getXStreamNew(Class clazz, String aliasName) {
  73.         // dom方式解析
  74.         XStream xstream = new XStream();
  75.         // 动态修改类注解
  76.         if(aliasName != null && !"".equals(aliasName)){
  77.             xstream.alias(aliasName, clazz);
  78.         }
  79.         // 开启注解检查，指定注解类
  80.         xstream.processAnnotations(clazz);
  81.         // 注册日期对象的转换器
  82.         xstream.registerConverter(new Converter() {
  83.             // Date → String
  84.             public void marshal(Object arg0, HierarchicalStreamWriter arg1, MarshallingContext arg2) {
  85.                 DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
  86.                 arg1.setValue(dateFormat.format((Date) arg0));
  87.             }
  89.             // String → Date
  90.             public Object unmarshal(HierarchicalStreamReader arg0, UnmarshallingContext arg1) {
  91.                 SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  92.                 if(!"".equals(arg0.getValue())){
  93.                     if(arg0.getValue().length() < 19){
  94.                         dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm");
  95.                     } 
  96.                     if(arg0.getValue().length() < 11){
  97.                         dateFormat = new SimpleDateFormat("yyyy-MM-dd");
  98.                     }
  99.                     try {
  100.                         return dateFormat.parse(arg0.getValue());
  101.                     } catch (ParseException e) {
  102.                         e.printStackTrace();
  103.                         throw new RuntimeException(e.getCause());
  104.                     }
  105.                 }else{
  106.                     return null;
  107.                 }
  108.             }
  110.             // 对Date类型转换
  111.             public boolean canConvert(Class arg0) {
  112.                 return arg0.equals(Date.class);
  113.             }
  115.         });
  117.         return xstream;
  118.     }
  120.     public static String toXml(Object obj) {
  121.         String xml = getXStream(obj.getClass()).toXML(obj);
  122.         xml = xml.replaceAll("__", "_");    // xstream的bug，应避免使用下划线作为连接符
  123.         return xml;
  124.     }
  126.     public static String toXmlNew(Object obj, String aliasName){
  127.         String xml = getXStreamNew(obj.getClass(), aliasName).toXML(obj);
  128.         xml = xml.replaceAll("__", "_");    // xstream的bug，应避免使用下划线作为连接符
  129.         return xml;
  130.     }
  132.     public static <T> T fromXmlNew(String xml, Class<T> clazz, String aliasName) {
  133.         T t = (T) getXStreamNew(clazz, aliasName).fromXML(xml);
  134.         return t;
  135.     }
  137.     public static <T> T fromXml(String xml, Class<T> clazz) {
  138.         T t = (T) getXStream(clazz).fromXML(xml);
  139.         return t;
  140.     }
  142.     public static <T> T fromXml(File xml, Class<T> clazz) {
  143.         T t = (T) getXStream(clazz).fromXML(xml);
  144.         return t;
  145.     }
  147.     public static <T> T fromXml(InputStream xml, Class<T> clazz) {
  148.         T t = (T) getXStream(clazz).fromXML(xml);
  149.         return t;
  150.     }
  153. }
  155. java开发中肯定有所帮助，如果有疑问可以留言：我会及时帮你解决

发表评论

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

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

相关阅读