Gestion des exceptions Java basée sur l'annotation Spring AOP

1. Avant-propos

Lorsque le projet a été développé pour la première fois, nous n'étions pas complètement préparés. Ce n’est que lorsque le développement aura atteint un certain niveau que vous réaliserez qu’il reste encore des problèmes non résolus. Par exemple, aujourd'hui, je veux parler d'un problème : la gestion des exceptions. Lors de l'écriture d'un programme, les exceptions sont généralement gérées via try...catch...finally, mais pouvons-nous vraiment gérer toutes les exceptions possibles lors de l'écriture d'un programme ? Et quelle logique est exécutée lorsqu'une exception se produit, quelles informations d'invite sont renvoyées et à quelle page accéder, tout cela doit être pris en considération.

2. Gestion des exceptions basée sur @ControllerAdvice (contrôleur amélioré)

L'annotation @ControllerAdvice utilise en interne @ExceptionHandler, @ InitBinder et Les méthodes annotées @ModelAttribute s'appliquent à toutes les méthodes annotées @RequestMapping. Dans cet exemple, ExceptionHandler est utilisé pour s'appliquer à toutes les méthodes annotées @RequestMapping afin de gérer les exceptions qui se produisent.

Exemple de code :

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

Si cela ne fonctionne pas, veuillez vérifier le fichier de configuration de spring-mvc pour voir s'il y a la configuration suivante de 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. Gestion des exceptions basée sur AOP

1. Traitement de l'exception de couche de contrôleur WebExceptionAspect.java

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 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();
 }
}

2. Gérer l'exception de couche de service ServiceExceptionAspect.java

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

3. Pour l'utiliser, ajoutez la configuration suivante au fichier de configuration public de Spring :

<aop:aspectj-autoproxy proxy-target-class="true" />
<bean class="com.hjz.exception.aspect.ServiceExceptionAspect" />
<bean class="com.hjz.exception.aspect.WebExceptionAspect" />

ou personnalisez un Registration Class, ServiceExceptionAspect.java et WebExceptionAspect.java ajoutent tous deux l'annotation @Component

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 {

}

@Aspect
@Component
public class WebExceptionAspect {
 .......... 
}


@Aspect
@Component
public class ServiceExceptionAspect {
 .........
}

4. Doutes

@within(org.springframework.stereotype.Service), intercepte toutes les méthodes des classes annotées avec @Service

@annotation (org.springframework.web.bind.annotation.RequestMapping), interceptez la méthode d'annotation avec @RquestMapping

5. Test

Écrivez des classes de test d'exception pour la couche contrôleur et la couche service respectivement. C'est très simple, il suffit de lancer une exception dans la méthode. Enfin, vérifiez simplement si la méthode correspondant à @AfterThrowing est exécutée lorsque l'exception se produit.

Ce qui précède représente l'intégralité du contenu de cet article. J'espère qu'il sera utile à l'apprentissage de chacun. J'espère également que tout le monde soutiendra le site Web PHP chinois.

Pour plus d'articles sur la gestion des exceptions basés sur Java et basés sur l'annotation Spring AOP, veuillez faire attention au site Web PHP chinois !