JAX-RS / Jersey como personalizar o tratamento de erros?

Estou aprendendo JAX-RS (também conhecido como JSR-311) usando Jersey. Criei com êxito um Recurso Raiz e estou brincando com os parâmetros:

@Path("/hello")
public class HelloWorldResource {

    @GET
    @Produces("text/html")
    public String get(
        @QueryParam("name") String name,
        @QueryParam("birthDate") Date birthDate) {

         // Return a greeting with the name and age
    }
}

Isso funciona muito bem e manipula qualquer formato no código de idioma atual que seja entendido pelo construtor Date (String) (como AAAA / mm / dd e mm / dd / AAAA). Mas se eu fornecer um valor inválido ou não compreendido, recebo uma resposta 404.

Por exemplo:

GET /hello?name=Mark&birthDate=X

404 Not Found

Como posso personalizar esse comportamento? Talvez um código de resposta diferente (provavelmente "400 Request Bad")? Que tal registrar um erro? Talvez adicione uma descrição do problema ("formato de data inválido") em um cabeçalho personalizado para ajudar na solução de problemas? Ou retornar uma resposta de erro inteira com detalhes, junto com um código de status 5xx?

Existem várias abordagens para customizar o comportamento de manipulação de erros com o JAX-RS. Aqui estão três das maneiras mais fáceis.

A primeira abordagem é criar uma classe Exception que estenda o WebApplicationException.

Exemplo:

public class NotAuthorizedException extends WebApplicationException {
     public NotAuthorizedException(String message) {
         super(Response.status(Response.Status.UNAUTHORIZED)
             .entity(message).type(MediaType.TEXT_PLAIN).build());
     }
}

E para lançar essa exceção recém-criada, você simplesmente:

@Path("accounts/{accountId}/")
    public Item getItem(@PathParam("accountId") String accountId) {
       // An unauthorized user tries to enter
       throw new NotAuthorizedException("You Don't Have Permission");
}

Observe que você não precisa declarar a exceção em uma cláusula throws, porque WebApplicationException é uma exceção de tempo de execução. Isso retornará uma resposta 401 para o cliente.

A segunda e mais fácil abordagem é simplesmente construir uma instância do WebApplicationException diretamente no seu código. Essa abordagem funciona desde que você não precise implementar suas próprias exceções de aplicativo.

Exemplo:

@Path("accounts/{accountId}/")
public Item getItem(@PathParam("accountId") String accountId) {
   // An unauthorized user tries to enter
   throw new WebApplicationException(Response.Status.UNAUTHORIZED);
}

Esse código também retorna um 401 para o cliente.

Obviamente, este é apenas um exemplo simples. Você pode tornar a exceção muito mais complexa, se necessário, e pode gerar o código de resposta http sempre que precisar.

Uma outra abordagem é agrupar uma exceção existente, talvez uma ObjectNotFoundExceptionclasse de wrapper pequena que implemente a ExceptionMapperinterface anotada com uma @Provideranotação. Isso informa ao tempo de execução do JAX-RS que, se a Exceção agrupada for gerada, retorne o código de resposta definido em ExceptionMapper.

@Provider
public class BadURIExceptionMapper implements ExceptionMapper<NotFoundException> {

public Response toResponse(NotFoundException exception){

    return Response.status(Response.Status.NOT_FOUND).
    entity(new ErrorResponse(exception.getClass().toString(),
                exception.getMessage()) ).
    build();
}
}

Crie a classe acima. Isso manipulará 404 (NotFoundException) e aqui no método toResponse você poderá fornecer sua resposta personalizada. Da mesma forma, existem ParamException etc. que você precisaria mapear para fornecer respostas personalizadas.

Jersey lança um com.sun.jersey.api.ParamException quando falha ao desmarcar os parâmetros, portanto, uma solução é criar um ExceptionMapper que lida com esses tipos de exceções:

@Provider
public class ParamExceptionMapper implements ExceptionMapper<ParamException> {
    @Override
    public Response toResponse(ParamException exception) {
        return Response.status(Status.BAD_REQUEST).entity(exception.getParameterName() + " incorrect type").build();
    }
}

Você também pode escrever uma classe reutilizável para variáveis ​​anotadas por QueryParam

public class DateParam {
  private SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");

  private Calendar date;

