使用SpringBoot AOP記錄操作日志和異常日志

平時我們在做項目時經常需要對一些重要功能操作記錄日志，方便以后跟蹤是誰在操作此功能；我們在操作某些功

能時也有可能會發(fā)生異常，但是每次發(fā)生異常要定位原因我們都要到服務器去查詢日志才能找到，而且也不能對發(fā)

生的異常進行統計，從而改進我們的項目，要是能做個功能專門來記錄操作日志和異常日志那就好了。

當然我們肯定有方法來做這件事情，而且也不會很難，我們可以在需要的方法中增加記錄日志的代碼，和在每個方

法中增加記錄異常的代碼，最終把記錄的日志存到數據庫中。聽起來好像很容易，但是我們做起來會發(fā)現，做這項

工作很繁瑣，而且都是在做一些重復性工作，還增加大量冗余代碼，這種方式記錄日志肯定是不可行的。

我們以前學過Spring 三大特性，IOC（控制反轉），DI（依賴注入），AOP（面向切面），那其中AOP的主要功能

就是將日志記錄，性能統計，安全控制，事務處理，異常處理等代碼從業(yè)務邏輯代碼中劃分出來。今天我們就來用

springBoot Aop 來做日志記錄，好了，廢話說了一大堆還是上貨吧。

1、創(chuàng)建日志記錄表、異常日志表，表結構如下

操作日志表OperationLog

