SpringBoot-AOP记录操作日志

最新推荐文章于 2024-07-02 10:38:04 发布
最新推荐文章于 2024-07-02 10:38:04 发布
阅读量94 收藏
点赞数
文章标签： java aop spring hashmap python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44204751/article/details/115747220
版权
本文介绍了如何使用Spring AOP实现对`com.meeno.inner.oa.extend.project.module.service`模块服务的方法进行操作记录，包括新增、编辑、删除等，并将操作日志持久化到OperateRecord表中。
摘要由CSDN通过智能技术生成 
package com.meeno.inner.oa.extend.operaterecord.aop;

import com.alibaba.fastjson.JSONArray;
import com.google.common.collect.Lists;
import com.meeno.inner.oa.common.utils.AopUtils;
import com.meeno.inner.oa.extend.operaterecord.enums.OperateRecordTypeEnum;
import com.meeno.inner.oa.extend.operaterecord.repository.OperateRecordRepository;
import com.meeno.inner.oa.extend.operaterecord.service.OperateRecordService;
import com.meeno.inner.oa.extend.operaterecord.service.model.OperateRecordModel;
import com.meeno.inner.oa.extend.project.module.controller.form.ModuleModel;
import com.meeno.inner.oa.extend.project.module.entity.Module;
import com.meeno.inner.oa.extend.project.module.enums.ModuleTypeEnum;
import com.meenoframework.common.filter.ThreadLocalClient;
import lombok.NoArgsConstructor;
import lombok.extern.java.Log;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.List;

/**
 * @description: 切面类
 * @author: Wzq
 * @create: 2020-03-30 11:20
 */
@Aspect
@Component
@Log
public class ModuleAspect {

    @Autowired
    private OperateRecordService operateRecordService;


    @Pointcut("execution(public * com.meeno.inner.oa.extend.project.module.service.ModuleService.*(..))")
    public void cutPoint(){}

    /**
     * AfterReturning遇到异常不执行
     * @param joinPoint
     * @param retrunObj 方法返回值
     */
    @AfterReturning(returning="retrunObj",pointcut = "cutPoint()")
    public void before(JoinPoint joinPoint,Object retrunObj){
        //获取方法名称
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method =  signature.getMethod();
        log.info("aop->MethodName:"+method.getName());
        //方法中的值
        Object[] args = joinPoint.getArgs();
        /*Object target = joinPoint.getTarget();
        Object aThis = joinPoint.getThis();
        String classType = joinPoint.getTarget().getClass().getName();*/
        //方法名称
        String methodName = joinPoint.getSignature().getName();
        MethodNameEnum methodNameEnum = MethodNameEnum.get(methodName);
        HashMap<String, Object> fieldsMap = AopUtils.getFieldsName(method, args);

        //获取操作记录的Model
        List<OperateRecordModel> operationRecordList = null;
        if(methodNameEnum != null){
            operationRecordList = this.getOperationRecord(methodNameEnum, fieldsMap,retrunObj);
        }

        this.operateRecordService.addAll(operationRecordList);

    }

