Jersey ignores ExceptionMapper

Question

I made an ExceptionMapper to catch and log all exceptions, like:

@Provider
public class CatchAllExceptionsMapper implements ExceptionMapper<Throwable> {
    private static final Logger LOG = LoggerFactory.getLogger(CatchAllExceptionsMapper.class);
    @Override
    public Response toResponse(Throwable exception) {
        LOG.error("Exception not catched!", exception);
        return Response.serverError().build();
    }
}

It catches the Exceptions my code throws, but if I send a Request with a JSON value that throws an IllegalStateException at my object's creation, this ExceptionMapper is ignored and I get a 400 Bad Request Response.

Funny thing is this Response is not the traditional Tomcat HTML formatted Response, its just plain text. It say just:

Cannot construct instance of `com.example.vo.AutoValue_Customer$Builder`, problem: First name is null or empty. at [Source: (org.glassfish.jersey.message.internal.ReaderInterceptorExecutor$UnCloseableInputStream); line: 14, column: 1]

I thought this might be something short-circuiting Jersey, but my @PreMatching ContainerRequestFilter is executed beforehand, so I really have no idea why the 400 Response is not the traditional HTML one from Tomcat.

Why is this happening? What can I do to catch this and return my own Response?

There is probably another exception mapper handling this. Only one mapper will be called per request. The one with the closest exception type to the type of the exception will be used. If you are using the Jackson provider, it is likely its mapper is being used. It is known to spit out the exception message as the response. — Paul Samsotha, Jun 30 '19 at 18:52
I only made one ExceptionMapper, how can I confirm its Jackson's one? — Michel Feinstein, Jun 30 '19 at 18:53
The JacksonFeature in that module will automatically register the Jackson exception mappers. You can override the mappers by creating your own for both JsonMappingException and JsonParseException. — Paul Samsotha, Jun 30 '19 at 18:59
But how will Jersey know which one to invoke? Mine or Jackson's? If both of them have the same type — Michel Feinstein, Jun 30 '19 at 19:02
I don't really know how but it always does. That's all I can say about it. — Paul Samsotha, Jun 30 '19 at 19:03
Haha ok, probably the last registered one gets preference I guess... I would guess an internal map gets overriden — Michel Feinstein, Jun 30 '19 at 19:04
Paul, I found the `JsonMappingExceptionMapper` code and it doesn't have the `@Provider` annotation, isn't it obligatory to have one once registered? — Michel Feinstein, Jun 30 '19 at 21:32
I discovered that the order matters, `JacksonFeature` has to be registered last for this to work. — Michel Feinstein, Jun 30 '19 at 22:30
`@Provider` is only needed for discovery during scanning. It's not needed if registered manually. Jersey already recognizes certain interfaces to be "providers." — Paul Samsotha, Jun 30 '19 at 23:52
I see... now I am getting a curious result, I have 2 Resource classes: `@Path("/customers")` and `@Path("/keepalive")`, all is working, but if I change keepalive to `@Path("/customers/keepalive")` my ExceptionMappers get ignored and Jackon returns his own Response — Michel Feinstein, Jul 01 '19 at 00:02
FIY using `@Priority(1)` in my own Exception Mappers did the trick. — Michel Feinstein, Jul 09 '19 at 23:24

Michel Feinstein · Accepted Answer · 2019-07-09T23:23:12.710

As stated by Paul Samsotha in the comments, JacksonFeature from the jersey-media-json-jackson package define some ExceptionMappers, like JsonMappingException and JsonParseException. The solution is to create our own, register them within the ResourceConfig and register JacksonFeature last, otherwise it won't work.

e.g.

@Provider
@Priority(1) // hack for overriding other implementations.
public class JsonMappingExceptionMapper implements ExceptionMapper<JsonMappingException> {
    @Override
    public Response toResponse(JsonMappingException exception) {        
        return Response.status(Status.BAD_REQUEST).build();
    }
}


@Provider
@Priority(1) // hack for overriding other implementations.
public class JsonParseExceptionMapper implements ExceptionMapper<JsonParseException> {
    @Override
    public Response toResponse(JsonParseException exception) {        
        return Response.status(Status.BAD_REQUEST).build();
    }
}

public class MyResourceConfig extends ResourceConfig {
    public MyResourceConfig() {
        register(CatchAllExceptionsMapper.class);
        register(JsonMappingExceptionMapper.class);
        register(JsonParseExceptionMapper.class);
        register(JacksonFeature.class);
    }
}

Jersey ignores ExceptionMapper

1 Answers1