泛型解决方案

Question

我有一个现有系统，它在GUI和服务器之间使用基于protobuf的通信协议。现在我想添加一些持久性，但目前protobuf消息直接转换为第三方自定义对象。

有没有办法将 proto 消息转换为 json ，然后可以将其保存到数据库。

NB：我不太喜欢将二进制protobuf写入数据库的想法，因为它有一天会变得不能与新版本向后兼容并以这种方式破坏系统。

Answer 1

我们目前正在使用protobuf-java-format将我们的Protobuf消息（Message的任何子类）转换为JSON格式，以通过我们的Web API发送。

简单地说：

  JsonFormat.printToString(protoMessage)

Answer 2

正如an answer to a similar question中所述，自v3.1.0以来，这是ProtocolBuffers支持的功能。对于Java，请包含扩展模块com.google.protobuf:protobuf-java-util并使用JsonFormat，如下所示：

JsonFormat.parser().ignoringUnknownFields().merge(json, yourObjectBuilder);
YourObject value = yourObjectBuilder.build();

Answer 3

我不太喜欢将二进制protobuf写入数据库的想法，因为它有一天会变得不能与新版本向后兼容并以这种方式破坏系统。

将protobuf转换为JSON进行存储，然后在加载时将其转换回protobuf可能会导致兼容性问题，因为：

如果执行转换的进程不是使用最新版本的protobuf架构构建的，那么转换将以静默方式删除该进程不知道的任何字段。存储和装载两端都是如此。
即使使用最新的架构，JSON＆lt; - ＆gt;在存在不精确的浮点值和类似的极端情况下，Protobuf转换可能是有损的。
与JSON相比，Protobufs实际上具有（略微）更强的向后兼容性保证。与JSON一样，如果添加新字段，旧客户端将忽略它。与JSON不同，Protobufs允许声明一个默认值，这可以使新客户端更容易处理原本缺少该字段的旧数据。这只是一个小优势，但Protobuf和JSON具有相同的向后兼容性属性，因此您无法通过存储JSON获得任何向后兼容性优势。

总而言之，有很多库用于将protobufs转换为JSON，通常构建在Protobuf反射接口上（不要与Java反射接口混淆; Protobuf反射由com.google.protobuf.Message接口提供）。

Answer 4

添加到Ophir的答案，即使在protobuf 3.0之前，JsonFormat也可用。但是，这样做的方式有所不同。

在Protobuf 3.0+中，JsonFormat类是单例，因此可以执行以下操作

String jsonString = "";
JsonFormat.parser().ignoringUnknownFields().merge(json,yourObjectBuilder);

在Protobuf 2.5+中，以下应该可以使用

String jsonString = "";
JsonFormat jsonFormat = new JsonFormat();
jsonString = jsonFormat.printToString(yourProtobufMessage);

这是我写的tutorial的链接，它在TypeAdapter中使用JsonFormat类，可以注册到GsonBuilder对象。然后，您可以使用Gson的toJson和fromJson方法将原型数据转换为Java并返回。

回复jean。如果我们在文件中有protobuf数据并想要将其解析为protobuf消息对象，请使用合并方法TextFormat类。请参阅以下代码段：

// Let your proto text data be in a file MessageDataAsProto.prototxt
// Read it into string  
String protoDataAsString = FileUtils.readFileToString(new File("MessageDataAsProto.prototxt"));

// Create an object of the message builder
MyMessage.Builder myMsgBuilder = MyMessage.newBuilder();

// Use text format to parse the data into the message builder
TextFormat.merge(protoDataAsString, ExtensionRegistry.getEmptyRegistry(), myMsgBuilder);

// Build the message and return
return myMsgBuilder.build();

Answer 5

尝试JsonFormat.printer().print(MessageOrBuilder)，它看起来很适合proto3。但是，目前还不清楚如何将实际的protobuf消息（作为我在.proto文件中定义的java包提供）转换为com.google.protbuf.Message对象。

Answer 6

对于protobuf 2.5，请使用依赖项：

"com.googlecode.protobuf-java-format" % "protobuf-java-format" % "1.2"

然后使用代码：

com.googlecode.protobuf.format.JsonFormat.merge(json, builder)
com.googlecode.protobuf.format.JsonFormat.printToString(proto)

Answer 7

好吧，根据我的发现，没有捷径可做，但您却以某种方式
只需几个简单的步骤即可实现

首先，您必须声明'ProtobufJsonFormatHttpMessageConverter'类型的

@Bean  
@Primary  
public ProtobufJsonFormatHttpMessageConverter protobufHttpMessageConverter() {  
  return new ProtobufJsonFormatHttpMessageConverter(JsonFormat.parser(), JsonFormat.printer());  
}

然后，您只需编写一个像ResponseBuilder这样的Utility类，因为它可以默认解析请求，但是如果不进行这些更改，它就不会产生Json响应。然后您可以编写一些方法将响应类型转换为与其相关的对象类型。

public static <T> T build(Message message, Class<T> type) {
  Printer printer = JsonFormat.printer();
  Gson gson = new Gson();
  try {
    return gson.fromJson(printer.print(message), type);
  } catch (JsonSyntaxException | InvalidProtocolBufferException e) {
    throw new ApiException(HttpStatus.INTERNAL_SERVER_ERROR, "Response   conversion Error", e);
  }
}

然后，您可以从控制器类的最后一行调用此方法，例如-

return ResponseBuilder.build(<returned_service_object>, <Type>);

希望这将帮助您以json格式实现protobuf。

Answer 8

这是我的实用程序类，您可以使用：

