1

This post does not resolve the issue: ResponseExceptionMapper in cxf client . You will notice that I did in fact register and annotate my Provider, and I tried with WebApplicationException as suggested instead of Exception/CustomException.

Problem Statement: Unable to implement custom client side exception handler using Client (javax.ws.rs.client.Client) API, and @Provider class implementing the ResponseExceptionMapper interface.

Questions:

  1. Does Client API not support custom client side providers for exception handling?
  2. Any literature I looked up for this problem statement uses JAXRSClientFactory implementation; I'm yet to find any using Client API for this scenario. Would I have to switch my implementation?
  3. What is the difference between Client API and JAXRSClientFactory implementations?

I am working on a cxf Client API implementation in Java, and noticed that for http status codes above 300 cxf wraps the Response in either a WebApplicationException or ProcessingException (depending upon the response status code). The server in my case has a customized response body indicating the actual reason for an http status code !200, like below (for response code = 412):

{
"requestError": {
  "serviceException": {
       "messageId": "SVC4120",
       "text": "Invalid Request: Invalid Coupon Code."
    }
  }
}

Unfortunately the WebApplicationException itself does not render this. Instead the only message captured in the exception directly is a generic "412 Precondition Failed". I can do something similar to below exception block from code snippet (includes Client API code snippet):

protected RESPOBJ invoke(String endPointUrl) throws CustomException {
    Object reqPOJO = prepareRequest();
    try {
        if(client == null) {
            ClientBuilder builder = ClientBuilder.newBuilder();
            //register custom JAX-RS components
            builder.register(new CustomMapper());
        }
        WebTarget target = client.target(endPointUrl);
        //do this when queryParams exist
        if(!getUriParams().isEmpty()) {
            for(Map.Entry<String, String> queryParams : getUriParams().entrySet()) {
                target = target.queryParam(queryParams.getKey(), queryParams.getValue());
            }
        }
        Invocation.Builder builder = target.request();
        //create headers here
        MultivaluedMap<String, Object> headers = new MultivaluedHashMap<>();
        if(isBasicAuthRequired()) {
            headers.add(AUTH_HEADER_PARAM, getBasicAuthentication());
        }
        headers.add(CONTENT_TYPE, getMediaType().toString());
        builder.headers(headers);
        builder.accept(getMediaType().toString());
        //GET or POST
        if(HttpMethodType.GET.equals(getHttpMethod())) {
            return builder.get(RESPOBJ.class);
        }
        return builder.post(Entity.entity(reqPOJO, getMediaType()), RESPOBJ.class);
    }
    catch (Exception ex) {
        if(ex instanceof ResponseProcessingException) {
            ResponseProcessingException e = (ResponseProcessingException) ex;
            logger.error("Unmarshalling failed: [" + e.getResponse().readEntity(String.class) + "]");
        }
        else if(ex instanceof WebApplicationException) {
            WebApplicationException e = (WebApplicationException) ex;
            logger.error("Error Response: ["+e.getResponse().readEntity(String.class) + "]");
        }
        throw new CustomException(ex);
    }
}

However, I am looking to implement something cleaner, preferably using a custom Exception handler that implements ResponseExceptionMapper<> interface. From literature I noticed the only implementations of ResponseExceptionMapper for custom client side exception handling are using JAXRSClientFactory. My current implementation however uses the Client API (code snippet below). From a design aspect I will modify this to have a separate CustomExceptionMapper class that would be the Provider only for Exception cases, but I do not see why this Custom class is registered as a Provider (works for 200 status codes as MBR, and the MBW works always) but does not work for exception cases.

Update: While debugging and observing changes between a 200 vs >300 status code (412 in my case), I noticed that for 200 case JAXRSUtils.readFromMessageBodyReader() method gets invoked, which for the 1st time retrieves the Custom Provider. The code never gets here for status codes shown below in code snippet which should be the reason for not finding the CustomMapper. Is there any difference in how I must register my CustomExceptionMapper? Or does the Client API simply not support this functionality?

// for failure case the method above returns null (status > 300), whereas for success 200 case it executes method in last line and gets the provider. // AbstractClient class that invokes the doReadEntity() method which in turn invokes and finds the Provider in JAXRSUtils.readFromMessageBodyReader() method code

protected <T> T readBody(Response r, Message outMessage, Class<T> cls, 
                         Type type, Annotation[] anns) {

    if (cls == Response.class) {
        return cls.cast(r);
    }

    int status = r.getStatus();

    //this is invoked for failure case
    if ((status < 200 || status == 204) && r.getLength() <= 0 || status >= 300) {
        return null;
    }
    //this for 200 status code
    return ((ResponseImpl)r).doReadEntity(cls, type, anns);                                                
}

//My custom provider code
@Provider
@Consumes
@Produces(MediaType.APPLICATION_JSON)
public class CustomMapper implements MessageBodyReader<CustomResponse>, MessageBodyWriter<CustomRequest>, ResponseExceptionMapper<CustomException> {
    private Gson gson = new GsonBuilder().excludeFieldsWithoutExposeAnnotation().create();

    @Override
    public boolean isReadable(Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType) {
        return type.isAssignableFrom(CustomResponse.class);
    }

    @Override
    public CustomResponse readFrom(Class<CustomResponse> type, Type genericType, Annotation[] annotations,
        MediaType mediaType, MultivaluedMap<String, String> httpHeaders, InputStream entityStream) throws IOException, WebApplicationException {
        CustomResponse respObj = new CustomResponse();
        //json to pojo code
        return respObj;
    }

    @Override
    public long getSize(CustomRequest reqObj, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType) {
        return -1;
    }

    @Override
    public boolean isWriteable(Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType) {
        return type.isAssignableFrom(CustomRequest.class);
    }

    @Override
    public void writeTo(CustomRequest reqObj, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType,
        MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream) throws IOException, WebApplicationException {
        entityStream.write(gson.toJson(reqObj).getBytes());
    }

    @Override
    public CustomException fromResponse(Response exceptionResponse) {
        //Response obj to my CustomException code
        return (CustomException);
    }
}

Questions:

I'm trying to figure out what is done wrong here, and if Client API does not support custom client side exception handling for any reason? What is the difference between Client API and JAXRSClientFactory implementations? I also am looking into possibly using ClientResponseFilter (haven't tried this yet).

Any help appreciated. Thanks.

Sanjeev R
  • 43
  • 6

0 Answers0