kryo、fst实现序列化

水深无声 2022-12-03 09:22 283阅读 0赞

## 一、fst ##

**介绍**：FST fast-serialization 是重新实现的 Java 快速对象序列化的开发包  
**开源地址**：[https://gitee.com/mirrors/fst][https_gitee.com_mirrors_fst]  
**依赖**：

<dependency>
                <groupId>de.ruedigermoeller</groupId>
                <artifactId>fst</artifactId>
                <version>2.57</version>
            </dependency>

**代码实现**：

import lombok.Data;
    import org.nustaq.serialization.FSTConfiguration;
    import org.nustaq.serialization.FSTObjectInput;
    import org.nustaq.serialization.FSTObjectOutput;
    import org.nustaq.serialization.coders.JSONAsString;
    
    import java.io.*;
    
    public class StringText { 
    
        static FSTConfiguration conf = FSTConfiguration.createAndroidDefaultConfiguration();
    
        static void writeObject(OutputStream outputStream, FstObject fstObject) throws IOException { 
            FSTObjectOutput out = conf.getObjectOutput(outputStream);
            out.writeObject(fstObject);
            out.close();
        }
    
        static FstObject readObject(InputStream inputStream) throws Exception { 
            FSTObjectInput input = conf.getObjectInput(inputStream);
            FstObject fstObject = (FstObject) input.readObject(FstObject.class);
            input.close();
            return fstObject;
        }
    
        @Data
        public static class TS implements Serializable { 
            @JSONAsString
            byte[] bytes;
        }
    
        @Data
        static class PJ implements Serializable { 
            int a = 10;
        }
    
        @Data
        public static class FstObject{ 
            private String name;
            private int age;
        }
        
        // 2种配置 实现不同
        public static void main(String[] args) throws UnsupportedEncodingException { 
            TS t = new TS();
            FSTConfiguration conf = FSTConfiguration.createJsonConfiguration(true,false);
            byte[] bytes = conf.asByteArray(t);
            System.out.println(new String(bytes,"UTF-8"));
            FSTConfiguration fst = FSTConfiguration.createJsonConfiguration();
            PJ pojo = new PJ();
            String x = fst.asJsonString(pojo);
            System.out.println(x);
    
            FSTConfiguration conks = FSTConfiguration.createAndroidDefaultConfiguration();
            FstObject object = new FstObject();
            object.setName("test");
            object.setAge(30);
            System.out.println("serialization, " + object);
            byte[] bytes1 = conks.asByteArray(object);
            FstObject newObject = (FstObject) conks.asObject(bytes1);
            System.out.println("deSerialization, " + newObject);
        }
    }

## 二、kryo ##

**介绍**：Kryo是用于Java的快速高效的二进制对象图序列化框架。该项目的目标是高速，小尺寸和易于使用的API。每当需要将对象持久保存到文件，数据库还是通过网络时，该项目都是有用的。  
Kryo还可以执行自动的深浅复制/克隆。这是从对象到对象的直接复制，而不是从对象到字节的复制。

**开源地址**：[https://github.com/EsotericSoftware/kryo][https_github.com_EsotericSoftware_kryo]  
**依赖**：

<dependency>
                <groupId>com.esotericsoftware</groupId>
                <artifactId>kryo-shaded</artifactId>
                <version>4.0.2</version>
            </dependency>
            
            
    		<dependency>
    		    <groupId>org.objenesis</groupId>
    		    <artifactId>objenesis</artifactId>
    		    <version>3.1</version>
    		</dependency>

**代码实现**：

public interface Serializer { 
    
        /** * 序列化 * @param object * @param bytes */
        void serializer(Object object,byte[] bytes);
    
        /** * * @param object * @param bytes * @param offset * @param count */
        void serializer(Object object,byte[] bytes,int offset,int count);
    
        /** * 反序列化 * @param bytes * @param <T> * @return */
        <T> T deserializer(byte[] bytes);
    
        /** * 反序列化 * @param bytes * @param offset * @param count * @param <T> * @return */
        <T> T deserializer(byte[] bytes,int offset,int count);
    }

import com.esotericsoftware.kryo.Kryo;
    import com.esotericsoftware.kryo.io.Input;
    import com.esotericsoftware.kryo.io.Output;
    import com.esotericsoftware.kryo.serializers.BeanSerializer;
    import org.objenesis.strategy.StdInstantiatorStrategy;
    import org.springframework.stereotype.Component;
    
    
    /** * kryo实现序列化和反序列化接口 * kryo不是线程安全的，需要注意，使用独立线程实现 */
    @Component
    public class KryoSerializer implements Serializer { 
    
        //将kryo对象存储在线程中，只有这个线程可以访问到，这样保证kryo的线程安全性，ThreadLocal(线程内部存储类)
        //通过get()&set()方法读取线程内的数据
        private final ThreadLocal<Kryo> kryoThreadLocal = new ThreadLocal<Kryo>(){ 
            @Override
            protected Kryo initialValue() { 
                Kryo kryo = new Kryo();
                kryo.register(aClass, new BeanSerializer<>(kryo,aClass));
                //引用，对A对象序列化时，默认情况下kryo会在每个成员对象第一次序列化时写入一个数字，
                // 该数字逻辑上就代表了对该成员对象的引用，如果后续有引用指向该成员对象，
                // 则直接序列化之前存入的数字即可，而不需要再次序列化对象本身。
                // 这种默认策略对于成员存在互相引用的情况较有利，否则就会造成空间浪费
                // （因为没序列化一个成员对象，都多序列化一个数字），
                // 通常情况下可以将该策略关闭，kryo.setReferences(false);
                kryo.setReferences(false);
                //设置是否注册全限定名，
                kryo.setRegistrationRequired(false);
                //设置初始化策略，如果没有默认无参构造器，那么就需要设置此项,使用此策略构造一个无参构造器
                kryo.setInstantiatorStrategy(new StdInstantiatorStrategy());
                return kryo;
            }
        };
    
        private final  ThreadLocal<Output> outputThreadLocal = new ThreadLocal<>();
    
        private final  ThreadLocal<Input> inputThreadLocal = new ThreadLocal<>();
    
        private Class<?> aClass = null;
    
    
        public Class<?> getaClass() { 
            return aClass;
        }
    
        public void setaClass(Class<?> aClass) { 
            this.aClass = aClass;
        }
    
        @Override
        public void serializer(Object object, byte[] bytes) { 
            Kryo kryo = kryoThreadLocal.get();
            Output output =getOutPut(bytes);
            kryo.writeObjectOrNull(output,object,object.getClass());
            output.flush();
        }
    
        @Override
        public void serializer(Object object, byte[] bytes, int offset, int count) { 
            Kryo kryo = kryoThreadLocal.get();
            Output output =getOutPut(bytes,offset,count);
            kryo.writeObjectOrNull(output,object,object.getClass());
            output.flush();
        }
    
        @Override
        public <T> T deserializer(byte[] bytes) { 
            Kryo kryo =  kryoThreadLocal.get();
            Input input = getInPut(bytes);
            return (T)kryo.readObjectOrNull(input,aClass);
        }
    
        @Override
        public <T> T deserializer(byte[] bytes, int offset, int count){ 
            Kryo kryo = kryoThreadLocal.get();
            Input input = getInPut(bytes,offset,count);
            return (T)kryo.readObjectOrNull(input,aClass);
        }
    
        private Output getOutPut(byte[] bytes){ 
            Output output = outputThreadLocal.get();
            if(output == null){ 
                output = new Output();
                outputThreadLocal.set(new Output());
            }
            if(bytes!=null){ 
                output.setBuffer(bytes);
            }
            return output;
        }
        private Output getOutPut(byte[] bytes,int offset,int count){ 
            Output output = outputThreadLocal.get();
            if(output == null){ 
                output = new Output();
                outputThreadLocal.set(new Output());
            }
            if(bytes!=null){ 
                output.writeBytes(bytes,offset,count);
            }
            return output;
        }
        private Input getInPut(byte[] bytes){ 
            Input input = inputThreadLocal.get();
            if(input == null){ 
                input= new Input();
                outputThreadLocal.set(new Output());
            }
            if(bytes!=null){ 
                input.setBuffer(bytes);
            }
            return input;
        }
    
        private Input getInPut(byte[] bytes,int offser,int count){ 
            Input input = inputThreadLocal.get();
            if(input == null){ 
                input= new Input();
                outputThreadLocal.set(new Output());
            }
            if(bytes!=null){ 
                input.setBuffer(bytes,offser,count);
            }
            return input;
        }
    }

import com.esotericsoftware.kryo.Kryo;
    import com.esotericsoftware.kryo.pool.KryoPool;
    import lombok.Data;
    import org.objenesis.strategy.StdInstantiatorStrategy;
    
    import java.util.Arrays;
    import java.util.List;
    
    /** * kryo的对象本身不是线程安全的，所以我们有两种选择来保障线程安全。 */
    public class KryoTest { 
    
        private static final ThreadLocal<Kryo> kryoLocal = ThreadLocal.withInitial(() -> { 
            Kryo kryo = new Kryo();
            kryo.setInstantiatorStrategy(new Kryo.DefaultInstantiatorStrategy(
                    new StdInstantiatorStrategy()));
            return kryo;
        });
    
    
    
        public KryoPool newKryoPool() { 
            return new KryoPool.Builder(() -> { 
                final Kryo kryo = new Kryo();
                kryo.setInstantiatorStrategy(new Kryo.DefaultInstantiatorStrategy(
                        new StdInstantiatorStrategy()));
                return kryo;
            }).softReferences().build();
        }
    
        public static void main(String[] args) { 
            byte[] bytes =new byte[200];
            String[] strings = { "s1","s2"};
            System.out.println(Arrays.toString(bytes));
            
            KryoSerializer kryoSerializer = new KryoSerializer();
            kryoSerializer.setaClass(TestSerialization.class);
            TestSerialization testSerialization = new TestSerialization();
            testSerialization.setText("test1");
            testSerialization.setName("test2");
            testSerialization.setId(1);
            testSerialization.setFlag(false);
            testSerialization.setList(Arrays.asList(strings));
            kryoSerializer.serializer(testSerialization, bytes);
            System.out.println(testSerialization.toString());
           
            System.out.println(Arrays.toString(bytes));
           
            TestSerialization testSerialization1 = kryoSerializer.deserializer(bytes);
            System.out.println(testSerialization1.toString());
            System.out.println(Arrays.toString(bytes));
        }
    
        @Data
        public static class TestSerialization { 
            private int id;
            private String text;
            private String name;
            private boolean flag;
            private List<String> list;
        }
    }

## 三、请求与响应测试 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNDQ3MzAx_size_16_color_FFFFFF_t_70_pic_center]

[https_gitee.com_mirrors_fst]: https://gitee.com/mirrors/fst
[https_github.com_EsotericSoftware_kryo]: https://github.com/EsotericSoftware/kryo
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNDQ3MzAx_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/d0bd6bf1e61e496481e5e4df29896efb.png