使用groovy循环模板GStringTemplateEngine（）(looping a template using groovy GStringTemplateEngine())

 您可以使用JAX-RS API的HttpHeaders管理由ExceptionMapper返回的适当格式，并获取请求实体的MediaType ，请参阅javadoc： http : //docs.oracle.com/javaee/7/api/javax/ws /rs/core/HttpHeaders.html#getMediaType-- 
 
 所以你的代码如下： 
 
@Provider
public class GenericExceptionMapper implements ExceptionMapper<Exception> {

    @Context
    private HttpHeaders m_headers;

    private final Logger LOG = LoggerFactory.getLogger(GenericExceptionMapper.class);

    @Override
    public Response toResponse(Exception exception) {
        ErrorResponse errorResponse = new ErrorResponse(exception.getClass().getSimpleName(), exception.getMessage());

        if (exception instanceof WebApplicationException) {
            LOG.error("Type: {}", exception.getClass().getSimpleName());
            LOG.error("Message: {}", exception.getMessage());
            WebApplicationException webApplicationException = (WebApplicationException) exception;
            return Response.status(webApplicationException.getResponse().getStatus()).entity(errorResponse).build();
        }

        return Response.serverError().entity(errorResponse).type(m_headers.getMediaType()).build();
    }
}

In case of custom exceptions which extend WebApplicationException such as
 
public class MyCustomException extends WebApplicationException 
 
does not require an explicit ExceptionMapper<MyCustomerException> for exception handling and response creation. 
 
ExceptionMapper can be very helpful to handle exceptions which derive from Exception (or its subclasses) but not WebApplicationException (and its subclasses) (note WebApplicationException is also a child class of Exception)
 
For example ExceptionMapper can be used to handle an exception such as IllegalArgumentException and creating a response.
 
In both case above the response can be serialized according to the @Producesspecified on the Resource method.
 
However after looking at the spec implementation of RestEasy I found out, the even for WebApplicationException(s), if an ExceptionMapper is @Provided by the rest service, it will be trigged. 
 
resteasy-jaxrs:3.1.0.Final
class: ExceptionHandler
method: public Response handleException(HttpRequest request, Throwable e)

  // First try and handle it with a mapper
  if ((jaxrsResponse = executeExceptionMapper(e)) != null) {
     return jaxrsResponse;
  }
 
So either I make sure that ExceptionMapper is used for some specific Exceptions such as ExceptionMapper<IllegalArgumentException> instead of catching all exceptions as shown above in the code ExceptionMapper<Exception> or simply return the response as shown in the code below:
 
 if (exception instanceof WebApplicationException) {
    WebApplicationException webApplicationException = (WebApplicationException) exception;
    return webApplicationException.getResponse();
}
 
The serialization error will not occur. Why? because the framework takes care of this (based on @Produces annotation it will serialize the response for NON WebApplicationException based responses. And for WebApplicationException based response as shown above, framework will take care of the response as well (since ErrorResponse entity was never used)
 
However coming to the problem mentioned in this ticket. NotAllowedException occurs in the spec implementation code before the method associated with URI gets executed. Thus the @Produces annotation doesn't take effect and while Marshalling the response, a default MediaType octet-stream is used.
 
resteasy-jaxrs:3.1.0.Final
class: SegmentNode
method: public Match match(List<Match> matches, String httpMethod, HttpRequest request)
 
So while the following exceptions occur; DefaultOptionsMethodException NotAllowedException NotSupportedException NotAcceptableException
 
request attribute RESTEASY_CHOSEN_ACCEPT doesn't get set
 
  request.setAttribute(RESTEASY_CHOSEN_ACCEPT, sortEntry.getAcceptType());
  return sortEntry.match;
 
and when the server tries to write a response it doesn't find the MediaType (as we never set it while creating a response object)
 
resteasy-jaxrs:3.1.0.Final
class: ServerResponseWriter
method: public static void writeNomapResponse(BuiltResponse jaxrsResponse, final HttpRequest request, ...

 if (jaxrsResponse.getEntity() != null && jaxrsResponse.getMediaType() == null) {
     setDefaultContentType(request, jaxrsResponse, providerFactory, method);
 }
 
It tries to set it from method annotations; which as mentioned before were never set, since the NotAllowedException occurred before RESTEASY_CHOSEN_ACCEPT could have been set.
 
It finds a wild card as no accept headers were specified and thus octet stream was set
 
resteasy-jaxrs:3.1.0.Final
class: ServerResponseWriter
method: protected static void setDefaultContentType(HttpRequest request, BuiltResponse ...
if (chosen.isWildcardType()) {
     chosen = MediaType.APPLICATION_OCTET_STREAM_TYPE;
}
 
(this a just a summary; for detailed steps I must go back to the spec implementation code)
 
Thus I must specify a mediatype. This can done looking at the HttpHeaders from @Context to make it dynamic or if nothing is specified in the headers as in my case, I provide a default MediaType Application/XML for serialization to proceed.
 
Hope this helps someone also facing the same issue.