    public List<OperateRecordModel> getOperationRecord(MethodNameEnum methodNameEnum, HashMap<String, Object> fieldsMap,Object retrunObj){
        //操作记录Model
        List<OperateRecordModel> recordModelList = Lists.newArrayList();
        Long loginUserId = ThreadLocalClient.get().getId();
        //操作日志类型
        OperateRecordTypeEnum type = OperateRecordTypeEnum.MODULE;
        //模块
        Module module = null;
        //操作日志内容
        StringBuffer content = new StringBuffer();
        ModuleModel model = null;
        OperateRecordModel recordModel = null;
        switch (methodNameEnum){
            case ADD:
                content.append("创建了->");
                String moduleTypeStr = null;
                model = (ModuleModel) fieldsMap.get("model");
                //项目id
                Long projectId = model.getProjectId();
                //获取模块层级
                this.moduleModelLevelToString(model,content);
                //获取功能点数组字符串
                moduleTypeStr = model.getModuleTypeStr();
                //判断是否是多个type
                if(moduleTypeStr != null && !moduleTypeStr.isEmpty()){
                    //生成多条记录
                    JSONArray jsonArray = JSONArray.parseArray(moduleTypeStr);
                    if(jsonArray != null && !jsonArray.isEmpty()){
                        for (int i = 0; i < jsonArray.size(); i++) {
                            Integer moduleTypeCode = jsonArray.getInteger(i);
                            ModuleTypeEnum typeEnum = ModuleTypeEnum.getModuleTypeEnum(moduleTypeCode);
                            switch (typeEnum){
                                case WEB:
                                    content.append(" 类型:web");
                                    break;
                                case IOS:
                                    content.append(" 类型:ios");
                                    break;
                                case ANDROID:
                                    content.append(" 类型:android");
                                    break;
                                case SERVER:
                                    content.append(" 类型:server");
                                    break;
                            }
                            //每个type创建一条操作记录
                            OperateRecordModel tempRecordModel = new OperateRecordModel();
                            tempRecordModel.setProjectId(projectId);
                            tempRecordModel.setUserId(loginUserId);
                            tempRecordModel.setContent(content.toString());
                            tempRecordModel.setType(type);
                            //加入到集合中
                            recordModelList.add(tempRecordModel);
                        }
                    }
                }else{
                    //生成一条记录
                    recordModel = new OperateRecordModel();
                    recordModel.setProjectId(projectId);
                    recordModel.setUserId(loginUserId);
                    recordModel.setContent(content.toString());
                    recordModel.setType(type);
                    //加入到集合中
                    recordModelList.add(recordModel);
                }
                break;
            case EDIT:
                content.append("编辑了->");
                //方法中的参数
                model = (ModuleModel) fieldsMap.get("model");
                //返回的对象
                module = (Module) retrunObj;
                //获取模块层级
                this.moduleModelLevelToString(model,content);
                content.append(" 预计投入修改为: " + model.getPredictInput());
                //生成一条记录
                recordModel = new OperateRecordModel();
                recordModel.setProjectId(module.getProjectId());
                recordModel.setUserId(loginUserId);
                recordModel.setContent(content.toString());
                recordModel.setType(type);
                //加入到集合中
                recordModelList.add(recordModel);
                break;
            case DELETE:
                content.append("删除了->");
                //返回的对象
                module = (Module) retrunObj;
                //获取模块层级
                this.moduleLevelToString(module,content);
                //生成一条记录
                recordModel = new OperateRecordModel();
                recordModel.setProjectId(module.getProjectId());
                recordModel.setUserId(loginUserId);
                recordModel.setContent(content.toString());
                recordModel.setType(type);
                //加入到集合中
                recordModelList.add(recordModel);
                break;
            case EDIT_STATUS:
                content.append("修改模块状态->");
                //返回的对象
                module = (Module) retrunObj;
                //获取模块层级
                this.moduleLevelToString(module,content);
                //获取模块的状态
                this.moduleStatusToString(module,content);
                //生成一条记录
                recordModel = new OperateRecordModel();
                recordModel.setProjectId(module.getProjectId());
                recordModel.setUserId(loginUserId);
                recordModel.setContent(content.toString());
                recordModel.setType(type);
                //加入到集合中
                recordModelList.add(recordModel);
                break;
            case EDIT_REAL_INPUT:
                content.append("修改模块实际投入->");
                //返回的对象
                module = (Module) retrunObj;
                //获取模块层级
                this.moduleLevelToString(module,content);
                content.append(" 修改实际投入为: " + module.getRealInput());
                //生成一条记录
                recordModel = new OperateRecordModel();
                recordModel.setProjectId(module.getProjectId());
                recordModel.setUserId(loginUserId);
                recordModel.setContent(content.toString());
                recordModel.setType(type);
                //加入到集合中
                recordModelList.add(recordModel);
                break;
            case EDIT_PREDICT_INPUT:
                content.append("修改模块预计投入->");
                //返回的对象
                module = (Module) retrunObj;
                //获取模块层级
                this.moduleLevelToString(module,content);
                content.append(" 修改预计投入为: " + module.getRealInput());
                //生成一条记录
                recordModel = new OperateRecordModel();
                recordModel.setProjectId(module.getProjectId());
                recordModel.setUserId(loginUserId);
                recordModel.setContent(content.toString());
                recordModel.setType(type);
                //加入到集合中
                recordModelList.add(recordModel);
                break;
            /*case SET_WEIGHT:
                break;*/
            default:
                break;

        }
        return recordModelList;
    }

    /**
     * 修改模块的状态ToString
     * @param module
     * @param content
     */
    private void moduleStatusToString(Module module,StringBuffer content){
        if(module != null){
            switch (module.getStatus()){
                case NOT_INITIATED:
                    //未开始
                    content.append(" 修改状态为:未开始");
                    break;
                case PROCESSING:
                    //进行中
                    content.append(" 修改状态为:进行中");
                    break;
                case OVER:
                    //结束
                    content.append(" 修改状态为:结束");
                    break;
            }

        }

    }


