【Java】SpringBoot使用AOP进行日志解析打印+系统异常全局处理配置

已于 2023-07-24 09:22:08 修改
阅读量1.8k 收藏 4
点赞数 3
文章标签： java spring boot spring
于 2023-04-17 15:31:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42666609/article/details/130200851
版权

文章目录

前言

为了方便项目部署在服务器之后，当出现BUG以及某些特殊需求时，会因为无法看到日志或者出现异常无法快速及时处理的情况的时候，那么AOP日志拦截打印的作用就体现出来了。同时加上作者日志生成到服务器的工具，将会更加方便处理问题；

提示：以下是本篇文章正文内容，下面案例可供参考

一、导入Lombok

代码如下

            <!--Lombok-->
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>1.18.24</version>
            </dependency>

二、创建日志打印Model

代码如下：

import lombok.Data;

/**
 * @author 孤巷.
 * @description 日志打印model
 * @date 2021/3/13 11:44
 */
@Data
public class SystemRequestLogModel {
  private String ip;
  private String url;
  private String httpMethod;
  private String classMethod;
  private Object requestParams;
  private Object result;
  private Long timeCost;
}

三、创建日志切面工具类

代码如下：

import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

/**
 * @author 孤巷.
 * @description 方法级日志切面
 * @date 2021/3/22 11:36
 */
@Slf4j
@Component
public class RequestUtil {

    @Autowired(required = false)
    protected HttpServletRequest request; // 自动注入request

    /**
     * reqContext对象中的key: 转换好的json对象
     */
    private static final String REQ_CONTEXT_KEY_PARAMJSON = "REQ_CONTEXT_KEY_PARAMJSON";

    /**
     * 获取客户端ip地址 *
     */
    public String getClientIp() {
        String ipAddress = null;
        ipAddress = request.getHeader("x-forwarded-for");
        if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
            ipAddress = request.getHeader("Proxy-Client-IP");
        }
        if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
            ipAddress = request.getHeader("WL-Proxy-Client-IP");
        }
        if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
            ipAddress = request.getRemoteAddr();
        }

        // 对于通过多个代理的情况，第一个IP为客户端真实IP,多个IP按照','分割
        if (ipAddress != null && ipAddress.length() > 15) {
            if (ipAddress.indexOf(",") > 0) {
                ipAddress = ipAddress.substring(0, ipAddress.indexOf(","));
            }
        }
        if ("0:0:0:0:0:0:0:1".equals(ipAddress)) {
            ipAddress = "127.0.0.1";
        }
        return ipAddress;
    }

    public String getRequestParams(JoinPoint proceedingJoinPoint) {
        // 参数名
        String[] paramNames =
                ((MethodSignature) proceedingJoinPoint.getSignature()).getParameterNames();
        // 参数值
        Object[] paramValues = proceedingJoinPoint.getArgs();
        return buildRequestParam(paramNames, paramValues);
    }

    private String buildRequestParam(String[] paramNames, Object[] paramValues) {
        Map<String, Object> requestParams = new HashMap<>();
        for (int i = 0; i < paramNames.length; i++) {
            Object value = paramValues[i];
            if (value instanceof HttpServletRequest || value instanceof HttpServletResponse) {
                continue;
            }
            // 如果是文件对象
            if (value instanceof MultipartFile) {
                MultipartFile file = (MultipartFile) value;
                value = file.getOriginalFilename(); // 获取文件名
            }
            requestParams.put(paramNames[i], value);
        }

        JSONObject json = new JSONObject(requestParams);
        return json.toJSONString();
    }
}

四、需要用到的一些常量类

代码如下：

/**
 * @author 孤巷.
 * @description 常量
 * @date 2021/3/13 11:44
 */
public class Constant {
    public static final String NULL_POINTER_EXCEPTION = "空指针异常";
    public static final String PARSE_EXCEPTION = "格式解析异常";
    public static final String ARRAY_INDEX_OUT_OF_BOUNDS_EXCEPTION = "超出索引异常";
    public static final String SQL_EXCEPTION = "SQL异常";
    public static final String INTERNAL_SERVER_ERROR = "内部服务器异常";
    public static final String NETWORK_BUSY = "网络繁忙，请稍后重试";
    public static final String SQL_EXCEPTION_MESSAGE = "数据库执行异常：";
    public static final String DATE_FORMAT_ERROR = "时间格式异常";
    public static final String DATABASE_CONNECT_OUT_TIME = "数据库连接超时";
}

