基于Springboot+AOP记录操作日志

已于 2024-05-17 11:31:26 修改
阅读量336 收藏 10
点赞数 7
文章标签： spring boot 后端 java
于 2024-05-16 22:34:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74197140/article/details/138976901
版权

基于Springboot+AOP记录操作日志

一、后端代码

1.在pom.xml中引入相关依赖

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

2.导入获取ip的工具（如果不获取用户的ip可以不导入）

package com.example.springboot.utils;

import javax.servlet.http.HttpServletRequest;

public class IpUtils {

    public static String getIpAddr(HttpServletRequest request) {
        String ip = request.getHeader("x-forwarded-for");
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("X-Forwarded-For");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("WL-Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("X-Real-IP");
        }

        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
        }
        return "0:0:0:0:0:0:0:1".equals(ip) ? "127.0.0.1" : ip;
    }
    
}

3.自定义枚举类 系统日志操作类型

package com.example.springboot.common;

public enum LogType {

    ADD("新增"),
    DELETE("删除"),
    BATCH_DELETE("批量删除"),
    UPDATE("修改"), 
    LOGIN("登录"), 
    REGISTER("注册");

    private String value;

    LogType(String value) {
        this.value = value;
    }
}

4.自定义注解

package com.example.springboot.anno;

import com.example.springboot.common.LogType;

import java.lang.annotation.*;

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

    // 操作的模块
    String operation();

    // 操作类型
    LogType type();

}

5.相关实体类 Logs

package com.example.springboot.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
@TableName(value = "logs")
public class Logs {

    @TableId(type = IdType.AUTO)
    private Integer id;

    private String operation;
    private String type;
    private String ip;
    private String user;
    private String time;

}

6.持久层 LogsMapper

package com.example.springboot.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.example.springboot.entity.Logs;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface LogsMapper extends BaseMapper<Logs> {
}

7.业务层接口 LogsService

package com.example.springboot.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.example.springboot.entity.Logs;

public interface LogsService extends IService<Logs> {
}

8.业务层 LogsServiceImpl

package com.example.springboot.service.Impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.springboot.entity.Logs;
import com.example.springboot.mapper.LogsMapper;
import com.example.springboot.service.LogsService;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service
public class LogsServiceImpl extends ServiceImpl<LogsMapper, Logs> implements LogsService {

}

9.控制层 LogsController

package com.ljh.springboot3.controller;

import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ljh.springboot3.common.Result;
import com.ljh.springboot3.pojo.Logs;
import com.ljh.springboot3.service.LogsService;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/logs")
public class LogsController {

    @Autowired
    private LogsService logsService;

    /**
     * 获取日志列表
     *
     * @param id 日志ID
     * @return 成功或失败
     */
    @DeleteMapping("/delete/{id}")
    public Result delete(@PathVariable Integer id) {
        logsService.removeById(id);
        return Result.success();
    }

    /**
     * 批量删除日志
     *
     * @param ids 日志ID列表
     * @return 成功或失败
     */
    @DeleteMapping("/delete/batch")
    public Result batchDelete(@RequestBody List<Integer> ids) {
        logsService.removeBatchByIds(ids);
        return Result.success();
    }

    /**
     * 多条件模糊查询信息
     *
     * @param pageNum   当前的页码
     * @param pageSize  每页查询的个数
     * @param operation 操作模块
     * @param type      操作类型
     * @param user      操作人
     * @return 满足条件的日志信息
     */
    @GetMapping("/selectByPage")
    public Result selectByPage(
            @RequestParam Integer pageNum,
            @RequestParam Integer pageSize,
            @RequestParam(required = false) String operation,
            @RequestParam(required = false) String type,
            @RequestParam(required = false) String user
    ) {
        LambdaQueryWrapper<Logs> queryWrapper = new LambdaQueryWrapper<Logs>().orderByDesc(Logs::getId);        // 默认倒序，让最新的数据在最上面
        queryWrapper.like(StrUtil.isNotBlank(operation), Logs::getOperation, operation);
        queryWrapper.like(StrUtil.isNotBlank(type), Logs::getType, type);
        queryWrapper.like(StrUtil.isNotBlank(user), Logs::getUser, user);
        Page<Logs> page = logsService.page(new Page<>(pageNum, pageSize), queryWrapper);
        return Result.success(page);
    }

}

10.LogsAspect切面类

package com.example.springboot.aop;

import cn.hutool.core.date.DateUtil;
import cn.hutool.core.thread.ThreadUtil;
import cn.hutool.core.util.ArrayUtil;
import com.example.springboot.anno.HoneyLogs;
import com.example.springboot.entity.Logs;
import com.example.springboot.entity.User;
import com.example.springboot.service.LogsService;
import com.example.springboot.utils.IpUtils;
import com.example.springboot.utils.TokenUtils;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
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;

