Calling parseFrom() method for generic protobuffer class in java

Question

I'm calling an api to get the an input stream and then call static method parseFrom(inputstream) to convert it to the protobuffclass.

If I do it with a specific class it works:

public CustomerDTOOuterClass.CustomerDTO GetCustomer()
{
    CustomerDTOOuterClass.CustomerDTO customer = null;
    try
    {
        URL url = new URL("https://localhost:44302/Api/customer/1?");

        HttpsURLConnection conn = (HttpsURLConnection)url.openConnection();
        conn.setRequestMethod("GET");
        conn.setRequestProperty("Content-Type", "application/x-protobuf");
        conn.connect();

        InputStream is = conn.getInputStream();

        CustomerDTOOuterClass.CustomerDTO customer =
                CustomerDTOOuterClass.CustomerDTO.parseFrom(is);

        conn.disconnect();
    }
    catch(Exception ex)
    {
        System.out.println("[ "+ex.getMessage()+" ]");
    }

    return customer;
}

but if I change it to generic type it fails because T doesn't have the method parseFrom, is there any interface I could implement in T so I can call the parseFrom method?

public T GetObject()
{
    T object = null;
    try
    {
        URL url = new URL("https://localhost:44302/Api/customer/1?");

        HttpsURLConnection conn = (HttpsURLConnection)url.openConnection();
        conn.setRequestMethod("GET");
        conn.setRequestProperty("Content-Type", "application/x-protobuf");
        conn.connect();

        InputStream is = conn.getInputStream();

        T object = T.parseFrom(is);

        conn.disconnect();
    }
    catch(Exception ex)
    {
        System.out.println("[ "+ex.getMessage()+" ]");
    }

    return object;
}

this is the error I get: Error:(68, 27) error: cannot find symbol method parseFrom(InputStream)

Two things found with quick search, maybe one helps: http://stackoverflow.com/questions/4035027/generic-parsing-of-pb-in-java and http://www.transylvania-jug.org/archives/365 — The111, Dec 24 '14 at 21:09
Can you tell us what you trying to achieve. You could look at DynamicMessage's if your processing is very generic. Alternatively you could pass in a Builder class to getObject() method and use the mergeFrom method of the builder class — Bruce Martin, Dec 24 '14 at 21:40
You cant really do this? Serialized protos don't know their own type. — Louis Wasserman, Dec 24 '14 at 22:08

score 12 · Answer 1 · answered Dec 26 '14 at 01:36

12

Every generated protobuf type contains a static member called PARSER which is an implementation of the com.google.protobuf.Parser<T> interface. Your getObject method simply needs to take a Parser<T> as a parameter. So then you'd call it like:

Foo foo = getObject(Foo.PARSER);

answered Dec 26 '14 at 01:36

Kenton Varda

41,353
8
121
105

Good answer, I was interested in how this would play out so I hacked around with it a bit and expanded in a separate answer, hope you don't mind! – The111 Dec 26 '14 at 03:49

gub · Answer 2 · 2015-11-13T20:40:06.917

If you want to do this for T, it's easier and more natural to pass the Class<T> (i.e. the class of the Proto type) into the constructor of your class, and then obtain the Parser from that like this:

public class Thing<T extends Message> {
    final Parser<T> parser;

    Thing(Class<T> cls) {
        parser = (Parser<T>) cls.getMethod("parser").invoke(null);
    }

    T deserialize(byte[] bytes) {
        parser.parseFrom(bytes);  // try/catch etc
    }
}

score 1 · Answer 3 · answered Dec 26 '14 at 03:49

To expand on Kenton Varda's answer:

First I'd refactor your method into separate methods for getting the input stream and parsing it. Only the latter has any reason to be generic.

public InputStream getInputStream() {
  // get it
}

Now you intend to parse the input stream and build a POJO from the protobuf. It's reasonable IMO to expect that at this point your code must be aware of what type of object you're going to get, because otherwise how would you do something intelligent with it next? E.g.

InputStream is = getInputStream();
Object o = parseGenericInputStream(is);
doSomethingWithParsedObject(o); // how to do this if you don't know o's type?

You reasonably must know o's type once you've parsed it (and therefore before you parse it), otherwise you can't do anything meaningful with it that I can think of.

So... again with credit to Kenton Varda:

public void doStuff() {
  ...
  InputStream is = getInputStream();
  MyProtobufClass pojo = parseGenericInputStream(MyProtobufClass.PARSER, is);
  doSomethingWithParsedObject(pojo);
  ...
}

private <T> T parseGenericInputStream(Parser<T> parser, InputStream inputStream)
    throws InvalidProtocolBufferException {
  return parser.parseFrom(inputStream);
}

At this point though you're writing a generic method for one line of code, which is kind of not worth it if you ask me.

Louis Wasserman · Answer 4 · 2014-12-25T09:50:34.517

0

No, there is not; you cannot deserialize a proto without knowing its type.

If you do know its type, then you can pass in a Builder for its type, however.

(Additionally, you can't call static methods on a type variable like T.)

edited Dec 25 '14 at 09:50

answered Dec 24 '14 at 23:05

Louis Wasserman

191,574
25
345
413

Calling parseFrom() method for generic protobuffer class in java

4 Answers4

Linked