在我们的开发过程中，序列化是经常需要处理的问题，比如在做分布式访问数据时，或者是在做redis缓存存储数据时，如果我们涉及的知识面不够广的话，可能会简单的使用JDK的序列化，也即在需要序列化的类上implements Serializable接口去实现序列化，我想说的是这种方式在小系统中尚且可以用一用，如果是并发很大的系统会受到严重影响，这是由于JDK自带的序列化效率很低，不论是时间上还是空间上。我们经常使用的序列化方式还有XML和Json，说实在的我更多的是使用Json，我觉得它很方便很友好，但这些都不够好，我今天要将的是google开发的开源的序列化方案protocol buffer（简称protobuf），它的好处很多，独立于语言，独立于平台，最最重要的是它的效率相当高，用protobuf序列化后的大小是json的10分之一，xml格式的20分之一，是二进制序列化的10分之一。
protobuf使用起来非常简单，它的主要流程是：我们需要自己写一个.proto文件用来描述序列化的格式，然后用protobuf提供的protoc工具将.proto文件编译成一个Java文件（protobuf官方支持很多语言：Java、C++、C#、Go、Python ，protobuf是一个开源项目，因此有很多大牛也实现了其他语言，但它们的可靠性还有待验证），最后将该Java文件引入到我们的项目中就可以使用了，当然还得引入protobuf的依赖包。
一、protobuf 示例
1、我们需要到官网下载 protobuf 的相应版本，我这里下载的是 Windows下的 3.1.0 版 protoc-3.1.0-win32.zip
2、将下载好的zip解压，能看到 bin目录下有一个 protoc.exe 的文件，等下需要用它来编译文件，我们直接在bin目录下 创建一个简单的 person.proto 的描述文件，内容如下：
syntax = "proto3";
option java_package = "gudao.red.protobuf";
option java_outer_classname = "PersonFactory";
message Person{
int32 id = 1;
string name = 2;
int32 age = 3;
Addr addr = 4;
}
message Addr{
string contry = 1;
string city = 2;
}
内容非常简单，大概介绍一下：
syntax = "proto3"; 我们使用proto3版协议
option java_package = "gudao.red.protobuf"; 编译之后生成的Java文件的包名
option java_outer_classname = "PersonFactory"; 编译之后生成的Java类的类名
message 相当于Java中的class
详细的介绍，还请自行去官网查看
3、使用protoc编译上述.proto文件，生成Java类，使用如下命令完成该操作
protoc --java_out=./src ./person.proto
--java_out：生成的Java文件输出的位置，其他语言有相应的选项
这样就会在 src 目录下生成一个 名为 PersonFactory 的Java文件
4、将PersonFactory.java文件引入到我们的项目中，并引入对应版本的protobuf的依赖包
5、写测试代码
package gudao.red.protobuf_test;
import java.net.Socket;
import gudao.red.protobuf.PersonFactory.Addr;
import gudao.red.protobuf.PersonFactory.Person;
public class Client {
public static void main(String[] args) throws Exception {
Socket socket = new Socket("127.0.0.1",3030);
Person.Builder person = Person.newBuilder();
Addr.Builder addr = Addr.newBuilder();
addr.setContry("china").setCity("shenzhen");
person.setId(1).setAge(12).setName("ccf");
person.setAddr(addr);
byte[] messageBody = person.build().toByteArray();
int headerLen = 1;
byte[] message = new byte[headerLen+messageBody.length];
message[0] = (byte)messageBody.length;
System.arraycopy(messageBody, 0, message, 1, messageBody.length);
System.out.println("msg len:"+message.length);
socket.getOutputStream().write(message);
}
}
package gudao.red.protobuf_test;
import java.net.ServerSocket;
import java.net.Socket;
import gudao.red.protobuf.PersonFactory.Person;
public class Server {
/**
* @param args
*/
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
ServerSocket serverSock = new ServerSocket(3030);
while(true){
Socket sock = serverSock.accept();
byte[] msg = new byte[256];
sock.getInputStream().read(msg);
int msgBodyLen = msg[0];
System.out.println("msg body len:"+msgBodyLen);
byte[] msgbody = new byte[msgBodyLen];
System.arraycopy(msg, 1, msgbody, 0, msgBodyLen);
Person person = Person.parseFrom(msgbody);
System.out.println("Receive:");
System.out.println(person);
}
}
}
先后启动Server和Client，就可以看到控制台的输出如下：
至此，我们的简单使用过程就完成了，是不是很简单。是，这个例子看上去是挺简单的，但如果我们需要序列化的类非常多，那么我们是不是得写非常多的.proto文件，并且还需要更新它们，这个代价可以想象一下也是非常大的。那么，接下来我们就来讲一讲protostuff，看这名字是不是跟protobuf很像，嗯，它们是有关系，前者就是基于后者实现的。
二、protostuff 示例
protostuff 是一个基于protobuf实现的序列化方法，它较于protobuf最明显的好处是，在几乎不损耗性能的情况下做到了不用我们写.proto文件来实现序列化。使用它也非常简单，所以直接上代码。
1、引入Maven依赖的JAR包
<dependency>
<groupId>io.protostuff</groupId>
<artifactId>protostuff-core</artifactId>
<version>1.5.9</version>
</dependency>
<dependency>
<groupId>io.protostuff</groupId>
<artifactId>protostuff-runtime</artifactId>
<version>1.5.9</version>
</dependency>
<dependency>
<groupId>io.protostuff</groupId>
<artifactId>protostuff-api</artifactId>
<version>1.5.9</version>
</dependency>
2、编写需要被序列化的实体类
这里是 User.java（成员属性包含了其它类）
package demo.protostuff;
import java.util.List;
public class User {
private String firstName;
private String lastName;
private String email;
private List<User> friends;
private List<Car> cars;
public User() {
}
public User(String email) {
this.email = email;
}
// getters and setters
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public List<User> getFriends() {
return friends;
}
public void setFriends(List<User> friends) {
this.friends = friends;
}
public List<Car> getCars() {
return cars;
}
public void setCars(List<Car> cars) {
this.cars = cars;
}
@Override
public String toString() {
return "User{" + "firstName='" + firstName + '\'' + ", lastName='" + lastName + '\'' + ", email='" + email
+ '\'' + ", friends=" + friends + ", cars=" + cars + '}';
}
}
Car.java
package demo.protostuff;
public class Car {
private String color;
private String car_name;
private Integer price;
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public String getCar_name() {
return car_name;
}
public void setCar_name(String car_name) {
this.car_name = car_name;
}
public Integer getPrice() {
return price;
}
public void setPrice(Integer price) {
this.price = price;
}
public Car(String car_name) {
super();
this.car_name = car_name;
}
public Car() {
super();
}
@Override
public String toString() {
return "Car [color=" + color + ", car_name=" + car_name + ", price=" + price + "]";
}
}
3、主程序类
这里是 App.java
package demo.protostuff;
import java.util.ArrayList;
import java.util.List;
import io.protostuff.LinkedBuffer;
import io.protostuff.ProtostuffIOUtil;
import io.protostuff.runtime.RuntimeSchema;
public class App {
private static RuntimeSchema<User> schema = RuntimeSchema.createFrom(User.class);
public static void main(String[] args) {
User user1 = new User();
user1.setEmail("10000@qq.com");
user1.setFirstName("zhang");
user1.setLastName("sanfeng");
List<User> users = new ArrayList<>();
users.add(new User("20000@qq.com"));
user1.setFriends(users);
Car car1 = new Car("宾利");
Car car2 = new Car("法拉利");
List<Car> cars = new ArrayList<>();
cars.add(car1);
cars.add(car2);
user1.setCars(cars);
byte[] bytes = ProtostuffIOUtil.toByteArray(user1, schema,
LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE));
User user2 = schema.newMessage(); // 或 User user2 = new User();
ProtostuffIOUtil.mergeFrom(bytes, user2, schema);
System.out.println(user2);
System.out.println();
// 使用自定义的工具类
byte[] bytes1 = ProtostuffUtil.serializer(user1);
User newUser = ProtostuffUtil.deserializer(bytes1, User.class);
System.out.println(newUser);
}
}
程序说明：
- RuntimeSchema类用于在运行时从Java实体对象中生成所需的模式Schema
- ProtostuffIOUtil是一个工具类，用于对消息或对象进行序列化/反序列化
- LinkedBuffer是一个缓冲区类，它封装了字节数组并具有对下一个缓冲区的引用以便能动态增加容量。
执行程序，输出如下：
User{firstName=’zhang’, lastName=’sanfeng’, email=’10000@qq.com’, friends=[User{firstName=’null’, lastName=’null’, email=’20000@qq
.com’, friends=null, cars=null}], cars=[Car [color=null, car_name=宾利, price=null], Car [color=null, car_name=法拉利, price=null]]}
User{firstName=’zhang’, lastName=’sanfeng’, email=’10000@qq.com’, friends=[User{firstName=’null’, lastName=’null’, email=’20000@qq
.com’, friends=null, cars=null}], cars=[Car [color=null, car_name=宾利, price=null], Car [color=null, car_name=法拉利, price=null]]}
4、根据Protostuff库自行封装的工具类
这里是 ProtostuffUtil.java
package demo.protostuff;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import io.protostuff.LinkedBuffer;
import io.protostuff.ProtostuffIOUtil;
import io.protostuff.Schema;
import io.protostuff.runtime.RuntimeSchema;
public class ProtostuffUtil {
private static Map<Class<?>, Schema<?>> cachedSchema = new ConcurrentHashMap<Class<?>, Schema<?>>();
private static <T> Schema<T> getSchema(Class<T> clazz) {
@SuppressWarnings("unchecked")
Schema<T> schema = (Schema<T>) cachedSchema.get(clazz);
if (schema == null) {
schema = RuntimeSchema.getSchema(clazz);
if (schema != null) {
cachedSchema.put(clazz, schema);
}
}
return schema;
}
/**
* 将对象序列化
* @param obj 对象
* @return
*/
public static <T> byte[] serializer(T obj) {
@SuppressWarnings("unchecked")
Class<T> clazz = (Class<T>) obj.getClass();
LinkedBuffer buffer = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE);
try {
Schema<T> schema = getSchema(clazz);
return ProtostuffIOUtil.toByteArray(obj, schema, buffer);
} catch (Exception e) {
throw new IllegalStateException(e.getMessage(), e);
} finally {
buffer.clear();
}
}
/**
* 将字节数组数据反序列化
* @param data 字节数组
* @param clazz 对象
* @return
*/
public static <T> T deserializer(byte[] data, Class<T> clazz) {
try {
T obj = clazz.newInstance();
Schema<T> schema = getSchema(clazz);
ProtostuffIOUtil.mergeFrom(data, obj, schema);
return obj;
} catch (Exception e) {
throw new IllegalStateException(e.getMessage(), e);
}
}
}