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:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | @Controller
public class GlobalController {
@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("出错了！");
}
}
|
Nach dem Login kopieren
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:
1 2 3 4 5 6 7 8 9 10 11 12 | @Component
public class ExceptionTest implements HandlerExceptionResolver{
public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler,
Exception ex) {
System.out.println("This is exception handler method!");
return null;
}
}
|
Nach dem Login kopieren
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.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 | @ControllerAdvice
@ResponseBody
public class WebExceptionHandle {
private static Logger logger = LoggerFactory.getLogger(WebExceptionHandle.class);
@ResponseStatus(HttpStatus.BAD_REQUEST)
@ExceptionHandler(HttpMessageNotReadableException.class)
public ServiceResponse handleHttpMessageNotReadableException(HttpMessageNotReadableException e) {
logger.error("参数解析失败", e);
return ServiceResponseHandle.failed("could_not_read_json");
}
@ResponseStatus(HttpStatus.METHOD_NOT_ALLOWED)
@ExceptionHandler(HttpRequestMethodNotSupportedException.class)
public ServiceResponse handleHttpRequestMethodNotSupportedException(HttpRequestMethodNotSupportedException e) {
logger.error("不支持当前请求方法", e);
return ServiceResponseHandle.failed("request_method_not_supported");
}
@ResponseStatus(HttpStatus.UNSUPPORTED_MEDIA_TYPE)
@ExceptionHandler(HttpMediaTypeNotSupportedException.class)
public ServiceResponse handleHttpMediaTypeNotSupportedException(Exception e) {
logger.error("不支持当前媒体类型", e);
return ServiceResponseHandle.failed("content_type_not_supported");
}
@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");
}
}
|
Nach dem Login kopieren
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:
1 2 3 4 5 6 7 8 | @ControllerAdvice
public class GlobalExceptionHandler {
@ExceptionHandler()
@ResponseBody
String handleException(Exception e){
return "Exception Deal! " + e.getMessage();
}
}
|
Nach dem Login kopieren
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:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 | @Slf4j
@ControllerAdvice
public class ExceptionHandlerBean extends ResponseEntityExceptionHandler {
@ExceptionHandler({DataNotFoundException.class})
public ResponseEntity<Object> handleDataNotFoundException(RuntimeException ex, WebRequest request) throws IOException {
return getResponseEntity(ex,request,ReturnStatusCode.DataNotFoundException);
}
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);
}
}
|
Nach dem Login kopieren
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!
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
