How does MessageBodyReader know what the generic type is?

Question

I have a MessageBodyReader with the following class:

@Provider
@Consumes(MediaType.APPLICATION_JSON)
public class TransactionMessageBodyReader implements MessageBodyReader<Transaction<Customer>> 

boolean isReadable(Class<?> type,
                       Type genericType,
                       Annotation[] annotations,
                       MediaType mediaType)

And I have the following REST endpoint:

@POST
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
@Path("trans")
public Response checkStatus(Transaction<Customer> transaction) { ... }

In my debugger I have a breakpoint on isReadable and it hits the breakpoint before calling the checkStatus method. Good so far. I can see in my debugger that the genericType says Transaction<Customer> ... in other words, it knows about the type information. How can it possibly know the type information when Java type erasure erases it to just be Transaction at runtime? I see that the genericType is made up of an ParameterizedType which I believe is used to pass type information around (to get around the type erasure problem). However, how is Jersey populating the genericType automatically? Because I never specified type information except in the method headers that I posted above.

Also, a second question: if Jersey 'automatically' knows so much about my types, why do I need a MessageBodyReader at all? Isn't there some easier way to use generics with Jersey/REST endpoints and make it "just work"?

Answer 1

Take a look at the javadoc.

genericType - the type of instance to be produced. E.g. if the message body is to be converted into a method parameter, this will be the formal type of the method parameter as returned by Method.getGenericParameterTypes.

Generic parameterization in classes, methods, and fields is maintained in the corresponding .class files. This is obviously necessary for compilation. You wouldn't be able to package and use Java classes as a library if this wasn't the case.

Reflection exposes this type information (and more).

Jersey basically scans your classes for handler methods, ones annotated with @POST and the like and retrieves corresponding Method objects. Once it has that, it can use Method#getGenericParameterTypes()

Returns an array of Type objects that represent the formal parameter types, in declaration order, of the executable represented by this object. Returns an array of length 0 if the underlying executable takes no parameters.

If a formal parameter type is a parameterized type, the Type object returned for it must accurately reflect the actual type parameters used in the source code.

On other words, the Type has to represent both the parameter's raw type and its parameterization, if it has one.

So Jersey retrieves those types and feeds them into your MessageBodyReader. The expectation is that your implementation should be able to handle the genericType.

I don't know Jersey that well, but if it follows the same strategy as Spring MVC, it will simply iterate over all the MessageBodyReader instances that were registered. It doesn't actually care about its type (eg. your TransactionMessageBodyReader), that's why it relies on isReadable. It could theoretically keep a mapping of types to MessageBodyReader implementations, but that becomes unwieldy in the end and less flexible. In any case, an application doesn't typically have that many types/formats it can serialize to, so iterating a few objects isn't that big of a deal.

---

Since Java 8, you also have access to Executable#getParameters (Method is a subtype of Executable).

---

Here's an example of what Jersey could do

public class StackOverflow {
    public static void main(String[] args) throws Exception {
        Method method = StackOverflow.class.getDeclaredMethod("method", List.class);
        Type[] parameterTypes = method.getGenericParameterTypes();
        for (Type parameterType : parameterTypes) {
            System.out.println(parameterType.getClass());
            System.out.println(parameterType);
            ParameterizedType parameterizedType = (ParameterizedType) parameterType;
            System.out
                    .println(parameterizedType.getRawType().getTypeName() + "<" + parameterizedType.getActualTypeArguments()[0].getTypeName() + ">");
        }
    }

    public String method(List<StackOverflow> parameter) {
        return "example";

    }
}

prints

class sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl
java.util.List<com.example.StackOverflow>
java.util.List<com.example.StackOverflow>