json中date(JSONObject)引发的血案

素颜马尾好姑娘i 2022-04-01 04:50 855阅读 0赞

前言

1、测试bean

1、包含集合的测试bean

  1. package com.hlj.data.res.test;
  3. import io.swagger.annotations.ApiModel;
  4. import lombok.Data;
  5. import lombok.experimental.Accessors;
  7. import java.math.BigDecimal;
  8. import java.util.Date;
  9. import java.util.List;
  11. /** * @Desc: json测试实体 * @Author HealerJean * @Date 2018/9/25 上午11:10. * */
  12. @Data
  13. @Accessors(chain = true)
  14. @ApiModel (description = "json测试实体")
  15. public class TsJsonData { 
  18.     /** {"error":"0","msg":"操作成功","data":[{"n_long":"3923600074","n_string":"小当","n_bigDecimal":"5.9000","n_date":"2018-12-13 20:31:04","n_integer":1},{"n_long":"3923600074","n_string":"小当","n_bigDecimal":"5.9000","n_date":"2018-12-13 20:31:04","n_integer":1}]} * error : 0 * msg : 操作成功 * data : [{"n_long":"3923600074","n_string":"小当","n_bigDecimal":"5.9000","n_date":"2018-12-13 20:31:04","n_integer":1},{"n_long":"3923600074","n_string":"小当","n_bigDecimal":"5.9000","n_date":"2018-12-13 20:31:04","n_integer":1}] */
  20.     private String error;
  21.     private String msg;
  22.     private List<DataBean> data;
  24.     @Data
  25.     @Accessors(chain = true)
  26.     public static class DataBean { 
  27.         /** * n_long : 3923600074 * n_string : name * n_bigDecimal : 5.9000 * n_date : 2018-12-13 20:31:04 * income_rate : 0.9000 * n_integer : 1 */
  29.         private Long n_long;
  30.         private String n_string;
  31.         private BigDecimal n_bigDecimal;
  32.         private Date n_date;
  33.         private Integer n_integer;
  36.     }
  37. }

2、普通Bean

  1. package com.hlj.data.res.test;
  3. import lombok.Data;
  4. import lombok.experimental.Accessors;
  6. import java.io.Serializable;
  7. import java.math.BigDecimal;
  8. import java.util.Date;
  10. /** * 作者 ：HealerJean * 日期 ：2018/12/14 下午7:56. * 类描述： */
  11. @Data
  12. @Accessors(chain = true)
  13. public class JavaBean implements Serializable { 
  15.     private Long n_long;
  16.     private String n_string;
  17.     private BigDecimal n_bigDecimal;
  18.     private Date n_date;
  19.     private Integer n_integer;
  21. }

3、不返回null的bean

  1. package com.hlj.data.res.test;
  3. import com.fasterxml.jackson.annotation.JsonInclude;
  4. import lombok.Data;
  5. import lombok.experimental.Accessors;
  7. import java.math.BigDecimal;
  8. import java.util.Date;
  10. /** * 作者 ：HealerJean * 日期 ：2018/12/28 下午7:36. * 类描述： */
  12. @Data
  13. @Accessors(chain = true)
  14. @JsonInclude(JsonInclude.Include.NON_NULL)
  15. public class IncludeJavaBean { 
  17.         private Long n_long;
  18.         private String n_string;
  19.         private BigDecimal n_bigDecimal;
  20.         private Date n_date;
  21.         private Integer n_integer;
  24. }

2、开始正儿八经测试

3.0、准备假数据

  1. /** * 假数据JavaBean * @return */
  2.     private JavaBean getJavaBean() { 
  3.         JavaBean javaBean = new JavaBean();
  4.         javaBean.setN_long(10045456456L);
  5.         javaBean.setN_bigDecimal(new BigDecimal("12.12245"));
  6.         javaBean.setN_date(new Date());
  7.         javaBean.setN_integer(100);
  8.         javaBean.setN_string("HealerJean");
  10.         return javaBean;
  11.     }
  14.     /** * 假数据JavaBean 对应的 Map * @return */
  15.     private Map<String, Object> getJavaBeanMap() { 
  16.         Map<String, Object> map = new HashMap<>();
  17.         map.put("n_long", 10045456456L);
  18.         map.put("n_string", "张宇晋");
  19.         map.put("n_bigDecimal",new BigDecimal("12.12245") );
  20.         map.put("n_date",new Date() );
  21.         map.put("n_integer",100 );
  22.         return map;
  23.     }
  25.     /** * 假数据 IncludeJavaBean 用于测试 include.not_null * @return */
  26.     private IncludeJavaBean getIncludeJavaBean() { 
  27.         IncludeJavaBean  includeJavaBean = new IncludeJavaBean();
  28.         includeJavaBean.setN_long(10045456456L);
  29.         includeJavaBean.setN_bigDecimal(new BigDecimal("12.12245"));
  30.         includeJavaBean.setN_date(null);
  31.         includeJavaBean.setN_integer(100);
  32.         /** * 下面和这个设置为null */
  33.         includeJavaBean.setN_string(null);
  35.         return includeJavaBean;
  36.     }

3.1、date类型必须是long

3.2、JSONObcjet不可以随便使用，和对象一起用的时候，会将date变质

3.3、强烈要求使用objectMapper

  1. /** * 一、 * 1、date类型不是long是错误的，不能转化成果 * 2、如果将有date参数的对象 通过JSONObject 打印成String字符串，则，date会变质，不会变成long类型的了，如下 * 但是需要注意的是，这其实只要不转化出String来，这些对象都是可以操作的，不受影响 * * JSONObject.fromObject(tsJsonData).toString() * 3、通过objectMapper的转化，一切正常 ，如下 * JsonUtils.toJson(tsJsonData) */
  2.     @Test
  3.     public void JsonObjectForJsonToBean(){ 
  5.         // 1、错误的，转化直接报错 String jsonDataStr = "{\"error\":\"0\",\"msg\":\"操作成功\",\"data\":[{\"n_long\":\"3923600074\",\"n_string\":\"小当\",\"n_bigDecimal\":\"5.9000\",\"n_date\":\"2018-12-13 20:31:04\",\"n_integer\":1},{\"n_long\":\"3923600074\",\"n_string\":\"小当\",\"n_bigDecimal\":\"5.9000\",\"n_date\":\"2018-12-13 20:31:04\",\"n_integer\":1}]}";
  6.         String jsonDataStr = "{\"error\":\"0\",\"msg\":\"操作成功\",\"data\":[{\"n_long\":\"3923600074\",\"n_string\":\"小当\",\"n_bigDecimal\":\"5.9000\",\"n_date\":\"1544782308409\",\"n_integer\":1},{\"n_long\":\"3923600074\",\"n_string\":\"小当\",\"n_bigDecimal\":\"5.9000\",\"n_date\":\"1544782308409\",\"n_integer\":1}]}";
  7.         log.info("\n1、JsonObjectForJsonToBean\n"+JSONObject.fromObject(jsonDataStr).toString());
  8.         //打印结果：正常，因为没有经过对象中date变质
  9.         // {"error":"0","msg":"操作成功","data":[{"n_long":"3923600074","n_string":"小当","n_bigDecimal":"5.9000","n_date":"1544782308409","n_integer":1},{"n_long":"3923600074","n_string":"小当","n_bigDecimal":"5.9000","n_date":"1544782308409","n_integer":1}]}
  11.         //2、JSONObject将具有date的对象进行洗礼
  12.         TsJsonData tsJsonData =   JsonUtils.toObject(jsonDataStr, TsJsonData.class );
  13.         log.info("\n2、JsonObjectForJsonToBean\n"+JSONObject.fromObject(tsJsonData).toString());
  14.         //打印结果：date变质了哦
  15.         //{"data":[{"n_bigDecimal":5.9,"n_date":{"date":14,"day":5,"hours":18,"minutes":11,"month":11,"seconds":48,"time":1544782308409,"timezoneOffset":-480,"year":118},"n_integer":1,"n_long":3923600074,"n_string":"小当"},{"n_bigDecimal":5.9,"n_date":{"date":14,"day":5,"hours":18,"minutes":11,"month":11,"seconds":48,"time":1544782308409,"timezoneOffset":-480,"year":118},"n_integer":1,"n_long":3923600074,"n_string":"小当"}],"error":"0","msg":"操作成功"}
  17.         //3、通过objectMapper的转化
  18.         log.info("\n3、JsonObjectForJsonToBean\n"+JsonUtils.toJson(tsJsonData));
  19.         //打印结果： 一切正常
  20.         //{"error":"0","msg":"操作成功","data":[{"n_long":3923600074,"n_string":"小当","n_bigDecimal":5.9000,"n_date":1544782308409,"n_integer":1},{"n_long":3923600074,"n_string":"小当","n_bigDecimal":5.9000,"n_date":1544782308409,"n_integer":1}]}
  22.     }