@Component
@Aspect
@Slf4j
public class LogsAspect {

    @Resource
    private LogsService logsService;

    @AfterReturning(pointcut = "@annotation(honeyLogs)", returning = "jsonResult")
    public void recordLog(JoinPoint joinPoint, HoneyLogs honeyLogs, Object jsonResult) {
        // 获取当前登录的用户的信息
        User loginUser = TokenUtils.getCurrentUser();
        if (loginUser == null) { // 用户未登录的情况下  loginUser是null  是null的话我们就要从参数里面获取操作人信息
            // 登录、注册
            Object[] args = joinPoint.getArgs();
            if (ArrayUtil.isNotEmpty(args)) {
                if (args[0] instanceof User) {
                    loginUser = (User) args[0];
                }
            }
        }
        if (loginUser == null) {
            log.error("记录日志信息报错，未获取到当前操作用户信息");
            return;
        }

        // 获取HttpServletRequest对象
        ServletRequestAttributes servletRequestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = servletRequestAttributes.getRequest();

        //获取IP地址信息
        String ipAddr = IpUtils.getIpAddr(request);

        //组装日志的实体对象
        Logs logs = Logs.builder()
                .user(loginUser.getUsername())
                .operation(honeyLogs.operation())
                .type(honeyLogs.type().getValue())
                .ip(ipAddr)
                .time(DateUtil.now())
                .build();

        //插入数据到数据库
        ThreadUtil.execAsync(() -> {
            // 异步记录日志信息
            logsService.save(logs);
        });
    }
}

11.使用aop

在方法上添加注解@HoneyLogs

// 添加操作
@HoneyLogs(operation = "用户信息", type = LogType.ADD)

// 删除操作
@HoneyLogs(operation = "用户信息", type = LogType.DELETE)

// 批量删除操作
@HoneyLogs(operation = "用户信息", type = LogType.BATCH_DELETE)

// 更新操作
@HoneyLogs(operation = "用户信息", type = LogType.UPDATE)

// 登录操作
@HoneyLogs(operation = "登录", type = LogType.LOGIN)

// 注册操作
@HoneyLogs(operation = "注册", type = LogType.REGISTER)

二、数据库代码

