关于数据序列化（4）自定义序列化的实现，支持常用集合框架

下面的示例很好的揭示了如何实现自定义序列化的方法。
支持byte, byte[], boolean, boolean[], int, int[], long, long[] ,double ,double[], String, String[], 以及Enum, List,Map两种包装类型，以及实现了ISerilizable的实体类。
稍加改造就可以在项目中应用

/**
 * 分布式序列化接口
 * 除了基本类型 其余数据需要分布式传输必须实现本接口
 * 注：实现本接口的类必须有无参构造函数!
 * @see SerializeTool#write(Object, java.io.DataOutputStream)
 * @see SerializeTool#read(java.io.DataInputStream)
 */
public interface ISerilizable {
public void writeTo(OutputStream out) throws IOException;
public void readFrom(InputStream in) throws IOException;
}

/**
 * 支持实现{@link ISerilizable}的类,<br>
 * 以及<b>byte,float,double,long</b>四种基本类型,<br>和
 * <b>Collection(list和set),map</b>三种集合框架,<br>和
 * <b>protobuf</b>.
 * <br>
 * TODO:循环因引用
 * @author BAO
 * @see #readFile(String fileName) 创建关闭FileInputStream DataInputStream
 * @see #read(DataInputStream in)
 * @see #readObject(DataInputStream stream) throws Exception
 * 
 */
