一：解答：
当需要将数据存入文件或者通过网络发送出去时，需将数据对象转化为字节流，即对数据序列化。
- 数据序列化本质上是将JVM中链式存储的对象转化成连续存储的字节数组，这将极大的减少数据大小。
- 对于每一个序列化的Java对象来说都有唯一的序列化 UID，这样可以保证在新的 JVM 中恢复对象即反序列化后同一个对象只会存在一份，这减少了内存的占用，同时也解决了对象之间依赖的问题。
当需要将数据存入文件或者通过网络发送出去时，需将数据对象转化为字节流，即对数据序列化。
补充
序列化技术是如何发展的？
考虑到性能、占用空间以及兼容性等因素，我们通常会经历以下几个阶段的技术演化，最终找到解决该问题的最优方案:
阶段1——字符串
不考虑任何复杂的序列化方案，直接将数据转化成字符串，以文本形式保存或传输，如果一条数据存在多个字段，则使用分隔符(比如“,”)分割。
该方案存储简单数据绰绰有余，但对于复杂数据，且数据模式经常变动时，将变得非常烦琐，通常会面临以下问题。
难以表达嵌套数据:如果每条数据是嵌套式的，比如存在类似于map，list数据结构时，以文本方式存储是非常困难的。
无法表达二进制数据:图片、视频等二进制数据无法表达，因为这类数据无法表示成简单的文本字符串。
难以应对数据模式变化:在实际应用过程中，由于用户考虑不周全或需求发生变化，
数据模式可能会经常发生变化。而每次发生变化，之前所有写入和读出(解析)模块均不可用，所有解析程序均需要修改，非常烦琐。
阶段2——编程语言内置序列化机制
采用编程语言内置的序列化机制，比如 Java Serialization， Python pickle等。
这种方式解决了阶段1面临的大部分问题，但随着使用逐步深入，我们发现这种方式将数据表示方式跟某种特定语言绑定在一起，很难做到跨语言数据的写入和读取。
阶段3——JSON/XML
为了解决阶段2面临的问题，我们决定使用应用范围广、跨语言的数据表示格式，比如JSON和XML。
但使用一段时间后，你会发现这种方式存在严重的性能问题:解析速度太慢，同时数据存储冗余较大，比如JSON会重复存储每个属性的名称等。
阶段4——统一schema
阶段4:到这一阶段，我们期望出现一种带有 schema描述的数据表示格式，通过统一化的
schema描述，可约束每个字段的类型，进而为存储和解析数据带来优化的可能。
此外，统一schema的引入，可减少属性名称重复存储带来的开销，同时，也有利于数据共享。
二：序列化的几种方式
1.xml序列化 XmlSerializer
2.二进制序列化 BinaryFormatter
3.Soap序列化 SoapFormatter
4.WCF序列化 DataContractSerializer
5.Json序列化 DataContractJsonSerializer和JavascriptSerializer
三： 用redis 举例
redis自带的是json的方式序列化
** 1: java自带序列化**
/**
* 序列化
*
* @param object
* @return
*/
public static byte[] serialize(Object object) {
ObjectOutputStream oos = null;
ByteArrayOutputStream baos = null;
try {
// 序列化
baos = new ByteArrayOutputStream();
oos = new ObjectOutputStream(baos);
oos.writeObject(object);
byte[] bytes = baos.toByteArray();
return bytes;
} catch (Exception e) {
throw new RuntimeException(e.getMessage(), e);
}
}
/**
* 反序列化
*
* @param bytes
* @return
*/
public static Object unserialize(byte[] bytes) {
ByteArrayInputStream bais = null;
try {
// 反序列化
bais = new ByteArrayInputStream(bytes);
ObjectInputStream ois = new ObjectInputStream(bais);
return ois.readObject();
} catch (Exception e) {
throw new RuntimeException(e.getMessage(), e);
}
}
2: 二进制序列化方式
@Autowired
private StringRedisTemplate redisTemplate;
/**
* 以二进制序列化方式向redis保存对象 2019
*
* @param key
* @param value
*/
public void setObj(String key, Object value) {
final byte[] vbytes = SerializeUtil.serialize(value);
redisTemplate.execute(new RedisCallback() {
@Override
public Object doInRedis(RedisConnection connection) throws DataAccessException {
// connection.set(redisTemplateSer.getStringSerializer().serialize(key), vbytes);
connection.set(SerializeUtil.serialize(key), vbytes);
return null;
}
});
}
/**
* 以二进制序列化方式从redis获取对象 2019
*
* @param key
* @param <T>
* @return
*/
public <T> T getObj(String key) {
return redisTemplate.execute(new RedisCallback<T>() {
@Override
public T doInRedis(RedisConnection connection) throws DataAccessException {
// byte[] keyByte = redisTemplateSer.getStringSerializer().serialize(key);
byte[] keyByte = SerializeUtil.serialize(key);
if (connection.exists(keyByte)) {
byte[] valuebytes = connection.get(keyByte);
@SuppressWarnings("unchecked")
T value = (T) SerializeUtil.unserialize(valuebytes);
return value;
}
return null;
}
});
}
3: Jackson、fastjson
序列化工具方法
/**
* jackson序列化反序列化工具
*/
private static ObjectMapper objectMapper = new ObjectMapper();
public static <T> String obj2String(T obj) {
if (obj == null) {
return null;
}
try {
return obj instanceof String ? (String) obj : objectMapper.writeValueAsString(obj);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
//字符串转对象
public static <T> T string2Obj(String str, Class<T> clazz) {
if (StringUtils.isEmpty(str) || clazz == null) {
return null;
}
try {
return clazz.equals(String.class) ? (T) str : objectMapper.readValue(str, clazz);
} catch (IOException e) {
e.printStackTrace();
return null;
}
}
// /**
// * fastjson序列化反序列化工具
// */
// public static <T> String obj2String(T obj) {
// return JSON.toJSONString(obj);
// }
//
// //字符串转对象
// public static <T> T string2Obj(String str, Class<T> clazz) {
// return JSON.parseObject(str,clazz);
// }
redisUtils
/**
* 以JSON序列化方式向redis保存对象 推荐这种用法速度快 2019
* @param key
* @param value
*/
public void setObjJson(String key,Object value){
redisTemplate.opsForValue().set(key,SerializeUtil.obj2String(value));
}
/**
* 以JSON序列化方式从redis获取对象 推荐这种用法速度快 2019
* @param key
* @param clazz
* @param <T>
* @return
*/
public <T> T getObjJson(String key,Class<T> clazz){
String strValue = redisTemplate.opsForValue().get(key);
if(!StringUtils.isEmpty(strValue)){
T value = SerializeUtil.string2Obj(strValue,clazz);
return value;
}
return null;
}
4： ProtoBuf方式
maven依赖
<dependency>
<groupId>io.protostuff</groupId>
<artifactId>protostuff-core</artifactId>
<version>1.4.0</version>
</dependency>
<dependency>
<groupId>io.protostuff</groupId>
<artifactId>protostuff-runtime</artifactId>
<version>1.4.0</version>
</dependency>
序列化工具方法
/**
* protobuf序列化工具
*/
public static <T> byte[] serializePb(T o) {
Schema schema = RuntimeSchema.getSchema(o.getClass());
return ProtobufIOUtil.toByteArray(o, schema, LinkedBuffer.allocate(256));
}
public static <T> T unserializePb(byte[] bytes, Class<T> clazz) {
T obj = null;
try {
obj = clazz.newInstance();
Schema schema = RuntimeSchema.getSchema(obj.getClass());
ProtostuffIOUtil.mergeFrom(bytes, obj, schema);
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
return obj;
}
redisUtils，pb方式如果是嵌套对象会有一定问题（这块回头再研究一下），并且需要序列化的成员变量需要添加@Tag(7)注解，如：
@Data
public class SimplePojo {
@Tag(1)
private String a;
@Tag(2)
private String b;
@Tag(3)
private String c;
}
/**
* 以pb序列化方式向redis保存对象 2019
*
* @param key
* @param value
*/
public void setObjPb(String key, Object value) {
final byte[] vbytes = SerializeUtil.serializePb(value);
redisTemplate.execute(new RedisCallback() {
@Override
public Object doInRedis(RedisConnection connection) throws DataAccessException {
connection.set(SerializeUtil.serializePb(key), vbytes);
return null;
}
});
}
/**
* 以pb序列化方式从redis获取对象 2019
*
* @param key
* @param <T>
* @return
*/
public <T> T getObjPb(String key,Class<T> clazz) {
return redisTemplate.execute(new RedisCallback<T>() {
@Override
public T doInRedis(RedisConnection connection) throws DataAccessException {
byte[] keyByte = SerializeUtil.serializePb(key);
if (connection.exists(keyByte)) {
byte[] valuebytes = connection.get(keyByte);
@SuppressWarnings("unchecked")
T value = (T) SerializeUtil.unserializePb(valuebytes,clazz);
return value;
}
return null;
}
});
}
四：序列化：ProtoBuf与JSON的比较
介绍
ProtoBuf 是google团队开发的用于高效存储和读取结构化数据的工具。什么是结构化数据呢，正如字面上表达的，就是带有一定结构的数据。比如电话簿上有很多记录数据，每条记录包含姓名、ID、邮件、电话等，这种结构重复出现。
同类
XML、JSON 也可以用来存储此类结构化数据，但是使用ProtoBuf表示的数据能更加高效，并且将数据压缩得更小
原理
ProtoBuf 是通过ProtoBuf编译器将与编程语言无关的特有的 .proto 后缀的数据结构文件编译成各个编程语言(Java,C/C++,Python)专用的类文件,然后通过Google提供的各个编程语言的支持库lib即可调用API。(关于proto结构体怎么编写，可自行查阅文档)
ProtoBuf编译器安装
Mac : brew install protobuf
举个例子
1.先创建一个proto文件
message.proto
syntax = "proto3";
message Person {
int32 id = 1;
string name = 2;
repeated Phone phone = 4;
enum PhoneType {
MOBILE = 0;
HOME = 1;
WORK = 2;
}
message Phone {
string number = 1;
PhoneType type = 2;
}
}
-
创建一个Java项目
并且将proto文件放置 src/main/proto 文件夹下 -
编译proto文件至Java版本
用命令行 cd 到 src/main 目录下
终端执行命令 : protoc --java_out=./java ./proto/*.proto
会发现，在你的src/main/java 里已经生成里对应的Java类
- 依赖Java版本的ProtoBuf支持库
这里只举一个用Gradle使用依赖的栗子
implementation 'com.google.protobuf:protobuf-java:3.9.1'
- 将Java对象转为ProtoBuf数据
Message.Person.Phone.Builder phoneBuilder = Message.Person.Phone.newBuilder();
Message.Person.Phone phone1 = phoneBuilder
.setNumber("100860")
.setType(Message.Person.PhoneType.HOME)
.build();
Message.Person.Phone phone2 = phoneBuilder
.setNumber("100100")
.setType(Message.Person.PhoneType.MOBILE)
.build();
Message.Person.Builder personBuilder = Message.Person.newBuilder();
personBuilder.setId(1994);
personBuilder.setName("XIAOLEI");
personBuilder.addPhone(phone1);
personBuilder.addPhone(phone2);
Message.Person person = personBuilder.build();
long old = System.currentTimeMillis();
byte[] buff = person.toByteArray();
System.out.println("ProtoBuf 编码耗时：" + (System.currentTimeMillis() - old));
System.out.println(Arrays.toString(buff));
System.out.println("ProtoBuf 数据长度:" + buff.length);
- 将ProtoBuf数据，转换回Java对象
System.out.println("-开始解码-");
old = System.currentTimeMillis();
Message.Person personOut = Message.Person.parseFrom(buff);
System.out.println("ProtoBuf 解码耗时：" + (System.currentTimeMillis() - old));
System.out.printf("Id:%d, Name:%s\n", personOut.getId(), personOut.getName());
List<Message.Person.Phone> phoneList = personOut.getPhoneList();
for (Message.Person.Phone phone : phoneList)
{
System.out.printf("手机号:%s (%s)\n", phone.getNumber(), phone.getType());
}
比较
为了能体现ProtoBuf的优势，我写了同样结构体的Java类，并且将Java对象转换成JSON数据，来与ProtoBuf进行比较。JSON编译库使用Google提供的GSON库，JSON的部分代码就不贴出来了，直接展示结果
比较结果结果
运行 1 次
【 JSON 开始编码 】
JSON 编码1次，耗时：22ms
JSON 数据长度:106
-开始解码-
JSON 解码1次，耗时：1ms
【 ProtoBuf 开始编码 】
ProtoBuf 编码1次,耗时：32ms
ProtoBuf 数据长度:34
-开始解码-
ProtoBuf 解码1次,耗时：3ms
运行 1000 次
【 JSON 开始编码 】
JSON 编码1000次，耗时：39ms
JSON 数据长度:106
-开始解码-
JSON 解码1000次，耗时：21ms
【 ProtoBuf 开始编码 】
ProtoBuf 编码1000次,耗时：37ms
ProtoBuf 数据长度:34
-开始解码-
ProtoBuf 解码1000次,耗时：8ms
运行 10万 次
【 JSON 开始编码 】
JSON 编码100000次，耗时：248ms
JSON 数据长度:106
-开始解码-
JSON 解码100000次，耗时：180ms
【 ProtoBuf 开始编码 】
ProtoBuf 编码100000次,耗时：51ms
ProtoBuf 数据长度:34
-开始解码-
ProtoBuf 解码100000次,耗时：58ms
总结
编解码性能
上述栗子只是简单的采样，实际上据我的实验发现
次数在1千以下，ProtoBuf 的编码与解码性能，都与JSON不相上下，甚至还有比JSON差的趋势。
次数在2千以上，ProtoBuf的编码解码性能，都比JSON高出很多。
次数在10万以上，ProtoBuf的编解码性能就很明显了，远远高出JSON的性能。
内存占用
ProtoBuf的内存34，而JSON到达106 ，ProtoBuf的内存占用只有JSON的1/3.
如果在redis中的需求是为了节省空间为什么不采用压缩算法呢？
因为采用压缩算法会损耗性能，序列化就是因为解决性能、占用空间以及兼容性等因素而产生的
6151
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