五、创建接口请求切面

重点来了哈！代码如下：

import cn.hutool.core.io.IORuntimeException;
import cn.hutool.crypto.CryptoException;
import cn.hutool.http.HttpException;
import com.alibaba.fastjson.JSONException;
import com.alibaba.fastjson.JSONObject;
import com.whxx.common.constant.Constant;
import com.whxx.common.exception.IllegalTokenException;
import com.whxx.common.exception.NetworkBusyException;
import com.whxx.common.exception.PayException;
import com.whxx.common.exception.SysConfigException;
import com.whxx.common.model.SystemRequestLogModel;
import com.whxx.common.util.RequestUtil;
import com.whxx.common.util.ResultUtil;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.jdbc.BadSqlGrammarException;
import org.springframework.jdbc.CannotGetJdbcConnectionException;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.sql.SQLException;
import java.text.ParseException;
import java.time.format.DateTimeParseException;

/**
 * @author 孤巷.
 * @description 接口请求切面
 * @date 2020/11/17 9:44
 */
@Aspect
@Component
@Slf4j
public class ControllerRequestAspect {

    @Resource
    private RequestUtil requestUtil;

    /**
     * 扫描所有Controller
     */
    @Pointcut("execution(public * com.whxx.exchange.controller.*.*(..))")
    public void request() {
    }

    @Around("request()")
    public Object doAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        ServletRequestAttributes attributes =
                (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        if (attributes == null) {
            throw new Exception("ServletRequestAttributes is null");
        }
        HttpServletRequest request = attributes.getRequest();
        SystemRequestLogModel systemRequestLogModel = new SystemRequestLogModel();
        systemRequestLogModel.setIp(request.getRemoteAddr());
        systemRequestLogModel.setUrl(request.getRequestURL().toString());
        systemRequestLogModel.setHttpMethod(request.getMethod());
        if ("get".equalsIgnoreCase(request.getMethod())) {
            // 处理GET请求中文参数乱码
            String decodeParams = "";
            if (request.getQueryString() != null) {
                try {
                    decodeParams = URLDecoder.decode(request.getQueryString(), "utf-8"); // 将中文转码
                } catch (UnsupportedEncodingException e) {
                    e.printStackTrace();
                }
            }
            systemRequestLogModel.setRequestParams(decodeParams);
        } else {
            systemRequestLogModel.setRequestParams(
                    requestUtil.getRequestParams(proceedingJoinPoint));
        }
        systemRequestLogModel.setClassMethod(
                String.format(
                        "%s.%s",
                        proceedingJoinPoint.getSignature().getDeclaringTypeName(),
                        proceedingJoinPoint.getSignature().getName()));
        Object result;
        try {
            result = proceedingJoinPoint.proceed();
            systemRequestLogModel.setResult(result);
            systemRequestLogModel.setTimeCost(System.currentTimeMillis() - start);
            log.info("请求信息 == {}", systemRequestLogModel);
        } catch (Exception e) {
            result = exceptionGet(e, systemRequestLogModel);
        }
        return result;
    }