    /**
     * 模块ModelToString
     * @param model
     * @param content
     */
    private void moduleLevelToString(Module model,StringBuffer content){
        if(model != null){
            switch (model.getLevel()){
                case one:
                    //一级模块
                    content.append("一级模块名称:" + model.getName());
                    break;
                case two:
                    //二级模块
                    content.append("二级模块名称:" + model.getName());
                    break;
                case three:
                    //三级模块
                    content.append("功能点名称:" + model.getName());
                    break;
            }
        }
    }

    /**
     * 模块ModelLevelToString
     * @param model
     * @param content
     */
    private void moduleModelLevelToString(ModuleModel model,StringBuffer content){
        if(model != null){
            switch (model.getLevel()){
                case one:
                    //一级模块
                    content.append("一级模块名称:" + model.getModuleName());
                    break;
                case two:
                    //二级模块
                    content.append("二级模块名称:" + model.getModuleName());
                    break;
                case three:
                    //三级模块
                    content.append("功能点名称:" + model.getModuleName());
                    break;
            }
        }
    }

    @NoArgsConstructor
    private enum MethodNameEnum{
        ADD("add"),
        EDIT("edit"),
        DELETE("delete"),
        EDIT_STATUS("editStatus"),
        EDIT_REAL_INPUT("editRealInput"),
        EDIT_PREDICT_INPUT("editPredictInput"),
        SET_WEIGHT("setWeight")
        ;

        private String methodName;

        MethodNameEnum(String methodName) {
            this.methodName = methodName;
        }

        public String getMethodName() {
            return methodName;
        }

        public void setMethodName(String methodName) {
            this.methodName = methodName;
        }

