AOP 实现全局异常处理

最新推荐文章于 2024-04-30 11:49:15 发布

秋素啊

最新推荐文章于 2024-04-30 11:49:15 发布

阅读量8.2k

点赞数 2

分类专栏： Java

本文链接：https://blog.csdn.net/u013764330/article/details/105834790

版权

Java 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

第一种：

1. 我们将采用Spring AOP统一处理异常，统一返回后端接口的结果。

2. 使用一个自定义异常和一个错误前端提示枚举来逐层传递消息

3. 一个错误枚举来代替新建异常信息类，减少业务异常信息文件的数量

//正常返回的枚举
SUCCESS(true, 2000,"正常返回", "操作成功"),

// 系统错误，50开头
SYS_ERROR(false, 5000, "系统错误", "亲，系统出错了哦~"),
PARAM_INVILAD(false, 5001, "参数出现异常", "参数出现异常"),
DATA_NO_COMPLETE(false, 5002, "数据填写不完整，请检查", "数据填写不完整，请检查");

private ErrorMsgEnum(boolean ok, int code, String msg ,String userMsg) {
this.ok = ok;
this.code = code;
this.msg = msg;
this.userMsg = userMsg;
}

private boolean ok;
private int code;
private String msg;
private String userMsg;
}

控制层返回结果POJO类

public class JsonResponse{

String msg;
Object data;

public JsonResponse() {
msg = "";
data = null;
}

public static JsonResponse newOk() {
JsonResponse response = new JsonResponse();
response.setState(State.newOk());
return response;
}

public static JsonResponse newOk(Object data) {
JsonResponse response = new JsonResponse();
response.setData(data);
response.setState(State.newOk());
return response;
}

public static JsonResponse newError() {
JsonResponse response = new JsonResponse();
response.setMsg("无情的系统异常!");
return response;
}

public static JsonResponse newError(ErrorMsgEnum errorMsgEnum) {
JsonResponse response = new JsonResponse();
state.setMsg(errorMsgEnum.getErrorMsg());
return response;
}
}

自定义异常类

public class CustomException extends Exception {

private ErrorMsgEnum errorMsgEnum;

public CustomException(ErrorMsgEnum errorMsgEnum) {
this.errorMsgEnum = errorMsgEnum;
}
}

AOP捕获异常处理类

@Around("execution(public * com.jason.*.controller..*.*(..))")
public JsonResponse serviceAOP(ProceedingJoinPoint pjp) throws Exception {

JsonResponse newResultVo = null;

try {
return (JsonResponse) pjp.proceed();
} catch (CustomException e) {
logger.info("自定义业务异常:" + e.getMessage());
ErrorMsgEnum errorMsgEnum = e.getErrorMsgEnum();
if (Objects.nonNull(errorMsgEnum)) {
newResultVo = JsonResponse.newError(errorMsgEnum);
} else {
newResultVo = JsonResponse.newError(e.getMessage());
}
} catch (Exception e) {
//可以顺便处理你的日志，此处能取到方法名，参数等等
logger.error("出现运行时异常：", e);
newResultVo = JsonResponse.newError();
}

return newResultVo;

}

第二种

在springboot中使用aop 来处理异常

1. 在SpringBoot中引入AOP

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>

2. 创建一个返回体报文的实体类

