Mondial de la gestion des exceptions en Jersey & le Printemps?

- Je utiliser jersey2.11 avec Tomcat et presque l'exception de la poignée avec ExceptionMapper.
(Dans le domaine de la logique, seulement DB processus de restauration d'utiliser le code try-catch.)

Je pense que ExceptionMapper avec @Fournisseur automatiquement choisir la bonne ExceptionMapper. Donc je suppose que cette fonction est satisfait "je veux prendre plus de CMIS exception ou d'Exception par défaut ou IO Exception etc."

Ce code est à mes manipulations ExceptionMapper code de conception.

1.Certains Maillot Racine De La Classe De Ressources

@GET
@Produces("application/json")
public String getUser(@NotNull @QueryParam("id") String id, 
  @NotNull @QueryParam("token") String token) throws Exception { //This level throws exceptions handled by ExceptionMapper

  someComplexMethod(id, token); //possible throw Exception, IOException or other exceptions.

  return CLICHED_MESSAGE;
}

2.ExceptionMapper paquet. com.votredomaine.exceptionmapper

AbstractExceptionMapper.java (Tous les ExceptionMapper cette classe étend la classe Abstraite)

public abstract class AbstractExceptionMapper {
  private static Logger logger = LogManager.getLogger(); //Example log4j2.

  protected Response errorResponse(int status, ResponseEntity responseEntity) {
    return customizeResponse(status, responseEntity);
  }

  protected Response errorResponse(int status, ResponseEntity responseEntity, Throwable t) {
    logger.catching(t); //logging stack trace.

    return customizeResponse(status, responseEntity);
  }

  private Response customizeResponse(int status, ResponseEntity responseEntity) {
     return Response.status(status).entity(responseEntity).build();
  }
 }

ExceptionMapper.java (Au moins cette mapper peut attraper une exception qui n'est pas de définir spécifier exception mappeur.)

@Provider
 public class ExceptionMapper extends AbstractExceptionMapper implements
 javax.ws.rs.ext.ExceptionMapper<Exception> {

 @Override
 public Response toResponse(Exception e) {
 //ResponseEntity class's Member Integer code, String message, Object data. For response format.
 ResponseEntity re = new ResponseEntity(Code.ERROR_MISC); 

  return this.errorResponse(HttpStatus.INTERNAL_SERVER_ERROR_500, re, e);
 }
}

WebApplicationExceptionMapper.java (Préciser WebApplicationException)

@Provider
public class WebApplicationExceptionMapper extends AbstractExceptionMapper implements
    ExceptionMapper<WebApplicationException> {

  @Override
  public Response toResponse(WebApplicationException e) {
    ResponseEntity re = new ResponseEntity(Code.ERROR_WEB_APPLICATION);

    return this.errorResponse(e.getResponse().getStatus(), re, e);
  }
}

ConstraintViolationExceptionMapper.java (Préciser Hibernate Validator ConstraintViolationException)

@Provider
public class ConstraintViolationExceptionMapper extends AbstractExceptionMapper implements
    ExceptionMapper<ConstraintViolationException> {

  @Override
  public Response toResponse(ConstraintViolationException e) {
    ResponseEntity re = new ResponseEntity(Code.ERROR_CONSTRAINT_VIOLATION);

    List<Map<String, ?>> data = new ArrayList<>();
    Map<String, String> errorMap;
    for (final ConstraintViolation<?> error : e.getConstraintViolations()) {
      errorMap = new HashMap<>();
      errorMap.put("attribute", error.getPropertyPath().toString());
      errorMap.put("message", error.getMessage());
      data.add(errorMap);
    }

    re.setData(data);

    return this.errorResponse(HttpStatus.INTERNAL_SERVER_ERROR_500, re, e);
  }
}

.. et l'autre à préciser exception peut créer ExceptionMapper classes.

Dans mon expérience, à l'Exception Mappeur de haut niveau idée pour se concentrer à un domaine logique. Il pourrait chasser ennuyeux dispersés bloc try-catch code du domaine de la logique.
Donc j'espère que vous vous sentez le "Oui, je suis" à la Question 3, pour résoudre le problème à votre environnement.

bonne chance.

je ne peux pas "ajouter un commentaire" pour la réponse, j'ai donc ajouter un commentaire ci-dessous.

vous n'avez pas utilisé essayez de l'attraper et de le jeter n'importe où dans l'application.

Mon code de conception de l'utilisation jette à la méthode de ce genre et ce faire gérer par ExceptionMapper classes.

public String getUser(@NotNull @QueryParam("id") String id, 
  @NotNull @QueryParam("token") String token) throws Exception

Donc dans l'approche ci-dessus, j'ai créé, à seulement 1 classe pour toutes les exceptions qui je pourrais m'attendre et pour n'importe quel inconnu exception de la base Exception sera là pour l'attraper.
Maintenant, où que ce soit dans mon application si une exception se produit il s'agit de la CentralControllerException et la réponse adéquate avec le code d'état http est envoyée en retour.
Q. 2. Prévoyez-vous des problème dans l'approche ci-dessus.

Je pense que si un projet simple ou jamais de mise à jour/modifier le projet (cycle de vie des projets à court de temps), une classe d'exception approche de mapper ok.
Mais ... je ne prends jamais de cette approche. Tout simplement, si besoin de gérer plus d'exception, cette méthode à devenir de grands et complexes, et difficiles à lire et à maintenir devenir.

Dans ma politique, de la programmation orientée objet doit utiliser le pléomorphisme stratégie de n'importe quel niveau du code(plan de classe -, DI-plan) et cette approche une partie pour but de conduire si/bloc de commutateurs dans le code. Et cette idée de faire de chaque méthode de code court et simple, claire de "domaine de la logique" et le code de devenir résistants à modifier.

J'ai donc créer implémente ExceptionMapper et délégué à la DI qui ExceptionMapper classe de gérer d'exception.
(Si DI gérer remplacer votre classe unique Si le bloc de gérer la gestion des exceptions, ce qui est généralement le refactoring approche similaire Extrait xxx http://refactoring.com/catalog/extractClass.html.
Dans notre discussion de cas, seule la classe et une méthode trop occupé, de sorte que l'extrait de chaque ExceptionMapper classe approche et DI appeler adapté classe & méthode de stratégie.)

Btw, système résultat du traitement est de même au présent point. Mais en cas de besoin afin de réduire les coûts de développement ,ne devrait pas pris approche d'une classe d'exception régime de traitement. Parce que s'abandonner simplement le code et refactoriser le statut, le code du projet est mort plus rapide.

C'est mon idée, et pourquoi ce.

ce qui concerne.

OriginalL'auteur kj13