基于SpringAOP的操作日志记录实现

最新推荐文章于 2024-07-21 15:41:03 发布
最新推荐文章于 2024-07-21 15:41:03 发布
阅读量1.2k 收藏 1
点赞数
分类专栏： Spring-AOP 文章标签： springaop 全局记录操作日志
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qism007/article/details/53032259
版权

项目中，我们经常会遇到这样的需求，记录用户一些特殊的操作日志，我遇到过好几次，所以今天我分享下自己的实现。
实现方式有很多种，我是依据SpringAop+SpEL表达式实现的，下面看下代码：

  • 自定义一个用于标注操作日志的注解
    这里写图片描述

  • 操作类型枚举
    这里写图片描述

  • 注解应用
    这里写图片描述

  • 注解解析类和切面配置
    实现方法可以是在spring配置文件中配置切面层，也可以是自定义标有Aspect注解的类，接下来我先采用配置方式实现
    解析处理类 SysLogAspect.java

package com.smqi.common.log;

import com.smqi.common.aop.OperInfo;
import com.smqi.common.aop.OperationType;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.LocalVariableTableParameterNameDiscoverer;
import org.springframework.expression.Expression;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.common.TemplateParserContext;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;

import java.lang.reflect.Method;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 系统操作日志记录
 * <p>
 * Created by smqi on 2016/11/4.
 */
public class SysLogAspect {
    /**
     * 日志记录器
     */
    protected final Logger logger = LoggerFactory.getLogger(getClass());

    /**
     * 缓存标注有自定义日志注解的方法参数名称
     */
    private static Map<String, String[]> parameterNameCaches = new ConcurrentHashMap<String, String[]>();
    /**
     * 缓存SPEL Expression
     */
    private static Map<String, Expression> spelExpressionCaches = new ConcurrentHashMap<String, Expression>();
    /**
     * Spel表达式语法分析式
     */
    private static ExpressionParser parser = new SpelExpressionParser();
    /**
     * 用于获取方法参数名称数组
     */
    private static LocalVariableTableParameterNameDiscoverer parameterNameDiscovere =
            new LocalVariableTableParameterNameDiscoverer();

    public Object doAroundMethodForCtLog(ProceedingJoinPoint pjp)
            throws Throwable {
        //获取当前注解
        Method theMethod = getMethod(pjp);
        if (theMethod != null
                && theMethod.isAnnotationPresent(OperInfo.class)) {
            OperInfo annotation = theMethod.getAnnotation(OperInfo.class); // 获取指定注解
            String descpTemp = annotation.description();
            String descption = executeTemplate(descpTemp, pjp);
            OperationType type = annotation.type();
            logger.info("操作类型:【{}】，日志信息：【{}】",type.getType(),descption);
            
            //TODO 调用数据存储层进行入库，此处省略……
        }
        return pjp.proceed();
    }

    /**
     * 解析执行description中的SPEL模板。
     *
     * @param template
     * @param joinPoint
     * @return
     */
    private String executeTemplate(String template, ProceedingJoinPoint joinPoint) {
        //获取原始对象方法名
        String methodLongName = joinPoint.getSignature().toLongString();
        String[] parameterNames = parameterNameCaches.get(methodLongName);
        if (parameterNames == null) {
            Method method = getMethod(joinPoint);
            parameterNames = parameterNameDiscovere.getParameterNames(method);
            parameterNameCaches.put(methodLongName, parameterNames);
        }
        StandardEvaluationContext context = new StandardEvaluationContext();
        Object[] args = joinPoint.getArgs();
        if (args.length == parameterNames.length) {
            for (int i = 0, len = args.length; i < len; i++)
                context.setVariable(parameterNames[i], args[i]);
        }
        Expression expression = spelExpressionCaches.get(template);
        if (expression == null) {
            expression = parser.parseExpression(template, new TemplateParserContext());
            spelExpressionCaches.put(template, expression);
        }
        return expression.getValue(context, String.class);
    }

    /**
     * 获取当前执行的方法
     *
     * @param joinPoint
     * @return
     */
    private Method getMethod(ProceedingJoinPoint joinPoint) {
        Object target = joinPoint.getTarget();
        Method method = ((MethodSignature) joinPoint.getSignature()).getMethod();
        try {
            method = target.getClass().getMethod(method.getName(),
                    method.getParameterTypes());
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        return method;
    }
}

xml文件配置如下：

<!--系统操作日志记录-->
    <bean id="sysLogAspect" class="com.smqi.common.log.SysLogAspect"/>

这里写图片描述
这里我集成到了数据库读写分离的aop配置里，不要的话可以把第一个aop:aspect配置删掉

下面我在controller层调用demoService.addDemo(user)方法，看下运行结果：
这里写图片描述
上述是基于配置的实现，下面我们再尝试下自定义标有Aspect注解的类
先将原先的配置删除，只需要添加类SysLogAspect2的bean即可

SysLogAspect2.java

package com.smqi.common.log;

import com.smqi.common.aop.OperInfo;
import com.smqi.common.aop.OperationType;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.LocalVariableTableParameterNameDiscoverer;
import org.springframework.expression.Expression;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.common.TemplateParserContext;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;

import java.lang.reflect.Method;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 *
 * Created by smqi on 2016/11/4.
 */
@Aspect
public class SysLogAspect2 {
    /**
     * 日志记录器
     */
    protected final Logger logger = LoggerFactory.getLogger(getClass());