public class Result<T> {

// error_code 状态值：0 极为成功，其他数值代表失败
private Integer status;

// error_msg 错误信息，若status为0时，为success
private String msg;

// content 返回体报文的出参，使用泛型兼容不同的类型
private T data;

public Integer getStatus() {
return status;
}

public void setStatus(Integer code) {
this.status = code;
}

public String getMsg() {
return msg;
}

public void setMsg(String msg) {
this.msg = msg;
}

public T getData(Object object) {
return data;
}

public void setData(T data) {
this.data = data;
}

public T getData() {
return data;
}

@Override
public String toString() {
return "Result{" +
"status=" + status +
", msg='" + msg + '\'' +
", data=" + data +
'}';
}

3. 创建一个枚举类，来记录一些我们已知的错误信息，可以在代码中直接使用。

public enum ExceptionEnum {
UNKNOW_ERROR(-1,"未知错误"),
USER_NOT_FIND(-101,"用户不存在"),
;

private Integer code;

private String msg;

ExceptionEnum(Integer code, String msg) {
this.code = code;
this.msg = msg;
}

public Integer getCode() {
return code;
}

public String getMsg() {
return msg;
}
}

4. 创建一个工具类在代码中使用

public class ResultUtil {

/**
* 返回成功，传入返回体具体出參
* @param object
* @return
*/
public static Result success(Object object){
Result result = new Result();
result.setStatus(0);
result.setMsg("success");
result.setData(object);
return result;
}

/**
* 提供给部分不需要出參的接口
* @return
*/
public static Result success(){
return success(null);
}

/**
* 自定义错误信息
* @param code
* @param msg
* @return
*/
public static Result error(Integer code,String msg){
Result result = new Result();
result.setStatus(code);
result.setMsg(msg);
result.setData(null);
return result;
}

/**
* 返回异常信息，在已知的范围内
* @param exceptionEnum
* @return
*/
public static Result error(ExceptionEnum exceptionEnum){
Result result = new Result();
result.setStatus(exceptionEnum.getCode());
result.setMsg(exceptionEnum.getMsg());
result.setData(null);
return result;
}
}

5. 一般系统抛出的错误是不含错误代码的，除去部分的404，400，500错误之外，我们如果想把错误代码定义的更细致，就需要自己继承RuntimeException这个类后重新定义一个构造方法来定义我们自己的错误信息：

public class DescribeException extends RuntimeException{

private Integer code;

/**
* 继承exception，加入错误状态值
* @param exceptionEnum
*/
public DescribeException(ExceptionEnum exceptionEnum) {
super(exceptionEnum.getMsg());
this.code = exceptionEnum.getCode();
}

/**
* 自定义错误信息
* @param message
* @param code
*/
public DescribeException(String message, Integer code) {
super(message);
this.code = code;
}

public Integer getCode() {
return code;
}

public void setCode(Integer code) {
this.code = code;
}
}

6. 使用一个Handle来把Try，Catch中捕获的错误进行判定，是一个我们已知的错误信息，还是一个未知的错误信息，如果是未知的错误信息，那我们就用log记录它，便于之后的查找和解决：

@ControllerAdvice
public class ExceptionHandle {

private final static Logger LOGGER = LoggerFactory.getLogger(ExceptionHandle.class);

/**
* 判断错误是否是已定义的已知错误，不是则由未知错误代替，同时记录在log中
* @param e
* @return
*/
@ExceptionHandler(value = Exception.class)
@ResponseBody
public Result exceptionGet(Exception e){
if(e instanceof DescribeException){
DescribeException MyException = (DescribeException) e;
return ResultUtil.error(MyException.getCode(),MyException.getMessage());
}

LOGGER.error("【系统异常】{}",e);
return ResultUtil.error(ExceptionEnum.UNKNOW_ERROR);
}
}

7. 我们使用接口若出现了异常，很难知道是谁调用接口，是前端还是后端出现的问题导致异常的出现，那这时，AOP久发挥作用了，我们之前已经引入了AOP的依赖，现在我们编写一个切面类

@Aspect
@Component
public class HttpAspect {

private final static Logger LOGGER = LoggerFactory.getLogger(HttpAspect.class);

@Autowired
private ExceptionHandle exceptionHandle;

@Pointcut("execution(public * com.zzp.controller.*.*(..))")
public void log(){

}

@Before("log()")
public void doBefore(JoinPoint joinPoint){
ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
HttpServletRequest request = attributes.getRequest();

//url
LOGGER.info("url={}",request.getRequestURL());
//method
LOGGER.info("method={}",request.getMethod());
//ip
LOGGER.info("id={}",request.getRemoteAddr());
//class_method
LOGGER.info("class_method={}",joinPoint.getSignature().getDeclaringTypeName() + "," + joinPoint.getSignature().getName());
//args[]
LOGGER.info("args={}",joinPoint.getArgs());
}

@Around("log()")
public Object doAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
Result result = null;
try {

} catch (Exception e) {
return exceptionHandle.exceptionGet(e);
}
if(result == null){
return proceedingJoinPoint.proceed();
}else {
return result;
}
}

@AfterReturning(pointcut = "log()",returning = "object")//打印输出结果
public void doAfterReturing(Object object){
LOGGER.info("response={}",object.toString());
}
}

8. 我们使用@Aspect来声明这是一个切面，使用@Pointcut来定义切面所需要切入的位置，这里我们是对每一个HTTP请求都需要切入，在进入方法之前我们使用@Before记录了调用的接口URL，调用的方法，调用方的IP地址以及输入的参数等。在整个接口代码运作期间，我们使用@Around来捕获异常信息，并用之前定义好的Result进行异常的返回，最后我们使用@AfterReturning来记录我们的出參。
以上全部，我们就完成了异常的统一管理以及切面获取接口信息

