Kryo 序列化与反序列化一些问题_kryo序列化反序列化_gaording的博客

CSDN博客 · · 383 次点击 · · 开始浏览    
这是一个创建于 的文章,其中的信息可能已经有所发展或是发生改变。

公司其他组有个公共的maven依赖包中的序列化与反序列化采用了kryo,所以我在新代码中也测试了下kryo,测试的时候有几个问题记录如下:

  1.kryo反序列化时是通过反射默认调用类的无参构造函数,如果类或者类的对象属性没有无参构造构造函数,则会抛出反序列化失败的异常,解决方法可以写一个继承kryo类的子类,重新实现通过反射去获取实例的方法,参考博客:https://vyloy.iteye.com/blog/1483029

2.kryo在序列化和反序列化ArrayList和HashMap时需注册ArrayList.class和HashMap.class的序列化类,才可序列化和反序列化成功

MapSerializer serializer = new MapSerializer();
serializer.setKeyClass(String.class, new JavaSerializer());
serializer.setKeysCanBeNull(false);
serializer.setValueClass(clazz, new BeanSerializer<T>(kryo, clazz));
serializer.setValuesCanBeNull(true);
kryo.register(HashMap.class, serializer);
CollectionSerializer serializer = new CollectionSerializer();
serializer.setElementClass(clazz, new BeanSerializer<T>(kryo, clazz));
serializer.setElementsCanBeNull(false);
kryo.register(clazz, new BeanSerializer<T>(kryo, clazz));
kryo.register(ArrayList.class, serializer);

3.序列化的ArrayList的字节流过大时,需显示设置输出流的大小,否则可能因默认流限制导致字节流传送有误,反序列化失败

ByteArrayOutputStream byteBufferOutputStream = new ByteArrayOutputStream();
//设置输出流大小限制为100000字节
Output output = new Output(byteBufferOutputStream,100000);
kryo.writeObject(output, list);
//kryo中io目录下的output默认设置buffersize为4096字节
public Output(OutputStream outputStream) {
        this(4096, 4096);
        if (outputStream == null) {
            throw new IllegalArgumentException("outputStream cannot be null.");
        } else {
            this.outputStream = outputStream;
        }
}

4.传输对象的List属性不能用Arrays.asList(array)形式生成,Arrays.asList(array)的返回结果是Arrays的一个内部类,不是集合ArrayList,用Arrays内部类会导致反序列化异常

    //这是Arrays中实现了RandomAccess和java.io.Serializable的一个内部类
    /**
     * @serial include
     */
    private static class ArrayList<E> extends AbstractList<E>
        implements RandomAccess, java.io.Serializable
    {
        private static final long serialVersionUID = -2764017481108945198L;
        private final E[] a;

        ArrayList(E[] array) {
            a = Objects.requireNonNull(array);
        }

        @Override
        public int size() {
            return a.length;
        }

        @Override
        public Object[] toArray() {
            return a.clone();
        }

        @Override
        @SuppressWarnings("unchecked")
        public <T> T[] toArray(T[] a) {
            int size = size();
            if (a.length < size)
                return Arrays.copyOf(this.a, size,
                                     (Class<? extends T[]>) a.getClass());
            System.arraycopy(this.a, 0, a, 0, size);
            if (a.length > size)
                a[size] = null;
            return a;
        }

        @Override
        public E get(int index) {
            return a[index];
        }

        @Override
        public E set(int index, E element) {
            E oldValue = a[index];
            a[index] = element;
            return oldValue;
        }

        @Override
        public int indexOf(Object o) {
            E[] a = this.a;
            if (o == null) {
                for (int i = 0; i < a.length; i++)
                    if (a[i] == null)
                        return i;
            } else {
                for (int i = 0; i < a.length; i++)
                    if (o.equals(a[i]))
                        return i;
            }
            return -1;
        }

        @Override
        public boolean contains(Object o) {
            return indexOf(o) != -1;
        }

        @Override
        public Spliterator<E> spliterator() {
            return Spliterators.spliterator(a, Spliterator.ORDERED);
        }

        @Override
        public void forEach(Consumer<? super E> action) {
            Objects.requireNonNull(action);
            for (E e : a) {
                action.accept(e);
            }
        }

        @Override
        public void replaceAll(UnaryOperator<E> operator) {
            Objects.requireNonNull(operator);
            E[] a = this.a;
            for (int i = 0; i < a.length; i++) {
                a[i] = operator.apply(a[i]);
            }
        }

        @Override
        public void sort(Comparator<? super E> c) {
            Arrays.sort(a, c);
        }
    }

 

383 次点击  
加入收藏 微博
暂无回复
添加一条新回复 (您需要 登录 后才能回复 没有账号 ?)
  • 请尽量让自己的回复能够对别人有帮助
  • 支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
  • 支持 @ 本站用户;支持表情(输入 : 提示),见 Emoji cheat sheet
  • 图片支持拖拽、截图粘贴等方式上传