Json 格式在数据中较为常见，为了避免重复开发，整理了比较实用的代码片段，仅供参考。

    Java 版

    1. package com.xx.common.util;
    3. import java.io.IOException;
    4. import java.util.ArrayList;
    5. import java.util.HashMap;
    6. import java.util.List;
    7. import java.util.Map;
    8. import java.util.Map.Entry;
    10. import com.fasterxml.jackson.annotation.JsonInclude;
    11. import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
    12. import com.fasterxml.jackson.core.JsonGenerator;
    13. import com.fasterxml.jackson.core.JsonParser;
    14. import com.fasterxml.jackson.core.JsonParseException;
    15. import com.fasterxml.jackson.core.type.TypeReference;
    16. import com.fasterxml.jackson.databind.ObjectMapper;
    17. import com.fasterxml.jackson.databind.DeserializationFeature;
    18. import com.fasterxml.jackson.databind.JsonNode;
    19. import com.fasterxml.jackson.databind.JsonMappingException;
    20. import com.fasterxml.jackson.databind.SerializationFeature;
    21. import com.fasterxml.jackson.databind.node.ArrayNode;
    22. import com.fasterxml.jackson.databind.node.JsonNodeFactory;
    23. import com.fasterxml.jackson.databind.node.ObjectNode;
    25. import org.apache.commons.lang.StringUtils;
    27. public class JsonUtil {
    29.     public final static ObjectMapper objectMapper = new ObjectMapper();
    31.     static {
    33.         /**
    34.          * 如果为空则不输出
    35.          */
    36.         objectMapper.setSerializationInclusion(JsonInclude.Include.NON_EMPTY);
    38.         /**
    39.          *  对于空的对象转json的时候不抛出错误
    40.          *  
    41.          *  是否允许一个类型没有注解表明打算被序列化。默认true，抛出一个异常；否则序列化一个空对象，比如没有任何属性。
    42.          */
    43.         objectMapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
    45.         /**
    46.          * 禁用序列化日期为timestamps
    47.          * 
    48.          * 该特性决定是否将基于Date的值序列化为timestamp数字式的值，或者作为文本表示。
    49.          * 如果文本表示，则实际格式化的时候会调用{@link #getDateFormat}方法。
    50.          * 
    51.          * 该特性可能会影响其他date相关类型的处理，虽然我们理想情况是只对date起作用。
    52.          */
    53.         objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
    55.         /**
    56.          * 禁用遇到未知属性抛出异常
    57.          * 
    58.          * 该特性决定了当遇到未知属性（没有映射到属性，没有任何setter或者任何可以处理它的handler），是否应该抛出一个
    59.          * JsonMappingException异常。这个特性一般式所有其他处理方法对未知属性处理都无效后才被尝试，属性保留未处理状态。
    60.          *
    61.          * 默认情况下，该设置是被打开的。若不设置, 可以在 java class 中使用 @JsonIgnoreProperties 注解
    62.          */
    63.         objectMapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
    65.         /**
    66.          * 视空字符传为null
    67.          * 
    68.          * 该特性可以允许JSON空字符串转换为POJO对象为null。如果禁用，则标准POJO只会从JSON null或者JSON对象转换过来；
    69.          * 如果允许，则空JSON字符串可以等价于JSON null。
    70.          * @since 1.8
    71.          */
    72.         objectMapper.enable(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT);
    74.         /**
    75.          * 该特性决定parser将是否允许解析使用Java/C++ 样式的注释（包括'/'+'*' 和'//' 变量）。 由于JSON标准说明书上面没有提到注释是否是合法的组成，所以这是一个非标准的特性；
    76.          * 尽管如此，这个特性还是被广泛地使用。
    77.          *
    78.          * 注意：该属性默认是false，因此必须显式允许，即通过 JsonParser.Feature.ALLOW_COMMENTS 配置为 true。
    79.          */
    80.         objectMapper.configure(JsonParser.Feature.ALLOW_COMMENTS, true);
    82.         /**
    83.          * 允许属性名称没有引号
    84.          * 
    85.          * 这个特性决定parser是否将允许使用非双引号属性名字， （这种形式在Javascript中被允许，但是JSON标准说明书中没有）。
    86.          *
    87.          * 注意：由于JSON标准上需要为属性名称使用双引号，所以这也是一个非标准特性，默认是false的。
    88.          * 同样，需要设置JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES为true，打开该特性。
    89.          *
    90.          */
    91.         objectMapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true);
    93.         /**
    94.          * 允许单引号
    95.          * 
    96.          * 该特性决定parser是否允许JSON字符串包含非引号控制字符（值小于32的ASCII字符，包含制表符和换行符）。 如果该属性关闭，则如果遇到这些字符，则会抛出异常。
    97.          * JSON标准说明书要求所有控制符必须使用引号，因此这是一个非标准的特性。
    98.          *
    99.          * 注意：默认时候，该属性关闭的。需要设置：JsonParser.Feature.ALLOW_UNQUOTED_CONTROL_CHARS为true。
    100.          */
    101.         objectMapper.configure(JsonParser.Feature.ALLOW_SINGLE_QUOTES, true);
    103.         /**
    104.          * 取消对非ASCII字符的转码
    105.          */
    106.         objectMapper.configure(JsonGenerator.Feature.ESCAPE_NON_ASCII, false);
    108.         /**
    109.          * 该特性决定parser是否允许JSON字符串包含非引号控制字符（值小于32的ASCII字符，包含制表符和换行符）。 如果该属性关闭，则如果遇到这些字符，则会抛出异常。
    110.          * JSON标准说明书要求所有控制符必须使用引号，因此这是一个非标准的特性。
    111.          *
    112.          * 注意：默认时候，该属性关闭的。需要设置：JsonParser.Feature.ALLOW_UNQUOTED_CONTROL_CHARS 为 true。
    113.          */
    114.         objectMapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_CONTROL_CHARS, true);
    115.     }
    118.     public static Map<String, Object> JsonToMap(String json)  {  
    119.         // jackson
    120.         Map<String, Object> map = new HashMap<String, Object>();
    121.         try {
    122.             map = objectMapper.readValue(json, new TypeReference<Map<String, Object>>(){});
    123.         } catch (JsonParseException e) {
    124.             e.printStackTrace();
    125.         } catch (JsonMappingException e) {
    126.             e.printStackTrace();
    127.         } catch (IOException e) {
    128.             e.printStackTrace();
    129.         }
    130.         return map;
    131.     }
    134.     public static <T> T JsonToBean(String json, Class<T> clz) {
    135.         // json to javabean
    136.         T t = null;
    137.         try {
    138.            t = objectMapper.readValue(json, clz);
    139.         } catch (JsonParseException e) {
    140.             e.printStackTrace();
    141.         } catch (JsonMappingException e) {
    142.             e.printStackTrace();
    143.         } catch (IOException e) {
    144.             e.printStackTrace();
    145.         }
    146.         return t;
    147.     }
    150.     public static String JsonFindPath(String json, String path) {
    151.         String resultPath = null;
    153.         try {
    154.             JsonNode pathNode = objectMapper.readTree(json);
    155.             String[] paths = StringUtils.split(path,".");
    157.             for (int i = 0, len = paths.length; i < len; i ++ ) {
    158.                 String curPath = paths[i];
    159.                 if (curPath.isEmpty()) {
    160.                     continue;
    161.                 } else if (StringUtils.isNumeric(curPath)) {
    162.                     int idxPath =  java.lang.Integer.parseInt(curPath);
    163.                     pathNode = pathNode.path(idxPath);
    164.                 } else {
    165.                     pathNode = pathNode.path(curPath);
    166.                 }
    167.             }
    169.             resultPath = pathNode.toString();
    170.         } catch (IOException e) {
    171.             e.printStackTrace();
    172.         }
    174.         return resultPath;
    175.     }
    178.     public static Map<String, Object> ListMapToMap(List<Map<String, Object>> listMap) {
    179.         // 保存处理好的 Json 格式
    180.         Map<String, Object> resultMap = new HashMap<String, Object>();
    182.         try {
    183.             Map<String, Object> formatMap;
    184.             for (int i = 0, len = listMap.size(); i < len; i ++) {
    185.                 Map<String, Object> valMap = listMap.get(i);
    186.                 try {
    187.                     formatMap = valMap;
    188.                     // 把 list map 中嵌套数据, 放到 map 中
    189.                     for(Entry<String, Object> entry :formatMap.entrySet()) {
    190.                         resultMap.put(entry.getKey(), entry.getValue());
    191.                     }
    192.                 } catch (ClassCastException e)  {
    193.                     System.out.println("Exception: " + valMap + " : " + e.getMessage());
    194.                 }
    195.                 formatMap = null;
    196.             }
    198.         } catch(Exception e) {
    199.             System.out.println("Exception: " + listMap + " : " + e.toString());
    200.         }
    202.         return resultMap;
    203.     }
    204. }

    Scala 版

    1. package com.xx.common.util
    3. import net.minidev.json.{JSONObject, JSONArray}
    4. import net.minidev.json.parser.JSONParser
    6. import scala.collection.mutable.Map
    7. import scala.collection.JavaConversions.mapAsScalaMap
    8. import scala.collection.JavaConversions.mutableMapAsJavaMap
    10. object ScalaJsonUtil {
    12.     /**
    13.      * map -> json
    14.      * @param map 输入格式 mutable.Map[String,Object]
    15.      * @return
    16.      * */
    17.     def SmartMapToJson(map : Map[String, Object]): String = {
    18.         val jsonString = JSONObject.toJSONString(map)
    19.         jsonString
    20.     }
    22.    /**
    23.    * json -> Map
    24.    * @param json 输入json字符串
    25.    * @return
    26.    * */
    27.     def SmartJsonToMap(json: String): Map[String, Object] = {
    28.         val map : Map[String, Object]= Map()
    29.         if (json == null || json == "") {
    30.             return map 
    31.         }
    33.         //将string转化为jsonObject
    34.         val jsonParser = new JSONParser()
    35.         try {
    36.             val jsonObj: JSONObject = jsonParser.parse(json).asInstanceOf[JSONObject]
    37.             if (jsonObj == null) {
    38.                 return map
    39.             }
    41.             //获取所有键
    42.             val jsonKey = jsonObj.keySet()
    43.             val iter = jsonKey.iterator()
    45.             while (iter.hasNext){
    46.               val field = iter.next()
    47.               val value = jsonObj.get(field).toString
    49.               if(value.startsWith("{")&&value.endsWith("}")){
    50.                 val value = mapAsScalaMap(jsonObj.get(field).asInstanceOf[java.util.HashMap[String, String]])
    51.                 map.put(field,value)
    52.               }else{
    53.                 map.put(field,value)
    54.               }
    55.             }
    56.         }  catch {
    57.             case ex: Exception => return map
    58.         }
    60.         return map
    61.     }
    64.     /**
    65.      * json list map -> list string
    66.      * [{},{}] -> List[String]
    67.      */
    68.     def SmartJsonToList(json: String): List[String] = {
    69.         var list = List[String]()
    70.         if (json == null || json == "") {
    71.             return list 
    72.         }
    73.         val jsonParser = new JSONParser()
    74.         val jsonArr: JSONArray = jsonParser.parse(json).asInstanceOf[JSONArray]
    75.         for(i <- 0 to jsonArr.size() - 1) {
    76.             if(jsonArr.get(i) != null){
    77.               val node = jsonArr.get(i).toString()
    78.               list = list :+ node
    79.             }
    80.         }
    82.         return list
    83.     }
    86.     /**
    87.      * [{},{}] -> List[Map, Map]
    88.      */
    89.     def SmartJsonToListMap(json: String): List[Map[String, Object]] = {
    90.         var listMap = List[Map[String, Object]]()
    91.         if (json == null || json == "") {
    92.             return listMap 
    93.         }
    95.         val jsonParser = new JSONParser()
    96.         val jsonArr: JSONArray = jsonParser.parse(json).asInstanceOf[JSONArray]
    97.         for(i <- 0 to jsonArr.size() - 1) {
    98.             if (jsonArr.get(i) != null || jsonArr.get(i) != "" ) {
    99.                 val node = SmartJsonToMap(jsonArr.get(i).toString())
    100.                 if (node != null) {
    101.                     listMap = listMap :+ node
    102.                 }
    103.             } 
    104.         }
    106.         return listMap
    107.     }
    110.     /**
    111.      * json Object -> Map
    112.      */
    113.     def SmartGetMap(ob: Object): Map[String, Object] = {
    114.         var map = Map[String, Object]()
    115.         if (ob != null || ob != "") {
    116.             map = ob.asInstanceOf[scala.collection.mutable.Map[String, Object]];
    117.         } 
    118.         map
    119.     }
    122.     def JsonListToMap(fields: String): Map[String, Object] = {
    123.         //val listStr = SmartJsonToList(fields)
    124.         val listMap = SmartJsonToListMap(fields)
    126.         //ListStrToMap(listStr)
    127.         ListMapToMap(listMap)
    128.     }
    131.     /**
    132.      * List[Json] -> Map
    133.      */
    134.     def ListStrToMap(list: List[String]): Map[String, Object] = {
    135.         val formatMap = Map[String, Object]()
    136.         list.foreach { json => 
    137.             val map = SmartJsonToMap(json)
    138.             for ((k, v) <- map) {
    139.                 formatMap.put(k, v)
    140.             }
    141.         }
    142.         formatMap
    143.     }
    146.     /**
    147.      * List[Map] -> Map
    148.      */
    149.     def ListMapToMap(listMap: List[Map[String, Object]]): Map[String, Object] = {
    150.         val formatMap = Map[String, Object]()
    151.         listMap.foreach{ map =>
    152.             for ((k, v) <- map) {
    153.                 formatMap.put(k, v)
    154.             }
    155.         }
    156.         formatMap
    157.     }
    159.     /**
    160.       * 对象转Json字符串
    161.       * @param ob 对象
    162.       * @return 字符串
    163.       */
    164.     def objectToJson(ob: Object): String = {
    165.       var commonJson = ""
    166.       if (ob != "") {
    167.         val commonMap = SmartGetMap(ob)
    168.         commonJson = SmartMapToJson(commonMap)
    169.       }
    170.       commonJson
    171.     }
    173. }