In diesem Artikel wird hauptsächlich die auf Spring Annotation AOP basierende Java-Ausnahmebehandlungsmethode vorgestellt. Interessierte Freunde können darauf verweisen.
1. Einleitung
Als das Projekt zum ersten Mal entwickelt wurde, waren wir nicht vollständig vorbereitet. Erst wenn die Entwicklung ein bestimmtes Niveau erreicht, wird einem klar, dass es noch einige ungelöste Probleme gibt. Heute möchte ich zum Beispiel über ein Problem sprechen: die Ausnahmebehandlung. Beim Schreiben eines Programms werden Ausnahmen im Allgemeinen über try...catch...finally behandelt. Aber können wir beim Schreiben eines Programms wirklich alle möglichen Ausnahmen behandeln? Und welche Logik ausgeführt wird, wenn eine Ausnahme auftritt, welche Eingabeaufforderungsinformationen zurückgegeben werden und zu welcher Seite gesprungen werden soll, all dies muss berücksichtigt werden.
2. Ausnahmebehandlung basierend auf @ControllerAdvice (erweiterter Controller)
Die @ControllerAdvice-Annotation verwendet intern @ExceptionHandler, @ InitBinder und Mit @ModelAttribute annotierte Methoden gelten für alle mit @RequestMapping annotierten Methoden. In diesem Beispiel wird ExceptionHandler verwendet, um alle mit @RequestMapping annotierten Methoden zur Behandlung auftretender Ausnahmen anzuwenden.
Beispielcode:
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import com.hjz.exception.ServiceException;
import com.hjz.exception.utils.ExceptionUtils;
@ResponseBody
public class ExceptionAdvice {
private static final Logger LOGGER = LoggerFactory.getLogger(ExceptionAdvice.class);
/**
* 拦截web层异常，记录异常日志，并返回友好信息到前端
* 目前只拦截Exception，是否要拦截Error需再做考虑
*
* @param e 异常对象
* @return 异常提示
*/
@ExceptionHandler(Exception.class)
public ResponseEntity<String> handleException(Exception e) {
//不需要再记录ServiceException，因为在service异常切面中已经记录过
if (!(e instanceof ServiceException)) {
LOGGER.error(ExceptionUtils.getExcTrace(e));
}
HttpHeaders headers = new HttpHeaders();
headers.set("Content-type", "text/plain;charset=UTF-8");
headers.add("icop-content-type", "exception");
String message = StringUtils.isEmpty(e.getMessage()) ? "系统异常!!" : e.getMessage();
return new ResponseEntity<>(message, headers, HttpStatus.OK);
}
}Wenn es nicht funktioniert, überprüfen Sie bitte die Konfigurationsdatei von spring-mvc, um festzustellen, ob dies der Fall ist die folgende Konfiguration von ControllerAdvice
<context:component-scan base-package="com.sishuok.es" use-default-filters="false"> <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/> <context:include-filter type="annotation" expression="org.springframework.web.bind.annotation.ControllerAdvice"/> </context:component-scan>
3 > 1. Verarbeitung der Controller-Layer-Ausnahme WebExceptionAspect.java
2. Behandeln der Service-Layer-Ausnahme ServiceExceptionAspect.javaimport org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import com.hjz.exception.ServiceException;
import com.hjz.exception.utils.ExceptionUtils;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
/**
* web异常切面
* 默认spring aop不会拦截controller层，使用该类需要在spring公共配置文件中注入改bean，
* 另外需要配置<aop:aspectj-autoproxy proxy-target-class="true"/>
*/
@Aspect
public class WebExceptionAspect {
private static final Logger LOGGER = LoggerFactory.getLogger(WebExceptionAspect.class);
@Pointcut("@annotation(org.springframework.web.bind.annotation.RequestMapping)")
private void webPointcut() {}
/**
* 拦截web层异常，记录异常日志，并返回友好信息到前端
* 目前只拦截Exception，是否要拦截Error需再做考虑
*
* @param e 异常对象
*/
@AfterThrowing(pointcut = "webPointcut()", throwing = "e")
public void handleThrowing(Exception e) {
//不需要再记录ServiceException，因为在service异常切面中已经记录过
if (!(e instanceof ServiceException)) {
LOGGER.error(ExceptionUtils.getExcTrace(e));
}
String errorMsg = StringUtils.isEmpty(e.getMessage()) ? "系统异常" : e.getMessage();
writeContent(errorMsg);
}
/**
* 将内容输出到浏览器
*
* @param content 输出内容
*/
private void writeContent(String content) {
HttpServletResponse response = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getResponse();
response.reset();
response.setCharacterEncoding("UTF-8");
response.setHeader("Content-Type", "text/plain;charset=UTF-8");
response.setHeader("icop-content-type", "exception");
PrintWriter writer = null;
try {
writer = response.getWriter();
} catch (IOException e) {
e.printStackTrace();
}
writer.print(content);
writer.flush();
writer.close();
}
}import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import com.hjz.exception.ServiceException;
import com.hjz.exception.utils.ExceptionUtils;
@Aspect
public class ServiceExceptionAspect {
private static final Logger LOGGER = LoggerFactory.getLogger(ServiceExceptionAspect.class);
/**
* @within(org.springframework.stereotype.Service)，拦截带有 @Service 注解的类的所有方法
* @annotation(org.springframework.web.bind.annotation.RequestMapping)，拦截带有@RquestMapping的注解方法
*/
@Pointcut("@within(org.springframework.stereotype.Service) && execution(public * *(..))")
private void servicePointcut() {}
/**
* 拦截service层异常，记录异常日志，并设置对应的异常信息
* 目前只拦截Exception，是否要拦截Error需再做考虑
*
* @param e 异常对象
*/
@AfterThrowing(pointcut = "servicePointcut()", throwing = "e")
public void handle(JoinPoint point, Exception e) {
LOGGER.error(ExceptionUtils.getExcTrace(e));
String signature = point.getSignature().toString();
String errorMsg = getMessage(signature) == null ? (StringUtils.isEmpty(e.getMessage()) ? "服务异常" : e.getMessage()) : getMessage(signature);
throw new ServiceException(errorMsg, e);
}
/**
* 获取方法签名对应的提示消息
*
* @param signature 方法签名
* @return 提示消息
*/
private String getMessage(String signature) {
return null;
}
}<aop:aspectj-autoproxy proxy-target-class="true" /> <bean class="com.hjz.exception.aspect.ServiceExceptionAspect" /> <bean class="com.hjz.exception.aspect.WebExceptionAspect" />
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
/**
* 异常相关bean注册类
*/
@Configuration
@EnableAspectJAutoProxy
@ComponentScan("com.hjz.exception.aspect")
public class ExceptionConfig {
}< hinzu 🎜>
@Aspect
@Component
public class WebExceptionAspect {
..........
}
@Aspect
@Component
public class ServiceExceptionAspect {
.........
}@within(org.springframework.stereotype.Service), alle mit @Service annotierten Methoden abfangen @annotation (org.springframework.web.bind.annotation.RequestMapping), Annotationsmethode mit @RquestMapping abfangen
5. TestenSchreiben Sie Ausnahmetestklassen für die Controller-Schicht bzw. die Service-Schicht. Das ist ganz einfach: Lösen Sie einfach eine Ausnahme in der Methode aus. Überprüfen Sie abschließend einfach, ob die @AfterThrowing entsprechende Methode ausgeführt wird, wenn die Ausnahme auftritt. Für Einzelheiten schauen Sie sich bitte die Demo an, die ich geschrieben habe, hehehe! ! ! Das Obige ist der Inhalt des Beispielcodes der Java-Ausnahmebehandlungsmethode basierend auf Spring Annotation AOP. Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn)!
