Comment encapsuler les exceptions des gestionnaires?

Question

Je travaille sur une application qui a différentes couches (Handlers -> Services -> DAO).

EmployeeHandler { 
    Employee get(){...} 
    Employee save(){...} 
    Employee update(){...} 
    etc(){...} 
} 

CompanyHandler { 
    Company get(){...} 
    Company save(){...} 
    Company update(){...} 
    etc(){...} 
} 

ManagerHandler { 
    Manager get(){...} 
    Manager save(){...} 
    Manager update(){...} 
    etc(){...} 
} 

Les gestionnaires sont ceux qui interceptent les exceptions. Ils ont les mêmes méthodes mais avec une implémentation différente, j'effectue quelques validations et plus de tâches requises.

Manager save(){ 
    try{ 
    // do something 
    employeeService.save(employee); 
    } 
    catch (MyCustomException e) { 
    // handle exception -- here I do the same for each method in all handlers 
    } 
    catch (Exception e) { 
    // catch any exception -- here I also do the same thing for all handlers 
    } 
} 

Donc, fondamentalement, le seul code qui change est celui à l'intérieur du bloc « essayer », le reste est le même dans chaque gestionnaire.

Je veux encapsuler la gestion des exceptions de sorte que je n'ai pas à répéter partout, et à l'avenir Si je dois gérer une exception différente, je n'ai pas à faire la modification dans tous les gestionnaires. L'idée que j'ai est que depuis que j'utilise Spring, je pourrais créer un bean 'ExceptionHandler' afin qu'il puisse être injecté dans tous les gestionnaires, mais je voudrais savoir s'il y a de meilleurs moyens pour réaliser ce que je veux.

Answer 1

Voici un exemple rapide je l'ai écrit qui n'utilise quoi que ce soit du printemps (je suis sûr de printemps doit être vous fournir quelque chose pour le scénario ci-dessus)

interface ExceptionHandler<T extends Throwable> { 

    void handle(T exception); 

} 

class UnsupportedOperationExceptionHandler implements ExceptionHandler<UnsupportedOperationException> { 

    @Override 
    public void handle(UnsupportedOperationException exception) { 
     //blaa 
    } 
} 

class IllegalArguementExceptionHandler implements ExceptionHandler<IllegalArgumentException> { 

    @Override 
    public void handle(IllegalArgumentException exception) { 
     //blaa part 2 
    } 
} 

class YourHandler { 

    private final Map<Class<? extends Throwable>, ExceptionHandler> exceptionHandlers; //This will contain all your handlers 

    @Inject 
    YourHandler(Map<Class<? extends Throwable>, ExceptionHandler> exceptionHandlers) { 
     this.exceptionHandlers = exceptionHandlers; 
    } 

    public void save() { 
     try { 
      //some method here. 
     } catch (Exception e) { 
      exceptionHandlers.get(e.getClass()).handle(e); 
     } 
    } 
} 

Answer 2

Spring provides a @ExceptionHandler annotation gérer dans une méthode gestionnaire des exceptions spécifiques levées par des méthodes d'une classe.
Annotez simplement les méthodes qui seront le gestionnaire d'exception et spécifiez la classe d'exception attendue à gérer dans chacune d'entre elles.

Par exemple:

@ExceptionHandler(MyCustomException.class) 
public void handleException(MyCustomException e) { 
    ... // exception handling 

} 

@ExceptionHandler(Exception.class) 
public void handleException(Exception e) { 
    ... // exception handling   
} 

Si vos gestionnaires sont les haricots de printemps, vous pouvez créer une classe abstraite qui va contenir les méthodes de gestionnaire pour la gestion des exceptions et vous pouvez faire vos gestionnaires en béton hérité de celui-ci.

---

Si vos gestionnaires sont des contrôleurs de printemps et que vous voulez faire de la gestion des exceptions de la même manière pour tous les contrôleurs, vous pouvez faire des choses encore plus simple en déclarant un haricot avec le @ControllerAdvice annotation et en spécifiant la manière générique pour gérer l'exception dans.
Vous n'avez plus besoin d'avoir une classe abstraite commune.

Answer 3

Vous pouvez utiliser Spring AOP de @AfterThrowing conseils (ci-dessous) pour gérer les exceptions à une place centrale (vous pouvez regarder here par exemple Spring doc):

@Aspect 
public class MyProjectExceptionHandler { 

    @AfterThrowing (pointcut = "execution(* com.myproject.service.impl..*(..))", 
           throwing = "ex") 
    public void handleMyCustomException(MyCustomException ex) 
         throws Throwable { 
     //add your code here 
     } 

    @AfterThrowing (pointcut = "execution(* com.myproject.service.impl..*(..))", 
        throwing = "ex") 
    public void handleException(Exception ex) 
     throws Throwable { 
     //add your code here 
     } 
}