Protostuff 序列化/反序列化集合等对象

2023-11-22 17:21| 来源: 网络整理| 查看: 265

在使用 Protostuff 的时候会遇到一些无法直接序列化/反序列化的对象，比如Map、List等。

在序列化这些无法直接序列化/反序列化的对象时，可以引入一个包装类来吧这些数据包装一下，然后对这个包装类进行序列化/反序列化。

具体实现如下：

1. 定义一个包装类

SerializeDeserializeWrapper.java

package com.butioy.commons.beans; /** *

* 序列化/反序列化对象包装类 * 专为基于 Protostuff 进行序列化/反序列化而定义。 * Protostuff 是基于POJO进行序列化和反序列化操作。 * 如果需要进行序列化/反序列化的对象不知道其类型，不能进行序列化/反序列化； * 比如Map、List、String、Enum等是不能进行正确的序列化/反序列化。 * 因此需要映入一个包装类，把这些需要序列化/反序列化的对象放到这个包装类中。 * 这样每次 Protostuff 都是对这个类进行序列化/反序列化,不会出现不能/不正常的操作出现 *

* * @author butioy */ public class SerializeDeserializeWrapper { private T data; public static SerializeDeserializeWrapper builder(T data) { SerializeDeserializeWrapper wrapper = new SerializeDeserializeWrapper(); wrapper.setData(data); return wrapper; } getter and setter... } 2. 编写Protostuff工具类

ProtostuffUtils.java

package com.butioy.commons.utils; import com.butioy.commons.beans.SerializeDeserializeWrapper; import com.google.common.collect.Maps; import io.protostuff.LinkedBuffer; import io.protostuff.ProtostuffIOUtil; import io.protostuff.Schema; import io.protostuff.runtime.RuntimeSchema; import java.util.ArrayList; import java.util.HashMap; import java.util.HashSet; import java.util.Hashtable; import java.util.LinkedList; import java.util.List; import java.util.Map; import java.util.Set; import java.util.SortedMap; import java.util.Stack; import java.util.TreeMap; import java.util.Vector; import java.util.concurrent.CopyOnWriteArrayList; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** *

* Protostuff 序列化/反序列化工具类 *

* * @author butioy */ public class ProtostuffUtils { private static Logger logger = LoggerFactory.getLogger(ProtostuffUtils.class); /** * 需要使用包装类进行序列化/反序列化的class集合 */ private static final Set, Schema> CACHE_SCHEMA = Maps.newConcurrentMap(); /** * 预定义一些Protostuff无法直接序列化/反序列化的对象 */ static { WRAPPER_SET.add(List.class); WRAPPER_SET.add(ArrayList.class); WRAPPER_SET.add(CopyOnWriteArrayList.class); WRAPPER_SET.add(LinkedList.class); WRAPPER_SET.add(Stack.class); WRAPPER_SET.add(Vector.class); WRAPPER_SET.add(Map.class); WRAPPER_SET.add(HashMap.class); WRAPPER_SET.add(TreeMap.class); WRAPPER_SET.add(Hashtable.class); WRAPPER_SET.add(SortedMap.class); WRAPPER_SET.add(Map.class); WRAPPER_SET.add(Object.class); } /** * 注册需要使用包装类进行序列化/反序列化的 Class 对象 * * @param clazz 需要包装的类型 Class 对象 */ public static void registerWrapperClass(Class clazz) { WRAPPER_SET.add(clazz); } /** * 获取序列化对象类型的schema * * @param cls 序列化对象的class * @param 序列化对象的类型 * @return 序列化对象类型的schema */ @SuppressWarnings({"unchecked", "rawtypes"}) private static Schema getSchema(Class cls) { Schema schema = (Schema) CACHE_SCHEMA.get(cls); if (schema == null) { schema = RuntimeSchema.createFrom(cls); CACHE_SCHEMA.put(cls, schema); } return schema; } /** * 序列化对象 * * @param obj 需要序列化的对象 * @param 序列化对象的类型 * @return 序列化后的二进制数组 */ @SuppressWarnings("unchecked") public static byte[] serialize(T obj) { Class clazz = (Class) obj.getClass(); LinkedBuffer buffer = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE); try { Object serializeObject = obj; Schema schema = WRAPPER_SCHEMA; if (!WRAPPER_SET.contains(clazz)) { schema = getSchema(clazz); } else { serializeObject = SerializeDeserializeWrapper.builder(obj); } return ProtostuffIOUtil.toByteArray(serializeObject, schema, buffer); } catch (Exception e) { logger.error("序列化对象异常 [" + obj + "]", e); throw new IllegalStateException(e.getMessage(), e); } finally { buffer.clear(); } } /** * 反序列化对象 * * @param data 需要反序列化的二进制数组 * @param clazz 反序列化后的对象class * @param 反序列化后的对象类型 * @return 反序列化后的对象集合 */ public static T deserialize(byte[] data, Class clazz) { try { if (!WRAPPER_SET.contains(clazz)) { T message = clazz.newInstance(); Schema schema = getSchema(clazz); ProtostuffIOUtil.mergeFrom(data, message, schema); return message; } else { SerializeDeserializeWrapper wrapper = new SerializeDeserializeWrapper(); ProtostuffIOUtil.mergeFrom(data, wrapper, WRAPPER_SCHEMA); return wrapper.getData(); } } catch (Exception e) { logger.error("反序列化对象异常 [" + clazz.getName() + "]", e); throw new IllegalStateException(e.getMessage(), e); } } } 3. 编写测试类 import com.butioy.commons.beans.SerializeDeserializeWrapper; import java.util.HashMap; import java.util.Map; /** *

* 测试类 *

* * @author butioy */ public class Main { public static void main(String[] args) { Map map = new HashMap(); map.put("key1", "butioy"); map.put("key2", "protostuff"); map.put("key3", "serialize"); SerializeDeserializeWrapper wrapper = SerializeDeserializeWrapper.builder(map); byte[] serializeBytes = ProtostuffUtils.serialize(wrapper); System.out.println("序列化map集合二进制数组长度 length=" + serializeBytes.length); SerializeDeserializeWrapper deserializeWrapper = ProtostuffUtils.deserialize(serializeBytes, SerializeDeserializeWrapper.class); System.out.println("反序列化map对象：" + deserializeWrapper.getData()); } }

输出结果这里写图片描述

好了，到此就想使用正常POJO一样使用集合进行序列化/反序列化了。本例只是更具个人的想法简单的实现，未经严格测试。如有错误，还请指正。

【本文地址】

公司简介

联系我们