Kryo序列化及反序列化用法示例

更新时间：2017年10月09日 10:50:50 作者：nettm

这篇文章主要介绍了Kryo序列化及反序列化用法示例，小编觉得挺不错的，这里分享给大家，需要的朋友可以参考下。

Kryo 是一个快速高效的 Java 对象图形序列化框架，主要特点是性能、高效和易用。该项目用来序列化对象到文件、数据库或者网络。

代码地址：https://github.com/EsotericSoftware/kryo

Kryo的序列化及反序列速度很快，据说很多大公司都在用。我在把对象序列化都转换成了字符串形式，是为了把对象存储到缓存中。我们日常项目中使用的数据形式包括对象、List、Set和Map，因此主要把这几种类型的数据进行了序列化及反序列化，支持对象中包含List、Set和Map。

首先在项目的pom文件中引入：

<dependency>
  <groupId>com.esotericsoftware</groupId>
  <artifactId>kryo-shaded</artifactId>
  <version>3.0.3</version>
</dependency>

代码KryoTest：

package com.nettm.serializable;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.commons.codec.binary.Base64;
import org.testng.Assert;
import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Test;
import com.esotericsoftware.kryo.Kryo;
import com.esotericsoftware.kryo.io.Input;
import com.esotericsoftware.kryo.io.Output;
import com.esotericsoftware.kryo.serializers.CollectionSerializer;
import com.esotericsoftware.kryo.serializers.JavaSerializer;
import com.esotericsoftware.kryo.serializers.MapSerializer;
public class KryoTest {
  private long time;
  @BeforeTest
  public void beforeTest() {
    time = System.currentTimeMillis();
  }
  @AfterTest
  public void afterTest() {
    System.out.println(System.currentTimeMillis() - time);
  }
  @Test(invocationCount = 1, threadPoolSize = 1)
  public void testObject() {
    CustomItemDto val = new CustomItemDto();
    val.setId(Long.parseLong(String.valueOf(1)));
    val.setItemCode("");
    val.setItemDespositPrice(32.45);
    val.setItemMemo(null);
    val.setItemName("张金");
    val.setItemPrice(89.02);
    val.setSort(10);
    String a = serializationObject(val);
    CustomItemDto newValue = deserializationObject(a, CustomItemDto.class);
    Assert.assertEquals(val.getId(), newValue.getId());
  }
  @Test(invocationCount = 1, threadPoolSize = 1)
  public void testList() {
    List<CustomItemDto> lst = new ArrayList<CustomItemDto>();
    for (int i = 0; i < 10; i++) {
      CustomItemDto val = new CustomItemDto();
      val.setId(Long.parseLong(String.valueOf(i)));
      val.setItemCode("");
      val.setItemDespositPrice(32.45);
      val.setItemMemo(null);
      val.setItemName("张金");
      val.setItemPrice(89.02);
      val.setSort(10);
      lst.add(val);
    }
    String a = serializationList(lst, CustomItemDto.class);
    List<CustomItemDto> newValue = deserializationList(a,
        CustomItemDto.class);
    Assert.assertEquals(lst.size(), newValue.size());
  }
  @Test(invocationCount = 1, threadPoolSize = 1)
  public void testBean() {
    List<CustomCategoryDto> lst = new ArrayList<CustomCategoryDto>();
    for (int j = 0; j < 10; j++) {
      CustomCategoryDto dto = new CustomCategoryDto();
      dto.setCategoryCode("ABCD_001");
      dto.setCategoryName("呼吸系统");
      for (int i = 0; i < 10; i++) {
        CustomItemDto val = new CustomItemDto();
        val.setId(Long.parseLong(String.valueOf(i)));
        val.setItemCode("");
        val.setItemDespositPrice(32.45);
        val.setItemMemo(null);
        val.setItemName("张金");
        val.setItemPrice(89.02);
        val.setSort(10);
        dto.getCustomItemList().add(val);
      }
      for (int i = 0; i < 10; i++) {
        CustomItemDto val = new CustomItemDto();
        val.setId(Long.parseLong(String.valueOf(i)));
        val.setItemCode("");
        val.setItemDespositPrice(32.45);
        val.setItemMemo(null);
        val.setItemName("张金");
        val.setItemPrice(89.02);
        val.setSort(10);
        dto.getCustomItemSet().add(val);
      }
      for (int i = 0; i < 10; i++) {
        CustomItemDto val = new CustomItemDto();
        val.setId(Long.parseLong(String.valueOf(i)));
        val.setItemCode("");
        val.setItemDespositPrice(32.45);
        val.setItemMemo(null);
        val.setItemName("张金");
        val.setItemPrice(89.02);
        val.setSort(10);
        dto.getCustomItemMap().put(String.valueOf(i), val);
      }
      lst.add(dto);
    }
    String a = serializationList(lst, CustomCategoryDto.class);
    List<CustomCategoryDto> newValue = deserializationList(a,
        CustomCategoryDto.class);
    Assert.assertEquals(lst.size(), newValue.size());
  }
  @Test(invocationCount = 1, threadPoolSize = 1)
  public void testMap() {
    Map<String, CustomItemDto> map = new HashMap<String, CustomItemDto>();
    for (int i = 0; i < 10; i++) {
      CustomItemDto val = new CustomItemDto();
      val.setId(Long.parseLong(String.valueOf(i)));
      val.setItemCode("");
      val.setItemDespositPrice(32.45);
      val.setItemMemo(null);
      val.setItemName("张金");
      val.setItemPrice(89.02);
      val.setSort(10);
      map.put(new ObjectId().toString(), val);
    }
    String a = serializationMap(map, CustomItemDto.class);
    Map<String, CustomItemDto> newValue = deserializationMap(a,
        CustomItemDto.class);
    Assert.assertEquals(map.size(), newValue.size());
  }
  @Test(invocationCount = 1, threadPoolSize = 1)
  public void testSet() {
    Set<CustomItemDto> set = new HashSet<CustomItemDto>();
    for (int i = 0; i < 10; i++) {
      CustomItemDto val = new CustomItemDto();
      val.setId(Long.parseLong(String.valueOf(i)));
      val.setItemCode("");
      val.setItemDespositPrice(32.45);
      val.setItemMemo(null);
      val.setItemName("金星");
      val.setItemPrice(89.02);
      val.setSort(10);
      set.add(val);
    }
    String a = serializationSet(set, CustomItemDto.class);
    Set<CustomItemDto> newValue = deserializationSet(a, CustomItemDto.class);
    Assert.assertEquals(set.size(), newValue.size());
  }
  private <T extends Serializable> String serializationObject(T obj) {
    Kryo kryo = new Kryo();
    kryo.setReferences(false);
    kryo.register(obj.getClass(), new JavaSerializer());
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    Output output = new Output(baos);
    kryo.writeClassAndObject(output, obj);
    output.flush();
    output.close();
    byte[] b = baos.toByteArray();
    try {
      baos.flush();
      baos.close();
    } catch (IOException e) {
      e.printStackTrace();
    }
    return new String(new Base64().encode(b));
  }
  @SuppressWarnings("unchecked")
  private <T extends Serializable> T deserializationObject(String obj,
      Class<T> clazz) {
    Kryo kryo = new Kryo();
    kryo.setReferences(false);
    kryo.register(clazz, new JavaSerializer());
    ByteArrayInputStream bais = new ByteArrayInputStream(
        new Base64().decode(obj));
    Input input = new Input(bais);
    return (T) kryo.readClassAndObject(input);
  }
  private <T extends Serializable> String serializationList(List<T> obj,
      Class<T> clazz) {
    Kryo kryo = new Kryo();
    kryo.setReferences(false);
    kryo.setRegistrationRequired(true);
    CollectionSerializer serializer = new CollectionSerializer();
    serializer.setElementClass(clazz, new JavaSerializer());
    serializer.setElementsCanBeNull(false);
    kryo.register(clazz, new JavaSerializer());
    kryo.register(ArrayList.class, serializer);
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    Output output = new Output(baos);
    kryo.writeObject(output, obj);
    output.flush();
    output.close();
    byte[] b = baos.toByteArray();
    try {
      baos.flush();
      baos.close();
    } catch (IOException e) {
      e.printStackTrace();
    }
    return new String(new Base64().encode(b));
  }
  @SuppressWarnings("unchecked")
  private <T extends Serializable> List<T> deserializationList(String obj,
      Class<T> clazz) {
    Kryo kryo = new Kryo();
    kryo.setReferences(false);
    kryo.setRegistrationRequired(true);
    CollectionSerializer serializer = new CollectionSerializer();
    serializer.setElementClass(clazz, new JavaSerializer());
    serializer.setElementsCanBeNull(false);
    kryo.register(clazz, new JavaSerializer());
    kryo.register(ArrayList.class, serializer);
    ByteArrayInputStream bais = new ByteArrayInputStream(
        new Base64().decode(obj));
    Input input = new Input(bais);
    return (List<T>) kryo.readObject(input, ArrayList.class, serializer);
  }
  private <T extends Serializable> String serializationMap(
      Map<String, T> obj, Class<T> clazz) {
    Kryo kryo = new Kryo();
    kryo.setReferences(false);
    kryo.setRegistrationRequired(true);
    MapSerializer serializer = new MapSerializer();
    serializer.setKeyClass(String.class, new JavaSerializer());
    serializer.setKeysCanBeNull(false);
    serializer.setValueClass(clazz, new JavaSerializer());
    serializer.setValuesCanBeNull(true);
    kryo.register(clazz, new JavaSerializer());
    kryo.register(HashMap.class, serializer);
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    Output output = new Output(baos);
    kryo.writeObject(output, obj);
    output.flush();
    output.close();
    byte[] b = baos.toByteArray();
    try {
      baos.flush();
      baos.close();
    } catch (IOException e) {
      e.printStackTrace();
    }
    return new String(new Base64().encode(b));
  }
  @SuppressWarnings("unchecked")
  private <T extends Serializable> Map<String, T> deserializationMap(
      String obj, Class<T> clazz) {
    Kryo kryo = new Kryo();
    kryo.setReferences(false);
    kryo.setRegistrationRequired(true);
    MapSerializer serializer = new MapSerializer();
    serializer.setKeyClass(String.class, new JavaSerializer());
    serializer.setKeysCanBeNull(false);
    serializer.setValueClass(clazz, new JavaSerializer());
    serializer.setValuesCanBeNull(true);
    kryo.register(clazz, new JavaSerializer());
    kryo.register(HashMap.class, serializer);
    ByteArrayInputStream bais = new ByteArrayInputStream(
        new Base64().decode(obj));
    Input input = new Input(bais);
    return (Map<String, T>) kryo.readObject(input, HashMap.class,
        serializer);
  }
  public static <T extends Serializable> String serializationSet(Set<T> obj,
      Class<T> clazz) {
    Kryo kryo = new Kryo();
    kryo.setReferences(false);
    kryo.setRegistrationRequired(true);
    CollectionSerializer serializer = new CollectionSerializer();
    serializer.setElementClass(clazz, new JavaSerializer());
    serializer.setElementsCanBeNull(false);
    kryo.register(clazz, new JavaSerializer());
    kryo.register(HashSet.class, serializer);
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    Output output = new Output(baos);
    kryo.writeObject(output, obj);
    output.flush();
    output.close();
    byte[] b = baos.toByteArray();
    try {
      baos.flush();
      baos.close();
    } catch (IOException e) {
      e.printStackTrace();
    }
    return new String(new Base64().encode(b));
  }
  @SuppressWarnings("unchecked")
  public static <T extends Serializable> Set<T> deserializationSet(
      String obj, Class<T> clazz) {
    Kryo kryo = new Kryo();
    kryo.setReferences(false);
    kryo.setRegistrationRequired(true);
    CollectionSerializer serializer = new CollectionSerializer();
    serializer.setElementClass(clazz, new JavaSerializer());
    serializer.setElementsCanBeNull(false);
    kryo.register(clazz, new JavaSerializer());
    kryo.register(HashSet.class, serializer);
    ByteArrayInputStream bais = new ByteArrayInputStream(
        new Base64().decode(obj));
    Input input = new Input(bais);
    return (Set<T>) kryo.readObject(input, HashSet.class, serializer);
  }
}