    /**
     * 缓存标注有自定义日志注解的方法参数名称
     */
    private static Map<String, String[]> parameterNameCaches = new ConcurrentHashMap<String, String[]>();
    /**
     * 缓存SPEL Expression
     */
    private static Map<String, Expression> spelExpressionCaches = new ConcurrentHashMap<String, Expression>();
    /**
     * Spel表达式语法分析式
     */
    private static ExpressionParser parser = new SpelExpressionParser();
    /**
     * 用于获取方法参数名称数组
     */
    private static LocalVariableTableParameterNameDiscoverer parameterNameDiscovere =
            new LocalVariableTableParameterNameDiscoverer();

    @Around("execution(* com.smqi.modules..service.impl.*Impl.*(..)) && @annotation(annotation)")
    public Object doAroundMethodForCtLog(ProceedingJoinPoint pjp, OperInfo annotation)
            throws Throwable {
        //获取当前注解
        String descpTemp = annotation.description();
        String descption = executeTemplate(descpTemp, pjp);
        OperationType type = annotation.type();
        logger.info("操作类型:【{}】，日志信息：【{}】", type.getType(), descption);

        //TODO 调用数据存储层进行入库，此处省略……
        return pjp.proceed();
    }

    /**
     * 解析执行description中的SPEL模板。
     *
     * @param template
     * @param joinPoint
     * @return
     */
    private String executeTemplate(String template, ProceedingJoinPoint joinPoint) {
        //获取原始对象方法名
        String methodLongName = joinPoint.getSignature().toLongString();
        String[] parameterNames = parameterNameCaches.get(methodLongName);
        if (parameterNames == null) {
            Method method = getMethod(joinPoint);
            parameterNames = parameterNameDiscovere.getParameterNames(method);
            parameterNameCaches.put(methodLongName, parameterNames);
        }
        StandardEvaluationContext context = new StandardEvaluationContext();
        Object[] args = joinPoint.getArgs();
        if (args.length == parameterNames.length) {
            for (int i = 0, len = args.length; i < len; i++)
                context.setVariable(parameterNames[i], args[i]);
        }
        Expression expression = spelExpressionCaches.get(template);
        if (expression == null) {
            expression = parser.parseExpression(template, new TemplateParserContext());
            spelExpressionCaches.put(template, expression);
        }
        return expression.getValue(context, String.class);
    }