    private JSONObject exceptionGet(Exception e, SystemRequestLogModel systemRequestLogModel) {
        systemRequestLogModel.setResult(e);
        log.error(e.getMessage(), e);
        log.error("异常信息 == {}", systemRequestLogModel);
        if (e instanceof NetworkBusyException) { // 自定义异常：对外接口调用异常，失败/或对外接口自身报错
            return ResultUtil.error(Constant.NETWORK_BUSY);
        } else if (e instanceof PayException) { //自定义异常：支付异常
            return ResultUtil.fail(e.getMessage());
        } else if (e instanceof SysConfigException) { //自定义异常：系统配置异常
            return ResultUtil.fail(e.getMessage());
        } else if (e instanceof IllegalTokenException) {//自定义异常：非法token
            return ResultUtil.fail(e.getMessage());
        } else if (e instanceof NullPointerException) { // 空指针异常
            return ResultUtil.error(Constant.NULL_POINTER_EXCEPTION);
        } else if (e instanceof DuplicateKeyException) { // 唯一键冲突
            return ResultUtil.error(Constant.DUPLICATE_KEY);
        } else if (e instanceof ParseException) { // 时间格式解析异常
            return ResultUtil.error(Constant.PARSE_EXCEPTION);
        } else if (e instanceof ArrayIndexOutOfBoundsException) { // 超出索引异常
            return ResultUtil.error(Constant.ARRAY_INDEX_OUT_OF_BOUNDS_EXCEPTION);
        } else if (e instanceof SQLException) { // sql异常
            return ResultUtil.error(Constant.SQL_EXCEPTION);
        } else if (e instanceof DateTimeParseException) { // 时间格式解析异常
            return ResultUtil.error(Constant.DATE_FORMAT_ERROR);
        } else if (e instanceof CannotGetJdbcConnectionException) { // 数据库连接超时
            return ResultUtil.error(Constant.DATABASE_CONNECT_OUT_TIME);
        }  else if (e instanceof CryptoException) { // 二维码无效
            return ResultUtil.fail(Constant.CRYPTO_ERROR);
        } else if (e instanceof IORuntimeException) {  //请求被拒绝，服务器未开启
            return ResultUtil.fail(e.getMessage());
        } else if (e instanceof HttpException) { //hutool http请求超时
            return ResultUtil.fail(e.getMessage());
        } else if (e instanceof BadSqlGrammarException) {//数据库执行异常
            return ResultUtil.error(Constant.SQL_EXCEPTION_MESSAGE + ((BadSqlGrammarException) e).getSQLException().getMessage());
        } else if (e instanceof JSONException) { //JSON相关异常
            return ResultUtil.fail(e.getMessage());
        } else if (e instanceof RuntimeException) {
            return ResultUtil.error(e.getMessage());
        } else { // 其他未知异常
            return ResultUtil.error(Constant.INTERNAL_SERVER_ERROR);
        }
    }
}

最后只需要把下方的controller路径修改为实际的项目路径即可

@Pointcut(“execution(public * com.whxx.exchange.controller..(…))”)

六、系统异常全局配置

代码如下：

import com.alibaba.fastjson.JSONObject;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.exc.InvalidFormatException;
import com.whxx.common.util.ResultUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.converter.HttpMessageConversionException;
import org.springframework.validation.BindException;
import org.springframework.validation.BindingResult;
import org.springframework.validation.ObjectError;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.MissingServletRequestParameterException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

import javax.validation.UnexpectedTypeException;
import java.util.List;
import java.util.Objects;

/**
 * @author 孤巷.
 * @description 异常全局处理配置
 * @date 2020/11/17 9:44
 */
@RestControllerAdvice
@Slf4j
public class ExceptionControllerAdvice {

    @ExceptionHandler(MethodArgumentNotValidException.class)
    public JSONObject methodArgumentNotValidExceptionHandler(MethodArgumentNotValidException e) {
        BindingResult result = e.getBindingResult();
        List<ObjectError> errorList = result.getAllErrors();
        String defaultMessage = errorList.get(0).getDefaultMessage();
        log.error(String.format("参数校验异常1 == {}%s", result.getAllErrors()));
        return ResultUtil.failIllegalParameter(
                "参数【"
                        + Objects.requireNonNull(e.getFieldError()).getField()
                        + "】校验异常："
                        + defaultMessage);
    }

    /**
     * 参数校验注解错误导致的异常
     */
    @ExceptionHandler(UnexpectedTypeException.class)
    public JSONObject unexpectedTypeException(UnexpectedTypeException e) {
        return ResultUtil.error(e.getMessage());
    }

    @ExceptionHandler(BindException.class)
    public JSONObject bindExceptionHandler(BindException e) {
        BindingResult result = e.getBindingResult();
        List<ObjectError> errorList = result.getAllErrors();
        String defaultMessage = errorList.get(0).getDefaultMessage();
        log.error(String.format("参数校验异常2 == {}%s", result.getAllErrors()));
        return ResultUtil.failIllegalParameter(
                "参数【"
                        + Objects.requireNonNull(e.getFieldError()).getField()
                        + "】异常："
                        + defaultMessage);
    }