3.3、JavaBean转map

  1. /** 二.1 * JavaBean转Map * 用法：可以用于Http map传参 */
  2.     @Test
  3.     public void baenToMap() { 
  5.         JavaBean javaBean = getJavaBean();
  6.         Map<String, Object> map = (Map<String, Object>)JSONObject.fromObject(javaBean);
  7.         log.info("\nbaenToMap\n"+JsonUtils.toJson(map));
  8.         //下面这里发现date 变质了，但是map还是可以操作的，只是不要将它转化为string字符串，并且将它输出到前台也是正常的long类型的Json数据哦
  9.         //{"n_bigDecimal":12.12245,"n_date":{"date":14,"day":5,"hours":20,"minutes":0,"month":11,"seconds":31,"time":1544788831913,"timezoneOffset":-480,"year":118},"n_integer":100,"n_long":10045456456,"n_string":"张宇晋"}
  11.         Map<String, Object> map2= JsonUtils.toObject(JsonUtils.toJson(javaBean),new TypeReference<Map<String, Object>>( ){ } );
  12.         log.info(JsonUtils.toJson(map2));
  13.         //正常
  14.         //{"n_long":10045456456,"n_string":"HealerJean","n_bigDecimal":12.12245,"n_date":1546053984277,"n_integer":100}
  16.     }

3.3.2、将变质的日期输出到前台

  1. @GetMapping("getMapHaveDateFalse")
  2.     @ResponseBody
  3.     public Map<String ,Object> getMap(){ 
  5.         JavaBean javaBean = getJavaBean();
  6.         Map<String, Object> map = (Map<String, Object>) JSONObject.fromObject(javaBean);
  8.         return map ;
  9.     }

3.4、Map转javabean

  1. /** * 二.2 * Map转JavaBean */
  2.     @Test
  3.     public void MapTobaen() { 
  5.         Map<String, Object> map = getJavaBeanMap();
  6.         // String mapStr = JSONObject.fromObject(map).toString();
  7.         //1、 打印结果：date变质
  8.         //{"n_date":{"date":28,"day":5,"hours":19,"minutes":22,"month":11,"seconds":56,"time":1545996176773,"timezoneOffset":-480,"year":118},"n_integer":100,"n_bigDecimal":12.12245,"n_string":"张宇晋","n_long":10045456456}
  10.         String mapStr = JsonUtils.toJson(map);
  11.         log.info("\nMapTobaen\n"+mapStr);
  12.         //2、正常，所以不要使用 JSONObject
  13.         //{"n_date":1545996089637,"n_integer":100,"n_bigDecimal":12.12245,"n_string":"张宇晋","n_long":10045456456}
  14.     }