    /**
     * 获取当前执行的方法
     *
     * @param joinPoint
     * @return
     */
    private Method getMethod(ProceedingJoinPoint joinPoint) {
        Object target = joinPoint.getTarget();
        Method method = ((MethodSignature) joinPoint.getSignature()).getMethod();
        try {
            method = target.getClass().getMethod(method.getName(),
                    method.getParameterTypes());
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        return method;
    }
}
smqi
关注
专栏目录
基于aop的日志记录
while(True): print('adorable')
06-14 335
如题
SpringAop实现日志记录功能
weixin_45261485的博客
05-23 1999
AOP(面向切面编程) AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 AOP术语 AOP 领域中的特性术语： 通知（Advice）: AOP 框架中的增强处理。通知描述了切面何时执行以及如何执行增强处理。 连接点（join point）: 连接点表示应用执行过程中能够插入切面的一个点，这个点可以是方法的调用
Spring AOP 完成日志记录
Java软件工程师之路
12-30 1021
  Spring AOP 完成日志记录     1、技术目标     掌握Spring AOP基本用法 使用Spring AOP完成日志记录功能     提示：本文所用项目为"影片管理"，参看 http://hotstrong.iteye.com/blog/1160153 本文基于"影片管理"项目进行了日志记录功能扩充   注意：本文所实现的项目(MyEcli...
使用AOP+SPEL实现全局的操作日志记录（可直接使用）
最新发布
qq_42807952的博客
07-21 697
接口中的类为自定义，你需要记录什么就自己定义，我需要操作的实体类modelName，备注remark等，就先进行定义，然后可以在使用注解时候配合SPEL赋值，最终通过解析获取落库。/*** 自定义注解-实现操作日志记录*/@Component/*** 操作类*//*** 备注*//*** 内容*//*** 操作之前的原数据（SpEL）*//*** 操作之后的新数据（SpEL）*/
Spring AOP日志记录
TechnicianWang的博客
01-10 219
@Slf4j @Aspect @Component public class AspectLogTools { // @Aspect 表明是一个切面类 // @Component 将当前类注入到Spring容器内 // @Pointcut 切入点，其中execution用于使用切面的连接点。使用方法：execution(方法修饰符(可选) 返回类型 方法名 参数 异常模式(可选)) ，可以使用通配符匹配字符，*可以匹配任意字符。 // @Before 在方法前执行 // @A.
使用AOP切面实现日志记录功能
心态的博客
10-26 4639
说到AOP大家都可以想到他是面向切面的编程，它通过将横切关注点（例如日志记录、事务管理、权限控制等）从主要业务逻辑中分离出来，以模块化的方式进行管理。在AOP中，通过定义切面（Aspect）来捕获和处理横切关注点，然后将其应用于特定的目标对象或方法。官方的解释有点抽象，我们举个例子说明：假设我们需要在多个方法中添加日志记录功能。传统的方式是在每个方法中都添加日志代码，但这样会导致代码重复，并且当我们需要修改日志记录逻辑时，需要逐个修改所有方法。
spring aop 日志记录
wangwei2043869的专栏
06-27 167
package com.***.knot.common.aop; import java.util.HashMap; import java.util.Map; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import org.apache.log4j...
SpringBoot SpringAOP实现操作日志记录功能
CSDN_YCCAXTT的博客
09-15 915
项目环境： JDK1.8 SpringBoot2.3.3.RELEASE SpringAop2.3.3.RELEASE 第一步：引入jar包 <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId>
Spring Aop之AspectJ注解配置实现日志管理的方法
08-28
Spring Aop是基于AspectJ实现的面向切面编程（AOP），它提供了一个灵活的方式来实现日志管理。通过使用AspectJ注解，可以轻松地实现日志记录、性能监控、安全检查等功能。 知识点1: AspectJ注解 AspectJ是Java...
基于Spring AOP的日志功能实现
qq_38586378的博客
08-11 3525
前言 前一段时间学习了Spring，明确Spring的两大特征：IoC控制反转和AOP面向切面编程。后续遇到了系统日志功能，实现的时候使用到了AOP，在此进行总结。 IoC：主要是将程序中的对象通过创建bean对象的方式将其加入到Spring容器中，通过依赖注入的方式调用容器中的bean对象，从而降低程序间的依赖性（传统是通过new 方式获取类对象） AOP：面向切面编程，抽取出程序中重复度较高的代码，然后项目中哪里需要使用，就通过反向代理的方式调用这部分重复度高的代码，实现原功能的代码增强。 参考
使用Spring AOP实现日志记录
coder_jh的博客
07-01 847
在LogAspect类的方法上，我们使用了Spring AOP的注解，通过指定切点表达式来切入指定的方法。在上述示例中，我们创建了一个简单的Spring MVC控制器，并定义了两个接口：hello()和exception()。通过编写一个切面类，并通过配置文件激活切面，我们可以在需要记录日志的方法上切入相关逻辑，实现日志记录的同时保持代码的整洁性。为了让Spring框架识别并使用我们定义的LogAspect切面，我们需要在配置文件中进行配置。接下来，让我们来演示如何在实际的代码中应用日志记录切面。
spring aop 操作日志
06-04
本资源用来展示如何使用 spring aop 进行日志记录，例子里面通过aop的配置，把产生的日志存放到当前项目的根目录下，而且对方法执行过程中的参数进行了记录，对于aop如何记录日志不清楚的同学可以看看。
Spring AOP--日志管理
01-26
Spring AOP--日志管理，注释齐全，欢迎大家共同交流。
Spring aop 记录操作日志 Aspect 源码
01-04
时间过的真快，转眼就一年了，没想到随手写的笔记会被这么多人浏览，不想误人子弟，于是整理了一个优化版。感谢各位同道的支持!
Spring框架基于AOP实现简单日志管理步骤解析
08-19
Spring框架基于AOP实现简单日志管理步骤解析 在本篇文章中，我们将详细介绍如何使用Spring框架基于AOP（Aspect-Oriented Programming，面向方面编程）来实现简单日志管理步骤解析。AOP是一种编程范式，旨在将横切...
SpringAop日志记录
热门推荐
轻描淡写
03-13 1万+
spring日志记录（使用切面方式记录） 1. 创建pojo类 @Data @Table(name = "tb_operate_record") public class OperateRecord { @Id private String id; //记录请求时间 @Column(name = "record_time") private Date rec...
Spring之AOP日志记录
积跬步，至千里。
10-17 1573
在Java中，可以使用注解和切面技术来实现AOP（Aspect Oriented Programming）。AOP是一种编程范式，它通过将应用程序分解为关注点的模块来提高代码的可维护性和重用性。注解可以用于标记程序元素，例如类、方法和字段，以便切面可以识别和操作这些元素。
SpringAop实现日志记录
汣栀的博客
03-18 185
首先添加jar包 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> package com.kq.configmanager.annotation; import java.lang.annotation.*; @Documented @T
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值