public class SerializeTool {

/**
 * 从流中读取数据
 * 只能顺序读 会自动进行类型转换
 * @return
 */
public static <T> T read(DataInputStream stream) {
try {
return readObject(stream);
        } catch (Exception e) {
            LogCore.BASE.error("read err!", e);
throw new SysException(e);
        }
    }

/**
 * 从流中读取数据
 * 只能顺序读 会自动进行类型转换
 * @return
 */
@SuppressWarnings({ "unchecked", "rawtypes" })
private static <T> T readObject(DataInputStream stream) throws Exception {
        Object result = null;

//类型码
int wireFormat = stream.readInt();
//类型
int wireType = (wireFormat & ~ARRAY);
//是数组类型
boolean isArray = (wireFormat & ARRAY) == ARRAY;
//数组类型的长度
int arrayLen = 0;
if(isArray) {
            arrayLen = stream.readInt();
        }

//空对象
if(wireType == NULL) {
return null;
        }

//BYTE
if(wireType == BYTE) {
if(isArray) {
//result = stream.readRawBytes(arrayLen);//TODO 这个方法要调研一下! API应该提供此方法
byte[] values = new byte[arrayLen];
for(int i = 0; i < arrayLen; i++) {
                    values[i] = stream.readByte();
                }
                result = values;
            } else {
                result = stream.readByte();
            }
//BOOLEAN
        } else if(wireType == BOOLEAN) {
if(isArray) {
boolean[] values = new boolean[arrayLen];
for(int i = 0; i < arrayLen; i++) {
                    values[i] = stream.readBoolean();
                }
                result = values;
            } else {
                result = stream.readBoolean();
            }
//INT
        } else if(wireType == INT) {
if(isArray) {
int[] values = new int[arrayLen];
for(int i = 0; i < arrayLen; i++) {
                    values[i] = stream.readInt();
                }
                result = values;
            } else {
                result = stream.readInt();
            }
//LONG
        } else if(wireType == LONG) {
if(isArray) {
long[] values = new long[arrayLen];
for(int i = 0; i < arrayLen; i++) {
                    values[i] = stream.readLong();
                }
                result = values;
            } else {
                result = stream.readLong();
            }
//FLOAT
        } else if(wireType == FLOAT) {
if(isArray) {
float[] values = new float[arrayLen];
for(int i = 0; i < arrayLen; i++) {
                    values[i] = stream.readFloat();
                }
                result = values;
            } else {
                result = stream.readFloat();
            }
//DOUBLE
        } else if(wireType == DOUBLE) {
if(isArray) {
double[] values = new double[arrayLen];
for(int i = 0; i < arrayLen; i++) {
                    values[i] = stream.readDouble();
                }
                result = values;
            } else {
                result = stream.readDouble();
            }
//STRING
        } else if(wireType == STRING) {
if(isArray) {
                String[] values = new String[arrayLen];
for(int i = 0; i < arrayLen; i++) {
                    values[i] = stream.readUTF();
                }
                result = values;
            } else {
                result = stream.readUTF();
            }
//ENUM
        } else if(wireType == ENUM) {
//实际类型
            String className = stream.readUTF();
            String val = stream.readUTF();

//创建实例
            Class cls = Class.forName(className);
            result = Enum.valueOf(cls, val);

//COLLECTION LIST SET
        } else if(wireType == COLLECTION || wireType == LIST || wireType == SET) {
//长度
int len = stream.readInt();

//类型
            Collection list;
if(wireType == LIST) list = new ArrayList<>();
else if(wireType == SET) list = new HashSet<>();
else list = new ArrayList<>();  //未知Collection的具体实现 暂时一律使用arrayList子类的实现

//填充数据
for(int i = 0; i < len; i++) {
                list.add(read(stream));
            }
            result = list;

//MAP
        } else if(wireType == MAP) {
//长度
int len = stream.readInt();

//数据
            Map map = new LinkedHashMap<>();
for(int i = 0; i < len; i++) {
                Object key = read(stream);
                Object val = read(stream);

                map.put(key, val);
            }

            result = map;

//IDistributedSerilizable接口
        } else if(wireType == DISTRIBUTED) {
//实际类型
/*这种方式要提前生成常量池switch case(int)
 int id = stream.readInt();
 ISerilizable seriable = org.gof.core.CommonSerializer.create(id);
 if(seriable == null)
 seriable = _commonFunc.apply(id);
 seriable.readFrom(this);
 result = seriable;*/


            String className = stream.readUTF();
            Class<?> cls = Class.forName(className);

//创建实例并加载数据
            Constructor<?> constructor = cls.getDeclaredConstructor();
            constructor.setAccessible(true);
            ISerilizable seriable = (ISerilizable)constructor.newInstance();
            seriable.readFrom(stream);
            result = seriable;
//protobuf消息
        } else if(wireType == MSG) {

//Object[]
        } else if(wireType == OBJECT && isArray) {
            Object[] values = new Object[arrayLen];
for(int i = 0; i < arrayLen; i++) {
                values[i] = read(stream);
            }
            result = values;

//其余一律不支持
        } else {
throw new SysException("发现无法被反序列化的类型: wireType={}, isArray={}", wireType, isArray);
        }

//返回值
return (T) result;
    }
/*write*/

public static <T> T deserilize(byte[] data){
        ByteArrayInputStream in = new ByteArrayInputStream(data);
        DataInputStream stream = new DataInputStream(in);
return read(stream);
    }
/**
 * 连续读取Object到list
 */
public static <T> List<T> deserilize2List(byte[] data){
return deserilize2List(data, new ArrayList<>());
    }
public static <T> List<T> deserilize2List(byte[] data, List<T> list){
try (ByteArrayInputStream in = new ByteArrayInputStream(data);
                DataInputStream stream = new DataInputStream(in)){
while(stream.available() > 0){
                T t = read(stream);
                list.add(t);
            }
return list;
        } catch (Exception e) {
            LogCore.BASE.error("read file err:{}", e);
return null;
        }
    }
public static byte[] serlize(Object value) throws IOException {
try(ByteArrayOutputStream bout = new ByteArrayOutputStream();
            DataOutputStream stream = new DataOutputStream(bout)) {
            writeObject(value, stream);
return bout.toByteArray();
        } catch (Exception e) {
throw new SysException(e, "OutputStream写入数据失败。");
        }
    }
/**
 * 写入数据到流中
 * 仅支持
 * byte byte[] boolean boolean[] int int[] long long[] 
 * double double[] String String[] 
 * Enum枚举 List、Map两种包装类型
 * 以及实现了IDistributedSerilizable接口的类
 * @param value
 * @throws IOException
 */
public static void write(Object value, DataOutputStream stream) {
try {
            writeObject(value, stream);
//不支持序列化化的错误 要对外汇报
        } catch (Exception e) {
throw new SysException(e, "OutputStream写入数据失败。");
        }
    }

/**
 * 写入数据到流中
 * 仅支持
 * byte byte[] boolean boolean[] int int[] long long[] 
 * double double[] String String[] 
 * Enum枚举 List、Map两种包装类型
 * 以及实现了IDistributedSerilizable接口的类
 * @param value
 * @throws IOException
 */
static void writeObject(Object value, DataOutputStream stream) throws IOException {
//空对象
if(value == null) {
            stream.writeInt(NULL);
        }

//数据类型
        Class<?> clazz = value.getClass();

//BYTE
if(clazz == byte.class || clazz == Byte.class) {
            stream.writeInt(BYTE);
            stream.writeByte((byte)value);
        } else if(clazz == byte[].class) {
byte[] array = (byte[])value;
            stream.writeInt(BYTE | ARRAY);
            stream.writeInt(array.length);
            stream.write(array);
//BOOLEAN
        } else if(clazz == boolean.class || clazz == Boolean.class) {
            stream.writeInt(BOOLEAN);
            stream.writeBoolean((boolean)value);
        } else if(clazz == boolean[].class) {
boolean[] array = (boolean[])value;
            stream.writeInt(BOOLEAN | ARRAY);
            stream.writeInt(array.length);
for(int i = 0; i < array.length; i++) {
                stream.writeBoolean(array[i]);
            }
//INT
        } else if(clazz == int.class || clazz == Integer.class) {
            stream.writeInt(INT);
            stream.writeInt((int)value);
        } else if(clazz == int[].class) {
int[] array = (int[])value;
            stream.writeInt(INT | ARRAY);
            stream.writeInt(array.length);
for(int i = 0; i < array.length; i++) {
                stream.writeInt(array[i]);
            }
//LONG
        } else if(clazz == long.class || clazz == Long.class) {
            stream.writeInt(LONG);
            stream.writeLong((long)value);
        } else if(clazz == long[].class) {
long[] array = (long[])value;
            stream.writeInt(LONG | ARRAY);
            stream.writeInt(array.length);
for(int i = 0; i < array.length; i++) {
                stream.writeLong(array[i]);
            }
//FLOAT
        } else if(clazz == float.class || clazz == Float.class) {
            stream.writeFloat(FLOAT);
            stream.writeFloat((float)value);
        } else if(clazz == float[].class) {
float[] array = (float[])value;
            stream.writeInt(FLOAT | ARRAY);
            stream.writeInt(array.length);
for(int i = 0; i < array.length; i++) {
                stream.writeFloat(array[i]);
            }
//DOUBLE
        } else if(clazz == double.class || clazz == Double.class) {
            stream.writeInt(DOUBLE);
            stream.writeDouble((double)value);
        } else if(clazz == double[].class) {
double[] array = (double[])value;
            stream.writeInt(DOUBLE | ARRAY);
            stream.writeInt(array.length);
for(int i = 0; i < array.length; i++) {
                stream.writeDouble(array[i]);
            }
//STRING
        } else if(clazz == String.class) {
            stream.writeInt(STRING);
            stream.writeUTF((String)value);
        } else if(clazz == String[].class) {
            String[] array = (String[])value;
            stream.writeInt(STRING | ARRAY);
            stream.writeInt(array.length);
for(int i = 0; i < array.length; i++) {
                stream.writeUTF(array[i]);
            }
//ENUM
        } else if(value instanceof Enum) {
            Enum<?> val = (Enum<?>) value;
            stream.writeInt(ENUM);
            stream.writeUTF(val.getClass().getName());
            stream.writeUTF(val.name());

//COLLECTION LIST SET
        } else if(value instanceof Collection) {
            Collection<?> val = (Collection<?>) value;

//判断子类型
int type;
if(value instanceof List) type = LIST;
else if(value instanceof Set) type = SET;
else type = COLLECTION;

            stream.writeInt(type);
            stream.writeInt(val.size());

for(Object o : val) {
                write(o, stream);
            }

//MAP
        } else if(value instanceof Map) {
            Map<?,?> val = (Map<?,?>) value;

            stream.writeInt(MAP);
            stream.writeInt(val.size());

for(Entry<?, ?> e : val.entrySet()) {
                Object k = e.getKey();
                Object v = e.getValue();
                write(k, stream);
                write(v, stream);
            }

//IDistributedSerilizable接口
        } else if(value instanceof ISerilizable) {
            ISerilizable seriable = (ISerilizable)value;
            stream.writeInt(DISTRIBUTED);
            stream.writeInt(value.getClass().getName().hashCode());
            seriable.writeTo(stream);
//protobuf消息
// } else if(value instanceof Message) {
// Message msg = (Message)value;
// byte[] bytes = msg.toByteArray();
// 
// stream.writeInt32NoTag(MSG);
// stream.writeInt32NoTag(bytes.length); //消息长度 不包括消息类型
// stream.writeInt32NoTag(msg.getClass().getName().hashCode());
// stream.writeRawBytes(bytes);

//数组
        } else if(value instanceof Object[]) {
            Object[] array = (Object[])value;
            stream.writeInt(OBJECT | ARRAY);
            stream.writeInt(array.length);
for(Object o : array) {
                write(o, stream);
            }
//其余一律不支持
        } else {
throw new SysException("发现无法被序列化的类型:{}", clazz.getName());
        }
    }
}

思考：如何处理循环引用的问题？在json的序列化和protocol的序列化中的循环引用是如何处理的？