CREATE TABLE `OperationLog` (
  `oper_id` varchar(64) DEFAULT NULL COMMENT '主鍵id',
  `oper_modul` varchar(64) DEFAULT NULL COMMENT '功能模塊',
  `oper_type` varchar(64) DEFAULT NULL COMMENT '操作類型',
  `oper_desc` varchar(500) DEFAULT NULL COMMENT '操作描述',
  `oper_requ_param` text COMMENT '請求參數',
  `oper_resp_param` text COMMENT '返回參數',
  `oper_user_id` varchar(64) DEFAULT NULL COMMENT '操作員ID',
  `oper_user_name` varchar(64) DEFAULT NULL COMMENT '操作員名稱',
  `oper_method` varchar(255) DEFAULT NULL COMMENT '操作方法',
  `oper_uri` varchar(255) DEFAULT NULL COMMENT '請求URI',
  `oper_ip` varchar(64) DEFAULT NULL COMMENT '請求ID',
  `oper_create_time` datetime DEFAULT NULL COMMENT '操作時間',
  `oper_ver` varchar(64) DEFAULT NULL COMMENT '操作版本號',
  PRIMARY KEY (`oper_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

異常日志表ExceptionLog

CREATE TABLE `ExceptionLog` (
  `exp_id` varchar(64) NOT NULL DEFAULT "" COMMENT '主鍵id',
  `exp_requ_param` text COMMENT '請求參數',
  `exp_name` varchar(255) COMMENT '異常名稱',
  `exp_message` text COMMENT '異常信息',
  `oper_user_id` varchar(64) DEFAULT NULL COMMENT '操作員ID',
  `oper_user_name` varchar(64) DEFAULT NULL COMMENT '操作員名稱',
  `oper_method` varchar(255) DEFAULT NULL COMMENT '操作方法',
  `oper_uri` varchar(255) DEFAULT NULL COMMENT '請求URI',
  `oper_ip` varchar(64) DEFAULT NULL COMMENT '請求ID',
  `oper_create_time` datetime DEFAULT NULL COMMENT '操作時間',
  `oper_ver` varchar(64) DEFAULT NULL COMMENT '操作版本號',
  PRIMARY KEY (`exp_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

2、添加Maven依賴

<?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>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.6</version>
        <relativePath/>
    </parent>

    <groupId>com.aop.log</groupId>
    <artifactId>spring-boot-aop-log</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>spring-boot-aop-log</name>
    <description>spring-boot-aop-log</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>

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

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

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

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

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <!-- mybatis-plus依賴 -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.3.1.tmp</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.58</version>
        </dependency>

        <!-- mysql依賴 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.22</version>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

3、創(chuàng)建實體類

ExceptionLog實體

package com.aop.log.entity;

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

import java.util.Date;

/**
 * @author zhangshixing
 * @date 2021年11月05日 10:04
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("ExceptionLog")
public class ExceptionLog {

    // 主鍵id
    @TableId(value = "exp_id", type = IdType.ASSIGN_UUID)
    private String expId;
    // 請求參數
    private String expRequParam;
    // 異常名稱
    private String expName;
    // 異常信息
    private String expMessage;
    // 操作員ID
    private String operUserId;
    // 操作員名稱
    private String operUserName;
    // 操作方法
    private String operMethod;
    // 請求URI
    private String operUri;
    // 請求ID
    private String operIp;
    // 操作時間
    private Date operCreateTime;
    // 操作版本號
    private String operVer;
}

OperationLog實體

package com.aop.log.entity;

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

import java.io.Serializable;
import java.util.Date;

/**
 * @author zhangshixing
 * @date 2021年11月05日 9:52
 */

@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("OperationLog")
public class OperationLog implements Serializable {

    // 主鍵id
    @TableId(value = "oper_id", type = IdType.ASSIGN_UUID)
    private String operId;
    // 功能模塊
    private String operModul;
    // 操作類型
    private String operType;
    // 操作描述
    private String operDesc;
    // 請求參數
    private String operRequParam;
    // 返回參數
    private String operRespParam;
    // 操作員ID
    private String operUserId;
    // 操作員名稱
    private String operUserName;
    // 操作方法
    private String operMethod;
    // 請求URI
    private String operUri;
    // 請求ID
    private String operIp;
    // 操作時間
    private Date operCreateTime;
    // 操作版本號
    private String operVer;
}

OrderInfo訂單實體類

package com.aop.log.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @author zhangshixing
 * @date 2021年11月05日 10:33
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class OrderInfo {

    /**
     * 這里只是為了測試所以只添加了兩個參數
     */
    // 訂單編號
    private String orderid;
    // 訂單金額
    private int price;

}

RespBean公共返回對象

package com.aop.log.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @author zhangshixing
 * @date 2021年11月05日 10:31
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class RespBean {

    private long code;
    private String message;
    private Object obj;

    public static RespBean success(String message) {

        return new RespBean(200, message, null);
    }

    public static RespBean success(String message, Object obj) {

        return new RespBean(200, message, obj);
    }

    public static RespBean error(String message) {

        return new RespBean(500, message, null);
    }

    public static RespBean error(String message, Object obj) {

        return new RespBean(500, message, obj);
    }
}

4、創(chuàng)建Mapper

OperationLogMapper

package com.aop.log.mapper;

import com.aop.log.entity.OperationLog;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface OperationLogMapper extends BaseMapper<OperationLog> {

}

ExceptionLogMapper

package com.aop.log.mapper;

import com.aop.log.entity.ExceptionLog;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface ExceptionLogMapper extends BaseMapper<ExceptionLog> {

}

5、創(chuàng)建service

OperationLogService

package com.aop.log.service;

import com.aop.log.entity.OperationLog;
import com.baomidou.mybatisplus.extension.service.IService;

public interface OperationLogService extends IService<OperationLog> {
}

ExceptionLogService

package com.aop.log.service;

import com.aop.log.entity.ExceptionLog;
import com.baomidou.mybatisplus.extension.service.IService;

public interface ExceptionLogService extends IService<ExceptionLog> {

}

OperationLogServiceImpl

package com.aop.log.service.impl;

import com.aop.log.entity.OperationLog;
import com.aop.log.mapper.OperationLogMapper;
import com.aop.log.service.OperationLogService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;

/**
 * @author zhangshixing
 * @date 2021年11月05日 10:10
 */
@Service
public class OperationLogServiceImpl extends ServiceImpl<OperationLogMapper, OperationLog>
        implements OperationLogService {
}

ExceptionLogServiceImpl

package com.aop.log.service.impl;

import com.aop.log.entity.ExceptionLog;
import com.aop.log.mapper.ExceptionLogMapper;
import com.aop.log.service.ExceptionLogService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;

/**
 * @author zhangshixing
 * @date 2021年11月05日 10:10
 */
@Service
public class ExceptionLogServiceImpl extends ServiceImpl<ExceptionLogMapper, ExceptionLog>
        implements ExceptionLogService {
}

6、創(chuàng)建操作日志注解類OperLog

package com.aop.log.annotation;

import java.lang.annotation.*;

/**
 * @author zhangshixing
 * @date 2021年11月05日 9:43
 * 自定義操作日志注解
 */
//注解放置的目標位置,METHOD是可注解在方法級別上
@Target(ElementType.METHOD)
//注解在哪個階段執(zhí)行
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface OperLog {
    // 操作模塊
    String operModul() default "";

    // 操作類型
    String operType() default "";

    // 操作說明
    String operDesc() default "";
}

package com.aop.log.annotation;

public class OprLogConst {

    public static final String ADD = "add";
    public static final String INSERET = "insert";
    public static final String UPDATE = "update";
    public static final String DELETE = "delete";
}

7、創(chuàng)建切面類記錄操作日志

package com.aop.log.aop;

import com.alibaba.fastjson.JSON;
import com.aop.log.annotation.OperLog;
import com.aop.log.entity.ExceptionLog;
import com.aop.log.entity.OperationLog;
import com.aop.log.service.ExceptionLogService;
import com.aop.log.service.OperationLogService;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
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.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;

import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Method;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

/**
 * @author zhangshixing
 * @date 2021年11月05日 9:46
 * 切面處理類，操作日志異常日志記錄處理
 */
@Aspect
@Component
public class OperLogAspect {

    /**
     * 操作版本號
     * 項目啟動時從命令行傳入，例如：java -jar xxx.war --version=201902
     */
    @Value("${version}")
    private String operVer;

    @Autowired
    private OperationLogService operationLogService;

    @Autowired
    private ExceptionLogService exceptionLogService;

    /**
     * 設置操作日志切入點 記錄操作日志 在注解的位置切入代碼
     */
    @Pointcut("@annotation(com.aop.log.annotation.OperLog)")
    public void operLogPoinCut() {
    }

    /**
     * 設置操作異常切入點記錄異常日志 掃描所有controller包下操作
     */
    @Pointcut("execution(* com.aop.log.controller..*.*(..))")
    public void operExceptionLogPoinCut() {
    }

    /**
     * 正常返回通知，攔截用戶操作日志，連接點正常執(zhí)行完成后執(zhí)行， 如果連接點拋出異常，則不會執(zhí)行
     *
     * @param joinPoint 切入點
     * @param keys      返回結果
     */
    @AfterReturning(value = "operLogPoinCut()", returning = "keys")
    public void saveOperLog(JoinPoint joinPoint, Object keys) {
        // 獲取RequestAttributes
        RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
        // 從獲取RequestAttributes中獲取HttpServletRequest的信息
        HttpServletRequest request = (HttpServletRequest) requestAttributes
                .resolveReference(RequestAttributes.REFERENCE_REQUEST);
        // 創(chuàng)建OperationLog對象
        OperationLog operlog = new OperationLog();
        try {
            // 主鍵ID
            String uuid = UUID.randomUUID().toString();
            System.out.println("saveOperLog:" + uuid);
            operlog.setOperId(uuid);
            // 從切面織入點處通過反射機制獲取織入點處的方法
            MethodSignature signature = (MethodSignature) joinPoint.getSignature();
            // 獲取切入點所在的方法
            Method method = signature.getMethod();
            // 獲取操作
            OperLog opLog = method.getAnnotation(OperLog.class);
            if (opLog != null) {
                String operModul = opLog.operModul();
                String operType = opLog.operType();
                String operDesc = opLog.operDesc();
                // 操作模塊
                operlog.setOperModul(operModul);
                // 操作類型
                operlog.setOperType(operType);
                // 操作描述
                operlog.setOperDesc(operDesc);
            }
            // 獲取請求的類名
            String className = joinPoint.getTarget().getClass().getName();
            // 獲取請求的方法名
            String methodName = method.getName();
            methodName = className + "." + methodName;
            // 請求方法
            operlog.setOperMethod(methodName);
            // 請求的參數
            Map<String, String> rtnMap = converMap(request.getParameterMap());
            // 將參數所在的數組轉換成json
            String params = JSON.toJSONString(rtnMap);
            // 請求參數
            operlog.setOperRequParam(params);
            // 返回結果
            operlog.setOperRespParam(JSON.toJSONString(keys));
            // 請求用戶ID
            // operlog.setOperUserId(UserShiroUtil.getCurrentUserLoginName());
            // 這里寫一個固定的用戶ID
            operlog.setOperUserId("100293784");
            // 請求用戶名稱
            // operlog.setOperUserName(UserShiroUtil.getCurrentUserName());
            // // 這里寫一個固定的用戶名
            operlog.setOperUserName("yiyiyi");
            // 請求IP
            // operlog.setOperIp(IPUtil.getRemortIP(request));
            // 這里寫一個固定的IP
            operlog.setOperIp("127.0.0.1");
            // 請求URI
            operlog.setOperUri(request.getRequestURI());
            // 創(chuàng)建時間
            operlog.setOperCreateTime(new Date());
            // 操作版本
            operlog.setOperVer(operVer);
            // 將數據插入到數據庫
            operationLogService.save(operlog);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 異常返回通知，用于攔截異常日志信息 連接點拋出異常后執(zhí)行
     *
     * @param joinPoint 切入點
     * @param e         異常信息
     */
    @AfterThrowing(pointcut = "operExceptionLogPoinCut()", throwing = "e")
    public void saveExceptionLog(JoinPoint joinPoint, Throwable e) {
        // 獲取RequestAttributes
        RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
        // 從獲取RequestAttributes中獲取HttpServletRequest的信息
        HttpServletRequest request = (HttpServletRequest) requestAttributes
                .resolveReference(RequestAttributes.REFERENCE_REQUEST);
        ExceptionLog excepLog = new ExceptionLog();
        try {
            // 從切面織入點處通過反射機制獲取織入點處的方法
            MethodSignature signature = (MethodSignature) joinPoint.getSignature();
            // 獲取切入點所在的方法
            Method method = signature.getMethod();
            String uuid = UUID.randomUUID().toString();
            System.out.println("saveExceptionLog:" + uuid);
            excepLog.setExpId(uuid);
            // 獲取請求的類名
            String className = joinPoint.getTarget().getClass().getName();
            // 獲取請求的方法名
            String methodName = method.getName();
            methodName = className + "." + methodName;
            // 請求的參數
            Map<String, String> rtnMap = converMap(request.getParameterMap());
            // 將參數所在的數組轉換成json
            String params = JSON.toJSONString(rtnMap);
            // 請求參數
            excepLog.setExpRequParam(params);
            // 請求方法名
            excepLog.setOperMethod(methodName);
            // 異常名稱
            excepLog.setExpName(e.getClass().getName());
            // 異常信息
            excepLog.setExpMessage(stackTraceToString(e.getClass().getName(), e.getMessage(), e.getStackTrace()));
            // 操作員ID
            // excepLog.setOperUserName(UserShiroUtil.getCurrentUserName());
            excepLog.setOperUserId("100293784");
            // 操作員名稱
            excepLog.setOperUserName("yiyiyi");
            // 操作URI
            excepLog.setOperUri(request.getRequestURI());
            // 操作員IP
            // excepLog.setOperIp(IPUtil.getRemortIP(request));
            excepLog.setOperIp("127.0.0.1");
            // 操作版本號
            excepLog.setOperVer(operVer);
            // 發(fā)生異常時間
            excepLog.setOperCreateTime(new Date());
            exceptionLogService.save(excepLog);
        } catch (Exception e2) {
            e2.printStackTrace();
        }

    }

    /**
     * 轉換request 請求參數
     *
     * @param paramMap request獲取的參數數組
     */
    public Map<String, String> converMap(Map<String, String[]> paramMap) {
        Map<String, String> rtnMap = new HashMap<String, String>();
        for (String key : paramMap.keySet()) {
            rtnMap.put(key, paramMap.get(key)[0]);
        }
        return rtnMap;
    }

    /**
     * 轉換異常信息為字符串
     *
     * @param exceptionName    異常名稱
     * @param exceptionMessage 異常信息
     * @param elements         堆棧信息
     */
    public String stackTraceToString(String exceptionName, String exceptionMessage, StackTraceElement[] elements) {
        StringBuffer strbuff = new StringBuffer();
        for (StackTraceElement stet : elements) {
            strbuff.append(stet + "\n");
        }
        String message = exceptionName + ":" + exceptionMessage + "\n\t" + strbuff.toString();
        return message;
    }
}

8、在Controller層方法添加@OperLog注解

package com.aop.log.controller;

import com.aop.log.annotation.OperLog;
import com.aop.log.annotation.OprLogConst;
import com.aop.log.entity.OrderInfo;
import com.aop.log.entity.RespBean;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 * @author zhangshixing
 * @date 2021年11月05日 10:25
 */
@Controller
public class OrderController {
    /**
     * 新增訂單信息
     */
    @RequestMapping(value = "addOrderInfo")
    @ResponseBody
    @OperLog(operModul = "銷售管理-訂單新增", operType = OprLogConst.ADD, operDesc = "訂單新增功能")
    public RespBean addOrderInfo(OrderInfo orderInfo) {
        if (orderInfo.getPrice() < 0) {
            System.out.println(1 / 0);
            return RespBean.error("提交失敗!!!");
        } else if (orderInfo.getPrice() < 30) {
            return RespBean.success("提交成功!!!");
        } else {
            return RespBean.error("提交失敗!!!");
        }
    }
}

9、啟動類和配置文件

version = 2.1.1
server.port = 9000
spring.datasource.driver-class-name = com.mysql.cj.jdbc.Driver
spring.datasource.url = jdbc:mysql://localhost:3306/log?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
spring.datasource.username = root
spring.datasource.password = root

package com.aop.log;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SpringBootAopLogApplication {

	public static void main(String[] args) {
		SpringApplication.run(SpringBootAopLogApplication.class, args);
	}

}

10、操作日志、異常日志查詢功能

10.1 記錄操作日志

10.2 記錄異常日志

11、execution 表達式

學習Spring中的aop組裝切面時遇到的execution表達式，下面是execution表達式的詳解。

切入點表達式：

整個表達式可以分為五個部分：

1、execution(): 表達式主體。

2、第一個*號：方法返回類型， *號表示所有的類型。

3、包名：表示需要攔截的包名。

4、第二個*號：表示類名，*號表示所有的類。

5、*(..):最后這個星號表示方法名，*號表示所有的方法，后面( )里面表示方法的參數，兩個句點表示任

何參數。

表達式語法：

execution(* 包名.*.*(..))

規(guī)范寫法：execution(* com.baizhi.service.UserServiceImpl.*(..))

這個表達式是重點 ，是最通用的，表示執(zhí)行接口下的所有接口方法。

execution表達式舉例：

書寫接口實現方法：UserServiceImpl

方法類型：

add(); query(); add(String name); add(User user); add(String name,Integer age);

execution(* service.UserServiceImpl.add(..))        //執(zhí)行add()方法

execution(* service.UserServiceImpl.add(String))    //執(zhí)行add(String name)方法

execution(* service.UserServiceImpl.add(com.baizhi.entity.User))   //執(zhí)行add(User user)方法

execution(* service.UserServiceImpl.add(String , Integer))    //執(zhí)行add(String name,Interger age)方法

execution表達式的一般用法：

execution(* service.UserServiceImpl.*(java.util.List))
返回值：任意
包：com.baizhi.service
類：UserServiceImpl
方法：任意
參數：必須是List集合

execution(* service.UserServiceImpl.add*(..))  重點
返回值：任意
包：com.baizhi.service
類：UserServiceImpl
方法：以add關鍵字開頭的方法
參數：任意

execution(* service.UserServiceImpl.*.*(..))  重點
返回值：任意
包：com.baizhi.service
類：當前包下的所有類
方法：所有類中的所有方法
參數：任意

execution(* service..*.*(..))  重點
返回值：任意
包：service包以及它下面所有子包
類：所有包中的所有類
方法：所有類中的所有方法
參數：任意

execution(* *(..))   重點,不建議這樣寫,棧溢出

注意：要盡可能精準的切入。文章來源地址http://www.zghlxwxcb.cn/news/detail-766349.html

到了這里，關于使用SpringBoot AOP記錄操作日志和異常日志的文章就介紹完了。如果您還想了解更多內容，請在右上角搜索TOY模板網以前的文章或繼續(xù)瀏覽下面的相關文章，希望大家以后多多支持TOY模板網！