    @ExceptionHandler(InvalidFormatException.class)
    public JSONObject handHttpConverterException(InvalidFormatException e) {
        StringBuilder errors = new StringBuilder();
        List<JsonMappingException.Reference> path = e.getPath();
        for (JsonMappingException.Reference reference : path) {
            errors.append("参数【")
                    .append(reference.getFieldName())
                    .append("】输入不合法，需要的是 ")
                    .append(e.getTargetType().getName())
                    .append(" 类型，")
                    .append("提交的值是：")
                    .append(e.getValue().toString());
        }
        log.error("参数校验异常3 == {}", errors);
        return ResultUtil.failIllegalParameter(errors.toString());
    }

    @ExceptionHandler(MissingServletRequestParameterException.class)
    public JSONObject handleMissingServletRequestParameterException(
            MissingServletRequestParameterException e) {
        StringBuilder errors = new StringBuilder();
        errors.append("参数【").append(e.getParameterName()).append("】为必传字段：").append(e.getMessage());
        log.error("参数校验异常4 == {}", errors);
        return ResultUtil.failIllegalParameter(errors.toString());
    }

    @ExceptionHandler(HttpMessageConversionException.class)
    public JSONObject handleConversionException(HttpMessageConversionException e) {
        StringBuilder errors = new StringBuilder();
        errors.append("参数校验异常5：").append(e.getMessage());
        log.error("参数校验异常 == {}", errors);
        return ResultUtil.failIllegalParameter(errors.toString());
    }
}

总结

以上就是今天要讲的内容，本文仅仅简单介绍了AOP的使用，AOP不止是可以实现日志打印的效果，还能实现很多好用的方法，后续我们都会讲到，请持续关注。谢谢！

