Question

我正在开发一个具有不同图层的应用程序（处理程序 - ＆gt;服务 - ＆gt; 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(){...}
}

处理程序是捕获异常的人。它们具有相同的方法但具有不同的实现，我执行一些验证和更多必需的任务。

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
    }
}

所以基本上唯一改变的代码是'try'块中的代码，其余代码在每个处理程序中都是相同的。

我想封装异常处理，所以我不必在任何地方重复，将来如果我必须处理任何不同的异常，我不必在所有处理程序中进行更改。

我的想法是因为我使用的是Spring，我可以创建一个bean'ExceptionHandler'，因此它可以在所有处理程序中注入，但我想知道是否有更好的方法来实现我想要的。< / p>

Answer 1

Spring provides a @ExceptionHandler annotation处理一个处理程序方法特定的异常，这些异常来自一个类的方法只需注释将成为异常处理程序的方法，并指定要在每个方法中处理的预期异常类。

例如：

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

}

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

如果你的处理程序是Spring bean，你可以创建一个抽象类，它将包含异常处理的处理程序方法，然后你可以使你的具体处理程序继承。

如果您的处理程序是Spring控制器，并且您希望以相同的方式对所有控制器执行异常处理，则可以通过声明具有@ControllerAdvice annotation的bean并指定处理的通用方法来使事情变得更简单。例外你不需要再有一个共同的抽象类了。

Answer 2

这是我写的一个快速示例，它不使用Spring中的任何内容（我确信Spring必须为您提供上述场景的内容）

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 3

您可以使用Spring AOP的@AfterThrowing建议（如下所示）来处理中心位置的异常（您可以查看here以获取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
      }
}

如何封装处理程序的异常？

3 个答案: