Kryoシーケンス化と逆シーケンス化のいくつかの問題

会社の他のグループには共通の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(kryo, clazz));
serializer.setValuesCanBeNull(true);
kryo.register(HashMap.class, serializer);

CollectionSerializer serializer = new CollectionSerializer();
serializer.setElementClass(clazz, new BeanSerializer(kryo, clazz));
serializer.setElementsCanBeNull(false);
kryo.register(clazz, new BeanSerializer(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 extends AbstractList
        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[] 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 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 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);
        }
    }