实现自动记录日志

最新推荐文章于 2024-04-14 21:32:14 发布

遗憾♡ۣۖ

最新推荐文章于 2024-04-14 21:32:14 发布

阅读量464

点赞数

分类专栏： SpringBoot 文章标签： mybatis spring boot java

本文链接：https://blog.csdn.net/weixin_46565024/article/details/125828122

版权

SpringBoot 专栏收录该内容

2 篇文章

订阅专栏

我使用的是springboot+mybatis-plus实现自动记录日志

导入的xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.zwl</groupId>
    <artifactId>materiallog</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>materiallog</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-boot.version>2.3.7.RELEASE</spring-boot.version>
    </properties>
    <!--    <parent>-->
    <!--        <groupId>org.springframework.boot</groupId>-->
    <!--        <artifactId>spring-boot-starter-parent</artifactId>-->
    <!--        <version>2.7.0</version>-->
    <!--        <relativePath/>-->
    <!--    </parent>-->
    <dependencies>
        <!--aop-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
        </dependency>
        <!--拦截器-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.9</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.1</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper</artifactId>
            <version>5.3.1</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.7.RELEASE</version>
                <configuration>
                    <mainClass>com.zwl.MateriallogApplication</mainClass>
                </configuration>
                <executions>
                    <execution>
                        <id>repackage</id>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

yml配置

server:
  port: 8888
file:
  path: D:/Development/Excel
spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver   #我用的是mysql5的
    url: jdbc:mysql://localhost:3306/books?serverTimezone=GMT&useUnicode=true&characterEncoding=utf-8
    username: root
    password: root
mybatis-plus:
  # mybatis相关配置
  mapper-locations: classpath:mapper/*.xml
  configuration:
    map-underscore-to-camel-case: true
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  type-aliases-package: com.zwl.entity

方法一：Aop实现

数据库表

日志表

CREATE TABLE `device_log`  (
  `id` int(11) NOT NULL COMMENT 'id',
  `name` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '操作人',
  `uid` int(11) NULL DEFAULT NULL COMMENT '用户id',
  `type` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '操作类型',
  `error` varchar(5000) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '失败原因',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;

用户表

CREATE TABLE `user`  (
  `id` int(255) NOT NULL AUTO_INCREMENT COMMENT '主键Id，同时可用于工牌编号',
  `name` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '姓名',
  `password` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '密码',
  `phone` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '联系电话',
  `state` varchar(5) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '是否已禁用',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 2037460995 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = COMPACT;

创建实体类

DeviceLog

import com.baomidou.mybatisplus.annotation.*;
import com.zwl.emuns.OperationType;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;

import java.io.Serializable;

@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName(value = "device_log", autoResultMap = true)
public class DeviceLog implements Serializable {
    private static final long serialVersionUID = 1L;
    /**
     * id
     */
    private Integer id;
    /**
     * 操作人
     */
    private OperationType name;

    /**
     * 用户id
     */
    private Integer uid;
    /**
     * 操作类型
     */
    private String type;
    /**
     * 失败原因
     */
    private String error;
    
    
    public DeviceLog() {

    }

    public DeviceLog(Integer id, String type) {
        this.id = id;
        this.type = type;
    }
}

user

import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;

import java.io.Serializable;

@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
public class User implements Serializable {

    private static final long serialVersionUID = 5846464524840272868L;
    /**
     * 主键id
     */
    private Integer id;
    /**
     * 姓名
     */
    private String name;
    /**
     * 密码
     */
    private String password;
    /**
     * 手机号
     */
    private String phone;
    /**
     * 状态
     */
    private String state;
}

创建自定义注解

import com.zwl.emuns.OperationType;
import java.lang.annotation.*;

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface LogAnnotation {
    String module();
    /** 操作类型
     * @return*/
    OperationType type();
}

创建注解返回层

public enum OperationType {
    ADD,
    UPDATE,
    DELETE,
    Upload,
    Download,
    selectAll;

