Protostuff使用入门[通俗易懂]

全栈程序员站长

发布于 2022-08-18 20:23:09

3730

发布于 2022-08-18 20:23:09

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

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);
    }

}

发布者：全栈程序员栈长，转载请注明出处：https://javaforall.cn/135575.html原文链接：https://javaforall.cn

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2022年5月3，如有侵权请联系 cloudcommunity@tencent.com 删除

文件存储