Java exception handling based on spring annotation AOP-javaTutorial-php.cn

Java exception handling based on spring annotation AOP

高洛峰

Release： 2017-02-27 15:31:27

Original

1164 people have browsed it

1. Foreword

When the project was first developed, we were not fully prepared. Only when the development reaches a certain level will you realize that there are still some unresolved problems. For example, today I want to talk about a problem: exception handling. When writing a program, exceptions are generally handled through try...catch...finally, but can we really handle all possible exceptions when writing a program? And what logic is executed when an exception occurs, what prompt information is returned, and what page to jump to, these all need to be taken into consideration.

2. Exception handling based on @ControllerAdvice (enhanced controller)

@ControllerAdvice annotation internally uses @ExceptionHandler, @ InitBinder and @ModelAttribute annotated methods apply to all @RequestMapping annotated methods. In this example, ExceptionHandler is used to apply to all @RequestMapping annotated methods to handle exceptions that occur.

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

Copy after login

If it does not work, please check the configuration file of spring-mvc to see if there is the following configuration of 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>

Copy after login

3. AOP-based exception handling

1. Handle the exception WebExceptionAspect of the controller layer .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();
 }
}

Copy after login

2. Handle service layer exception 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;
 }
}

Copy after login

3. To use, add the following configuration to spring’s public configuration file:

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

Copy after login

or customize a registration class, both ServiceExceptionAspect.java and WebExceptionAspect.java Add the @Component annotation

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 {

}

Copy after login

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


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

Copy after login

## 4. Doubts

@within(org.springframework.stereotype.Service), intercept all methods of classes annotated with @Service

@annotation(org.springframework.web.bind.annotation.RequestMapping ), intercept the annotated method with @RquestMapping

5. Test

Write exception test classes for the controller layer and service layer respectively. This is very simple, just throw an exception in the method. Finally, just verify whether the method corresponding to @AfterThrowing is executed when the exception occurs.

The above is the entire content of this article. I hope it will be helpful to everyone's learning. I also hope that everyone will support the PHP Chinese website.

For more Java-based exception handling articles based on spring annotation AOP, please pay attention to the PHP Chinese website!