CREATE TABLE `logs`
(
    `id`        int(11) NOT NULL AUTO_INCREMENT,
    `operation` varchar(255) COLLATE utf8mb4_unicode_ci DEFAULT NULL COMMENT '操作名称',
    `type`      varchar(255) COLLATE utf8mb4_unicode_ci DEFAULT NULL COMMENT '操作类型',
    `ip`        varchar(255) COLLATE utf8mb4_unicode_ci DEFAULT NULL COMMENT 'ip地址',
    `user`      varchar(255) COLLATE utf8mb4_unicode_ci DEFAULT NULL COMMENT '操作人',
    `time`      varchar(255) COLLATE utf8mb4_unicode_ci DEFAULT NULL COMMENT '操作时间',
    PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='系统日志';

三、前端代码

<template>
    <div>
        <div>
            <el-input style="width: 200px" placeholder="查询模块" v-model="operation"></el-input>
            <el-select style="margin: 0 5px" v-model="type">
                <el-option v-for="item in ['新增', '修改', '删除', '批量删除', '登录', '注册']" :key="item" :value="item" :label="item"></el-option>
            </el-select>
            <el-input style="width: 200px" placeholder="查询操作人" v-model="optUser"></el-input>
            <el-button type="primary" style="margin-left: 10px" @click="load(1)">查询</el-button>
            <el-button type="info" @click="reset">重置</el-button>
        </div>
        <div style="margin: 10px 0">
            <el-button type="danger" plain @click="delBatch">批量删除</el-button>
        </div>
        <el-table :data="tableData" stripe :header-cell-style="{ backgroundColor: 'aliceblue', color: '#666' }"
                  @selection-change="handleSelectionChange">
            <el-table-column type="selection" width="55" align="center"></el-table-column>
            <el-table-column prop="id" label="序号" width="70" align="center"></el-table-column>
            <el-table-column prop="operation" label="操作模块"></el-table-column>
            <el-table-column prop="type" label="操作类型">
                <template v-slot="scope">
                    <el-tag type="primary" v-if="scope.row.type === '新增'">{{ scope.row.type }}</el-tag>
                    <el-tag type="info" v-if="scope.row.type === '修改'">{{ scope.row.type }}</el-tag>
                    <el-tag type="danger" v-if="scope.row.type === '删除'">{{ scope.row.type }}</el-tag>
                    <el-tag type="danger" v-if="scope.row.type === '批量删除'">{{ scope.row.type }}</el-tag>
                    <el-tag type="success" v-if="scope.row.type === '登录'">{{ scope.row.type }}</el-tag>
                    <el-tag type="success" v-if="scope.row.type === '注册'">{{ scope.row.type }}</el-tag>
                </template>
            </el-table-column>
            <el-table-column prop="ip" label="操作人IP"></el-table-column>
            <el-table-column prop="user" label="操作人"></el-table-column>
            <el-table-column prop="time" label="操作时间"></el-table-column>
            <el-table-column label="操作" align="center" width="180">
                <template v-slot="scope">
                    <el-button size="mini" type="danger" plain @click="del(scope.row.id)">删除</el-button>
                </template>
            </el-table-column>
        </el-table>

        <div style="margin: 10px 0">
            <el-pagination
                    @current-change="handleCurrentChange"
                    :current-page="pageNum"
                    :page-size="pageSize"
                    layout="total, prev, pager, next"
                    :total="total">
            </el-pagination>
        </div>
    </div>
</template>

<script>

export default {
    name: "Logs",
    data() {
        return {
            tableData: [],  // 所有的数据
            pageNum: 1,   // 当前的页码
            pageSize: 10,  // 每页显示的个数
            operation: '',
            type: '',
            optUser: ''
            total: 0,
            ids: [],
        }
    },
    
    created() {
        this.load()
    },
    
    methods: {
        delBatch() {
            if (!this.ids.length) {
                this.$message.warning('请选择数据')
                return
            }
            this.$confirm('您确认批量删除这些数据吗？', '确认删除', {type: "warning"}).then(response => {
                this.$request.delete('/logs/delete/batch', {data: this.ids}).then(res => {
                    if (res.code === '200') {   // 表示操作成功
                        this.$message.success('操作成功')
                        this.load(1)
                    } else {
                        this.$message.error(res.msg)  // 弹出错误的信息
                    }
                })
            }).catch(() => {
            })
        },
        
        handleSelectionChange(rows) {   // 当前选中的所有的行数据
            this.ids = rows.map(v => v.id)
        },
        
        del(id) {
            this.$confirm('您确认删除吗？', '确认删除', {type: "warning"}).then(response => {
                this.$request.delete('/logs/delete/' + id).then(res => {
                    if (res.code === '200') {   // 表示操作成功
                        this.$message.success('操作成功')
                        this.load(1)
                    } else {
                        this.$message.error(res.msg)  // 弹出错误的信息
                    }
                })
            }).catch(() => {
            })
        },
        
        reset() {
            this.operation = ''
            this.type = ''
            this.optUser = ''
            this.load()
        },
        
        load(pageNum) {  // 分页查询
            if (pageNum) this.pageNum = pageNum
            this.$request.get('/logs/selectByPage', {
                params: {
                    pageNum: this.pageNum,
                    pageSize: this.pageSize,
                    operation: this.operation,
                    type: this.type,
                    user: this.optUser,
                }
            }).then(res => {
                this.tableData = res.data.records
                this.total = res.data.total
            })
        },
        
        handleCurrentChange(pageNum) {
            this.load(pageNum)
        },
    }
}
</script>

<style>
.el-tooltip__popper {
    max-width: 300px !important;
}
</style>
正在学习的小屁孩
关注
  • 7
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
SpringBoot+AOP日志
04-24
在本项目中，"SpringBoot+AOP日志"是一个基于Spring Boot框架的日志管理系统，它利用了Spring Boot的便利性和AOP（面向切面编程）技术来实现对应用程序日志的高效、统一处理。让我们深入探讨一下这个项目的核心知识...
aopDemo：springboot + aopAround日志记录+自定义注释解@ReqLog
02-14
`@ReqLog`可能是用来标记需要记录日志的方法，这样通过AOP可以在方法执行前后自动添加日志信息，无需在每个方法内部手动编写日志代码，提高了代码的可读性和可维护性。 AOP的核心概念包括切点（Pointcut）、通知...
springboot使用aop记录接口日志信息
qq_37342720的博客
01-13 1130
之前写过一篇进行日志记录的文章springboot拦截器记录接口日志信息该文章是通过流进行获取请求数据，然后再将流的信息copy一份进行补充，因为流只能读取一次嘛！ 但是在此之前 我使用不是很好方式解决的，由于请求方式不固定及上送的参数有的是RequestParam,有的是RequestBody，所以使用的不同方式进行获取参数的 直接上代码，拦截器 package com.bigdata.bigdata.aop; import com.alibaba.fastjson.JSON; import..
springboot 自定义注解 ，aop切面@Around； 为接口实现日志插入【强行喂饭版】
北海_南风
07-26 2450
思路：aop切面使用`@Around`来控制目标方法的执行。 既然是日志表的话，那么需要 `获取方法（接口）的参数`，`方法名`，`方法执行结果`，`方法执行时间`，`调用者的ip`，根据ip地址查询位置信息
SpringBoot+AOP实现日志记录
张刚的博客
01-12 1446
SpringBoot+AOP实现日志记录，日志入库
SpringBoot+Vue实现AOP系统日志功能
白白白鲤鱼的博客
10-23 850
SpringBoot+Vue实现AOP系统日志功能
Vue中实现简单的AOP
Challenge Next Challenge
01-25 4598
有个简单的需求，需要在前端记录用户的一些行为，联想到Java中可以用annotation加拦截函数调用实现，试着在JS中看看能不能也这样实现。 annotation或者decorator的功能在JS中还处在草稿阶段，但是通过Babel的转换，已经可以使用了，例如React中的mobx状态管理，就可以通过decorator实现。下面是简单的实现过程： 先通过npm安装babel-
springboot+vue小白升级之路13-AOP实现登录、增删改查操作日志管理
虾米大王的学习历程
11-21 730
还是接着上一个的内容，我把这个新增的关于日志的功能代码都贴出来，供大家学习参考。数据库。
SpringBoot +VUE 日志功能（监控controller方法）
weixin_43173475的博客
12-18 491
SpringBoot +VUE 日志功能（监控controller方法）
SpringBoot实战（六）自定义注解 + AOP 记录接口访问日志
ACGkaka的博客
04-01 3171
目录一、AOP的简单介绍1. AOP是什么2. AOP能做什么3. 切面执行顺序4. AOP注解二、实战代码1. 依赖引入2. AOP示例3. 定义接口，进行测试4. 源码地址 一、AOP的简单介绍 1. AOP是什么 AOP（Aspect Oriented Programming）–面向切面编程 通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。 实现方式：JDK动态代理、CGLIB代理。前者基于接口，后者基于子类。 2. AOP能做什么 统计接口
基于springboot+mvc+freemarker+aop实现校友信息管理系统.zip
12-24
《基于SpringBoot+MVC+Freemarker+AOP实现校友信息管理系统》 SpringBoot作为现代化的Java开发框架，因其简洁的配置、内置的Tomcat服务器以及自动配置特性，深受开发者喜爱。在这个项目中，我们将深入探讨如何利用...
基于springboot+mybatis学生管理系统.rar
01-15
例如，使用Spring Security进行用户身份验证和授权，通过AOP（面向切面编程）处理全局异常，利用Log4j或Logback进行日志记录。 总之，“基于SpringBoot+MyBatis的学生管理系统”充分展示了这两种技术的融合优势，既...
管理信息系统课设（spring boot + vue）开发日志（一）
a983677218的博客
05-30 440
管理信息系统期末课设作业，心累的一天
SpringBoot实现自己的日志服务
我是新手的博客
03-25 874
如何设计一个优秀而又可靠的日志服务，是一直以来都是一个很难的课题，写本文的目的起源于大学时期做的一个项目，那时候后台部署到阿里云上，每次遇到Error的问题的时候都需要登陆服务器查看，非常的麻烦，于是我就突发奇想为什么不对Spring的日志进行拦截，展示到前端界面呢？于是就产生了这个项目。
【无标题】
weixin_45696856的博客
04-19 99
若以vue-plus aop 实现角色数据权限学习
SpringBoot使用AOP统一处理日志
weixin_43890927的博客
06-28 1145
查看数据 http://127.0.0.1:8080//api/logs/list。准备sys_log日志表（mysql）2.2 annotation包。2.4 aspect包（核心）Action 日 志 分 类。Log 实现 Aop 切面类。SysLog（日志模型）2.1 domain包。2.3 common包。
vue+spring boot+websocket模拟服务端实时向前端推送数据
weixin_41463944的博客
02-07 3565
一、后端 1、安装websocket依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-websocket</artifactId> </dependency> 2、配置websocket配置类 package com.iot.zmtestb
【Cookie 在 Spring Boot 中的实现】
最新发布
武帝为此的博客
07-06 423
Cookie是一小段文本信息，通常由服务器发送到浏览器，然后由浏览器存储在本地。它包含了一些键值对，用于存储关于用户的信息。浏览器在每次请求同一网站时都会将这些Cookie发送回服务器，从而维护会话状态。Cookie通常用于实现用户身份验证、跟踪用户行为、保存用户偏好设置等。
springboot+拦截器
10-31
Spring Boot是一个基于Spring框架的快速开发框架，它提供了...在拦截器中，我们可以对请求进行一些处理，例如身份验证、日志记录、性能监控等。同时，我们也可以通过拦截器来防止一些恶意请求，保证应用程序的安全性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值