孤巷守鹤
关注
  • 3
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
【七】springboot整合AOP实现日志操作
weixin_56995925的博客
09-07 1万+
springboot整合AOP实现日志操作
JAVA 中Spring aop 实现日志记载
01-28
该压缩包中包含了一个myeclipse6.5下开发的JAVA基于spring实现的日志记载例子，该例子提供了接受切点参数，解析切点返回值，并且都打印出来了，有详细的文档介绍。
SpringBoot AOP处理请求日志打印功能代码实例
08-19
主要介绍了SpringBoot AOP处理请求日志打印功能代码实例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
实际项目中的SpringAOP实现日志打印
qq_63218110的博客
01-27 1356
本篇主要借项目来巩固SpringAOP实现日志打印的功能。
Java利用Aop切面记录操作日志（注解方式）
最新发布
m0_73774439的博客
05-20 1053
⾯向切⾯编程，它是⼀种思想，它是对某⼀类事情的 集中处理。⽽ AOP 是⼀种思想，⽽ Spring AOP 是⼀个框架，提供了⼀种对 AOP 思想的实现，它们的关系和 IoC 与 DI 类似。@Mapping/*** 操作具体某个功能的描述* @return*//*** 操作类型* @return*/@Aspect@Component@Autowired@Autowired@Autowired@Autowired// 获取request对象。
springaop实现相关功能（事务、异常处理、记录日志）
唐昊
04-30 1095
当你的应用程序中的 com.example.myapp.service 包下的任意方法抛出异常时，ExceptionHandlingAspect 切面中的 handleException 方法将被自动调用，处理异常逻辑。事务管理器的类型取决于你使用的数据库和连接池。：虽然CGLIB代理在性能方面通常优于JDK动态代理，但由于它涉及到字节码操作，因此在创建代理类的过程中可能会存在一定的性能开销。：JDK动态代理要求目标对象必须实现至少一个接口，如果目标类没有实现任何接口，则无法使用JDK动态代理进行代理。
使用Spring AOP实现对外接口的日志自动打印
Yungang_Young的博客
02-07 583
相信我们都有过这样的经历，在提供第三方对外接口时，为了防止推诿扯皮，我们会在自己接口被调用时日志打印一下第三方的调用参数，再在业务逻辑结束返回时再打印一下给第三方的返回参数，这样在后续遇到bug时，能用日志方便排（shuai）查（guo）\
springboot 最简单的日志打印，输出日志文件 及全局异常捕获处理
2401_84010702的博客
04-03 412
学习技术是一条慢长而艰苦的道路，不能靠一时激情，也不是熬几天几夜就能学好的，必须养成平时努力学习的习惯。所以：贵在坚持！最后再分享的一些BATJ等大厂20、21年的面试题，把这些技术点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节，由于篇幅有限，上面只是以图片的形式给大家展示一部分。Mybatis面试专题MySQL面试专题并发编程面试专题《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》点击传送门即可获取！部分。
SpringAOP详解，使用SpringAop实现统一日志处理，异常处理
生而为人我很抱歉
08-03 3320
SpringAOP详解，使用SpringAop实现统一日志处理，异常处理
springboot使用aop记录日志
weixin_45541795的博客
10-12 3797
Springboot中添加AOP日志，对你会有帮助！
Java使用AOP操作日志，傻瓜版
Likeslowsongs的博客
06-02 681
面向切面的操作日志
SpringBoot使用AOP进行日志记录
qq_54421200的博客
01-19 1379
*** 获取某些方法执行的method操作(参照包com.example.demo.constant.OptTypeConstant下的常量选择)*///执行声明操作。
Spring Mvc AOP通过注解方式拦截controller等实现日志管理
08-18
Spring Mvc AOP通过注解方式拦截controller等实现日志管理
基于springboot校园台球厅人员与设备管理系统.zip
03-22
系统应具有完善的异常处理机制，例如使用Spring的@ControllerAdvice注解进行全局异常处理，并利用Log4j或Logback等日志框架记录系统运行日志，便于问题排查。 九、测试与部署 单元测试和集成测试是保证系统质量的...
基于springboot的图书进销存管理系统源码数据库.zip
03-09
例如，使用Spring Security进行权限管理，Log4j或Logback实现日志记录，以及使用AOP（面向切面编程）进行全局异常处理。 总之，基于SpringBoot的图书进销存管理系统是一个综合运用了Java后端技术、前端展示以及...
基于springboot的疫情下图书馆管理系统源码数据库.zip
03-12
通过Spring的AOP（面向切面编程）实现全局异常处理，统一捕获并处理可能出现的运行时错误。同时，利用Log4j或Logback等日志工具记录系统运行情况，便于问题排查和系统优化。 9. **测试与部署** 使用JUnit进行单元...
基于springboot的房地产销售管理系统源码数据库.zip
03-09
使用AOP（面向切面编程）实现全局异常处理，提供友好的错误提示。 总结来说，这个基于SpringBoot的房地产销售管理系统结合了Java的强大力量，利用SSM框架处理业务逻辑，通过JSP展示界面，旨在提供一个高效、安全、...
基于springboot的设备管理系统源码.zip
10-03
例如，使用Spring Boot的Logging Starter进行日志记录，通过AOP（面向切面编程）实现全局异常处理，集成Spring Security实现权限控制，以及使用缓存策略提升查询效率。 总结来说，基于SpringBoot的设备管理系统源码...
使用Aop的方式实现自动日志记录
weixin_55076626的博客
03-20 1734
允许注解在方法和类上添加： 以下注解在接口上添加： 2.1、先编写一个pt方法，此方法结合了上面自定义的注解：2.2、然后编写log方法，对加了LogAnnotation注解的类或者方法实现环绕通知： 2.3、最后完善redcordlog方法来记录日志，并在控制台输出相关记录的日志：完整代码： redcordlog方法包含了两个工具类（用来获取当前接口ip地址的），如下： 3、使用接口，查看控制台输出信息
使用java+springboot+springaop+redis+自定义注解，写一个分布式锁
03-21
可以使用 Redisson 实现分布式锁，具体实现如下： 1. 引入 Redisson 依赖： ```xml <groupId>org.redisson <artifactId>redisson-spring-boot-starter <version>3.16.1 ``` 2. 定义自定义注解 `Distributed...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值