@RestController
@RequestMapping("/result")
public class ResultController {

@Autowired
private ExceptionHandle exceptionHandle;

/**
* 返回体测试
* @param name
* @param pwd
* @return
*/
@RequestMapping(value = "/getResult",method = RequestMethod.POST)
public Result getResult(@RequestParam("name") String name, @RequestParam("pwd") String pwd){
Result result = ResultUtil.success();
try {
if (name.equals("zzp")){
result = ResultUtil.success(new UserInfo());
}else if (name.equals("pzz")){
result = ResultUtil.error(ExceptionEnum.USER_NOT_FIND);
}else{
int i = 1/0;
}
}catch (Exception e){
result = exceptionHandle.exceptionGet(e);
}
return result;
}
}

结果：

第三种：基于xml 配置的aop

上图中的接口上没有任何方法，但是实现了这个接口的类必须至少实现以下4个方法中的一个，否则程序报：

Caused by: java.lang.IllegalArgumentException: At least one handler method must be found in class

接口中的异常类可以为自己自定义的异常类，方法是通过反射调用。

1. 自定义异常类

package com.apt.study.exception;

public class StudyException extends RuntimeException {

/**
*
*/
private static final long serialVersionUID = -6183216129830888521L;

/**
* 异常信息
*/
protected String message;

/**
* 异常编码
*/
protected int code;

public static final StudyException PARAM_VALIDATE_EXCEPTION = new StudyException(1234,"参数校验出错");

public StudyException(int code, String msgFormat, Object... args) {
super(String.format(msgFormat, args));
this.code = code;
this.message = String.format(msgFormat, args);
}

public StudyException(String message, Throwable cause) {
super(message, cause);
}

public StudyException(Throwable cause) {
super(cause);
}

public StudyException(String message) {
super(message);
}

public String getMessage() {
return message;
}

public void setMessage(String message) {
this.message = message;
}

public int getCode() {
return code;
}

public void setCode(int code) {
this.code = code;
}

}

2. 异常日志处理类

package com.apt.study.exception;

import java.lang.reflect.Method;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.aop.ThrowsAdvice;

public class ExceptionLogHandler implements ThrowsAdvice{

public Logger logger = LoggerFactory.getLogger(ExceptionLogHandler.class);

public void afterThrowing(Method method, Object[] args, Object target, StudyException ex) {
logger.error("ExceptionLogHandler--StudyExcception");
logger.info("-------errCode:" + ex.getCode() + "; errMessage:" + ex.getMessage());
errorClassInfo(ex);
logger.info("-------" + ex.fillInStackTrace());
}

public void afterThrowing(Method method, Object[] args, Object target, Exception ex) {

logger.error("ExceptionLogHandler--Exception");
logger.error("------->Erro Class: "+ target.getClass().getName());
logger.error("------->Error method:"+ method.getName());

if(args != null) {
for(int i=0; i<args.length; i++) {
logger.error("------->args[" + i + "]: " + args[i]);
}
}

logger.error("------->Exception class: " + ex.getClass().getName());
errorClassInfo(ex);
logger.error("------->" + ex.fillInStackTrace());
}

//打印抛出异常地方的信息
private void errorClassInfo(Exception ex) {
/*
* ex.getStackTrace()返回堆栈跟踪元素的数组，每个元素表示一个堆栈帧。数组的第零个元素（假定数据的长度为非零）表示堆栈顶部，
* 它是序列中最后的方法调用。
* 通常，这是创建和抛出该 throwable 的地方。数组的最后元素（假定数据的长度为非零）表示堆栈底部，它是序列中第一个方法调用
*/
StackTraceElement[] stackTraceElementArr= ex.getStackTrace();
StackTraceElement stackTraceElement = stackTraceElementArr[0];
logger.error("------->Erro File:" + stackTraceElement.getFileName());
logger.error("------->Erro Method:" + stackTraceElement.getMethodName());
logger.error("------->Erro Line:" + stackTraceElement.getLineNumber());
}

}

3. spring-context.xml 配置

<bean id="exceptionLog" class="com.apt.study.exception.ExceptionLogHandler"></bean>
<aop:config>
<aop:pointcut id="exceptionTrade" expression="execution(* com.apt.study.service.*.*(..))" />
<aop:advisor pointcut-ref="exceptionTrade" advice-ref="exceptionLog"/>
</aop:config>

秋素啊

关注

2
点赞
踩
29

收藏

觉得还不错? 一键收藏
0
评论
AOP 实现全局异常处理

第一种：1. 我们将采用Spring AOP统一处理异常，统一返回后端接口的结果。2. 使用一个自定义异常和一个错误前端提示枚举来逐层传递消息3. 一个错误枚举来代替新建异常信息类，减少业务异常信息文件的数量//正常返回的枚举 SUCCESS(true, 2000,"正常返回", "操作成功"), // 系统错误，50开头 SY...
复制链接

扫一扫

专栏目录