Quelles sont les méthodes de sérialisation couramment utilisées en Java ? Prenons Kryo, Protostuff et Hessian comme exemples pour expliquer leurs principes de mise en œuvre.
- 王林avant
- 2023-05-07 21:01:07847parcourir
Avant-propos
Il y a quelque temps, lors de l'écriture du framework RPC, j'ai utilisé trois méthodes de sérialisation : Kryo, Hessian et Protostuff. Mais à cette époque, parce que j'étais impatient d'implémenter la fonction, j'ai juste brièvement examiné comment utiliser ces trois méthodes de sérialisation, sans me plonger dans les caractéristiques, avantages et inconvénients respectifs. Après avoir su que j'ai fini d'écrire le framework RPC maintenant, j'ai le temps de me calmer et de faire une comparaison et un résumé des trois méthodes.
Kryo, Hessain et Protostuff sont tous des frameworks de sérialisation/désérialisation open source tiers Pour comprendre leurs caractéristiques respectives, nous devons d'abord savoir ce qu'est la sérialisation/désérialisation :
Sérialisation : C'est tout Le processus de conversion. un objet en une séquence d’octets.
Désérialisation : Il s'agit du processus de conversion de séquences d'octets en objets.
sérialisation Sérialisation : Convertissez les objets dans un format qui facilite la transmission. Formats de sérialisation courants : format binaire, tableau d'octets, chaîne json, chaîne xml.
désérialisation Désérialisation : Le processus de restauration de données sérialisées sur des objets
Si les étudiants ne sont pas très clairs sur les concepts liés à la sérialisation, vous pouvez vous référer à la sérialisation et à la désérialisation de l'équipe technique Meituan
Comparaison des performances
Préparation
Nous créons d'abord un nouveau projet Maven
puis importons les dépendances
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>
<version>5.8.2</version>
<scope>test</scope>
</dependency>
<!-- 代码简化 -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.20</version>
</dependency>
<!--kryo-->
<dependency>
<groupId>com.esotericsoftware</groupId>
<artifactId>kryo-shaded</artifactId>
<version>4.0.2</version>
</dependency>
<dependency>
<groupId>commons-codec</groupId>
<artifactId>commons-codec</artifactId>
<version>1.10</version>
</dependency>
<!--protostuff-->
<dependency>
<groupId>io.protostuff</groupId>
<artifactId>protostuff-core</artifactId>
<version>1.7.2</version>
</dependency>
<dependency>
<groupId>io.protostuff</groupId>
<artifactId>protostuff-runtime</artifactId>
<version>1.7.2</version>
</dependency>
<!--hessian2-->
<dependency>
<groupId>com.caucho</groupId>
<artifactId>hessian</artifactId>
<version>4.0.62</version>
</dependency>Classe d'outils :
kryo
package cuit.pymjl.utils;
import com.esotericsoftware.kryo.Kryo;
import com.esotericsoftware.kryo.io.Input;
import com.esotericsoftware.kryo.io.Output;
import org.apache.commons.codec.binary.Base64;
import org.objenesis.strategy.StdInstantiatorStrategy;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.UnsupportedEncodingException;
/**
* @author Pymjl
* @version 1.0
* @date 2022/4/18 20:07
**/
@SuppressWarnings("all")
public class KryoUtils {
private static final String DEFAULT_ENCODING = "UTF-8";
//每个线程的 Kryo 实例
private static final ThreadLocal<Kryo> KRYO_LOCAL = new ThreadLocal<Kryo>() {
@Override
protected Kryo initialValue() {
Kryo kryo = new Kryo();
/**
* 不要轻易改变这里的配置！更改之后，序列化的格式就会发生变化，
* 上线的同时就必须清除 Redis 里的所有缓存，
* 否则那些缓存再回来反序列化的时候，就会报错
*/
//支持对象循环引用（否则会栈溢出）
kryo.setReferences(true); //默认值就是 true，添加此行的目的是为了提醒维护者，不要改变这个配置
//不强制要求注册类（注册行为无法保证多个 JVM 内同一个类的注册编号相同；而且业务系统中大量的 Class 也难以一一注册）
kryo.setRegistrationRequired(false); //默认值就是 false，添加此行的目的是为了提醒维护者，不要改变这个配置
//Fix the NPE bug when deserializing Collections.
((Kryo.DefaultInstantiatorStrategy) kryo.getInstantiatorStrategy())
.setFallbackInstantiatorStrategy(new StdInstantiatorStrategy());
return kryo;
}
};
/**
* 获得当前线程的 Kryo 实例
*
* @return 当前线程的 Kryo 实例
*/
public static Kryo getInstance() {
return KRYO_LOCAL.get();
}
//-----------------------------------------------
// 序列化/反序列化对象，及类型信息
// 序列化的结果里，包含类型的信息
// 反序列化时不再需要提供类型
//-----------------------------------------------
/**
* 将对象【及类型】序列化为字节数组
*
* @param obj 任意对象
* @param <T> 对象的类型
* @return 序列化后的字节数组
*/
public static <T> byte[] writeToByteArray(T obj) {
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
Output output = new Output(byteArrayOutputStream);
Kryo kryo = getInstance();
kryo.writeClassAndObject(output, obj);
output.flush();
return byteArrayOutputStream.toByteArray();
}
/**
* 将对象【及类型】序列化为 String
* 利用了 Base64 编码
*
* @param obj 任意对象
* @param <T> 对象的类型
* @return 序列化后的字符串
*/
public static <T> String writeToString(T obj) {
try {
return new String(Base64.encodeBase64(writeToByteArray(obj)), DEFAULT_ENCODING);
} catch (UnsupportedEncodingException e) {
throw new IllegalStateException(e);
}
}
/**
* 将字节数组反序列化为原对象
*
* @param byteArray writeToByteArray 方法序列化后的字节数组
* @param <T> 原对象的类型
* @return 原对象
*/
@SuppressWarnings("unchecked")
public static <T> T readFromByteArray(byte[] byteArray) {
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArray);
Input input = new Input(byteArrayInputStream);
Kryo kryo = getInstance();
return (T) kryo.readClassAndObject(input);
}
/**
* 将 String 反序列化为原对象
* 利用了 Base64 编码
*
* @param str writeToString 方法序列化后的字符串
* @param <T> 原对象的类型
* @return 原对象
*/
public static <T> T readFromString(String str) {
try {
return readFromByteArray(Base64.decodeBase64(str.getBytes(DEFAULT_ENCODING)));
} catch (UnsupportedEncodingException e) {
throw new IllegalStateException(e);
}
}
//-----------------------------------------------
// 只序列化/反序列化对象
// 序列化的结果里，不包含类型的信息
//-----------------------------------------------
/**
* 将对象序列化为字节数组
*
* @param obj 任意对象
* @param <T> 对象的类型
* @return 序列化后的字节数组
*/
public static <T> byte[] writeObjectToByteArray(T obj) {
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
Output output = new Output(byteArrayOutputStream);
Kryo kryo = getInstance();
kryo.writeObject(output, obj);
output.flush();
return byteArrayOutputStream.toByteArray();
}
/**
* 将对象序列化为 String
* 利用了 Base64 编码
*
* @param obj 任意对象
* @param <T> 对象的类型
* @return 序列化后的字符串
*/
public static <T> String writeObjectToString(T obj) {
try {
return new String(Base64.encodeBase64(writeObjectToByteArray(obj)), DEFAULT_ENCODING);
} catch (UnsupportedEncodingException e) {
throw new IllegalStateException(e);
}
}
/**
* 将字节数组反序列化为原对象
*
* @param byteArray writeToByteArray 方法序列化后的字节数组
* @param clazz 原对象的 Class
* @param <T> 原对象的类型
* @return 原对象
*/
@SuppressWarnings("unchecked")
public static <T> T readObjectFromByteArray(byte[] byteArray, Class<T> clazz) {
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArray);
Input input = new Input(byteArrayInputStream);
Kryo kryo = getInstance();
return kryo.readObject(input, clazz);
}
/**
* 将 String 反序列化为原对象
* 利用了 Base64 编码
*
* @param str writeToString 方法序列化后的字符串
* @param clazz 原对象的 Class
* @param <T> 原对象的类型
* @return 原对象
*/
public static <T> T readObjectFromString(String str, Class<T> clazz) {
try {
return readObjectFromByteArray(Base64.decodeBase64(str.getBytes(DEFAULT_ENCODING)), clazz);
} catch (UnsupportedEncodingException e) {
throw new IllegalStateException(e);
}
}
}He ssian
package cuit.pymjl.utils;
import com.caucho.hessian.io.Hessian2Input;
import com.caucho.hessian.io.Hessian2Output;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
/**
* @author Pymjl
* @version 1.0
* @date 2022/7/2 12:39
**/
public class HessianUtils {
/**
* 序列化
*
* @param obj obj
* @return {@code byte[]}
*/
public static byte[] serialize(Object obj) {
Hessian2Output ho = null;
ByteArrayOutputStream baos = null;
try {
baos = new ByteArrayOutputStream();
ho = new Hessian2Output(baos);
ho.writeObject(obj);
ho.flush();
return baos.toByteArray();
} catch (Exception ex) {
ex.printStackTrace();
throw new RuntimeException("serialize failed");
} finally {
if (null != ho) {
try {
ho.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (null != baos) {
try {
baos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/**
* 反序列化
*
* @param bytes 字节
* @param clazz clazz
* @return {@code T}
*/
public static <T> T deserialize(byte[] bytes, Class<T> clazz) {
Hessian2Input hi = null;
ByteArrayInputStream bais = null;
try {
bais = new ByteArrayInputStream(bytes);
hi = new Hessian2Input(bais);
Object o = hi.readObject();
return clazz.cast(o);
} catch (Exception ex) {
throw new RuntimeException("deserialize failed");
} finally {
if (null != hi) {
try {
hi.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (null != bais) {
try {
bais.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}Protostuff
package cuit.pymjl.utils;
import io.protostuff.LinkedBuffer;
import io.protostuff.ProtostuffIOUtil;
import io.protostuff.Schema;
import io.protostuff.runtime.RuntimeSchema;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
* @author Pymjl
* @version 1.0
* @date 2022/6/28 21:00
**/
public class ProtostuffUtils {
/**
* 避免每次序列化都重新申请Buffer空间
* 这个字段表示，申请一个内存空间用户缓存，LinkedBuffer.DEFAULT_BUFFER_SIZE表示申请了默认大小的空间512个字节，
* 我们也可以使用MIN_BUFFER_SIZE，表示256个字节。
*/
private static final LinkedBuffer BUFFER = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE);
/**
* 缓存Schema
* 这个字段表示缓存的Schema。那这个Schema是什么呢？就是一个组织结构，就好比是数据库中的表、视图等等这样的组织机构，
* 在这里表示的就是序列化对象的结构。
*/
private static final Map<Class<?>, Schema<?>> SCHEMA_CACHE = new ConcurrentHashMap<>();
/**
* 序列化方法，把指定对象序列化成字节数组
*
* @param obj 对象
* @return byte[]
*/
@SuppressWarnings("unchecked")
public static <T> byte[] serialize(T obj) {
Class<T> clazz = (Class<T>) obj.getClass();
Schema<T> schema = getSchema(clazz);
byte[] data;
try {
data = ProtostuffIOUtil.toByteArray(obj, schema, BUFFER);
} finally {
BUFFER.clear();
}
return data;
}
/**
* 反序列化方法，将字节数组反序列化成指定Class类型
*
* @param data 字节数组
* @param clazz 字节码
* @return
*/
public static <T> T deserialize(byte[] data, Class<T> clazz) {
Schema<T> schema = getSchema(clazz);
T obj = schema.newMessage();
ProtostuffIOUtil.mergeFrom(data, obj, schema);
return obj;
}
@SuppressWarnings("unchecked")
private static <T> Schema<T> getSchema(Class<T> clazz) {
Schema<T> schema = (Schema<T>) SCHEMA_CACHE.get(clazz);
if (schema == null) {
schema = RuntimeSchema.getSchema(clazz);
if (schema == null) {
SCHEMA_CACHE.put(clazz, schema);
}
}
return schema;
}
}Créer une classe d'entité pour les tests :
package cuit.pymjl.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serial;
import java.io.Serializable;
/**
* @author Pymjl
* @version 1.0
* @date 2022/7/2 12:32
**/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student implements Serializable {
@Serial
private static final long serialVersionUID = -91809837793898L;
private String name;
private String password;
private int age;
private String address;
private String phone;
}Comparaison de l'espace occupé par les octets après la sérialisation
Écrire une classe de test :
public class MainTest {
@Test
void testLength() {
Student student = new Student("pymjl", "123456", 18, "北京", "123456789");
int kryoLength = KryoUtils.writeObjectToByteArray(student).length;
int hessianLength = HessianUtils.serialize(student).length;
int protostuffLength = ProtostuffUtils.serialize(student).length;
System.out.println("kryoLength: " + kryoLength);
System.out.println("hessianLength: " + hessianLength);
System.out.println("protostuffLength: " + protostuffLength);
}
}Exécuter une capture d'écran :
Comme vous pouvez le voir sur l'image , l'espace occupé par les octets après la sérialisation Hessian est nettement plus grand que les deux autres méthodes
Autres comparaisons
Hessian utilise une longueur fixe pour stocker int et long, tandis que kryo utilise une longueur variable int et long pour garantir cela. Les types de données de base doit être aussi petit que possible après la sérialisation. Dans les applications réelles, des données très volumineuses n'apparaîtront pas souvent.
Lors de la sérialisation de Kryo, vous devez transmettre le nom complet de la classe ou utiliser register() pour enregistrer la classe sur Kryo à l'avance. Sa classe est associée à un ID de type int. Seul cet ID est stocké dans la séquence. , donc la séquence La taille est encore plus petite, tandis que Hessian met toutes les informations de champ de classe dans le tableau d'octets sérialisé et utilise directement le tableau d'octets pour la désérialisation. Aucune autre participation n'est requise, car la vitesse de traitement sera plus lente s'il y a plus de choses. stocké
Kryo n'a pas besoin d'implémenter l'interface Serialisable, Hessian doit l'implémenter
Les champs de classe de données Kryo augmentent et diminuent, la sérialisation et la désérialisation ne sont pas compatibles, alors que Hessian est compatible, Protostuff ne peut être que sur. la fin L'ajout de nouveaux champs est compatible avec
Les classes de données impliquées dans Kryo et Hessian doivent avoir des constructeurs sans paramètre
Hessian stockera toutes les propriétés des objets complexes dans une carte pour la sérialisation. Par conséquent, lorsqu'il y a des variables membres portant le même nom dans la classe parent et la sous-classe, lors de la sérialisation hessienne, la sous-classe est d'abord sérialisée, puis la classe parent est sérialisée. Par conséquent, le résultat de la désérialisation entraînera la variable membre portant le même nom. dans la sous-classe pour être écrasé par la valeur de la classe parent.
Kryo n'est pas thread-safe. Vous devez utiliser ThreadLocal ou créer un pool de threads Kryo pour garantir la sécurité des threads, tandis que Protostuff est thread-safe
. Les formats de sérialisation Protostuff et Kryo sont similaires, tous deux utilisent une marque pour enregistrer le type de champ, donc le volume sérialisé est relativement petit
Résumé
| Avantages | Inconvénients | |
|---|---|---|
| Kry o | Vitesse rapide, petit volume sérialisé | Support multilingue Plus complexe |
| Hessian | prend en charge plusieurs langues par défaut | plus lent |
| Protostuff | rapide, basé sur protobuf | a besoin d'une compilation statique |
| Protostuff-Runtime | Aucune compilation statique requise, mais la sérialisation Le schéma doit être transmis à l'avance | Les classes sans constructeurs par défaut ne sont pas prises en charge lors de la désérialisation, l'utilisateur doit initialiser lui-même l'objet sérialisé. responsable de l'attribution de l'objet. |
| Java | Facile à utiliser, peut sérialiser toutes les classes | est lente et prend de la place |
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!