Manejo de la respuesta de error personalizada en la biblioteca de cliente JAX-RS 2.0

Hay otras formas de obtener un mensaje de error personalizado para el cliente Jersey además de escribir un filtro personalizado. (aunque el filtro es una solución excelente)

1) Pase el mensaje de error en un campo de encabezado HTTP. El mensaje de error de detalle podría estar en la respuesta JSON y en un campo de encabezado adicional, como "x-error-message".

El servidor agrega el encabezado de error HTTP.

ResponseBuilder rb = Response.status(respCode.getCode()).entity(resp);
if (!StringUtils.isEmpty(errMsg)){
    rb.header("x-error-message", errMsg);
}
return rb.build();

El Cliente captura la excepción, NotFoundException en mi case, y lee el encabezado de la respuesta.

try {
    Integer accountId = 2222;
    Client client = ClientBuilder.newClient();
    WebTarget webTarget = client.target("http://localhost:8080/rest-jersey/rest");
    webTarget = webTarget.path("/accounts/"+ accountId);
    Invocation.Builder ib = webTarget.request(MediaType.APPLICATION_JSON);
    Account resp = ib.get(new GenericType<Account>() {
    });
} catch (NotFoundException e) {
    String errorMsg = e.getResponse().getHeaderString("x-error-message");
    // do whatever ...
    return;
}

2) Otra solución es capturar la excepción y leer el contenido de la respuesta.

try {
    // same as above ...
} catch (NotFoundException e) {
    String respString = e.getResponse().readEntity(String.class);
    // you can convert to JSON or search for error message in String ...
    return;
} 

La clase WebApplicationException fue diseñada para eso, pero por alguna razón ignora y sobrescribe lo que especifique como parámetro para el mensaje.

Por esa razón he creado mi propia extensión WebAppException que respeta los parámetros. Es una sola clase y no requiere ningún filtro de respuesta o un mapeador.

Prefiero excepciones que crear un Response ya que se puede lanzar desde cualquier lugar mientras se procesa.

Uso simple:

throw new WebAppException(Status.BAD_REQUEST, "Field 'name' is missing.");

El clase:

import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.Response.Status;
import javax.ws.rs.core.Response.Status.Family;
import javax.ws.rs.core.Response.StatusType;

public class WebAppException extends WebApplicationException {
    private static final long serialVersionUID = -9079411854450419091L;

    public static class MyStatus implements StatusType {
        final int statusCode;
        final String reasonPhrase;

        public MyStatus(int statusCode, String reasonPhrase) {
            this.statusCode = statusCode;
            this.reasonPhrase = reasonPhrase;
        }

        @Override
        public int getStatusCode() {
            return statusCode;
        }
        @Override
        public Family getFamily() {
            return Family.familyOf(statusCode);
        }
        @Override
        public String getReasonPhrase() {
            return reasonPhrase;
        }
    }

    public WebAppException() {
    }

    public WebAppException(int status) {
        super(status);
    }

    public WebAppException(Response response) {
        super(response);
    }

    public WebAppException(Status status) {
        super(status);
    }

    public WebAppException(String message, Response response) {
        super(message, response);
    }

    public WebAppException(int status, String message) {
        super(message, Response.status(new MyStatus(status, message)). build());
    }

    public WebAppException(Status status, String message) {
        this(status.getStatusCode(), message);
    }

    public WebAppException(String message) {
        this(500, message);
    }

}

Las siguientes obras para mí

Response.status(Response.Status.BAD_REQUEST).entity(e.getMessage()).build();

Una solución mucho más concisa para cualquiera que tropiece con esto:

Llamando a .get(Class<T> responseType) o cualquiera de los otros métodos que toman el tipo resultado como un argumento Invocation.Builder devolverá un valor del tipo deseado en lugar de un Response. Como efecto secundario, estos métodos verificarán si el código de estado recibido está en el rango 2xx y lanzarán un WebApplicationException apropiado de lo contrario.

De la documentación :

Lanza: WebApplicationException en caso de que la respuesta código de estado de la respuesta devuelta por el servidor no es exitosa y el el tipo de respuesta especificado no es Respuesta.

Esto permite capturar el WebApplicationException, recuperar el Response real, procesar la entidad contenida como detalles de excepción (ApiExceptionInfo) y lanzar una excepción apropiada (ApiException).

public <Result> Result get(String path, Class<Result> resultType) {
    return perform("GET", path, null, resultType);
}

public <Result> Result post(String path, Object content, Class<Result> resultType) {
    return perform("POST", path, content, resultType);
}

private <Result> Result perform(String method, String path, Object content, Class<Result> resultType) {
    try {
        Entity<Object> entity = null == content ? null : Entity.entity(content, MediaType.APPLICATION_JSON);
        return client.target(uri).path(path).request(MediaType.APPLICATION_JSON).method(method, entity, resultType);
    } catch (WebApplicationException webApplicationException) {
        Response response = webApplicationException.getResponse();
        if (response.getMediaType().equals(MediaType.APPLICATION_JSON_TYPE)) {
            throw new ApiException(response.readEntity(ApiExceptionInfo.class), webApplicationException);
        } else {
            throw webApplicationException;
        }
    }
}

ApiExceptionInfo es un tipo de datos personalizado en mi aplicación:

import lombok.Data;

@Data
public class ApiExceptionInfo {

    private int code;

    private String message;

}

ApiException es el tipo de excepción personalizado en mi aplicación:

import lombok.Getter;

public class ApiException extends RuntimeException {

    @Getter
    private final ApiExceptionInfo info;

    public ApiException(ApiExceptionInfo info, Exception cause) {
        super(info.toString(), cause);
        this.info = info;
    }

}