处理JAX中的自定义错误响应
我开始在JAX-RS中使用新的客户端API库，并且非常喜欢它。 但是我发现了一件我无法弄清楚的事情。 我使用的API有一个自定义的错误消息格式，例如：
{
"code": 400,
"message": "This is a message which describes why there was a code 400."
}
它返回400作为状态码，但还包含一个描述性错误消息，告诉你你做错了什么。
然而，JAX-RS 2.0客户端将400状态重新映射成通用的，我失去了良好的错误信息。 它正确地将其映射到BadRequestException，但带有通用的“HTTP 400 Bad Request”消息。
javax.ws.rs.BadRequestException: HTTP 400 Bad Request
at org.glassfish.jersey.client.JerseyInvocation.convertToException(JerseyInvocation.java:908)
at org.glassfish.jersey.client.JerseyInvocation.translate(JerseyInvocation.java:770)
at org.glassfish.jersey.client.JerseyInvocation.access$500(JerseyInvocation.java:90)
at org.glassfish.jersey.client.JerseyInvocation$2.call(JerseyInvocation.java:671)
at org.glassfish.jersey.internal.Errors.process(Errors.java:315)
at org.glassfish.jersey.internal.Errors.process(Errors.java:297)
at org.glassfish.jersey.internal.Errors.process(Errors.java:228)
at org.glassfish.jersey.process.internal.RequestScope.runInScope(RequestScope.java:424)
at org.glassfish.jersey.client.JerseyInvocation.invoke(JerseyInvocation.java:667)
at org.glassfish.jersey.client.JerseyInvocation$Builder.method(JerseyInvocation.java:396)
at org.glassfish.jersey.client.JerseyInvocation$Builder.get(JerseyInvocation.java:296)
是否有某种拦截器或自定义错误处理程序可以注入，以便我可以访问真正的错误消息。 我一直在查看文档，但看不到任何方式。
我现在正在使用Jersey，但是我使用CXF尝试了这一点，并得到了相同的结果。 这是代码的样子。
Client client = ClientBuilder.newClient().register(JacksonFeature.class).register(GzipInterceptor.class);
WebTarget target = client.target("https://somesite.com").path("/api/test");
Invocation.Builder builder = target.request()
.header("some_header", value)
.accept(MediaType.APPLICATION_JSON_TYPE)
.acceptEncoding("gzip");
MyEntity entity = builder.get(MyEntity.class);
更新：
我实施了下面评论中列出的解决方案。 它与JAX-RS 2.0客户端API中的类稍有不同，稍有不同。 我仍然认为默认行为是给出一个通用的错误信息并放弃真正的错误信息是错误的。 我明白为什么它不会解析我的错误对象，但应该返回未解析的版本。 我最终得到了库已经执行的复制异常映射。
谢谢您的帮助。
这是我的过滤器类：
@Provider
public class ErrorResponseFilter implements ClientResponseFilter {
private static ObjectMapper _MAPPER = new ObjectMapper();
@Override
public void filter(ClientRequestContext requestContext, ClientResponseContext responseContext) throws IOException {
// for non-200 response, deal with the custom error messages
if (responseContext.getStatus() != Response.Status.OK.getStatusCode()) {
if (responseContext.hasEntity()) {
// get the "real" error message
ErrorResponse error = _MAPPER.readValue(responseContext.getEntityStream(), ErrorResponse.class);
String message = error.getMessage();
Response.Status status = Response.Status.fromStatusCode(responseContext.getStatus());
WebApplicationException webAppException;
switch (status) {
case BAD_REQUEST:
webAppException = new BadRequestException(message);
break;
case UNAUTHORIZED:
webAppException = new NotAuthorizedException(message);
break;
case FORBIDDEN:
webAppException = new ForbiddenException(message);
break;
case NOT_FOUND:
webAppException = new NotFoundException(message);
break;
case METHOD_NOT_ALLOWED:
webAppException = new NotAllowedException(message);
break;
case NOT_ACCEPTABLE:
webAppException = new NotAcceptableException(message);
break;
case UNSUPPORTED_MEDIA_TYPE:
webAppException = new NotSupportedException(message);
break;
case INTERNAL_SERVER_ERROR:
webAppException = new InternalServerErrorException(message);
break;
case SERVICE_UNAVAILABLE:
webAppException = new ServiceUnavailableException(message);
break;
default:
webAppException = new WebApplicationException(message);
}
throw webAppException;
}
}
}
}
我相信你想要做这样的事情：
Response response = builder.get( Response.class );
if ( response.getStatusCode() != Response.Status.OK.getStatusCode() ) {
System.out.println( response.getStatusType() );
return null;
}
return response.readEntity( MyEntity.class );
你可以尝试的另一件事（因为我不知道这个API放在哪里 - 即在头或实体或什么）是：
Response response = builder.get( Response.class );
if ( response.getStatusCode() != Response.Status.OK.getStatusCode() ) {
// if they put the custom error stuff in the entity
System.out.println( response.readEntity( String.class ) );
return null;
}
return response.readEntity( MyEntity.class );
如果您希望将REST响应代码映射到Java异常，则可以添加客户端过滤器来执行此操作：
class ClientResponseLoggingFilter implements ClientResponseFilter {
@Override
public void filter(final ClientRequestContext reqCtx,
final ClientResponseContext resCtx) throws IOException {
if ( resCtx.getStatus() == Response.Status.BAD_REQUEST.getStatusCode() ) {
throw new MyClientException( resCtx.getStatusInfo() );
}
...
在上面的过滤器中，您可以为每个代码创建特定的异常，或创建一个包装响应代码和实体的通用异常类型。
WebApplicationException类是为此设计的，但由于某种原因它忽略并覆盖了您指定为消息参数的内容。
出于这个原因，我创建了我自己的扩展WebAppException来尊重WebAppException 。 它是一个单独的类，它不需要任何响应过滤器或映射器。
我比创建Response更喜欢异常，因为它可以在处理时从任何地方抛出。
简单的用法：
throw new WebAppException(Status.BAD_REQUEST, "Field 'name' is missing.");
报告：
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);
}
}
除了编写自定义过滤器之外，还有其他方法可以向Jersey客户端获取自定义错误消息。 （虽然过滤器是一个很好的解决方案）
1）在HTTP头域中传递错误消息。 详细错误消息可能位于JSON响应中并位于附加标题字段中，如“x-error-message”。
服务器添加HTTP错误标题。
ResponseBuilder rb = Response.status(respCode.getCode()).entity(resp);
if (!StringUtils.isEmpty(errMsg)){
rb.header("x-error-message", errMsg);
}
return rb.build();
客户端捕获异常，在我的情况下是NotFoundException，并读取响应头。
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）另一种解决方案是捕捉异常并阅读响应内容。
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;
}