java protobuf 反射_Protobuf与POJO的相互转化 - 通过Json

前言

这篇文章是《Protobuf与Json的相互转化》的一个后续，主要是为了解决系统分层中不同ProtoBean与POJO的相互转化问题。转化的Protobuf和Pojo具有相同名称及类型的属性(当Proto属性类型为Message时，对应的为Pojo的Object类型的属性，两者应该具有相同的属性)。

转化的基本思路

测试使用的protobuf文件如下：

StudentProto.proto

syntax = "proto3";

option java_package = "io.gitlab.donespeak.javatool.toolprotobuf.proto";

message Student {

string name = 1;

int32 age = 2;

Student deskmate = 3;

}

DataTypeProto.proto

syntax = "proto3";

import "google/protobuf/any.proto";

option java_package = "io.gitlab.donespeak.javatool.toolprotobuf.proto";

package data.proto;

enum Color {

NONE = 0;

RED = 1;

GREEN = 2;

BLUE = 3;

}

message BaseData {

double double_val = 1;

float float_val = 2;

int32 int32_val = 3;

int64 int64_val = 4;

uint32 uint32_val = 5;

uint64 uint64_val = 6;

sint32 sint32_val = 7;

sint64 sint64_val = 8;

fixed32 fixed32_val = 9;

fixed64 fixed64_val = 10;

sfixed32 sfixed32_val = 11;

sfixed64 sfixed64_val = 12;

bool bool_val = 13;

string string_val = 14;

bytes bytes_val = 15;

Color enum_val = 16;

repeated string re_str_val = 17;

map map_val = 18;

}

直接转化

通过映射的方法，直接将同名同类别的属性进行复制。该实现方式主要通过反射机制进行实现。

[ A ] [ B ]

直接转化的方式需要通过protobuf的反射机制才能实现地了，难度会比较大，也正在尝试实现。另一种方式是尝试使用Apache Common BeanUtils 或者 Spring BeanUtils，进行属性拷贝。这里使用Spring BeanUtils进行设计，代码如下：

public class ProtoPojoUtilWithBeanUtils {

public static void toProto(Message.Builder destProtoBuilder, Object srcPojo) throws ProtoPojoConversionException {

// Message 都是不可变类，没有setter方法，只能通过Builder进行setter

try {

BeanUtils.copyProperties(srcPojo, destProtoBuilder);

} catch (Exception e) {

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

}

}

public static PojoType toPojo(Class destPojoKlass, Message srcMessage)

throws ProtoPojoConversionException {

try {

PojoType destPojo = destPojoKlass.newInstance();

BeanUtils.copyProperties(srcMessage, destPojo);

return destPojo;

} catch (Exception e) {

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

}

}

}

这个实现是必然会有问题的，原因有如下几点

ProtoBean不允许有null值，而Pojo允许有null值，从Pojo拷贝到Proto必然会有非空异常

BeanUtils 会按照方法名及getter/setter类型进行匹配，嵌套类型因为类型不匹配而无法正常拷贝

Map和List的Proto属性生成的Java会分别在属性名后增加Map和List，如果希望能够进行拷贝，则需要按照这个规则明明Projo的属性名

Enum类型不匹配无法进行拷贝，如果希望能够进行拷贝，可以尝试使用ProtoBean的Enum域的get**Value()方法，并据此命名Pojo属性名

总的来说，BeanUtils 不适合用于实现这个任务。只能后续考虑使用Protobuf的反射进行实现了。这个不是本文的侧重点，我们继续看另一种实现。

间接转化(货币兑换)

通过一个统一的媒介进行转化，就好比货币一样，比如人名币要转日元，银行会先将人名币转美元，再将美元转为日元，反向也是如此。

[ A ] [ C ] [ B ]

具体到实现中，我们可以将平台无关语言无关的Json作为中间媒介C，先将ProtoBean的A转化为Json的C，再将Json的C转化为ProtoBean的B对象即可。下面将对此方法进行详细的讲解。

代码实现

可以将ProtoBean转化为Json的工具有两个，一个是com.google.protobuf/protobuf-java-util，另一个是com.googlecode.protobuf-java-format/protobuf-java-format，两个的性能和效果还有待对比。这里使用的是com.google.protobuf/protobuf-java-util，原因在于protobuf-java-format 中的JsonFormat会将Map格式化为{"key": "", "value": ""} 的对象列表，而protobuf-java-util中的JsonFormat能够序列化为理想的key-value的结构，也符合Pojo转json的格式。

