Protostuff使用入门[通俗易懂]

大家好，又见面了，我是你们的朋友全栈君。

Protostuff

The goal of protostuff is to generate a schema whether at compile-time or runtime and use that for reading/writing to various formats via the provided IO libs.

Schema

A class that encapsulates:

• the serialization logic of an object
• the deserialization logic of an object
• the validation of an object’s required fields
• the mapping of an object’s field names to field numbers
• the instantiation of the object.

For existing objects, use protostuff-runtime which uses reflection.

示例

User类是个简单的pojo类：

package demo.domain;

import lombok.Data;
import java.util.List;

@Data
public class User { 
   
    private String firstName;
    private String lastName;
    private String email;
    private List<User> friends;
}

定义User的序列化逻辑：UserSchema

package demo.serializing;
import demo.domain.User;
import io.protostuff.Input;
import io.protostuff.Output;
import io.protostuff.Schema;
import io.protostuff.UninitializedMessageException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
public class UserSchema implements Schema<User> { 

private static final HashMap<String, Integer> fieldMap = new HashMap<>();
static { 

fieldMap.put("email", 1);
fieldMap.put("firstName", 2);
fieldMap.put("lastName", 3);
fieldMap.put("friends", 4);
}
@Override
public String getFieldName(int number) { 

switch (number) { 

case 1:
return "email";
case 2:
return "firstName";
case 3:
return "lastName";
case 4:
return "friends";
default:
return null;
}
}
@Override
public int getFieldNumber(String name) { 

Integer number = fieldMap.get(name);
return number == null ? 0 : number;
}
@Override
public boolean isInitialized(User message) { 

return message.getEmail() != null;
}
@Override
public User newMessage() { 

return new User();
}
@Override
public String messageName() { 

return User.class.getSimpleName();
}
@Override
public String messageFullName() { 

return User.class.getName();
}
@Override
public Class<? super User> typeClass() { 

return User.class;
}
@Override
public void mergeFrom(Input input, User message) throws IOException { 

while (true) { 

int number = input.readFieldNumber(this);
switch (number) { 

case 0:
return;
case 1:
message.setEmail(input.readString());
break;
case 2:
message.setFirstName(input.readString());
break;
case 3:
message.setLastName(input.readString());
break;
case 4:
if (message.getFriends() == null)
message.setFriends(new ArrayList<>());
message.getFriends().add(input.mergeObject(null, this));
break;
default:
input.handleUnknownField(number, this);
}
}
}
@Override
public void writeTo(Output output, User user) throws IOException { 

if (user.getEmail() == null)
throw new UninitializedMessageException(user, this);
output.writeString(1, user.getEmail(), false);
if (user.getFirstName() != null)
output.writeString(2, user.getFirstName(), false);
if (user.getLastName() != null)
output.writeString(3, user.getLastName(), false);
if (user.getFriends() != null) { 

for (User friend : user.getFriends()) { 

if (friend != null)
output.writeObject(4, friend, this, true);
}
}
}
}

序列化和反序列化示例：

package demo;
import demo.domain.User;
import demo.serializing.UserSchema;
import io.protostuff.LinkedBuffer;
import io.protostuff.ProtostuffIOUtil;
import io.protostuff.Schema;
import lombok.extern.java.Log;
import java.util.ArrayList;
import java.util.List;
@Log
public class App { 

public static void main(String[] args) { 

User user1 = new User();
user1.setEmail("1178449100@qq.com");
user1.setFirstName("wenwen");
user1.setLastName("zha");
User user2 = new User();
user2.setEmail("gumengqin@qq.com");
List<User> users = new ArrayList<>();
users.add(user2);
user1.setFriends(users);
Schema<User> schema = new UserSchema();
byte[] data;
data = ProtostuffIOUtil.toByteArray(user1, schema, LinkedBuffer.allocate());
log.info("序列化完成：" + data.length);
User newUser = new User();
ProtostuffIOUtil.mergeFrom(data, newUser, schema);
log.info("反序列化完成：" + newUser);
}
}

RuntimeSchema

使用RuntimeSchema可以不用自定义Schema，省了不少工作。

package demo.serializing;
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;
public class ProtostuffUtils { 

//避免每次序列化都重新申请Buffer空间
private static LinkedBuffer buffer = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE);
//缓存Schema
private static Map<Class<?>, Schema<?>> schemaCache = new ConcurrentHashMap<Class<?>, Schema<?>>();
//序列化方法，把指定对象序列化成字节数组
@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类型
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>) schemaCache.get(clazz);
if (schema == null) { 

schema = RuntimeSchema.getSchema(clazz);
if (schema != null) { 

schemaCache.put(clazz, schema);
}
}
return schema;
}
}

重新测试：

package demo;
import demo.domain.User;
import demo.serializing.ProtostuffUtils;
import lombok.extern.java.Log;
import java.util.ArrayList;
import java.util.List;
@Log
public class App { 

public static void main(String[] args) { 

User user1 = new User();
user1.setEmail("1178449100@qq.com");
user1.setFirstName("wenwen");
user1.setLastName("zha");
User user2 = new User();
user2.setEmail("gumengqin@qq.com");
List<User> users = new ArrayList<>();
users.add(user2);
user1.setFriends(users);
byte[] data = ProtostuffUtils.serialize(user1);
log.info("序列化完成：" + data.length);
User newUser=ProtostuffUtils.deserialize(data,User.class);
log.info("反序列化完成：" + newUser);
}
}