    public String getType() {
        if (this.equals(ADD)) {
            return "ADD";
        }
        if (this.equals(UPDATE)) {
            return "UPDATE";
        }
        if (this.equals(DELETE)) {
            return "DELETE";
        }
        if (this.equals(Upload)) {
            return "Upload";
        }
        if (this.equals(Download)) {
            return "Download";
        }if (this.equals(selectAll)) {
            return "selectAll";
        }
        return null;
    };
}

public class LogsConstant {

    /**
     * 用户管理
     */
    public static final String BASICS_CURRENCY_USER =  "用户管理-";
    public static final String USER_ADD = BASICS_CURRENCY_ROLE + "新增角色";
    public static final String USER_UPDATE = BASICS_CURRENCY_ROLE + "编辑角色";
    public static final String USER_DELETE = BASICS_CURRENCY_ROLE + "删除角色";
    public static final String USER_SELECT = BASICS_CURRENCY_ROLE + "查看角色详情";
}

创建Aop切面

import com.zwl.annotation.LogAnnotation;
import com.zwl.entity.DeviceLog;
import com.zwl.sevice.DeviceLogService;
import lombok.AllArgsConstructor;
import lombok.Singular;
import lombok.extern.slf4j.Slf4j;
import org.apache.catalina.security.SecurityUtil;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;
import java.text.SimpleDateFormat;
import java.util.Date;

@Aspect
@Component
@Slf4j
@AllArgsConstructor
public class LogAspect {

    private DeviceLogService deviceLogService;

    /**
     * 定义切入点
     */

    @Pointcut("@annotation(com.zwl.annotation.LogAnnotation)")
    public void  pt(){}

    /**
     * 环绕通知
     */
    @Around("pt()")
    public Object log(ProceedingJoinPoint joinPoint) throws Throwable{
        /**
         * 定义时间
         */
        Long beginTime =System.currentTimeMillis();
        MethodSignature signature= (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        LogAnnotation annotation = method.getAnnotation(LogAnnotation.class);
        DeviceLog deviceLog = new DeviceLog();
        deviceLog.setType(annotation.module());
        deviceLog.setName(annotation.type());
        try {
            return joinPoint.proceed();
        } catch (Exception e) {
            log.error(e.getMessage());
            deviceLog.setError(e.getMessage());
            throw e;
        } finally {
            deviceLogService.addLog(deviceLog);
        }
    }
}

Controller层

UserController

import com.zwl.entity.User;
import com.zwl.response.Result;
import com.zwl.sevice.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserService userService;

    //采用注解方式
    @RequestMapping("/add")
    @LogAnnotation(module = LogsConstant.USER_ADD,type = OperationType.ADD)
    public Result addTest(User user){
        return  userService.addUser(user);
    }

    @RequestMapping("/update")
    @LogAnnotation(module = LogsConstant.USER_UPDATE,type = OperationType.UPDATE)
    public Result updateTest(User user){
        return  userService.updateUser(user);
    }

    @RequestMapping("/del")
    @LogAnnotation(module = LogsConstant.USER_DELETE,type = OperationType.DELETE)
    public Result deleteTest(Integer id){
        return  userService.deleteUser(id);
    }
}

DeviceLogController

import com.zwl.response.Result;
import com.zwl.sevice.DeviceLogService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/log")
public class DeviceLogController {

    @Autowired
    private DeviceLogService deviceLogService;

    @RequestMapping("/selectAll")
    public Result selectAll(){
        return deviceLogService.selectAll();
    }
}

返回层

ResultCode

package com.zwl.emuns;

/**
 * @author zhouleibin
 * @Type com.sunyard.am.result
 * @Desc
 * @date 2021/6/30 8:19
 */
public enum ResultCode {
    //2xx-成功
    SUCCESS(200, "操作成功"),

    private Integer code;
    private String msg;

    ResultCode(Integer code, String msg) {
        this.code = code;
        this.msg = msg;
    }

    public static ResultCode getEnum(Integer code) {
        for (ResultCode retEnum : ResultCode.values()) {
            if (retEnum.getCode().equals(code)) {
                return retEnum;
            }
        }
        return null;
    }

    public String getMsg() {
        return msg;
    }

    public Integer getCode() {
        return code;
    }
}

Result

