Java项目中基于AOP注解方式实现接口日志记录

已于 2024-05-11 20:19:52 修改
阅读量2.8k 收藏 11
点赞数 7
分类专栏： java开发解决方案分享 文章标签： java spring spring boot
于 2023-04-04 10:07:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jnsone/article/details/129934551
版权

最近要对系统进行改造，要对业务中的一些接口进行记录，包括接口调用时间，参数，操作类型等，最后决定以注解的方式去实现，不会对原来的业务逻辑产生影响。使用AOP和自定义注解是一种非常强大且优雅的方法。通过AOP（Aspect-Oriented Programming，面向切面编程）和自定义注解，我们可以将日志记录逻辑与业务逻辑分离，从而提高代码的可维护性和可扩展性。本文将介绍如何结合AOP和自定义注解来实现接口日志记录、接口耗时等信息，并展示其在实际项目中的应用。

  1. 首先自定义一个注解，自定义注解是Java语言提供的一种元数据（metadata）机制，它允许我们在代码中添加额外的信息和标记。
package com.dev.common.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @Version 1.0
 */
@Target({ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface OperationLog {

    /**
     * 传入需要获取的参数，可在default设置默认值
     */
    String moduleName() default "内容管理";

    /**
     * 操作类型
     */
    String operateType();
}
  1. 定义一个切面类，在AOP切面中根据自定义的注解标记来触发相应的行为。加上@Component注解，@Aspect注解加入配置管理，可以通过Hutool提供的方法获取客户端浏览器、操作系统，使用Hutool需要引入其依赖
<dependency>
   <groupId>cn.hutool</groupId>
   <artifactId>hutool-all</artifactId>
   <version>5.8.0.M2</version>
</dependency>

package com.dev.common.service;

import cn.hutool.http.useragent.UserAgent;
import cn.hutool.http.useragent.UserAgentUtil;
import com.dev.common.annotation.OperationLog;
import com.dev.common.utils.IpUtil;
import com.dev.common.utils.ParamsUtil;
import com.dev.service.CommonService;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.core.NamedThreadLocal;
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.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

/**
 * @Description 操作日志处理类
 * @Version 1.0
 */
@Aspect
@Component
@Slf4j
public class OperateLogAspect {

    @Resource
    private LogDao logDao;

    /** 计算操作消耗时间 */
    private static final ThreadLocal<Long> TIME_THREADLOCAL = new NamedThreadLocal<Long>("Cost Time");

    /**
     * 处理请求前执行
     */
    @Before(value = "@annotation(operationLog)")
    public void boBefore(JoinPoint joinPoint, OperationLog operationLog)
    {
        TIME_THREADLOCAL.set(System.currentTimeMillis());
    }

    /**
     * 处理完请求后执行
     *
     * @param joinPoint 切点
     * @param operationLog 注解
     */
    @AfterReturning(pointcut = "@annotation(operationLog)")
    public void doAfterReturning(JoinPoint joinPoint, OperationLog operationLog)
    {
        handleLog(joinPoint,operationLog,null);
    }

    /**
     * 拦截异常操作，方法异常时执行
     *
     * @param joinPoint 切点
     * @param operationLog 注解
     * @param e 异常
     */
    @AfterThrowing(value = "@annotation(operationLog)", throwing = "e")
    public void doAfterThrowing(JoinPoint joinPoint, OperationLog operationLog, Exception e)
    {
        handleLog(joinPoint, operationLog,e);
    }

    /**
     * 封装日志
     * @param joinPoint
     * @param operationLog
     * @param e
     */
    public void handleLog(final JoinPoint joinPoint,OperationLog operationLog,final Exception e) {

        try {
            HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes())
                    .getRequest();
            //获取请求参数
            String reqParam = preHandleParams(joinPoint, request);
            String userIp = IpUtil.getIpAddrPlus(request);
            String uaStr = request.getHeader("User-Agent");
            UserAgent userAgent = UserAgentUtil.parse(uaStr);
            //计算耗时
            long cost = System.currentTimeMillis() - TIME_THREADLOCAL.get();
            Map<String,Object> operLogMap = new HashMap<>();
            operLogMap.put("clientIp",userIp);
            operLogMap.put("requestUrl",request.getRequestURI());
            operLogMap.put("requestParam",reqParam);
            operLogMap.put("clientBrowser", userAgent.getBrowser());
            operLogMap.put("clientSystem", userAgent.getPlatform());
            // 获取自定义注解的参数
            operLogMap.put("moduleName",operationLog.moduleName());
            operLogMap.put("requestDuration",cost);
            // 默认成功
            operLogMap.put("isSuccess",1);
            operLogMap.put("errorMessage","");
            // 失败回填0，错误原因
            if(e != null){
                operLogMap.put("isSuccess",0);
                operLogMap.put("errorMessage",e.getMessage());
            }
            // 插入日志
            logDao.insertLog(operLogMap);
        } catch (Exception exp) {
            exp.printStackTrace();
        } finally {
            TIME_THREADLOCAL.remove();
        }
    }

	/**
     * 获取请求参数
     *
     * @param joinPoint
     * @param request
     * @return 参数字符串
     */
    private String preHandleParams(JoinPoint joinPoint, HttpServletRequest request) {
        // 签名
        Signature signature = joinPoint.getSignature();
        MethodSignature methodSignature = (MethodSignature) signature;
        Method targetMethod = methodSignature.getMethod();
        Annotation[] annotations = targetMethod.getAnnotations();
        Map<String, Object> params = new HashMap<>();
        for (int i = 0; i < annotations.length; i++) {
            // 获取被注解方法接收的参数
            if (annotations[i].annotationType().equals(OperationLog.class)) {
                params = requestParamMap(request);
                break;
            }
        }
        return params.toString();
    }

	/**
	 * 从请求中获取参数信息并转成 Map
	 * @param request
	 * @return Map
	 */
	@SuppressWarnings("unchecked")
	public static Map<String, Object> requestParamMap(HttpServletRequest request) {
		java.util.Iterator iter = request.getParameterMap().entrySet().iterator();
		Map<String, Object> map = new LinkedHashMap<String, Object>();
		while (iter.hasNext()) {
			Map.Entry entry = (Map.Entry) iter.next();
			String key = StringUtil.strFiltrate(entry.getKey().toString());
			String[] checkboxValues = request.getParameterValues(key);
			String value = StringUtil.nullToEmpty(request.getParameter(key));
			// 对&符号转义
			value = value.replace("&amp；", "&");
			if (checkboxValues != null && checkboxValues.length > 1) {
				String checkboxV = "";
				for (int i = 0; i < checkboxValues.length; i++) {
					checkboxV += checkboxValues[i] + ",";
				}
				if (!"".equals(checkboxV)) {
					value = checkboxV.substring(0, checkboxV.length() - 1);
				}
			}
			map.put(key, StringUtil.strFiltrate(value));
		}
		return map;
	}


}

如果是SpringMVC项目还需在配置文件中需要开启AspectJ注解支持

<?xml　encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	   xmlns:mvc="http://www.springframework.org/schema/mvc"
	   xmlns:context="http://www.springframework.org/schema/context"
	   xmlns:p="http://www.springframework.org/schema/p"
	   xmlns:util="http://www.springframework.org/schema/util" 	
	   xmlns:aop="http://www.springframework.org/schema/aop"
	   xsi:schemaLocation="http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/util/spring-util-3.1.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
	
	
	<aop:aspectj-autoproxy/>

</beans>
  1. 在你的方法接口上加上自定义注解，传入一些参数，就可以使用了．
　　 @GetMapping("/hello")
    @OperationLog(moduleName = "文章管理",operateType = "插入")
    public Result Hello(HttpServletRequest request){
        HashMap<Object, Object> result = new HashMap<>();
        result.put("code",200);
        result.put("msg","success");
        return Result.success(result);
    }

 　　@GetMapping("/test")
    @OperationLog(moduleName = "测试管理",operateType = "更新")
    public Result Hello(HttpServletRequest request){
        HashMap<Object, Object> result = new HashMap<>();
        result.put("code",200);
        result.put("msg","success");
        return Result.success(result);
    }

以上就是使用AOP注解记录接口日志的基本用法，后面再写接口只需要添加上这个注解就行了，是不是很方便呢！希望本文对你理解AOP、自定义注解以及接口日志记录有所帮助。

ℳ墨尔本
关注
  • 7
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 24
    评论
专栏目录
java上传文件接口调用源码案例
03-05
java调用需要上传文件的接口源码，其中含调用案例，调用工具，下载下来即可使用
java文件上传，断点续传+aop操作日志
04-11
java文件上传和下载，断点续传+aop操作日志
Java —— 基于注解的AOP切面实现 接口调用记录
简简单单记录
04-19 1620
一、预期效果 对所有@RequestMapping注解的接口全部记录接口调用情况并记入日志。 二、实现代码 tips: 这里使用了Lombok的@Slf4j实现日志 @Aspect @Component @Slf4j public class ReportApiCallTimesAspect { /*调用次数记录前缀,方便根据前缀获取所有接口的数据*/ public static final String WEB_API_CALL_COUNT = "web_api_call_count"; /
java实现AOP记录日志操作
最新发布
一只野生的coder博客
05-29 143
通过java中AOP切面和切点实现自定义注解，解析请求数据，完成记录日志的操作
java AOP实现记录操作日志
letterss的博客
04-21 6297
最近做项目需要添加一个用户操作记录功能，需要记录用户操作调用了哪些接口。实现方式当然用AOP啦，通过反射获取swagger注解上的接口说明，然后存到数据库，也可以不落库打印日志记录。 数据库： CREATE TABLE `job_operation_log` ( `id` bigint(20) NOT NULL AUTO_INCREMENT, `url` varchar(255) DEFAULT NULL COMMENT '请求接口地址', `http_method` varchar(25...
SSM-基于AOP日志管理
weixin_45203607的博客
09-15 1608
SSM项目基于AOP日志管理 准备工作 使用AOP日志管理需要在MVC中添加日志的AOP注解支持 最好就是spring和MVC都添加一个AOP 注解支持 这样防止有些使用AOP功能的 没有效果 <aop:aspectj-autoproxy proxy-target-class="true"/> 至于导入的Maven就不用多说了 因为到这一步 基本你的项目已经完成了, 应该jar导入的差不多了 使用AOP必须导入 <dependency> <group
Java使用Aop实现用户操作日志记录(新手入门)
m0_56759222的博客
03-10 4277
AOP实现用户操作日志记录
使用AOP切面实现日志记录功能
心态的博客
10-26 3518
说到AOP大家都可以想到他是面向切面的编程，它通过将横切关注点（例如日志记录、事务管理、权限控制等）从主要业务逻辑中分离出来，以模块化的方式进行管理。在AOP中，通过定义切面（Aspect）来捕获和处理横切关注点，然后将其应用于特定的目标对象或方法。官方的解释有点抽象，我们举个例子说明：假设我们需要在多个方法中添加日志记录功能。传统的方式是在每个方法中都添加日志代码，但这样会导致代码重复，并且当我们需要修改日志记录逻辑时，需要逐个修改所有方法。
java日志记录功能（对外接口追踪整个调用过程）
later_home的博客
07-26 1108
【代码】java日志记录功能（对外接口追踪整个调用过程）
aop注解方式实现全局日志管理方法
08-28
AOP注解方式实现全局日志管理方法是一种使用Aspect-Oriented Programming（面向方面编程）技术来实现日志管理的方法。该方法使用Java的注解方式来实现日志记录，能够对应用程序的日志进行统一管理。 知识点一：AOP...
Springboot接口项目如何使用AOP记录日志
08-19
Springboot 接口项目如何使用 AOP 记录日志 在软件开发中，日志记录是一项非常重要的任务，它可以帮助我们追踪程序的执行过程， debug 错误，优化性能等。但是，传统的日志记录方式通常需要在代码中添加大量的日志...
JAVA实现通用日志记录方法
08-30
在JAVA实现通用日志记录方法中，日志记录可以分为两种：一种是使用Filter层直接过滤httpServerletRequest请求进行日志处理，另一种是使用AOP（Aspect-Oriented Programming）记录操作日志。 使用Filter层直接过滤...
spring aop 自定义注解保存操作日志到mysql数据库 源码
11-25
4、想看spring aop 注解实现记录系统日志并入库等 二、能学到什么 1、收获可用源码 2、能够清楚的知道如何用spring aop实现自定义注解以及注解的逻辑实现 （需要知道原理的请看spring aop源码，此处不做赘述） 3、...
Spring Aop之AspectJ注解配置实现日志管理的方法
08-28
Spring Aop是基于AspectJ实现的面向切面编程（AOP），它提供了一个灵活的方式来实现日志管理。通过使用AspectJ注解，可以轻松地实现日志记录、性能监控、安全检查等功能。 知识点1: AspectJ注解 AspectJ是Java...
Java使用AOP操作日志，傻瓜版
Likeslowsongs的博客
06-02 687
面向切面的操作日志
java使用AOP切面获取请求日志并记录
unhejing的博客
03-18 4717
前言：为了完整的记录外部接口请求记录，记录内容包括：请求参数，响应参数，请求耗时，请求IP地址，请求成功还是失败，请求方法名称，请求接口地址等重要信息。 1.引入maven <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> <version>
一个简单的外部系统调用接口日志记录demo
qq_44299529的博客
06-24 700
一个简单的外部系统调用接口日志记录demo
Java自定义注解、Spring AOP、使用AOP实现和自定义注解实现日志记录
suiyishiguang的博客
09-02 2375
Java自定义注解以及Spring的AOP详解，通过AOP和自定义注解实现日志记录
不使用aop可以实现自定义日志记录注解吗
05-26
是的，可以通过自定义注解和编写拦截器来实现自定义日志记录。具体步骤如下： 1. 定义注解 ```java @Target({ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) public @interface Log { String value() default ""; } ``` 2. 编写拦截器 ```java @Component @Aspect public class LogAspect { @Autowired private LogService logService; @Pointcut("@annotation(com.example.demo.annotation.Log)") public void logPointCut() { } @Before("logPointCut()") public void before(JoinPoint joinPoint) { MethodSignature signature = (MethodSignature) joinPoint.getSignature(); Method method = signature.getMethod(); Log logAnnotation = method.getAnnotation(Log.class); String description = logAnnotation.value(); String methodName = signature.getName(); String className = joinPoint.getTarget().getClass().getName(); String params = Arrays.toString(joinPoint.getArgs()); logService.saveLog(className, methodName, params, description); } } ``` 3. 在需要记录日志的方法上使用注解 ```java @RestController public class UserController { @Autowired private UserService userService; @PostMapping("/users") @Log("添加用户") public Result addUser(@RequestBody User user) { userService.addUser(user); return Result.success(); } } ``` 这样，在调用 `addUser` 方法时就会触发拦截器，从而实现自定义日志记录。
评论 24
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值