SpringAop实现日志记录

最新推荐文章于 2024-05-13 13:16:21 发布
最新推荐文章于 2024-05-13 13:16:21 发布
阅读量178 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44102521/article/details/114978996
版权

首先添加jar包

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

package com.kq.configmanager.annotation;

import java.lang.annotation.*;

@Documented
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface OperationLogDetail {

    /**
     * 方法描述,可使用占位符获取参数:{{tel}}
     */
    String detail() default "";
    /**
     * 要执行的具体操作
     * @return
     */
    public String operationName() default "";
    /**
     * 操作类型(enum):主要是select,insert,update,delete
     */
    public String operationType() default "";


}

切入点为这个下面的类：
在这里插入图片描述

package com.kq.configmanager.aop;

import java.lang.reflect.Method;
import java.util.*;

import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

import cn.hutool.core.util.IdUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.kq.configmanager.annotation.OperationLogDetail;
import com.kq.configmanager.domain.OperationLog;
import com.kq.configmanager.service.IDssConfigLogService;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.springframework.web.multipart.MultipartFile;

/**
 * Created by xu on 2021/3/13.
 */
@Aspect
@Component
public class LogAspect {

    /**
     * 注入service
     */
    @Autowired
    private IDssConfigLogService iDssConfigLogService;

    private  static  final Logger logger = LoggerFactory.getLogger(LogAspect. class);

    //切入点
    @Pointcut("execution (* com.kq.configmanager.controller.release.*.*(..))")
    public  void controllerAspect() {}


    /**
     * 前置通知 用于拦截Controller层记录用户的操作、再切入点之前要干的
     *
     * @param joinPoint 切点
     */
    @Before("controllerAspect()")
    public void doBefore(JoinPoint joinPoint) {
        System.out.println("==========执行controller前置通知===============");
        if(logger.isInfoEnabled()){
            logger.info("before " + joinPoint);
        }
    }


    /**
     * 配置controller环绕通知,使用在方法aspect()上注册的切入点
     * @param joinPoint
     */
    @Around("controllerAspect()")
    public void around(JoinPoint joinPoint){
        System.out.println("==========开始执行controller环绕通知===============");
        long start = System.currentTimeMillis();
        try {
            ((ProceedingJoinPoint) joinPoint).proceed();
            long end = System.currentTimeMillis();
            if(logger.isInfoEnabled()){
                logger.info("around " + joinPoint + "\tUse time : " + (end - start) + " ms!");
            }
            addOperationLog(joinPoint);
            System.out.println("==========结束执行controller环绕通知===============");
        } catch (Throwable e) {
            long end = System.currentTimeMillis();
            if(logger.isInfoEnabled()){
                logger.info("around " + joinPoint + "\tUse time : " + (end - start) + " ms with exception : " + e.getMessage());
            }
        }
    }