3.5、@JsonInclude(JsonInclude.Include.NON_NULL)

  1. /** * Jsoninclude.NOT_NULL */
  2.     @Test
  3.     public void JSONInclude(){ 
  4.         //n_string 字段为null date字段为null
  5.         IncludeJavaBean includeJavaBean = getIncludeJavaBean() ;
  6.         //1、经过ObjectMapper处理
  7.         log.info("\nJSONInclude\n"+JsonUtils.toJson(includeJavaBean));
  8.         //打印结果：正常 使用了上面的注解，下面如果是null则不会出现 该字段
  9.         //{"n_long":10045456456,"n_bigDecimal":12.12245,"n_integer":100}
  11.         //2、如果是经过 JSONObject.fromObject ，
  12.         // null的字段会变成 空字符串"" ，
  13.         // 日期为空，则会变成null ，所以谨慎使用
  14.         log.info("\nJSONObject.fromObject(includeJavaBean).toString()\n"+JSONObject.fromObject(includeJavaBean).toString());
  15.         //打印结果：
  16.         // {"n_bigDecimal":12.12245,"n_date":null,"n_integer":100,"n_long":10045456456,"n_string":""}
  19.         /** * json转对象 */
  20.         String jsonNull = "{\"n_long\":10045456456,\"n_bigDecimal\":12.12245,\"n_integer\":100}" ;
  21.         String jsonPramsNull = "{\"n_bigDecimal\":12.12245,\"n_date\":null,\"n_integer\":100,\"n_long\":10045456456,\"n_string\":\"\"}" ;
  23.         IncludeJavaBean mapperjavaBean =JsonUtils.toObject(jsonNull,IncludeJavaBean.class );
  24.         //不存在显示 null
  25.         //IncludeJavaBean(n_long=10045456456, n_string=null, n_bigDecimal=12.12245, n_date=null, n_integer=100)
  26.         IncludeJavaBean mapperParamsNulljavaBean =JsonUtils.toObject(jsonPramsNull,IncludeJavaBean.class );
  27.         //空字符串显示 "" null表示null
  28.         //IncludeJavaBean(n_long=10045456456, n_string=, n_bigDecimal=12.12245, n_date=null, n_integer=100)
  30.         //下面二者同上
  31.         IncludeJavaBean javaBean = JsonUtils.toObject(JSONObject.fromObject(jsonNull).toString(), IncludeJavaBean.class);
  32.         //IncludeJavaBean(n_long=10045456456, n_string=null, n_bigDecimal=12.12245, n_date=null, n_integer=100)
  33.          IncludeJavaBean javaParamsNullBean = JsonUtils.toObject(JSONObject.fromObject(jsonPramsNull).toString(), IncludeJavaBean.class);
  34.         //IncludeJavaBean(n_long=10045456456, n_string=, n_bigDecimal=12.12245, n_date=null, n_integer=100)
  36.         System.out.println(mapperjavaBean.toString());
  37.         System.out.println(mapperParamsNulljavaBean.toString());
  38.         System.out.println(javaBean.toString());
  39.         System.out.println(javaParamsNullBean.toString());
  42.     }