总结

以上就是本文关于Kryo序列化及反序列化用法示例的全部内容，希望对大家有所帮助。感兴趣的朋友可以参阅：java原生序列化和Kryo序列化性能实例对比分析、 Kryo框架使用方法代码示例等，有什么问题可以随时留言，小编一定竭尽所能，答您所问。

您可能感兴趣的文章:

java组件smartupload实现上传文件功能
这篇文章主要为大家详细介绍了java组件smartupload实现上传文件功能,具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2016-10-10
MyBatis后端对数据库进行增删改查等操作实例
Mybatis是appach下开源的一款持久层框架,通过xml与java文件的紧密配合,避免了JDBC所带来的一系列问题,下面这篇文章主要给大家介绍了关于MyBatis后端对数据库进行增删改查等操作的相关资料,需要的朋友可以参考下
2022-08-08
解决Spring Mvc中对象绑定参数重名的问题
最近在工作中遇到了参数绑定的一个问题，发现网上这方面的资料较少，索性自己来总结下，下面这篇文章主要给大家介绍了关于如何解决Spring Mvc中对象绑定参数重名问题的相关资料，需要的朋友可以参考借鉴，下面来一起看看吧。
2017-08-08
java中堆和栈的区别分析
这篇文章主要介绍了java中堆和栈的区别,分析了Java中堆和栈的原理及使用时的注意事项,需要的朋友可以参考下
2014-09-09
Mybatis的详细使用教程
这篇文章主要介绍了Mybatis的详细使用教程,非常不错，具有参考借鉴价值，需要的朋友可以参考下
2016-12-12
Java实现简易的分词器功能
搜索功能是具备数据库功能的系统的一大重要特性和功能,生活中常见的搜索功能基本上都具备了分词搜索功能.然而ES功能固然强大,但对于学生或小项目而言整合起来太费人力物力,若是写个分词器就会使项目锦上添花,使其不仅仅是只能单关键词搜索的系统,需要的朋友可以参考下
2021-06-06
Mybatis中注入执行sql查询、更新、新增及建表语句案例代码
这篇文章主要介绍了Mybatis中注入执行sql查询、更新、新增以及建表语句,主要说明一个另类的操作，注入sql，并使用mybatis执行，结合案例代码详解讲解，需要的朋友可以参考下
2023-02-02
idea如何快速查找一个类或类中方法名和变量
这篇文章主要介绍了idea如何快速查找一个类或类中方法名和变量问题,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
2023-11-11
Java使用ByteArrayOutputStream 和 ByteArrayInputStream 避免重复读取配置文
这篇文章主要介绍了Java使用ByteArrayOutputStream 和 ByteArrayInputStream 避免重复读取配置文件的方法,需要的朋友可以参考下
2015-12-12
Spring-data-redis操作redis cluster的示例代码
这篇文章主要介绍了Spring-data-redis操作redis cluster的示例代码，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
2018-10-10

Kryo序列化及反序列化用法示例

相关文章

最新评论

大家感兴趣的内容

最近更新的内容

常用在线小工具