关于数据序列化（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的序列化中的循环引用是如何处理的？