3.6、json转化为list集合

  1. /** * json转化为数组 */
  2.     @Test
  3.     public void JsonToList(){ 
  5.         List<JavaBean> javaBeans = new ArrayList<>();
  6.         JavaBean javaBean1 = getJavaBean();
  8.         JavaBean javaBean2 = getJavaBean();
  9.         javaBeans.add(javaBean1);
  10.         javaBeans.add(javaBean2);
  12.         //list转化为string字符串，这里可别用JSONObject了，这个家伙太完蛋，一下子就会将date变质
  13.         String jsonArrayStr = JsonUtils.toJson(javaBeans);
  14.         log.info("\nJsonUtils.toJson(jsonArrayStr)\n"+jsonArrayStr);
  15.         //打印结果 正常打印
  16.         // [{"n_long":10045456456,"n_string":"HealerJean","n_bigDecimal":12.12245,"n_date":1546051110172,"n_integer":100},{"n_long":10045456456,"n_string":"HealerJean","n_bigDecimal":12.12245,"n_date":1546051110172,"n_integer":100}]
  19.         //2、转化为数组
  20.         List<JavaBean> lendReco =  JsonUtils.toObject(jsonArrayStr, new TypeReference<List<JavaBean>>() {  });
  21.         String lendRecoStr = JsonUtils.toJson(lendReco);
  22.         System.out.println(lendRecoStr);
  23.         //打印结果 正常打印
  24.         //[{"n_long":10045456456,"n_string":"HealerJean","n_bigDecimal":12.12245,"n_date":1546052196927,"n_integer":100},{"n_long":10045456456,"n_string":"HealerJean","n_bigDecimal":12.12245,"n_date":1546052196927,"n_integer":100}]
  28.     //第一种方式，只针对没有使用lombok注解的情况 ，这种方式不论有没有 date类型 使用了@Data注解 就会出现下面的问题，
  29.     // 有了date那也肯定的会是这种结局 ，
  30.     // 使用的时候下面这种的时候，不要用@Data注解，所以以后就不要使用了，jsonArray来源需要是原生的
  31.     // javaBeans = JSONArray.toList(jsonArray,new JavaBean() ,new JsonConfig());
  32.     // net.sf.json.JSONObject - Property 'n_bigDecimal' of class com.hlj.data.res.test.JavaBean has no write method. SKIPPED.
  33.     // 2018-12-14 20:27:08.129 [main] INFO net.sf.json.JSONObject - Property 'n_date' of class com.hlj.data.res.test.JavaBean has no write method. SKIPPED.
  34.     // 2018-12-14 20:27:08.130 [main] INFO net.sf.json.JSONObject - Property 'n_integer' of class com.hlj.data.res.test.JavaBean has no write method. SKIPPED.
  35.     // 2018-12-14 20:27:08.130 javaBeans[main] INFO net.sf.json.JSONObject - Property 'n_long' of class com.hlj.data.res.test.JavaBean has no write method. SKIPPED.
  36.     // 2018-12-14 20:27:08.130 [main] INFO net.sf.json.JSONObject - Property 'n_string' of class com.hlj.data.res.test.JavaBean has no write method. SKIPPED.
  37.     // 2018-12-14 20:27:08.130 [main] INFO net.sf.json.JSONObject - Property 'n_bigDecimal' of class com.hlj.data.res.test.JavaBean has no write method. SKIPPED.
  38.     // 2018-12-14 20:27:08.130 [main] INFO net.sf.json.JSONObject - Property 'n_date' of class com.hlj.data.res.test.JavaBean has no write method. SKIPPED.
  39.     // 2018-12-14 20:27:08.131 [main] INFO net.sf.json.JSONObject - Property 'n_integer' of class com.hlj.data.res.test.JavaBean has no write method. SKIPPED.
  40.     // 2018-12-14 20:27:08.131 [main] INFO net.sf.json.JSONObject - Property 'n_long' of class com.hlj.data.res.test.JavaBean has no write method. SKIPPED.
  41.     // 2018-12-14 20:27:08.131 [main] INFO net.sf.json.JSONObject - Property 'n_string' of class com.hlj.data.res.test.JavaBean has no write method. SKIPPED.
  43.     }

