Springboot集成ProtoBuf的实例

< dependency >

    < groupId >com.google.protobuf</ groupId >

     < artifactId >protobuf-java</ artifactId >

     < version >3.5.0</ version >

</ dependency >

< 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 >

package com.xrq.demo.utils; 

import java.util.Map;

import java.util.concurrent.ConcurrentHashMap;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.objenesis.Objenesis;

import org.springframework.objenesis.ObjenesisStd;

import io.protostuff.LinkedBuffer;

import io.protostuff.ProtostuffIOUtil;

import io.protostuff.Schema;

import io.protostuff.runtime.RuntimeSchema;

/**

  * ProtoBufUtil 转换工具类

  * 

  * @author XRQ

  *

  */

public class ProtoBufUtil {

     private static Logger log = LoggerFactory.getLogger(ProtoBufUtil. class );

     private static Map<Class<?>, Schema<?>> cachedSchema = new ConcurrentHashMap<Class<?>, Schema<?>>();

     private static Objenesis objenesis = new ObjenesisStd( true );

     @SuppressWarnings ( "unchecked" )

     private static <T> Schema<T> getSchema(Class<T> cls) {

         Schema<T> schema = (Schema<T>) cachedSchema.get(cls);

         if (schema == null ) {

             schema = RuntimeSchema.createFrom(cls);

             if (schema != null ) {

                 cachedSchema.put(cls, schema);

             }

         }

         return schema;

     }

     public ProtoBufUtil() {

     }

     @SuppressWarnings ({ "unchecked" })

     public static <T> byte [] serializer(T obj) {

         Class<T> cls = (Class<T>) obj.getClass();

         LinkedBuffer buffer = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE);

         try {

             Schema<T> schema = getSchema(cls);

             return ProtostuffIOUtil.toByteArray(obj, schema, buffer);

         } catch (Exception e) {

             log.error( "protobuf序列化失败" );

             throw new IllegalStateException(e.getMessage(), e);

         } finally {

             buffer.clear();

         }

     }

     public static <T> T deserializer( byte [] bytes, Class<T> clazz) {

         try {

             T message = (T) objenesis.newInstance(clazz);

             Schema<T> schema = getSchema(clazz);

             ProtostuffIOUtil.mergeFrom(bytes, message, schema);

             return message;

         } catch (Exception e) {

             log.error( "protobuf反序列化失败" );

             throw new IllegalStateException(e.getMessage(), e);

         }

     }

}

package com.xrq.demo.bo; 

import java.io.Serializable;

import java.util.Date;  

import io.protostuff.Tag;

/**

  * 用户信息类

  * 

  * @ClassName: User

  * @author XRQ

  * @date 2019年4月30日

  */

public class User implements Serializable

{

    private static final long serialVersionUID = 1L;

    // 用户ID

    @Tag ( 1 )

    private int userId;

    // 用户类型

    @Tag ( 2 )

    private int userTypeId;

    // 用户名 

    @Tag ( 3 )

    private String userName;

    // 创建时间

    @Tag ( 4 )

    private Date createDateTime; 

    public int getUserId()

    {

        return userId;

    }

    public void setUserId( int userId)

    {

        this .userId = userId;

    }

    public int getUserTypeId()

    {

        return userTypeId;

    }

    public void setUserTypeId( int userTypeId)

    {

        this .userTypeId = userTypeId;

    }

    public String getUserName()

    {

        return userName;

    }

    public void setUserName(String userName)

    {

        this .userName = userName;

    }

    public Date getCreateDateTime()

    {

        return createDateTime;

    }

    public void setCreateDateTime(Date createDateTime)

    {

        this .createDateTime = createDateTime;

    }

}

User user = new User();

user.setUserId( 1 );

user.setUserTypeId( 1 );

user.setUserName( "XRQ" );

user.setCreateDateTime( new Date());

//序列化成ProtoBuf数据结构

byte [] userProtoObj= ProtoBufUtil.serializer(userInfo)

//ProtoBuf数据结构反序列化成User对象

User newUserObj = ProtoBufUtil.deserializer(userProtoObj, User. class ))

< dependency >

     < groupId >io.protostuff</ groupId >

     < artifactId >protostuff-runtime</ artifactId >

     < version >1.4.0</ version >

</ dependency >

< plugin >

     < groupId >org.xolstice.maven.plugins</ groupId >

     < artifactId >protobuf-maven-plugin</ artifactId >

     < version >0.5.0</ version >

     < configuration >

     < protocArtifact >

         com.google.protobuf:protoc:3.1.0:exe:${os.detected.classifier}

     </ protocArtifact >

     < pluginId >grpc-java</ pluginId >

     </ configuration >

     < executions >

         < execution >

             < goals >

                 < goal >compile</ goal >

                 < goal >compile-custom</ goal >

             </ goals >

         </ execution >

     </ executions >

</ plugin >

// 版本号

syntax = "proto2";

// 打包路径

option java_package="XXX1";

// Java文件名

option java_outer_classname="XXX2";

// 属性信息

message BaseInfo {

     // 公司标识

     required string CompanyId       = 1;

     // 公司名称

     required string CompanyName     = 2;

     // 操作标识

     required uint32 Flag            = 3;

     // 更新时间

     required uint64 UpdateTime      = 4;

}

List<BaseInfo> baseInfoList = baseInfoMapper.selectAll();

XXX2.OTIpcList.Builder listBuilder = XXX2.OTIpcList.newBuilder();

XXX2.OTIpc.Builder otipcBuilder = XXX2.OTIpc.newBuilder();

otipcBuilder.setCompanyId(ProjectConstant.COMPANY_ID);

otipcBuilder.setSource(ProjectConstant.COMPANY_SOURCE);

otipcBuilder.setIPCType(OTIpcDef.IpcType.baseInfoCompany);

for ( int i= 0 ;i<baseInfoList .size();i++){

     try {

         XXX2.BaseInfo.Builder baseInfoBuilder = XXX2.BaseInfo.newBuilder();

         baseInfoBuilder .setCompanyId(baseInfoList .get(i).getCompanyid());

         baseInfoBuilder .setCompanyName(baseInfoList .get(i).getCompanyname());

         baseInfoBuilder .setFlag(baseInfoList .get(i).getFlag());

         baseInfoBuilder .setUpdateTime(baseInfoList .get(i).getUpdatetime());

         for ( int j= 0 ;j< 10 ;j++) {

             otipcBuilder.addBaseInfo(baseInfoBuilder .build());

         }

     }

     catch (Exception e){

         LoggerUtils.info(getClass(),e.getMessage());

     }

}

listBuilder.addOtpic(otipcBuilder);

public static String sendScreate(OTIpcDef.OTIpcList.Builder listBuilder) {

         String screateKeyString = getSecretKey();

         String screateKey = screateKeyString.split( ";" )[ 1 ];

         String screateValue = screateKeyString.split( ";" )[ 0 ];

         OTIpcDef.OTIpcList list = listBuilder.build();

         ByteArrayOutputStream output = new ByteArrayOutputStream();

         try {

             list.writeTo(output);

         } catch (IOException e) {

             e.printStackTrace();

         }

         byte [] data = null ;

         try {

             byte [] keyByte = new byte [screateValue.length()/ 2 ];

             for ( int j= 0 ;j<screateValue.length()/ 2 ;j++) {

                 byte b = ( byte ) ((Integer.valueOf(String.valueOf(screateValue.charAt(j* 2 )), 16 ) << 4 ) |

                         Integer.valueOf(String.valueOf(screateValue.charAt(j* 2 + 1 )), 16 ));

                 keyByte[j] = b;

         }

         Key secretKey= new SecretKeySpec(keyByte, "AES" );

         Security.addProvider( new org.bouncycastle.jce.provider.BouncyCastleProvider());

         Cipher cipher= Cipher.getInstance( "AES/ECB/PKCS7Padding" , "BC" );

         cipher.init(Cipher.ENCRYPT_MODE, secretKey);

         data = cipher.doFinal(output.toByteArray());

         sendPostJSON(screateKey, data);

         return "success" ;

     } catch (Exception e){

         e.printStackTrace();

     }

     return null ;

}