网站前台展示,稻壳ppt免费模板,公司可以做网站,丰金网络 做网站我们知道#xff0c;在自定义类中#xff0c;若想完成序列化必须要实现Serializable接口。
那么在实现后如何进行序列化呢#xff1f;
一.普通对象
序列化#xff1a;
1.首先我们要定义一个 序列化所需要的工具类 ObjectMapper //定义序列化所需要的工具类 转化机器…
我们知道在自定义类中若想完成序列化必须要实现Serializable接口。
那么在实现后如何进行序列化呢
一.普通对象
序列化
1.首先我们要定义一个 序列化所需要的工具类 ObjectMapper //定义序列化所需要的工具类 转化机器ObjectMapper objectMapper new ObjectMapper();
2.定义所要序列化的类 在这里以我正在做的项目中的一个类为例 //定义所要序列化的类 转化原料CommonResultString result CommonResult.error(500, 系统错误);
3.调用objectMapper.writeValueAsString方法序列化为String //定义序列化后的类 转化产品String str null;//序列化try {str objectMapper.writeValueAsString(result);} catch (JsonProcessingException e) {e.printStackTrace();}
这个方法只有一个参数就是要序列化对象本身
打印结果 反序列化 //反序列化 JsonParser:反序列化所转化的对象 ResolvedType: 所返回的对象的类型try {CommonResultString commonResult1 objectMapper.readValue(str, CommonResult.class);System.out.println(commonResult1);} catch (JsonProcessingException e) {e.printStackTrace();}
这个方法有两个参数 JsonParser:反序列化所转化的对象str 刚序列化后的产物 ResolvedType: 所返回的对象的类型CommonResult 返回值就是原本对象
打印结果 二.List对象
序列化
1.定义ObjectMapper 上文已经定义过
2.初始化所要序列化的List用于演示
3.调用objectMapper.writeValueAsString可见与普通对象无差别
真正的区别在反序列化 //序列化 ListListCommonResultString list Arrays.asList(CommonResult.success(success1),CommonResult.success(success2));try {str objectMapper.writeValueAsString(list);System.out.println(str);} catch (JsonProcessingException e) {e.printStackTrace();}
反序列化
因为我们不能保证在每个List中存放的类型一致所以在objectMapper.readValue方法的第二个参数类型不能保持一致这里引入一个新参数JavaType也就是反序列化调用的方法参数 看名字就知道它是用于描述java中类型的我们看看他怎么用的。 JavaType javaType objectMapper.getTypeFactory().constructParametricType(List.class, CommonResult.class);
1.调用objectMapper的类型工厂objectMapper.getTypeFactory(充当工具
2.获取JavaType constructParametricType(
这个方法有多个重载这里有两个参数
第一个不会变要序列化的对象类型List
第二个List中的属性类型CommonResult
在Map中由于Map有两个参数所以会有第三个参数按顺序写即可
然后调用objectMapper.readValue即可 ListCommonResultString result2 null;try {result2 objectMapper.readValue(str, javaType);// System.out.println(result2);for(CommonResultString a : result2) {System.out.println(a.getData());}} catch (JsonProcessingException e) {e.printStackTrace();}
三.Map对象
还是按照前文注意constructParametricType(方法传入三个参数即可 //序列化 MapMapInteger, CommonResultString map new HashMap();map.put(3,CommonResult.success(success3));map.put(4,CommonResult.success(success4));try {str objectMapper.writeValueAsString(map);System.out.println(str);} catch (JsonProcessingException e) {e.printStackTrace();}//反序列化 先构造一个所需要的参数类型 Map类型 内部是什么类型JavaType javaType2 objectMapper.getTypeFactory().constructParametricType(Map.class, Integer.class, CommonResult.class);MapInteger, CommonResultString result3 null;try {result3 objectMapper.readValue(str, javaType2);// System.out.println(result2);System.out.println(map.get(3).getCode());} catch (JsonProcessingException e) {e.printStackTrace();}
四.封装成方法
在上述写过程中try了许多的异常非常的冗余我们可以参考一下JacksonJsonParser源码对这个问题解决方法。
在源码部分对List与Map是这样实现的 public MapString, Object parseMap(String json) {return (Map)this.tryParse(() - {return (Map)this.getObjectMapper().readValue(json, MAP_TYPE);}, Exception.class);}public ListObject parseList(String json) {return (List)this.tryParse(() - {return (List)this.getObjectMapper().readValue(json, LIST_TYPE);}, Exception.class);}
我们发现它并没有进行异常捕获进入tryParse(方法看一下 protected final T T tryParse(CallableT parser, Class? extends Exception check) {try {return parser.call();} catch (Exception var4) {if (check.isAssignableFrom(var4.getClass())) {throw new JsonParseException(var4);} else {ReflectionUtils.rethrowRuntimeException(var4);throw new IllegalStateException(var4);}}}
原来是在这里进行了异常处理。通过在tryParse方法传入lambda表达式然后再call()返回这一步并没有进行实际业务执行单纯为了将处理异常这一步统一处理。再判断调用lambda时不活的异常是否是原业务的异常如果不是就再爆其他的异常。
我们参照这个解决逻辑完成一个在项目中使用的JacksonUtil类。
同时注意到在源码部分对ObjectMapper这个一直用的对象进行了单例模式的实现我们也学习一下。
1.单例模式实现ObjectMapper /*** 单例模式实现ObjectMapper*/private static final ObjectMapper OBJECT_MAPPER;static {OBJECT_MAPPER new ObjectMapper();}//构造方法私有化private JacksonUtil() {}//获取OBJECT_MAPPER对象public ObjectMapper getObjectMapper() {return JacksonUtil.OBJECT_MAPPER;}
2.解决try catch太多的方法
我们可以直接复制源码部分的tryParse代码
只需把final改为static方便其他方法调用
else判断的部分也可以不要jdk自己对异常的补充可以不要 protected static T T tryParse(CallableT parser, Class? extends Exception check) {try {return parser.call();} catch (Exception var4) {if (check.isAssignableFrom(var4.getClass())) {throw new JsonParseException(var4);}throw new IllegalStateException(var4);}}
我们可以对这个方法进行封装一下 /*** 封装tryParse方法 使其固定爆出JacksonException异常* param parser 传入的lambda表达式* param T* return*/private final T T tryParse(CallableT parser) {return JacksonUtil.tryParse(parser, JacksonException.class);}
3.实现序列化
由于普通对象与List Map的序列化过程几乎相同所以我们一个方法就可以实现。 /*** 序列化 对普通对象 与 List 都适用* param object* return*/public static String writeValueAsString(Object object) {return JacksonUtil.tryParse(() - {return JacksonUtil.getObjectMapper().writeValueAsString(object);});}4.实现反序列化
普通对象序列化 /*** 普通对象反序列化* param content* param valueType* param T* return*/public static T T readValue(String content, ClassT valueType) {return JacksonUtil.tryParse(() - {return JacksonUtil.getObjectMapper().readValue(content, valueType);});}
List反序列化注意将第二个参数类型改为 Class?而不是 ClassT /*** 反序列化 List* param content* param paramClasses* param T* return*/public static T T readListValue (String content, Class? paramClasses) {JavaType javaType JacksonUtil.getObjectMapper().getTypeFactory().constructParametricType(List.class, paramClasses);return JacksonUtil.tryParse(() - {return JacksonUtil.getObjectMapper().readValue(content, javaType);});}
最后附上测试代码 Testvoid jackUtilTest() {CommonResultString result CommonResult.error(500, 系统错误);String str JacksonUtil.writeValueAsString(result);System.out.println(str);CommonResultString commonResult JacksonUtil.readValue(str, CommonResult.class);System.out.println(commonResult);//序列化 ListListCommonResultString list Arrays.asList(CommonResult.success(success1),CommonResult.success(success2));String str1 JacksonUtil.writeValueAsString(list);System.out.println(str1);list JacksonUtil.readListValue(str1, CommonResult.class);for(CommonResultString a : list) {System.out.println(a.getData());}}