3、工具类

  1. package com.hlj.utils;
  3. import com.fasterxml.jackson.core.JsonGenerationException;
  4. import com.fasterxml.jackson.core.JsonParseException;
  5. import com.fasterxml.jackson.core.JsonProcessingException;
  6. import com.fasterxml.jackson.core.type.TypeReference;
  7. import com.fasterxml.jackson.databind.*;
  8. import com.fasterxml.jackson.databind.type.TypeFactory;
  9. import net.sf.json.JSONArray;
  10. import net.sf.json.JSONObject;
  11. import net.sf.json.util.JSONTokener;
  12. import org.springframework.util.Assert;
  14. import java.io.IOException;
  15. import java.io.Writer;
  16. import java.lang.reflect.Type;
  18. /** * Utils - JSON */
  19. public final class JsonUtils { 
  21.     /** * ObjectMapper */
  22.     private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
  24.     static { 
  25.         // jackson 1.9 and before
  26.         //objectMapper.configure(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES, false);
  27.         // or jackson 2.0
  28.         OBJECT_MAPPER.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
  29.     }
  31.     public static ObjectMapper getObjectMapper() { 
  32.         return OBJECT_MAPPER;
  33.     }
  35.     /** * 不可实例化 */
  36.     private JsonUtils() { 
  37.     }
  39.     /** * 将对象转换为JSON字符串 * * @param value 对象 * @return JSON字符串 */
  40.     public static String toJson(Object value) { 
  41.         Assert.notNull(value, "json 不允许为空");
  42.         try { 
  43.             return OBJECT_MAPPER.writeValueAsString(value);
  44.         } catch (JsonProcessingException e) { 
  45.             throw new RuntimeException(e.getMessage(), e);
  46.         }
  47.     }
  49.     /** * 将JSON字符串转换为对象 * * @param json JSON字符串 * @param valueType 类型 * @return 对象 */
  50.     public static <T> T toObject(String json, Class<T> valueType) { 
  51.         Assert.hasText(json, "json 不允许为空");
  52.         Assert.notNull(valueType, "valueType 不允许为空");
  53.         try { 
  54.             return OBJECT_MAPPER.readValue(json, valueType);
  55.         } catch (JsonParseException e) { 
  56.             throw new RuntimeException(e.getMessage(), e);
  57.         } catch (JsonMappingException e) { 
  58.             throw new RuntimeException(e.getMessage(), e);
  59.         } catch (IOException e) { 
  60.             throw new RuntimeException(e.getMessage(), e);
  61.         }
  62.     }
  64.     /** * 将JSON字符串转换为对象 * * @param json JSON字符串 * @param typeReference 类型 可以通过这个转化为List集合 ，举例： * List<JavaBean> list = JsonUtils.toObject(jsonArrayStr, new TypeReference<List<JavaBean>>() { }); * Map<String, Object> map = JsonUtils.toObject(JsonUtils.toJson(javaBean),new TypeReference<Map<String, Object>>( ){} ); * @return 对象 */
  65.     public static <T> T toObject(String json, TypeReference<?> typeReference) { 
  66.         Assert.hasText(json, "json 不允许为空");
  67.         Assert.notNull(typeReference, "typeReference 不允许为空");
  68.         try { 
  69.             return OBJECT_MAPPER.readValue(json, typeReference);
  70.         } catch (JsonParseException e) { 
  71.             throw new RuntimeException(e.getMessage(), e);
  72.         } catch (JsonMappingException e) { 
  73.             throw new RuntimeException(e.getMessage(), e);
  74.         } catch (IOException e) { 
  75.             throw new RuntimeException(e.getMessage(), e);
  76.         }
  77.     }
  79.     /** * 将JSON字符串转换为对象 * * @param json JSON字符串 * @param javaType 类型 * @return 对象 */
  80.     public static <T> T toObject(String json, JavaType javaType) { 
  81.         Assert.hasText(json, "json 不允许为空");
  82.         Assert.notNull(javaType, "javaType 不允许为空");
  83.         try { 
  84.             return OBJECT_MAPPER.readValue(json, javaType);
  85.         } catch (JsonParseException e) { 
  86.             throw new RuntimeException(e.getMessage(), e);
  87.         } catch (JsonMappingException e) { 
  88.             throw new RuntimeException(e.getMessage(), e);
  89.         } catch (IOException e) { 
  90.             throw new RuntimeException(e.getMessage(), e);
  91.         }
  92.     }
  95.     /** * 将JSON字符串转换为树 * * @param json JSON字符串 * @return 树 */
  96.     public static JsonNode toTree(String json) { 
  97.         Assert.hasText(json, "json 不允许为空");
  98.         try { 
  99.             return OBJECT_MAPPER.readTree(json);
  100.         } catch (JsonProcessingException e) { 
  101.             throw new RuntimeException(e.getMessage(), e);
  102.         } catch (IOException e) { 
  103.             throw new RuntimeException(e.getMessage(), e);
  104.         }
  105.     }
  107.     /** * 将对象转换为JSON流 * * @param writer Writer * @param value 对象 */
  108.     public static void writeValue(Writer writer, Object value) { 
  109.         Assert.notNull(writer, "writer 不允许为空");
  110.         Assert.notNull(value, "value 不允许为空");
  111.         try { 
  112.             OBJECT_MAPPER.writeValue(writer, value);
  113.         } catch (JsonGenerationException e) { 
  114.             throw new RuntimeException(e.getMessage(), e);
  115.         } catch (JsonMappingException e) { 
  116.             throw new RuntimeException(e.getMessage(), e);
  117.         } catch (IOException e) { 
  118.             throw new RuntimeException(e.getMessage(), e);
  119.         }
  120.     }
  123.     /** * 判断是jsonobject还是jsonArrsy * 如果是jsonObject则是1 * 如果是jsonArrsy 则是2 * 如果二者都不是则返回0 * @param json * @return */
  124.     public Integer judgeJson(String json){ 
  125.         Assert.hasText(json, "json 不允许为空");
  126.         Object jsonT = new JSONTokener(json).nextValue();
  127.         if(jsonT instanceof JSONObject){ 
  128.             return 1;
  129.         }else if (jsonT instanceof JSONArray) { 
  130.             return 2 ;
  131.         }else { 
  132.             return  0;
  133.         }
  134.     }
  137.     /** * 构造类型 * @param type 类型,类，接口，枚举字段类型 （java.class） * @return 类型 */
  138.     public static JavaType constructType(Type type) { 
  139.         Assert.notNull(type, "type 不允许为空");
  140.         return TypeFactory.defaultInstance().constructType(type);
  141.     }
  143.     /** * 构造类型 * @param typeReference 类型 new TypeReference<List<JavaBean>>() { } * @return 类型 */
  144.     public static JavaType constructType(TypeReference<?> typeReference) { 
  145.         Assert.notNull(typeReference, "typeReference 不允许为空");
  146.         return TypeFactory.defaultInstance().constructType(typeReference);
  147.     }
  151.     /** * @param resString * @return String * @Description Json 格式化到控制台打印 * */
  152.     public static   String responseFormat(String resString){ 
  154.         StringBuffer jsonForMatStr = new StringBuffer();
  155.         int level = 0;
  156.         for(int index=0;index<resString.length();index++)//将字符串中的字符逐个按行输出
  157.         { 
  158.             //获取s中的每个字符
  159.             char c = resString.charAt(index);
  161.             //level大于0并且jsonForMatStr中的最后一个字符为\n,jsonForMatStr加入\t
  162.             if (level > 0  && '\n' == jsonForMatStr.charAt(jsonForMatStr.length() - 1)) { 
  163.                 jsonForMatStr.append(getLevelStr(level));
  164.             }
  165.             //遇到"{"和"["要增加空格和换行，遇到"}"和"]"要减少空格，以对应，遇到","要换行
  166.             switch (c) { 
  167.                 case '{':
  168.                 case '[':
  169.                     jsonForMatStr.append(c + "\n");
  170.                     level++;
  171.                     break;
  172.                 case ',':
  173.                     jsonForMatStr.append(c + "\n");
  174.                     break;
  175.                 case '}':
  176.                 case ']':
  177.                     jsonForMatStr.append("\n");
  178.                     level--;
  179.                     jsonForMatStr.append(getLevelStr(level));
  180.                     jsonForMatStr.append(c);
  181.                     break;
  182.                 default:
  183.                     jsonForMatStr.append(c);
  184.                     break;
  185.             }
  186.         }
  187.         return jsonForMatStr.toString();
  188.     }
  189.         /** * @param level * @return * @throws * @author lgh * @date 2018/10/29-14:29 */
  190.         private static String getLevelStr(int level) { 
  191.             StringBuffer levelStr = new StringBuffer();
  192.             for (int levelI = 0; levelI < level; levelI++) { 
  193.                 levelStr.append("\t");
  194.             }
  195.             return levelStr.toString();
  196.         }
  199. }