package <removed>;
import com.google.protobuf.Message;
import com.google.protobuf.MessageOrBuilder;
import com.google.protobuf.util.JsonFormat;
/**
 * Author @espresso stackoverflow.
 * Sample use:
 *      Model.Person reqObj = ProtoUtil.toProto(reqJson, Model.Person.getDefaultInstance());
        Model.Person res = personSvc.update(reqObj);
        final String resJson = ProtoUtil.toJson(res);
 **/
public class ProtoUtil {
    public static <T extends Message> String toJson(T obj){
        try{
            return JsonFormat.printer().print(obj);
        }catch(Exception e){
            throw new RuntimeException("Error converting Proto to json", e);
        }
    }
   public static <T extends MessageOrBuilder> T toProto(String protoJsonStr, T message){
        try{
            Message.Builder builder = message.getDefaultInstanceForType().toBuilder();
            JsonFormat.parser().ignoringUnknownFields().merge(protoJsonStr,builder);
            T out = (T) builder.build();
            return out;
        }catch(Exception e){
            throw new RuntimeException(("Error converting Json to proto", e);
        }
    }
}

Answer 9

泛型解决方案

这是Json转换器的通用版本

package com.intuit.platform.util;

import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import com.google.protobuf.AbstractMessage.Builder;
import com.google.protobuf.Message;
import com.google.protobuf.MessageOrBuilder;
import com.google.protobuf.util.JsonFormat;

/**
 * Generic ProtoJsonUtil to be used to serialize and deserialize Proto to json
 * 
 * @author Marcello_deSales@intuit.com
 *
 */
public final class ProtoJsonUtil {

  /**
   * Makes a Json from a given message or builder
   * 
   * @param messageOrBuilder is the instance
   * @return The string representation
   * @throws IOException if any error occurs
   */
  public static String toJson(MessageOrBuilder messageOrBuilder) throws IOException {
    return JsonFormat.printer().print(messageOrBuilder);
  }

  /**
   * Makes a new instance of message based on the json and the class
   * @param <T> is the class type
   * @param json is the json instance
   * @param clazz is the class instance
   * @return An instance of T based on the json values
   * @throws IOException if any error occurs
   */
  @SuppressWarnings({"unchecked", "rawtypes"})
  public static <T extends Message> T fromJson(String json, Class<T> clazz) throws IOException {
    // https://stackoverflow.com/questions/27642021/calling-parsefrom-method-for-generic-protobuffer-class-in-java/33701202#33701202
    Builder builder = null;
    try {
      // Since we are dealing with a Message type, we can call newBuilder()
      builder = (Builder) clazz.getMethod("newBuilder").invoke(null);

    } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException
        | NoSuchMethodException | SecurityException e) {
      return null;
    }

    // The instance is placed into the builder values
    JsonFormat.parser().ignoringUnknownFields().merge(json, builder);

    // the instance will be from the build
    return (T) builder.build();
  }
}

使用它很简单，如下所示：

消息实例

GetAllGreetings.Builder allGreetingsBuilder = GetAllGreetings.newBuilder();

allGreetingsBuilder.addGreeting(makeNewGreeting("Marcello", "Hi %s, how are you", Language.EN))
        .addGreeting(makeNewGreeting("John", "Today is hot, %s, get some ice", Language.ES))
        .addGreeting(makeNewGreeting("Mary", "%s, summer is here! Let's go surfing!", Language.PT));

GetAllGreetings allGreetings = allGreetingsBuilder.build();

致Json Generic

String json = ProtoJsonUtil.toJson(allGreetingsLoaded);
log.info("Json format: " + json);

来自Json Generic

GetAllGreetings parsed = ProtoJsonUtil.fromJson(json, GetAllGreetings.class);
log.info("The Proto deserialized from Json " + parsed);

Answer 10

google protobuf 3.7.0 的最新答案：
Maven 更改 -- 将此添加到您的 pom.xml 中：

<dependency>
    <groupId>com.google.protobuf</groupId>
    <artifactId>protobuf-java</artifactId>
    <version>3.7.0</version>
</dependency>
<dependency>
    <groupId>com.google.protobuf</groupId>
    <artifactId>protobuf-java-util</artifactId>
    <version>3.7.0</version>
</dependency>
</dependencies>
<build>
    <extensions>
        <extension>
            <groupId>kr.motd.maven</groupId>
            <artifactId>os-maven-plugin</artifactId>
            <version>1.6.0</version>
        </extension>
    </extensions>
    <plugins>
    <plugin>
        <groupId>org.xolstice.maven.plugins</groupId>
        <artifactId>protobuf-maven-plugin</artifactId>
        <version>0.6.1</version>
        <extensions>true</extensions>
        <executions>
            <execution>
                <goals>
                    <goal>compile</goal>
                    <goal>test-compile</goal>
                </goals>
            </execution>
        </executions>
        <configuration>
            <additionalProtoPathElements>
                <additionalProtoPathElement>${project.basedir}/src/main/resources</additionalProtoPathElement>
            </additionalProtoPathElements>
            <protocArtifact>com.google.protobuf:protoc:3.7.0:exe:${os.detected.classifier}</protocArtifact>
        </configuration>
    </plugin>

这是java类：

public class ProtobufTrial {
  public static void main(String[] args) throws Exception {
    String jsonString = "";
    MyProto.MyEventMsg.Builder builder = MyProto.MyEventMsg.newBuilder();
    JsonFormat.parser().ignoringUnknownFields().merge(jsonString, builder);
    MyProto.MyEventMsg value = builder.build();

    // This is for printing the proto in string format
    System.out.println(JsonFormat.printer().print(value));
  }
}

Java：JSON - ＆gt; Protobuf＆amp;回转换

10 个答案:

泛型解决方案

消息实例

致Json Generic

来自Json Generic