    private void addOperationLog(JoinPoint joinPoint){
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        HttpSession session = request.getSession();
        //读取session中的用户
        String userId = String.valueOf(session.getAttribute("userId"));
        String userName = String.valueOf(session.getAttribute("userName"));
        OperationLog operationLog = new OperationLog();
        operationLog.setId(IdUtil.randomUUID());
        operationLog.setInsertTime(new Date());
        operationLog.setUserId(userId);
        operationLog.setUserName(userName);
        try {
            String targetName = joinPoint.getTarget().getClass().getName();
            String methodName = joinPoint.getSignature().getName();
            Object[] arguments = joinPoint.getArgs();
            Class targetClass = Class.forName(targetName);
            Method[] methods = targetClass.getMethods();
            String operationType = "";
            String operationName = "";
            for (Method method : methods) {
                if (method.getName().equals(methodName)) {
                    Class[] clazzs = method.getParameterTypes();
                    if (clazzs.length == arguments.length) {
                        operationType = method.getAnnotation(OperationLogDetail.class).operationType();
                        operationName = method.getAnnotation(OperationLogDetail.class).operationName();
                        break;
                    }
                }
            }
            if(operationType.equals("insert")){
                operationLog.setUserContent(operationName);
                operationLog.setOperationType(operationType);
                iDssConfigLogService.insert(operationLog);
            }else if(operationType.equals("updateStatus1")){
                operationLog.setUserContent(operationName);
                operationLog.setOperationType(operationType);
                iDssConfigLogService.insert(operationLog);
            }else if(operationType.equals("updateStatus2")){
                operationLog.setUserContent(operationName);
                operationLog.setOperationType(operationType);
                iDssConfigLogService.insert(operationLog);
            }else if(operationType.equals("updateData")){
                String paramter = "";
                //请求的参数
                Object[] args = joinPoint.getArgs();
                Object[] arguments1  = new Object[args.length];
                for (int i = 0; i < args.length; i++) {
                    if (args[i] instanceof ServletRequest || args[i] instanceof ServletResponse || args[i] instanceof MultipartFile) {
                        continue;
                    }
                    arguments1[i] = args[i];
                }
                if (arguments1 != null) {
                    try {
                        paramter = JSONObject.toJSONString(arguments1);
                    } catch (Exception e) {
                        paramter = arguments1.toString();
                    }
                }
                List<Map<String, Object>> maps = toListMap(paramter);
                Object satelliteSensor = maps.get(0).get("satelliteSensor");
                Object sceneStartTime = maps.get(0).get("sceneStartTime");
                Object sceneEndTime = maps.get(0).get("sceneEndTime");
                Object productStartTime = maps.get(0).get("productStartTime");
                Object productEndTime = maps.get(0).get("productEndTime");
                Object dbStartTime = maps.get(0).get("dbStartTime");
                Object dbEndTime = maps.get(0).get("dbEndTime");
                Object requirement = maps.get(0).get("requirement");

                StringBuilder sb = new StringBuilder("修改");
                if(satelliteSensor!=null){
                    sb.append("卫星为"+satelliteSensor+",");
                }
                if (sceneStartTime!=null){
                    sb.append("采集时间为"+sceneStartTime+" "+sceneEndTime+",");
                }
                if(productStartTime!=null){
                    sb.append("生产时间为"+productStartTime+" "+productEndTime+",");
                }
                if(dbStartTime!=null){
                    sb.append("入库时间为"+dbStartTime+" "+dbEndTime+",");
                }
                if(requirement!=null){
                    sb.append("需求说明为"+requirement+",");
                }

                operationName = sb.toString().substring(0,sb.toString().length()-1);
                //*========数据库日志=========*//
                //保存数据库
                operationLog.setUserContent(operationName);
                operationLog.setOperationType(operationType);
                iDssConfigLogService.insert(operationLog);
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    /**
     * 后置通知 用于拦截Controller层记录用户的操作
     *
     * @param joinPoint 切点
     */
    @After("controllerAspect()")
    public  void after(JoinPoint joinPoint) {
        System.out.println("=====controller后置通知结束=====");
    }


    //配置后置返回通知,使用在方法aspect()上注册的切入点
    @AfterReturning("controllerAspect()")
    public void afterReturn(JoinPoint joinPoint){
        System.out.println("=====执行controller后置返回通知=====");
        if(logger.isInfoEnabled()){
            logger.info("afterReturn " + joinPoint);
        }
    }


    /**
     * 异常通知 用于拦截记录异常日志
     *
     * @param joinPoint
     * @param e
     */
    @AfterThrowing(pointcut = "controllerAspect()", throwing="e")
    public  void doAfterThrowing(JoinPoint joinPoint, Throwable e) {
        logger.error("异常方法:{}异常代码:{}异常信息:{}", joinPoint.getTarget().getClass().getName() + joinPoint.getSignature().getName(), e.getClass().getName(), e.getMessage());
    }


    public List<Map<String, Object>> toListMap(String json){
        List<Object> list =JSON.parseArray(json);
        List< Map<String,Object>> listw = new ArrayList<Map<String,Object>>();
        for (Object object : list){
            Map <String,Object> ret = (Map<String, Object>) object;//取出list里面的值转为map
            listw.add(ret);
        }
        System.out.println(listw);
        return listw;
    }
}

在方法上添加：@OperationLogDetail(operationType=“insert”,operationName=“创建”)

package com.kq.configmanager.controller.release;

import cn.hutool.core.util.IdUtil;
import com.kq.common.exception.BaseException;
import com.kq.configmanager.annotation.OperationLogDetail;
import com.kq.configmanager.controller.BaseController;
import com.kq.configmanager.domain.DssConfigRelease;
import com.kq.configmanager.service.IDssConfigLogService;
import com.kq.configmanager.service.IDssConfigReleaseService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

import java.util.Date;


/**
 * (DssConfigRelease)表控制层
 *
 * @author makejava
 * @since 2021-03-12 13:59:28
 */
@Api(value = "DssConfigReleaseController",description = "发布配置管理")
@Controller
@RequestMapping("dssConfigRelease")
public class DssConfigReleaseController extends BaseController<DssConfigRelease,IDssConfigReleaseService> {

    @Autowired
    private IDssConfigReleaseService iDssConfigReleaseService;

    @Autowired
    private IDssConfigLogService iDssConfigLogService;

    @ApiOperation(value = "新增发布配置管理")
    @RequestMapping(value = "/save.do",method = RequestMethod.POST,produces = MediaType.APPLICATION_JSON_UTF8_VALUE)
    @ResponseBody
    @OperationLogDetail(operationType="insert",operationName="创建")
    public Object insert(@RequestBody DssConfigRelease dssConfigRelease) {
        boolean result = false;
        try{
            String s = IdUtil.randomUUID();
            dssConfigRelease.setId(s);
            dssConfigRelease.setInsertTime(new Date());
            result = this.defaultDAO.insert(dssConfigRelease);
        }catch (Exception e){
            e.printStackTrace();
            throw new BaseException("新增失败",500);
        }
        return super.jsonObjectResult(result, "新增成功");
    }

    @ApiOperation(value = "修改发布状态为停止")
    @RequestMapping(value = "/update1.do",method = RequestMethod.POST,produces = MediaType.APPLICATION_JSON_UTF8_VALUE)
    @ResponseBody
    @OperationLogDetail(operationType="updateStatus1",operationName="修改发布状态为停止")
    public Object update1(@RequestBody DssConfigRelease dssConfigRelease) {
        boolean result = false;
        try{
            String id = dssConfigRelease.getId();
            iDssConfigReleaseService.update1(id);
            result = true;
        }catch (Exception e){
            e.printStackTrace();
            throw new BaseException("状态修改失败",500);
        }
        return super.jsonObjectResult(result, "状态修改成功");
    }

    @ApiOperation(value = "修改发布状态为失效")
    @RequestMapping(value = "/update2.do",method = RequestMethod.POST,produces = MediaType.APPLICATION_JSON_UTF8_VALUE)
    @ResponseBody
    @OperationLogDetail(operationType="updateStatus2",operationName="修改发布状态为失效")
    public Object update2(@RequestBody DssConfigRelease dssConfigRelease) {
        boolean result = false;
        try{
            String id = dssConfigRelease.getId();
            iDssConfigReleaseService.update2(id);
            result = true;
        }catch (Exception e){
            e.printStackTrace();
            throw new BaseException("状态修改失败",500);
        }
        return super.jsonObjectResult(result, "状态修改成功");
    }



    @ApiOperation(value = "修改数据")
    @RequestMapping(value = "/updateData.do",method = RequestMethod.POST,produces = MediaType.APPLICATION_JSON_UTF8_VALUE)
    @ResponseBody
    @OperationLogDetail(operationType="updateData")
    public Object updateData(@RequestBody DssConfigRelease dssConfigRelease) {
        boolean result = false;
        try{
            result = this.defaultDAO.updateById(dssConfigRelease);
        }catch (Exception e){
            e.printStackTrace();
            throw new BaseException("修改失败",500);
        }
        return super.jsonObjectResult(result, "修改成功");
    }
}

数据库日志表中记录状态：
在这里插入图片描述

汣栀
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
spring aop实现日志分析管理
01-02
在Spring AOP（面向切面编程）中实现日志分析管理是一种常见的做法，它能帮助开发者跟踪和理解系统运行过程中的行为，同时提供详细的错误日志以支持运维工作。通过元注解的方式，我们可以轻松地将日志记录功能集成到...
Spring Aop之AspectJ注解配置实现日志管理的方法
08-28
通过使用AspectJ注解，可以轻松地实现日志记录、性能监控、安全检查等功能。 知识点1: AspectJ注解 AspectJ是Java平台上最流行的AOP实现之一，提供了丰富的注解来实现切面编程。AspectJ注解可以用来定义切面、切入...
spring Aop实现日志
weixin_41551987的博客
08-18 2095
这版讲到的日志是作用在方法的，通过aop来指定某些方法以完成在执行方法前后的一些操作，说是记录日志不如说是讲解aop的用法。
springboot使用aop记录日志
weixin_45541795的博客
10-12 3798
Springboot中添加AOP日志，对你会有帮助！
Spring AOP --实现日志记录
最新发布
2401_83412172的博客
05-13 603
Joint Point 简单说明getTarget() 获取当前对象getSignature().getName() 获得当前方法名getArgs() 获得传递的参数（形参）/**@Description 包含增强方法的JavaBean@Created by 闲言*///获取log日志对象/**前置增强的方法*/
SpringAOP详解，使用SpringAop实现统一日志处理，异常处理
生而为人我很抱歉
08-03 3322
SpringAOP详解，使用SpringAop实现统一日志处理，异常处理
AOP实现日志记录
qq_51438138的博客
01-06 765
AOP实现日志记录
使用Spring AOP实现日志记录
coder_jh的博客
07-01 806
在LogAspect类的方法上，我们使用了Spring AOP的注解，通过指定切点表达式来切入指定的方法。在上述示例中，我们创建了一个简单的Spring MVC控制器，并定义了两个接口：hello()和exception()。通过编写一个切面类，并通过配置文件激活切面，我们可以在需要记录日志的方法上切入相关逻辑，实现日志记录的同时保持代码的整洁性。为了让Spring框架识别并使用我们定义的LogAspect切面，我们需要在配置文件中进行配置。接下来，让我们来演示如何在实际的代码中应用日志记录切面。
Spring框架实现AOP添加日志记录功能过程详解
08-25
使用AspectJ，我们可以轻松地实现日志记录、安全检查、缓存、事务管理等cross-cutting concerns。 下面是一个简单的日志处理类的示例代码： ``` package aop; import java.util.Arrays; import org.apache.log4j....
spring aop实现日志功能 开发技术-其它
06-13
总结来说，Spring AOP提供了一种简洁且灵活的方式来实现日志功能，使得开发者可以专注于业务逻辑，而不是重复的日志记录代码。通过定义切面和通知，我们可以将日志操作与业务代码解耦，提升代码的可复用性和可扩展性...
spring aop实现日志功能
04-13
标题"spring aop实现日志功能"涉及到的是如何利用Spring AOP来记录和跟踪应用程序中的操作，这对于调试、性能分析和故障排查至关重要。下面我们将详细探讨如何通过Spring AOP来实现日志功能。 首先，理解AOP的基本...
spring aop 操作日志
06-04
本资源用来展示如何使用 spring aop 进行日志记录，例子里面通过aop的配置，把产生的日志存放到当前项目的根目录下，而且对方法执行过程中的参数进行了记录，对于aop如何记录日志不清楚的同学可以看看。
使用AOP实现记录系统日志
weixin_48911650的博客
08-21 256
*** 自定义操作日志记录注解*//*** 模块*//*** 功能*//*** 操作人类别*//*** 是否保存请求的参数*/
spring AOP实现日志管理
haiboSun的博客
03-16 4934
前言 spring AOP是使用spring提供的切面来横向拓展项目，使得一些和主业务无关的操作尽可能实现解耦，比如说我们经常使用的日志。 注： 需要用到pom文件 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> 实操 1、编写一个自
实际项目中的SpringAOP实现日志打印
qq_63218110的博客
01-27 1373
本篇主要借项目来巩固SpringAOP实现日志打印的功能。
AOP日志功能实现
weixin_52060913的博客
05-29 2224
在需要实现日志功能的方法上添加注解@LogAnnotation（module为名字，operator为方法的操作名称）@LogAnnotation(module = "用户" , operator = "获取用户列表")
AOP日志
我有故人折剑去，斩尽春风不曾归
06-28 302
AOP（面向切面编程）是一种编程思想，可以通过在代码中定义切面（Aspect），来实现对特定方法的拦截和增强。4.定义增强逻辑：在切面类中，定义增强逻辑，即在切入点前后执行的操作。1.导入相关依赖：首先，需要导入AOP框架的相关依赖，例如Spring AOP或AspectJ。2.定义切面：创建一个切面类，用于定义切入点和增强逻辑。5.配置AOP：通过注解或XML配置，将切面类与目标类进行关联，以实现AOP拦截和增强。3.定义切入点：在切面类中，使用注解或XML配置来定义切入点，即目标方法的执行位置。
Spring Boot AOP 扫盲，实现接口访问的统一日志记录
沉默王二
02-22 7068
AOP 是 Spring 体系中非常重要的两个概念之一（另外一个是 IoC），今天这篇文章就来带大家通过实战的方式，在编程猫 SpringBoot 项目中使用 AOP 技术为 controller 层添加一个切面来实现接口访问的统一日志记录。 一、关于 AOP AOP，也就是 Aspect-oriented Programming，译为面向切面编程，是计算机科学中的一个设计思想，旨在通过切面技术为业务主体增加额外的通知（Advice），从而对声明为“切点”（Pointcut）的代码块进行统一管理和装饰。 这
springaop实现日志记录
03-28
下面是实现日志记录的步骤： 1. 添加Spring AOP依赖 在Maven或Gradle中添加Spring AOP依赖。 2. 创建日志切面 创建一个用于记录日志的切面。这个切面可以拦截所有需要记录日志的方法。在这个切面中，我们需要...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值