  public DateParam(String in) throws WebApplicationException {
    try {
      date = Calendar.getInstance();
      date.setTime(format.parse(in));
    }
    catch (ParseException exception) {
      throw new WebApplicationException(400);
    }
  }
  public Calendar getDate() {
    return date;
  }
  public String format() {
    return format.format(value.getTime());
  }
}

use-o assim:

private @QueryParam("from") DateParam startDateParam;
private @QueryParam("to") DateParam endDateParam;
// ...
startDateParam.getDate();

Embora o tratamento de erros seja trivial nesse caso (lançando uma resposta de 400), o uso dessa classe permite fatorar o tratamento de parâmetros em geral, que pode incluir o registro etc.

Uma solução óbvia: pegue uma String, converta você mesmo para o Date. Dessa forma, você pode definir o formato desejado, capturar exceções e repetir ou personalizar o erro que está sendo enviado. Para análise, SimpleDateFormat deve funcionar bem.

Estou certo de que existem maneiras de conectar manipuladores para tipos de dados também, mas talvez um pouco de código simples seja tudo o que você precisa nesse caso.

Eu também gosto de StaxMan provavelmente implementaria esse QueryParam como uma String e depois lidaria com a conversão, reconvertendo conforme necessário.

Se o comportamento específico da localidade for o comportamento desejado e esperado, você usaria o seguinte para retornar o erro 400 BAD REQUEST:

throw new WebApplicationException(Response.Status.BAD_REQUEST);

Consulte o JavaDoc para javax.ws.rs.core.Response.Status para obter mais opções.

A documentação do @QueryParam diz

"O tipo T do parâmetro, campo ou propriedade anotado deve:

1) Seja um tipo primitivo
2) Tenha um construtor que aceite um único argumento String
3) Tenha um método estático chamado valueOf ou fromString que aceite um único argumento String (consulte, por exemplo, Integer.valueOf (String))
4) implementação registrada da javax.ws.rs.ext.ParamConverterProvider SPI de extensão JAX-RS que retorna uma instância javax.ws.rs.ext.ParamConverter capaz de uma conversão "da cadeia de caracteres" para o tipo.
5) Seja List, Set ou SortedSet, onde T satisfaz 2, 3 ou 4 acima. A coleção resultante é somente leitura. "

Se você deseja controlar qual resposta vai para o usuário quando o parâmetro de consulta no formulário String não pode ser convertido para o seu tipo T, você pode lançar WebApplicationException. O Dropwizard vem com as seguintes classes * Param que você pode usar para suas necessidades.

BooleanParam, DateTimeParam, IntParam, LongParam, LocalDateParam, NonEmptyStringParam, UUIDParam. Vejo https://github.com/dropwizard/dropwizard/tree/master/dropwizard-jersey/src/main/java/io/dropwizard/jersey/params

Se você precisar do Joda DateTime, use o Dropwizard DateTimeParam .

Se a lista acima não atender às suas necessidades, defina sua própria extensão estendendo AbstractParam. Substituir método de análise. Se você precisar de controle sobre o corpo da resposta a erros, substitua o método de erro.

Bom artigo de Coda Hale sobre isso está em http://codahale.com/what-makes-jersey-interesting-parameter-classes/

import io.dropwizard.jersey.params.AbstractParam;

import java.util.Date;

import javax.ws.rs.core.Response;
import javax.ws.rs.core.Response.Status;

public class DateParam extends AbstractParam<Date> {

    public DateParam(String input) {
        super(input);
    }

    @Override
    protected Date parse(String input) throws Exception {
        return new Date(input);
    }

    @Override
    protected Response error(String input, Exception e) {
        // customize response body if you like here by specifying entity
        return Response.status(Status.BAD_REQUEST).build();
    }
}

O construtor Date (String arg) foi descontinuado. Eu usaria as classes de data do Java 8 se você estivesse no Java 8. Caso contrário, o joda date time é recomendado.

Este é o comportamento correto, na verdade. Jersey tentará encontrar um manipulador para sua entrada e tentará construir um objeto a partir da entrada fornecida. Nesse caso, ele tentará criar um novo objeto Date com o valor X fornecido ao construtor. Como essa é uma data inválida, por convenção, Jersey retornará 404.

O que você pode fazer é reescrever e colocar a data de nascimento como uma String e, em seguida, tentar analisar e, se você não conseguir o que deseja, poderá liberar qualquer exceção que desejar por qualquer mecanismo de mapeamento de exceção (existem vários )

Eu estava enfrentando o mesmo problema.