感兴趣的，欢迎添加博主微信，

哈，博主很乐意和各路好友交流，如果满意，请打赏博主任意金额，感兴趣的在微信转账的时候，备注您的微信或者其他联系方式。添加博主微信哦。

请下方留言吧。可与博主自由讨论哦
















微信 微信公众号 支付宝
微信 微信公众号 支付宝

发表评论

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

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

相关阅读

    相关 参数名引发的血案

    概况 今天在解决一个Bug时，修改了原先的SQL语句，在数据库执行通过之后，复制到了项目中，使用MyBatis进行查询，却屡屡报错，现在把解决问题的过程记下来 报错信

    亦凉亦凉/ 0 赞/ 316 阅读

    相关 一个“-”引发的血案

    也许你永远遇不到这样的bug的，但是你要知道什么bug都有，所以不要惊讶！ 简化场景： 拼接了这样一个字符串：1.2,2.3,0.4-flag（三个double值用逗

    清疚清疚/ 0 赞/ 385 阅读

    相关 12 Json数据引发的血案

    Json 数据可真是大红大紫一番，它实在是太容易理解了，随着 Js 的火爆它就更加『肆无忌惮』起来。我们在 Java/Kotlin 当中解析它的时候经常会用到 Gson 这个库

    野性酷女野性酷女/ 0 赞/ 206 阅读