com.google.protobuf

protobuf-java-util

3.7.1

com.googlecode.protobuf-java-format

protobuf-java-format

1.4

对于Pojo与Json的转化，这里采用的是Gson，原因是和Protobuf都出自谷歌家。

完整的实现如下：ProtoBeanUtils.jave

import java.io.IOException;

import com.google.gson.Gson;

import com.google.protobuf.Message;

import com.google.protobuf.util.JsonFormat;

/**

* 相互转化的两个对象的getter和setter字段要完全的匹配。

* 此外，对于ProtoBean中的enum和bytes，与POJO转化时遵循如下的规则：

*

*

enum -> String

*

bytes -> base64 String

*

* @author Yang Guanrong

* @date 2019/08/18 23:44

*/

public class ProtoBeanUtils {

/**

* 将ProtoBean对象转化为POJO对象

*

* @param destPojoClass 目标POJO对象的类类型

* @param sourceMessage 含有数据的ProtoBean对象实例

* @param 目标POJO对象的类类型范型

* @return

* @throws IOException

*/

public static PojoType toPojoBean(Class destPojoClass, Message sourceMessage)

throws IOException {

if (destPojoClass == null) {

throw new IllegalArgumentException

("No destination pojo class specified");

}

if (sourceMessage == null) {

throw new IllegalArgumentException("No source message specified");

}

String json = JsonFormat.printer().print(sourceMessage);

return new Gson().fromJson(json, destPojoClass);

}

/**

* 将POJO对象转化为ProtoBean对象

*

* @param destBuilder 目标Message对象的Builder类

* @param sourcePojoBean 含有数据的POJO对象

* @return

* @throws IOException

*/

public static void toProtoBean(Message.Builder destBuilder, Object sourcePojoBean) throws IOException {

if (destBuilder == null) {

throw new IllegalArgumentException

("No destination message builder specified");

}

if (sourcePojoBean == null) {

throw new IllegalArgumentException("No source pojo specified");

}

String json = new Gson().toJson(sourcePojoBean);

JsonFormat.parser().merge(json, destBuilder);

}

}

和《Protobuf与Json的相互转化》一样，上面的实现无法处理 Any 类型的数据。需要自己添加 TypeRegirstry 才能进行转化。

A TypeRegistry is used to resolve Any messages in the JSON conversion. You must provide a TypeRegistry containing all message types used in Any message fields, or the JSON conversion will fail because data in Any message fields is unrecognizable. You don’t need to supply a TypeRegistry if you don’t use Any message fields.

添加TypeRegistry的方法如下：

// https://codeburst.io/protocol-buffers-part-3-json-format-e1ca0af27774

final var typeRegistry = JsonFormat.TypeRegistry.newBuilder()

.add(ProvisionVmCommand.getDescriptor())

.build();

final var jsonParser = JsonFormat.parser()

.usingTypeRegistry(typeRegistry);

final var envelopeBuilder = VmCommandEnvelope.newBuilder();

jsonParser.merge(json, envelopeBuilder);

测试

一个和Proto文件匹配的Pojo类 BaseDataPojo.java

import lombok.*;

import java.util.List;

import java.util.Map;

/**

* @author Yang Guanrong

* @date 2019/09/03 20:46

*/

@Getter

@Setter

@ToString

@NoArgsConstructor

@AllArgsConstructor(access = AccessLevel.PRIVATE)

@Builder

public class BaseDataPojo {

private double doubleVal;

private float floatVal;

private int int32Val;

private long int64Val;

private int uint32Val;

private long uint64Val;

private int sint32Val;

private long sint64Val;

private int fixed32Val;

private long fixed64Val;

private int sfixed32Val;

private long sfixed64Val;

private boolean boolVal;

private String stringVal;

private String bytesVal;

private String enumVal;

private List reStrVal;

private Map mapVal;

}

测试类 ProtoBeanUtilsTest.java

package io.gitlab.donespeak.javatool.toolprotobuf.withjsonformat;

import static org.junit.Assert.*;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.Map;

import org.junit.Test;

import com.google.common.io.BaseEncoding;

import com.google.protobuf.ByteString;

import io.gitlab.donespeak.javatool.toolprotobuf.bean.BaseDataPojo;

import io.gitlab.donespeak.javatool.toolprotobuf.proto.DataTypeProto;