Eu queria pegar todos os erros em um local central e transformá-los.

A seguir, está o código de como eu lidei com isso.

Crie a seguinte classe que implementa ExceptionMappere adicione @Provideranotações nessa classe. Isso irá lidar com todas as exceções.

Substitua o toResponsemétodo e retorne o objeto Response preenchido com dados customizados.

//ExceptionMapperProvider.java
/**
 * exception thrown by restful endpoints will be caught and transformed here
 * so that client gets a proper error message
 */
@Provider
public class ExceptionMapperProvider implements ExceptionMapper<Throwable> {
    private final ErrorTransformer errorTransformer = new ErrorTransformer();

    public ExceptionMapperProvider() {

    }

    @Override
    public Response toResponse(Throwable throwable) {
        //transforming the error using the custom logic of ErrorTransformer 
        final ServiceError errorResponse = errorTransformer.getErrorResponse(throwable);
        final ResponseBuilder responseBuilder = Response.status(errorResponse.getStatus());

        if (errorResponse.getBody().isPresent()) {
            responseBuilder.type(MediaType.APPLICATION_JSON_TYPE);
            responseBuilder.entity(errorResponse.getBody().get());
        }

        for (Map.Entry<String, String> header : errorResponse.getHeaders().entrySet()) {
            responseBuilder.header(header.getKey(), header.getValue());
        }

        return responseBuilder.build();
    }
}

// ErrorTransformer.java
/**
 * Error transformation logic
 */
public class ErrorTransformer {
    public ServiceError getErrorResponse(Throwable throwable) {
        ServiceError serviceError = new ServiceError();
        //add you logic here
        serviceError.setStatus(getStatus(throwable));
        serviceError.setBody(getBody(throwable));
        serviceError.setHeaders(getHeaders(throwable));

    }
    private String getStatus(Throwable throwable) {
        //your logic
    }
    private Optional<String> getBody(Throwable throwable) {
        //your logic
    }
    private Map<String, String> getHeaders(Throwable throwable) {
        //your logic
    }
}

//ServiceError.java
/**
 * error data holder
 */
public class ServiceError {
    private int status;
    private Map<String, String> headers;
    private Optional<String> body;
    //setters and getters
}

Abordagem 1: estendendo a classe WebApplicationException

Crie uma nova exceção estendendo WebApplicationException

public class RestException extends WebApplicationException {

         private static final long serialVersionUID = 1L;

         public RestException(String message, Status status) {
         super(Response.status(status).entity(message).type(MediaType.TEXT_PLAIN).build());
         }
}

Agora lance 'RestException' sempre que necessário.

public static Employee getEmployee(int id) {

         Employee emp = employees.get(id);

         if (emp == null) {
                 throw new RestException("Employee with id " + id + " not exist", Status.NOT_FOUND);
         }
         return emp;
}

Você pode ver a inscrição completa neste link .

Abordagem 2: Implementar ExceptionMapper

O mapeador a seguir lida com exceção do tipo 'DataNotFoundException'

@Provider
public class DataNotFoundExceptionMapper implements
        ExceptionMapper<DataNotFoundException> {

    @Override
    public Response toResponse(DataNotFoundException ex) {
        ErrorMessage model = new ErrorMessage(ex.getErrorCode(),
                ex.getMessage());
        return Response.status(Status.NOT_FOUND).entity(model).build();
    }

}

Você pode ver a inscrição completa neste link .

Apenas como uma extensão para a resposta de Steven Lavine, caso você queira abrir a janela de login do navegador. Achei difícil retornar corretamente a resposta ( autenticação HTTP MDN ) do filtro, caso o usuário ainda não estivesse autenticado

Isso me ajudou a criar a resposta para forçar o login do navegador, observe as modificações adicionais dos cabeçalhos. Isso definirá o código de status como 401 e definirá o cabeçalho que faz com que o navegador abra a caixa de diálogo nome de usuário / senha.

// The extended Exception class
public class NotLoggedInException extends WebApplicationException {
  public NotLoggedInException(String message) {
    super(Response.status(Response.Status.UNAUTHORIZED)
      .entity(message)
      .type(MediaType.TEXT_PLAIN)
      .header("WWW-Authenticate", "Basic realm=SecuredApp").build()); 
  }
}

// Usage in the Filter
if(headers.get("Authorization") == null) { throw new NotLoggedInException("Not logged in"); }