        public static MethodNameEnum get(String methodName){
            MethodNameEnum[] values = MethodNameEnum.values();
            for (MethodNameEnum value : values) {
                if (value.methodName.equals(methodName)) {
                    return value;
                }
            }
            return null;
        }
    }

}
GoslingWu
关注
SpringBoot-AOP环绕通知记录日志/鉴权
软件老王
08-13 2558
1、问题描述 微信公号h5开发，前后端分离，因为是在微信公号里面操作页面，还有涉及到不同手机操作也不一样，导致联调比较麻烦，定位问题也麻烦，以前写过通过aop记录所有前端http请求，就又拿出来梳理了下，记录日志，记录下，希望可以帮到有需要的朋友。 2、解决方案 项目是springboot项目，通过springboot-aop，配置环绕通知，记录调用地址、入参、返回参数、ip，同时记录执行时间等，以便定位问题。具体的入库就是弄个表，保存下获取到的值，这里就不多做介绍了。 2.1 AOP简要说明 （1）什么是
SpringBoot 配置 AOP 记录操作日志
死牛胖子的技术随笔
12-31 318
相关知识 AOP 即面对切面编程，是 Spring 框架的两大核心特性之一。 相关概念 切面（Aspect）：一个关注点的模块化，这个关注点可能会横切多个对象。事务管理是J2EE应用中一个关于横切关注点的很好的例子。在Spring AOP中，切面可以使用基于模式或者基于@Aspect注解的方式来实现。 连接点（Joinpoint）：在程序执行过程中某个特定的点，比如某方法调用的时候或者处理异常的...
Spring Boot 使用 AOP 记录日志
武培轩
03-01 603
在项目开发中经常，日志系统是必不可少的，特别是管理系统，对于重要的操作都会有操作日志，然而这个操作不需要我们在相应的方法中一个一个的去实现，这肯定是不合适的，这样的操作无疑是加大了开发量，...
SpringBoot AOP记录用户操作日志
u010741112的博客
06-23 548
Aop记录用户操作日志相关依赖 <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjrt --> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjrt</artifactId> <version>1.9.5</version> </depe
【Springboot】基于AOP实现操作日志记录
最新发布
ASL2915的博客
07-02 1555
基于AOP实现springboot项目中中的操作日志记录功能
springboot aop 记录日志
lovely960823的博客
09-24 160
肯定不用说，这篇又有抄的成分。自己稍微改善了一点，先看效果 上代码 @Table(name="syslog") @Data public class SysLog implements Serializable{ /** * */ private static final long serialVersionUID = 1L; private Integer id; private String username; //用户名 private String
SpringBoot Aop 日志记录
dingwen
04-30 76
文章目录前言一、Aop1.基本概念2.术语理解3.通知类型二、SpringBoot Aop 整合1.引入依赖2.注解3.切面4.使用 前言 本文基于Springboot2.x整合Aop时限日志记录 一、Aop 1.基本概念 AOP（Aspect Oriented Programming），即面向切面编程，可以说是OOP（Object Oriented Programming），面向对象编程的补充和完善。面向切面编程是面向对象中的一种方式而已。在代码执行过程中，动态嵌入其他代码，叫做面向切面编程。面向切面编
SpringBoot AOP 日志记录
我的树洞
03-26 1146
1.首先引入依赖，我的2.2.5版本需要引入，但是另一个2.1.5版本是不需要引入就可以使用注解 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </...
springboot-aop
11-09
本项目"springboot-aop"旨在演示如何在Spring Boot应用中配置和使用AOP来处理横切关注点，如日志记录、事务管理等。以下将详细讲解AOP的五种通知类型以及它们在Spring Boot中的应用。 1. 前置通知（Before Advice）...
springboot-aop-aspect:Springboot使用Aspect实现一个切面，以记录日志为例
05-15
本项目以记录日志为例，展示了如何在Spring Boot中使用AspectJ来实现AOP。 首先，我们需要了解Spring AOP的基础概念。AOP是一种编程范式，它将关注点分离为不同的模块，这些模块称为切面。切面通常包含通知...
SpringBoot使用AOP注解记录操作日志
04-30
// 从事件中获取请求信息，记录日志 // event.getException() 获取异常信息 // event.getRequest() 获取HttpServletRequest对象，从中获取IP、请求参数等 } } ``` 在这个监听器中，我们可以捕获到处理失败的...
详解基于SpringBoot使用AOP技术实现操作日志管理
08-25
主要介绍了详解基于SpringBoot使用AOP技术实现操作日志管理，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
spring boot Aop日志记录
Z__Sheng的博客
07-16 245
spring boot Aop日志记录 Aop 面向切面编程。让业务逻辑代码和关注点分离，我们只用关注切点就好，对本身写的业务逻辑代码没有影响。 首先，我们用图片解释一下什么叫做切面，如下图： Aop表达式 详解 在使用spring框架配置AOP的时候，不管是通过XML配置文件还是注解的方式都需要定义pointcut”切入点” 例如定义切入点表达式execution(*...
springboot利用aop日志记录
Xx__WangQi的博客
07-14 129
springboot利用aop日志记录 本文是使用mongoDB储存日志数据 添加依赖jar包 <!--aop--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> 创建aspectj包 包下新建 LogAspectj
SpringBoot之AOP实现日志记录
qq_41343166的博客
06-14 543
SpringBoot之AOP 一、什么是AOP AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 二、目的 ​ 在不侵入代码的情况下记录请求日志，具体如下，在执行方法前记录请
使用Spring Boot AOP实现日志记录
一名想当程序员的人
07-30 3926
1.1 什么是AOPAOP（Aspect Oriented Programming），面向切面思想，是Spring的三大核心思想之一（两外两个：IOC-控制反转、DI-依赖注入）。那么AOP为何那么重要呢？在我们的程序中，经常存在一些系统性的需求，比如权限校验、日志记录、统计等，这些代码会散落穿插在各个业务逻辑中，例如下面这个示意图：有多少业务操作，就要写多少重复的校验和日志记录代码，这显然是无法接受的。
SpringBoot利用AOP记录系统日志
qq_40814565的博客
09-19 749
SpringBoot 利用 AOP记录系统日志
Spring Boot项目中通过AOP记录日志
duchaopeng的专栏
04-15 384
然后，我们需要定义一个切面来记录日志。这个切面可以在方法执行前后记录日志信息。@Aspect@Component：在方法执行前记录日志信息；：在方法执行后（返回结果后）记录日志信息；：在方法执行抛出异常时记录日志信息。通过使用AOP来记录日志，我们可以更加优雅地记录日志信息。在Spring Boot中，我们可以通过添加依赖、定义切面和应用切面的方式来实现这个功能。
SpringBoot中AOP实现接口日志打印的实战教程
4. **Advice**：是针对Jointpoint执行的操作，如进入方法前后执行的日志记录、事务开始、结束或回滚。Advice与Pointcut结合使用，定义了切面的行为。 5. **AOPProxy**：这是一个动态代理机制，Spring使用它将Advice...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值