Drei Möglichkeiten, Spring MVC-Ausnahmen einheitlich zu behandeln

Spring bietet drei Möglichkeiten, einheitliche Ausnahmen zu behandeln, nämlich:

Verwendung der @ExceptionHandler-Annotation, Implementierung der HandlerExceptionResolver-Schnittstelle und Verwendung der @controlleradvice-Annotation

Verwenden Sie die Annotation @ExceptionHandler

Ein Nachteil der Verwendung dieser Annotation besteht darin, dass sich die Methode zur Ausnahmebehandlung im selben Controller befinden muss wie die Methode, die den Fehler verursacht hat. Verwenden Sie es wie folgt:

@Controller      
public class GlobalController {
/**    
     * 用于处理异常的    
     * @return    
     */      
@ExceptionHandler({MyException.class})
public String exception(MyException e) {
System.out.println(e.getMessage());
e.printStackTrace();
return "exception";
}
@RequestMapping("test")
public void test() {
throw new MyException("出错了！");
}
}

Wie Sie sehen, besteht der größte Fehler dieser Methode darin, dass sie Ausnahmen nicht global steuern kann. Jede Klasse muss einmal geschrieben werden.

Implementieren Sie die HandlerExceptionResolver-Schnittstelle

Diese Methode ermöglicht die globale Ausnahmekontrolle. Zum Beispiel:

@Component  
public class ExceptionTest implements HandlerExceptionResolver{
/**  
     * TODO 简单描述该方法的实现功能（可选）.  
     * @see org.springframework.web.servlet.HandlerExceptionResolver#resolveException(javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, java.lang.Object, java.lang.Exception)  
     */  
public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler,  
            Exception ex) {
System.out.println("This is exception handler method!");
return null;
}
}

Verwenden Sie die Annotation @ControllerAdvice+ @ExceptionHandler

Wie oben erwähnt, muss sich die @ExceptionHandler-Methode, die eine Ausnahmebehandlung erfordert, im selben Controller befinden wie die Methode, die sie verursacht hat der Fehler. Wenn der Code dann @ControllerAdvice hinzufügt, muss er sich nicht im selben Controller befinden. Dies ist auch eine neue Funktion von Spring 3.2. Wie aus dem Namen hervorgeht, bedeutet dies im Allgemeinen eine Controller-Erweiterung. Mit anderen Worten, @controlleradvice + @ExceptionHandler kann auch eine globale Ausnahmeabfangung erreichen.

Bitte stellen Sie sicher, dass diese WebExceptionHandle-Klasse gescannt und in den Spring-Container geladen werden kann.

@ControllerAdvice
@ResponseBody
public class WebExceptionHandle {
private static Logger logger = LoggerFactory.getLogger(WebExceptionHandle.class);
/**
     * 400 - Bad Request
     */
@ResponseStatus(HttpStatus.BAD_REQUEST)
@ExceptionHandler(HttpMessageNotReadableException.class)
public ServiceResponse handleHttpMessageNotReadableException(HttpMessageNotReadableException e) {
logger.error("参数解析失败", e);
return ServiceResponseHandle.failed("could_not_read_json");
}
/**
     * 405 - Method Not Allowed
     */
@ResponseStatus(HttpStatus.METHOD_NOT_ALLOWED)
@ExceptionHandler(HttpRequestMethodNotSupportedException.class)
public ServiceResponse handleHttpRequestMethodNotSupportedException(HttpRequestMethodNotSupportedException e) {
logger.error("不支持当前请求方法", e);
return ServiceResponseHandle.failed("request_method_not_supported");
}
/**
     * 415 - Unsupported Media Type
     */
@ResponseStatus(HttpStatus.UNSUPPORTED_MEDIA_TYPE)
@ExceptionHandler(HttpMediaTypeNotSupportedException.class)
public ServiceResponse handleHttpMediaTypeNotSupportedException(Exception e) {
logger.error("不支持当前媒体类型", e);
return ServiceResponseHandle.failed("content_type_not_supported");
}
/**
     * 500 - Internal Server Error
     */
@ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
@ExceptionHandler(Exception.class)
public ServiceResponse handleException(Exception e) {
if (e instanceof BusinessException){
return ServiceResponseHandle.failed("BUSINESS_ERROR", e.getMessage());
}
logger.error("服务运行异常", e);
e.printStackTrace();
return ServiceResponseHandle.failed("server_error");
}
}

Wenn der zu behandelnde Ausnahmetyp nicht in der Annotation @ExceptionHandler deklariert ist, wird standardmäßig der Ausnahmetyp in der Parameterliste verwendet. Es kann also auch so geschrieben werden:

@ControllerAdvice
public class GlobalExceptionHandler {
@ExceptionHandler()
@ResponseBody
String handleException(Exception e){
return "Exception Deal! " + e.getMessage();
}
}

Das Parameterobjekt ist das von der Controller-Ebene ausgelöste Ausnahmeobjekt!

Erben Sie die ResponseEntityExceptionHandler-Klasse, um die globale Ausnahmeerfassung für die Rest-Schnittstelle zu implementieren, und können Sie ein benutzerdefiniertes Format zurückgeben:

@Slf4j
@ControllerAdvice
public class ExceptionHandlerBean  extends ResponseEntityExceptionHandler {
/**
     * 数据找不到异常
     * @param ex
     * @param request
     * @return
     * @throws IOException
     */
@ExceptionHandler({DataNotFoundException.class})
public ResponseEntity<Object> handleDataNotFoundException(RuntimeException ex, WebRequest request) throws IOException {
return getResponseEntity(ex,request,ReturnStatusCode.DataNotFoundException);
}
/**
     * 根据各种异常构建 ResponseEntity 实体. 服务于以上各种异常
     * @param ex
     * @param request
     * @param specificException
     * @return
     */
private ResponseEntity<Object> getResponseEntity(RuntimeException ex, WebRequest request, ReturnStatusCode specificException) {
ReturnTemplate returnTemplate = new ReturnTemplate();
returnTemplate.setStatusCode(specificException);
returnTemplate.setErrorMsg(ex.getMessage());
return handleExceptionInternal(ex, returnTemplate,
new HttpHeaders(), HttpStatus.OK, request);
}
}

Das obige ist der detaillierte Inhalt vonDrei Möglichkeiten, Spring MVC-Ausnahmen einheitlich zu behandeln. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!