/**

* @author Yang Guanrong

* @date 2019/09/04 14:05

*/

public class ProtoBeanUtilsTest {

private DataTypeProto.BaseData getBaseDataProto() {

DataTypeProto.BaseData baseData = DataTypeProto.BaseData.newBuilder()

.setDoubleVal(100.123D)

.setFloatVal(12.3F)

.setInt32Val(32)

.setInt64Val(64)

.setUint32Val(132)

.setUint64Val(164)

.setSint32Val(232)

.setSint64Val(264)

.setFixed32Val(332)

.setFixed64Val(364)

.setSfixed32Val(432)

.setSfixed64Val(464)

.setBoolVal(true)

.setStringVal("ssss..tring")

.setBytesVal(ByteString.copyFromUtf8("itsbytes"))

.setEnumVal(DataTypeProto.Color.BLUE)

.addReStrVal("re-item-0")

.addReIntVal(33)

.putMapVal("m-key", DataTypeProto.BaseData.newBuilder()

.setStringVal("base-data")

.build())

.build();

return baseData;

}

public BaseDataPojo getBaseDataPojo() {

Map map = new HashMap<>();

map.put("m-key", BaseDataPojo.builder().stringVal("base-data").build());

BaseDataPojo baseDataPojo = BaseDataPojo.builder()

.doubleVal(100.123D)

.floatVal(12.3F)

.int32Val(32)

.int64Val(64)

.uint32Val(132)

.uint64Val(164)

.sint32Val(232)

.sint64Val(264)

.fixed32Val(332)

.fixed64Val(364)

.sfixed32Val(432)

.sfixed64Val(464)

.boolVal(true)

.stringVal("ssss..tring")

.bytesVal("itsbytes")

.enumVal(DataTypeProto.Color.BLUE.toString())

.reStrVal(Arrays.asList("re-item-0"))

.reIntVal(new int[]{33})

.mapVal(map)

.build();

return baseDataPojo;

}

@Test

public void toPojoBean() throws IOException {

DataTypeProto.BaseData baseDataProto = getBaseDataProto();

BaseDataPojo baseDataPojo = ProtoBeanUtils.toPojoBean(BaseDataPojo.class, baseDataProto);

// System.out.println(new GsonBuilder().setPrettyPrinting().create().toJson(baseDataPojo));

asserEqualsVerify(baseDataPojo, baseDataProto);

}

@Test

public void toProtoBean() throws IOException {

BaseDataPojo baseDataPojo = getBaseDataPojo();

DataTypeProto.BaseData.Builder builder = DataTypeProto.BaseData.newBuilder();

ProtoBeanUtils.toProtoBean(builder, baseDataPojo);

DataTypeProto.BaseData baseDataProto = builder.build();

// System.out.println(new GsonBuilder().setPrettyPrinting().create().toJson(baseDataPojo));

// 不可用Gson转化Message(含有嵌套结构的，且嵌套的Message中含有嵌套结构)，会栈溢出的

// 因为Protobuf没有null值

// System.out.println(JsonFormat.printer().print(baseDataProto));

asserEqualsVerify(baseDataPojo, baseDataProto);

}

private void asserEqualsVerify(BaseDataPojo baseDataPojo, DataTypeProto.BaseData baseDataProto) {

assertTrue((baseDataPojo == null) == (!baseDataProto.isInitialized()));

if(baseDataPojo == null) {

return;

}

assertEquals(baseDataPojo.getDoubleVal(), baseDataProto.getDoubleVal(), 0.0000001D);

assertEquals(baseDataPojo.getFloatVal(), baseDataProto.getFloatVal(), 0.00000001D);

assertEquals(baseDataPojo.getInt32Val(), baseDataProto.getInt32Val());

assertEquals(baseDataPojo.getInt64Val(), baseDataProto.getInt64Val());

assertEquals(baseDataPojo.getUint32Val(), baseDataProto.getUint32Val());

assertEquals(baseDataPojo.getUint64Val(), baseDataProto.getUint64Val());

assertEquals(baseDataPojo.getSint32Val(), baseDataProto.getSint32Val());

assertEquals(baseDataPojo.getSint64Val(), baseDataProto.getSint64Val());

assertEquals(baseDataPojo.getFixed32Val(), baseDataProto.getFixed32Val());

assertEquals(baseDataPojo.getInt64Val(), baseDataProto.getInt64Val());

assertEquals(baseDataPojo.isBoolVal(), baseDataProto.getBoolVal());

assertEquals(baseDataPojo.isBoolVal(), baseDataProto.getBoolVal());

assertEquals(baseDataPojo.getStringVal(), baseDataProto.getStringVal());

// ByteString 转 base64 Strings

if(baseDataPojo.getBytesVal() == null) {

// 默认值为 ""

assertTrue(baseDataProto.getBytesVal().isEmpty());

} else {

assertEquals(baseDataPojo.getBytesVal(), BaseEncoding.base64().encode(baseDataProto.getBytesVal().toByteArray()));

}

// Enum 转 String

if(baseDataPojo.getEnumVal() == null) {

// 默认值为 0

assertEquals(DataTypeProto.Color.forNumber(0), baseDataProto.getEnumVal());

} else {

assertEquals(baseDataPojo.getEnumVal(), baseDataProto.getEnumVal().toString());

}

if(baseDataPojo.getReStrVal() == null) {

// 默认为空列表

assertEquals(0, baseDataProto.getReStrValList().size());

} else {

assertEquals(baseDataPojo.getReStrVal().size(), baseDataProto.getReStrValList().size());

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

assertEquals(baseDataPojo.getReStrVal().get(i), baseDataProto.getReStrValList().get(i));

}

}

if(baseDataPojo.getReIntVal() == null) {

// 默认为空列表

assertEquals(0, baseDataProto.getReIntValList().size());

} else {

assertEquals(baseDataPojo.getReIntVal().length, baseDataProto.getReIntValList().size());

for(int i = 0; i < baseDataPojo.getReIntVal().length; i ++) {

int v1 = baseDataPojo.getReIntVal()[i];

int v2 = baseDataProto.getReIntValList().get(i);

assertEquals(v1, v2);

}

}

if(baseDataPojo.getMapVal() == null) {

// 默认为空集合

assertEquals(0, baseDataProto.getMapValMap().size());

} else {

assertEquals(baseDataPojo.getMapVal().size(), baseDataProto.getMapValMap().size());

for(Map.Entry entry: baseDataProto.getMapValMap().entrySet()) {

asserEqualsVerify(baseDataPojo.getMapVal().get(entry.getKey()), entry.getValue());

}

}

}