package com.zwl.response;

import com.zwl.emuns.ResultCode;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

/**
 * @author zhouleibin
 * @Type com.sunyard.am.result
 * @Desc
 * @date 2021/6/30 8:17
 */
public class Result<T> implements Serializable {

    private Integer code;
    private String msg;
    private T data;

    /***/
    public static <T> Result<T> create() {
        Result<T> result = new Result<>();
        result.setData(null);
        result.setMsg(ResultCode.SUCCESS.getMsg());
        result.setCode(ResultCode.SUCCESS.getCode());
        return result;
    }

    /***/
    public static <T> Result<T> create(T value) {
        Result<T> result = new Result<>();
        result.setData(value);
        result.setMsg(ResultCode.SUCCESS.getMsg());
        result.setCode(ResultCode.SUCCESS.getCode());
        return result;
    }

    /***/
    public static <T> Result<T> error(ResultCode resultCode) {
        Result<T> result = new Result<>();
        result.setData(null);
        result.setMsg(resultCode.getMsg());
        result.setCode(resultCode.getCode());
        return result;
    }

    /***/
    public static <T> Result<T> error(String message, ResultCode resultCode) {
        Result<T> result = new Result<>();
        result.setData(null);
        if (null == message || 0 == message.length()) {
            result.setMsg(resultCode.getMsg());
        } else {
            result.setMsg(message);
        }
        result.setCode(resultCode.getCode());
        return result;
    }

    /**
     * 创建自定义的回传信息
     *
     * @param code 回执代号
     * @param msg  回执信息
     * @param <T>  数据类型
     * @return 实例
     */
    public static <T> Result<T> error(String msg, Integer code) {
        Result<T> result = new Result<>();
        result.setData(null);
        result.setMsg(msg);
        result.setCode(code);
        return result;
    }

    /***/
    public boolean isSucc() {
        return ResultCode.SUCCESS.getCode().equals(this.code);
    }

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }
}

service层

DeviceLogService：

import com.zwl.entity.DeviceLog;

public interface DeviceLogService {

    void addLog(DeviceLog deviceLog);

    void selectAll();
}

userService：

import com.zwl.entity.User;

public interface UserService {

    void addUser(User user);

    void updateUser(User user);

    void deleteUser(Integer i);
}

serviceImpl层

DeviceLogServiceImpl

import com.zwl.response.Result;
import com.zwl.sevice.DeviceLogService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * Revision history
 * -------------------------------------------------------------------------
 *
 * Date Author Note
 * -------------------------------------------------------------------------
 *   creat
 */
@RestController
@RequestMapping("/log")
public class DeviceLogController {

    @Autowired
    private DeviceLogService deviceLogService;


    @RequestMapping("/selectAll")
    public Result selectAll(){
        return deviceLogService.selectAll();
    }
}

UserServiceImpl

package com.zwl.sevice.Impl;

import com.zwl.entity.DeviceLog;
import com.zwl.entity.User;
import com.zwl.mapper.UserMapper;
import com.zwl.response.Result;
import com.zwl.sevice.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserMapper userMapper;

    @Autowired
    private ApplicationEventPublisher applicationEventPublisher;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result addUser(User user) {
        userMapper.insert(user);
        DeviceLog deviceLog = new DeviceLog( null, "新增用户");
        applicationEventPublisher.publishEvent(deviceLog);
        return Result.create();
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result updateUser(User user) {
        userMapper.updateById(user);
        DeviceLog deviceLog = new DeviceLog(null, "编辑用户");
        applicationEventPublisher.publishEvent(deviceLog);
        return Result.create();
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result deleteUser(Integer i) {
        userMapper.deleteById(i);
        DeviceLog deviceLog = new DeviceLog(null,  "删除用户");
        applicationEventPublisher.publishEvent(deviceLog);
        return Result.create();
    }
}

Mapper层

DeviceLogMapper

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.zwl.entity.DeviceLog;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface DeviceLogMapper extends BaseMapper<DeviceLog> {

}

UserMapper

@Mapper
public interface UserMapper extends BaseMapper<User> {

}

方法二：拦截器实现