@Test

public void testDefaultValue() {

DataTypeProto.BaseData baseData = DataTypeProto.BaseData.newBuilder()

.setInt32Val(0)

.setStringVal("")

.addAllReStrVal(new ArrayList<>())

.setBoolVal(false)

.setDoubleVal(3.14D)

.build();

// 默认值不会输出

// double_val: 3.14

System.out.println(baseData);

}

}

以上测试是可以完成通过的，特别需要注意的是类类型的属性的默认值。Protobuf中是没有null值的，所以类类型属性的默认值也不会是null。但映射到了Pojo时，ProtoBean的默认值会转化为Pojo的默认值，也就是Java中数据类型的默认值。

默认值列表

类型

Proto默认值

Pojo默认值

int

0

0

long

0L

0L

float

0F

0F

double

0D

0D

boolean

false

false

string

""

null

BytesString

""

(string) null

enum

0

(string) null

message

{}

(object) null

repeated

[]

(List/Array) null

map

[]

(Map) null

该列表仅仅是做了一个简单得列举，如果需要更加详细得信息，建议看protobuf得官方文档。或者还有一种取巧得方法，就是创建一个含有所有数据类型得ProtoBean，如这里得DataTypeProto.BaseData，然后看该类里面得无参构造函数就大概可以知道是什么默认值了。

...

private static final DataTypeProto.BaseData DEFAULT_INSTANCE;

static {

DEFAULT_INSTANCE = new DataTypeProto.BaseData();

}

private BaseData() {

stringVal_ = "";

bytesVal_ = com.google.protobuf.ByteString.EMPTY;

enumVal_ = 0;

reStrVal_ = com.google.protobuf.LazyStringArrayList.EMPTY;

reIntVal_ = emptyIntList();

}

public static iDataTypeProto.BaseData getDefaultInstance() {

return DEFAULT_INSTANCE;

}

...

这里还是特别强调一下，protobuf没有null值，不能设置null值，也获取不到null值。

Protobuf 支持的Java数据类型见：com.google.protobuf.Descriptors.FieldDescriptor.JavaType

参考和推荐阅读