<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>2.0.x</version>
</dependency>

package com.example.aspect;                                  // 包名根據(jù)實際項目調(diào)整
import com.alibaba.fastjson.JSON;                            // 引入 JSON 序列化工具，用于格式化參數(shù)和返回值
import lombok.extern.slf4j.Slf4j;                            // 引入 Slf4j 注解，自動生成 log 日志對象
import org.aspectj.lang.ProceedingJoinPoint;                 // 引入 ProceedingJoinPoint，用于執(zhí)行目標(biāo)方法并獲取上下文
import org.aspectj.lang.annotation.Around;                   // 引入環(huán)繞通知注解，@Around 可以包裹目標(biāo)方法的執(zhí)行
import org.aspectj.lang.annotation.Aspect;                   // 引入切面注解，標(biāo)識該類為 AOP 切面
import org.aspectj.lang.annotation.Pointcut;                 // 引入切點注解，定義攔截規(guī)則
import org.springframework.stereotype.Component;              // 引入 Component 注解，將切面注入 Spring 容器
import org.springframework.web.context.request.RequestContextHolder;        // 引入 RequestContextHolder，獲取當(dāng)前請求的上下文
import org.springframework.web.context.request.ServletRequestAttributes;    // 引入 ServletRequestAttributes，獲取 HttpServletRequest
import javax.servlet.http.HttpServletRequest;                // 引入 HttpServletRequest，用于獲取請求 URL、方法類型等
import java.util.Arrays;                                     // 引入 Arrays 工具類，用于數(shù)組操作
import java.util.Map;                                        // 引入 Map 接口，用于存儲調(diào)用次數(shù)統(tǒng)計
import java.util.concurrent.ConcurrentHashMap;               // 引入 ConcurrentHashMap，線程安全的計數(shù)器容器
import java.util.concurrent.atomic.AtomicLong;               // 引入 AtomicLong，線程安全的原子計數(shù)器
/**
 * 接口監(jiān)控切面
 *
 * 功能：統(tǒng)計每個接口的調(diào)用次數(shù)、記錄傳入?yún)?shù)、返回參數(shù)、響應(yīng)耗時
 *
 * Args:
 *     無
 *
 * Returns:
 *     無（通過 log 輸出監(jiān)控信息）
 *
 * Example:
 *     自動生效，無需手動調(diào)用
 */
@Slf4j                                      // Lombok 注解，自動生成 log 字段，示例：log.info("消息")
@Aspect                                     // 標(biāo)識當(dāng)前類為切面類
@Component                                  // 將當(dāng)前類注入 Spring 容器
public class ApiMonitorAspect {
    // 線程安全的調(diào)用次數(shù)統(tǒng)計容器
    // Key: 接口方法名（類名+方法名），Value: 原子計數(shù)器
    // 示例：{"UserController.getUser" → 42, "OrderController.createOrder" → 15}
    private final Map<String, AtomicLong> callCountMap = new ConcurrentHashMap<>();
    /**
     * 定義切點：攔截 com.example.controller 包下所有類的所有方法
     *
     * Args:
     *     無
     *
     * Returns:
     *     無
     *
     * Example:
     *     execution(* com.example.controller.*.*(..)) 表示攔截 controller 包下所有方法
     */
    @Pointcut("execution(* com.example.controller.*.*(..))")
    public void controllerPointcut() {
        // 切點方法，無實際邏輯，僅用于定義攔截規(guī)則
    }
    /**
     * 環(huán)繞通知：在目標(biāo)方法執(zhí)行前后插入監(jiān)控邏輯
     *
     * Args:
     *     joinPoint: 連接點對象，包含目標(biāo)方法的全部上下文信息
     *
     * Returns:
     *     Object: 目標(biāo)方法的返回值，原封不動返回
     *
     * Example:
     *     @Around("controllerPointcut()")
     *     public Object monitorApi(ProceedingJoinPoint joinPoint)
     */
    @Around("controllerPointcut()")
    public Object monitorApi(ProceedingJoinPoint joinPoint) throws Throwable {
        // ===== 1. 獲取請求上下文信息 =====
        // 通過 RequestContextHolder 獲取當(dāng)前線程綁定的 Servlet 請求屬性
        // 數(shù)據(jù)流動：HttpServletRequest → RequestContextHolder → 提取 URL/Method/IP
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        String requestUrl = request.getRequestURL().toString();    // 獲取完整請求 URL，示例："http://localhost:8080/api/user/list"
        String httpMethod = request.getMethod();                   // 獲取 HTTP 方法類型，示例："GET"、"POST"
        String clientIp = request.getRemoteAddr();                 // 獲取客戶端 IP 地址，示例："127.0.0.1"
        // ===== 2. 獲取方法信息 =====
        // 獲取目標(biāo)方法的全限定名（包名+類名+方法名）
        // 數(shù)據(jù)流動：joinPoint.getSignature() → 方法簽名 → 類名.方法名
        String className = joinPoint.getTarget().getClass().getSimpleName();           // 獲取類名，示例："UserController"
        String methodName = className + "." + joinPoint.getSignature().getName();     // 組裝方法名，示例："UserController.getUser"
        // ===== 3. 統(tǒng)計調(diào)用次數(shù) =====
        // 從 callCountMap 中獲取或創(chuàng)建該方法的原子計數(shù)器，然后自增
        // 數(shù)據(jù)流動：methodName → ConcurrentHashMap.get() → AtomicLong.incrementAndGet() → 返回遞增后的值
        long currentCount = callCountMap.computeIfAbsent(methodName, k -> new AtomicLong(0)).incrementAndGet();
        // ===== 4. 獲取傳入?yún)?shù) =====
        // 獲取目標(biāo)方法的所有參數(shù)值列表
        // 數(shù)據(jù)流動：joinPoint.getArgs() → Object[] → JSON.toJSONString() → JSON 字符串
        Object[] args = joinPoint.getArgs();
        String requestParams = JSON.toJSONString(args);           // 將參數(shù)數(shù)組序列化為 JSON，示例："[{"id":1,"name":"張三"}]"
        // ===== 5. 記錄開始時間 =====
        // 記錄當(dāng)前時間戳，用于后續(xù)計算接口耗時
        long startTime = System.currentTimeMillis();
        // ===== 6. 執(zhí)行目標(biāo)方法 =====
        // proceed() 會執(zhí)行被攔截的原始方法，返回原始結(jié)果
        // 數(shù)據(jù)流動：joinPoint.proceed() → 目標(biāo)方法執(zhí)行 → 返回 Object 類型結(jié)果
        Object result = joinPoint.proceed();
        // ===== 7. 計算響應(yīng)耗時 =====
        // 用結(jié)束時間減去開始時間，得到接口處理耗時
        long elapsed = System.currentTimeMillis() - startTime;    // 計算耗時，單位：毫秒
        // ===== 8. 獲取返回參數(shù) =====
        // 將方法返回值序列化為 JSON 字符串
        // 數(shù)據(jù)流動：result Object → JSON.toJSONString() → JSON 字符串
        String responseResult = JSON.toJSONString(result);
        // ===== 9. 輸出監(jiān)控日志 =====
        // 匯總所有監(jiān)控信息，統(tǒng)一輸出
        log.info("\n========================================\n" +
                 "接口監(jiān)控信息：\n" +
                 "  請求地址: {} {}\n" +
                 "  客戶端IP: {}\n" +
                 "  接口方法: {}\n" +
                 "  調(diào)用次數(shù)(累計): {}\n" +
                 "  傳入?yún)?shù): {}\n" +
                 "  返回參數(shù): {}\n" +
                 "  響應(yīng)耗時: {}ms\n" +
                 "========================================",
                httpMethod, requestUrl,                          // 填充請求地址
                clientIp,                                        // 填充客戶端 IP
                methodName,                                      // 填充接口方法名
                currentCount,                                    // 填充累計調(diào)用次數(shù)
                requestParams.length() > 500 ? requestParams.substring(0, 500) + "..." : requestParams,  // 參數(shù)過長時截斷
                responseResult.length() > 500 ? responseResult.substring(0, 500) + "..." : responseResult,  // 返回值過長時截斷
                elapsed);                                        // 填充響應(yīng)耗時
        // 原封不動返回目標(biāo)方法的執(zhí)行結(jié)果，不對業(yè)務(wù)邏輯產(chǎn)生任何影響
        return result;
    }
    /**
     * 獲取指定接口的累計調(diào)用次數(shù)
     *
     * Args:
     *     methodName: 方法名，格式為 "類名.方法名"，示例："UserController.getUser"
     *
     * Returns:
     *     long: 該接口的累計調(diào)用次數(shù)，如果未找到返回 0
     *
     * Example:
     *     long count = apiMonitorAspect.getCallCount("UserController.getUser");
     */
    public long getCallCount(String methodName) {
        AtomicLong counter = callCountMap.get(methodName);       // 從 Map 中查詢指定方法的計數(shù)器
        return counter != null ? counter.get() : 0;              // 如果存在則返回計數(shù)，否則返回 0
    }
    /**
     * 獲取所有接口的調(diào)用次數(shù)統(tǒng)計（可用于對外暴露 API）
     *
     * Args:
     *     無
     *
     * Returns:
     *     Map<String, Long>: 所有接口的調(diào)用次數(shù)映射表，示例：{"UserController.getUser": 42}
     *
     * Example:
     *     Map<String, Long> allStats = apiMonitorAspect.getAllCallCounts();
     */
    public Map<String, Long> getAllCallCounts() {
        Map<String, Long> result = new ConcurrentHashMap<>();    // 創(chuàng)建結(jié)果容器
        callCountMap.forEach((key, value) -> result.put(key, value.get()));  // 遍歷并轉(zhuǎn)換 AtomicLong 為普通 Long
        return result;                                           // 返回不可修改的統(tǒng)計視圖
    }
}

package com.example.annotation;                               // 包名根據(jù)實際項目調(diào)整
import java.lang.annotation.ElementType;                      // 引入 ElementType 枚舉，用于指定注解的適用范圍
import java.lang.annotation.Retention;                        // 引入 Retention 枚舉，用于指定注解的生命周期
import java.lang.annotation.RetentionPolicy;                  // 引入 RetentionPolicy，RetentionPolicy.RUNTIME 表示運行時保留
import java.lang.annotation.Target;                           // 引入 Target 注解，用于限制注解能標(biāo)注的位置
/**
 * 接口監(jiān)控注解
 *
 * 用于標(biāo)記需要監(jiān)控調(diào)用次數(shù)、參數(shù)、耗時等信息的接口方法
 *
 * Args:
 *     value: 接口描述信息，可選，示例："用戶登錄接口"
 *
 * Returns:
 *     無（注解本身不返回值）
 *
 * Example:
 *     @Monitored("用戶登錄接口")
 *     public Result login(@RequestBody LoginDTO dto)
 */
@Target(ElementType.METHOD)                  // 注解只能標(biāo)注在方法上
@Retention(RetentionPolicy.RUNTIME)          // 注解在運行時保留，AOP 才能在運行時讀取
public @interface Monitored {
    /**
     * 接口描述信息
     *
     * Args:
     *     無
     *
     * Returns:
     *     String: 接口的描述說明，默認(rèn)為空字符串
     *
     * Example:
     *     @Monitored("用戶登錄接口")
     */
    String value() default "";               // 可選屬性，用于描述接口用途
}

/**
 * 基于自定義注解的接口監(jiān)控切面
 *
 * 功能：只對標(biāo)注了 @Monitored 注解的方法進(jìn)行監(jiān)控
 *
 * Args:
 *     無
 *
 * Returns:
 *     無（通過 log 輸出監(jiān)控信息）
 *
 * Example:
 *     在 Controller 方法上添加 @Monitored 即可生效
 */
@Slf4j
@Aspect
@Component
public class MonitoredApiAspect {

    // 線程安全的調(diào)用次數(shù)統(tǒng)計容器
    // Key: 接口方法名，Value: 原子計數(shù)器
    private final Map<String, AtomicLong> callCountMap = new ConcurrentHashMap<>();

    /**
     * 定義切點：攔截所有標(biāo)注了 @Monitored 注解的方法
     *
     * Args:
     *     monitored: 注入的注解實例，可在通知中讀取注解屬性
     *
     * Returns:
     *     無
     *
     * Example:
     *     @annotation(com.example.annotation.Monitored) 匹配所有標(biāo)有 @Monitored 的方法
     */
    @Pointcut("@annotation(com.example.annotation.Monitored)")
    public void monitoredPointcut() {
        // 切點方法，無實際邏輯
    }

    /**
     * 環(huán)繞通知：攔截并監(jiān)控標(biāo)注了 @Monitored 的方法
     *
     * Args:
     *     joinPoint: 連接點對象，包含目標(biāo)方法的全部上下文信息
     *     monitored: 目標(biāo)方法上的 @Monitored 注解實例，可讀取 value 屬性
     *
     * Returns:
     *     Object: 目標(biāo)方法的返回值
     *
     * Example:
     *     @Around("monitoredPointcut() && @annotation(monitored)")
     */
    @Around("monitoredPointcut() && @annotation(monitored)")
    public Object monitorAnnotatedApi(ProceedingJoinPoint joinPoint, Monitored monitored) throws Throwable {
        // 獲取注解中填寫的接口描述，示例："用戶登錄接口"
        String description = monitored.value();

        // 獲取方法信息
        String methodName = joinPoint.getTarget().getClass().getSimpleName() + "." + joinPoint.getSignature().getName();

        // 統(tǒng)計調(diào)用次數(shù)
        long currentCount = callCountMap.computeIfAbsent(methodName, k -> new AtomicLong(0)).incrementAndGet();

        // 獲取傳入?yún)?shù)
        Object[] args = joinPoint.getArgs();
        String requestParams = JSON.toJSONString(args);

        // 獲取請求信息
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();

        // 記錄開始時間
        long startTime = System.currentTimeMillis();

        // 執(zhí)行目標(biāo)方法
        Object result = joinPoint.proceed();

        // 計算耗時
        long elapsed = System.currentTimeMillis() - startTime;

        // 輸出監(jiān)控日志
        log.info("[接口監(jiān)控] {} | {} | 方法: {} | 累計調(diào)用: {} | 參數(shù): {} | 耗時: {}ms | 返回: {}",
                request.getMethod(), request.getRequestURL(),
                methodName, currentCount,
                requestParams, elapsed,
                JSON.toJSONString(result));

        return result;
    }
}

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

    @Monitored("用戶登錄接口")              // 標(biāo)注需要監(jiān)控的方法
    @PostMapping("/login")
    public Result login(@RequestBody LoginDTO loginDTO) {
        // 業(yè)務(wù)邏輯
        return Result.success("登錄成功");
    }

    @GetMapping("/list")                    // 未標(biāo)注 @Monitored，不會被監(jiān)控
    public Result list() {
        return Result.success(userService.list());
    }
}

package com.example.interceptor;                             // 包名根據(jù)實際項目調(diào)整

import com.alibaba.fastjson.JSON;                            // 引入 JSON 序列化工具，用于格式化請求參數(shù)
import lombok.extern.slf4j.Slf4j;                            // 引入 Slf4j 注解
import org.springframework.stereotype.Component;              // 引入 Component 注解，將攔截器注入 Spring 容器
import org.springframework.web.servlet.HandlerInterceptor;   // 引入 HandlerInterceptor 接口，需要實現(xiàn) preHandle 和 afterCompletion
import org.springframework.web.servlet.ModelAndView;         // 引入 ModelAndView 類

import javax.servlet.http.HttpServletRequest;               // 引入 HttpServletRequest
import javax.servlet.http.HttpServletResponse;               // 引入 HttpServletResponse
import java.util.Map;                                        // 引入 Map 接口，用于存儲統(tǒng)計信息
import java.util.concurrent.ConcurrentHashMap;               // 引入 ConcurrentHashMap，線程安全的統(tǒng)計容器
import java.util.concurrent.atomic.AtomicLong;               // 引入 AtomicLong，線程安全的計數(shù)器

/**
 * 接口監(jiān)控攔截器
 *
 * 功能：在請求處理前后記錄調(diào)用次數(shù)、參數(shù)、耗時等監(jiān)控信息
 *
 * Args:
 *     無
 *
 * Returns:
 *     無（通過 log 輸出監(jiān)控信息）
 *
 * Example:
 *     在 WebConfig 中注冊該攔截器即可生效
 */
@Slf4j
@Component
public class ApiMonitorInterceptor implements HandlerInterceptor {

    // 線程安全的統(tǒng)計容器
    // Key: URL（請求路徑），Value: 原子計數(shù)器
    // 示例：{"/api/user/list": 42, "/api/user/create": 15}
    private final Map<String, AtomicLong> urlCountMap = new ConcurrentHashMap<>();

    // 使用 ThreadLocal 存儲每個請求的開始時間，確保線程隔離
    // 數(shù)據(jù)流動：preHandle 中 set(startTime) → afterCompletion 中 get() 計算耗時 → finally 中 remove() 清理
    private final ThreadLocal<Long> startTimeHolder = new ThreadLocal<>();

    // 使用 ThreadLocal 存儲每個請求的 URL，用于在 afterCompletion 中統(tǒng)計
    private final ThreadLocal<String> urlHolder = new ThreadLocal<>();

    /**
     * 請求處理前執(zhí)行
     *
     * Args:
     *     request: HTTP 請求對象
     *     response: HTTP 響應(yīng)對象
     *     handler: 處理該請求的處理器（Controller 方法）
     *
     * Returns:
     *     boolean: true 表示繼續(xù)執(zhí)行，false 表示中斷請求
     *
     * Example:
     *     preHandle 中記錄開始時間和請求參數(shù)
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        // 獲取請求 URL，示例："/api/user/list"
        String requestUrl = request.getRequestURI();

        // 將請求 URL 存入 ThreadLocal，供 afterCompletion 使用
        urlHolder.set(requestUrl);

        // 該請求的調(diào)用次數(shù)加 1
        // 數(shù)據(jù)流動：urlCountMap.get(requestUrl) → AtomicLong.incrementAndGet() → 返回自增后的值
        long currentCount = urlCountMap.computeIfAbsent(requestUrl, k -> new AtomicLong(0)).incrementAndGet();

        // 記錄請求開始時間，存入 ThreadLocal
        startTimeHolder.set(System.currentTimeMillis());

        // 記錄請求信息
        log.info("[請求開始] {} {} | 累計調(diào)用: {} | 參數(shù): {}",
                request.getMethod(),                         // HTTP 方法，示例："GET"
                requestUrl,                                  // 請求路徑，示例："/api/user/list"
                currentCount,                                // 累計調(diào)用次數(shù)
                JSON.toJSONString(request.getParameterMap()) // 請求參數(shù) Map，示例：{"page":["1"],"size":["10"]}
        );

        return true;  // 返回 true，繼續(xù)執(zhí)行后續(xù)處理
    }

    /**
     * 請求完成后執(zhí)行（無論是否異常）
     *
     * Args:
     *     request: HTTP 請求對象
     *     response: HTTP 響應(yīng)對象
     *     handler: 處理該請求的處理器
     *     ex: 處理過程中拋出的異常（如果有）
     *
     * Returns:
     *     無
     *
     * Example:
     *     afterCompletion 中計算耗時并輸出日志
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        try {
            // 從 ThreadLocal 中取出開始時間
            Long startTime = startTimeHolder.get();
            if (startTime == null) {                          // 安全校驗：如果 startTime 為空，說明 preHandle 未執(zhí)行成功
                return;                                       // 直接返回，不進(jìn)行后續(xù)處理
            }

            // 計算處理耗時，單位：毫秒
            // 數(shù)據(jù)流動：結(jié)束時間戳 - 開始時間戳 → 耗時毫秒數(shù)
            long elapsed = System.currentTimeMillis() - startTime;

            // 獲取請求 URL
            String requestUrl = urlHolder.get();

            // 獲取 HTTP 狀態(tài)碼，示例：200、404、500
            int status = response.getStatus();

            // 輸出監(jiān)控日志
            log.info("[請求結(jié)束] {} | 狀態(tài): {} | 耗時: {}ms{}",
                    requestUrl,                              // 請求路徑
                    status,                                  // HTTP 狀態(tài)碼
                    elapsed,                                 // 響應(yīng)耗時
                    ex != null ? " | 異常: " + ex.getMessage() : ""  // 如果有異常則追加異常信息
            );
        } finally {
            // 清理 ThreadLocal，防止內(nèi)存泄漏（線程池中的線程會被復(fù)用）
            startTimeHolder.remove();
            urlHolder.remove();
        }
    }
}

package com.example.config;                                  // 包名根據(jù)實際項目調(diào)整

import com.example.interceptor.ApiMonitorInterceptor;         // 引入自定義攔截器
import org.springframework.beans.factory.annotation.Autowired;  // 引入自動注入注解
import org.springframework.context.annotation.Configuration;   // 引入 Configuration 注解，標(biāo)識為配置類
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;  // 引入攔截器注冊器
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;     // 引入 WebMvcConfigurer 接口，用于自定義 Spring MVC 配置

/**
 * Web MVC 配置類
 *
 * 功能：注冊自定義攔截器到 Spring MVC 攔截器鏈中
 *
 * Args:
 *     無
 *
 * Returns:
 *     無
 *
 * Example:
 *     @Configuration 注解的類會自動被 Spring 掃描并加載配置
 */
@Configuration                                                              // 標(biāo)識為配置類
public class WebConfig implements WebMvcConfigurer {

    @Autowired
    private ApiMonitorInterceptor apiMonitorInterceptor;                     // 注入自定義的接口監(jiān)控攔截器

    /**
     * 添加攔截器到 Spring MVC 框架
     *
     * Args:
     *     registry: 攔截器注冊器，用于添加和配置攔截器
     *
     * Returns:
     *     無
     *
     * Example:
     *     registry.addInterceptor(interceptor).addPathPatterns("/**");
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(apiMonitorInterceptor)                       // 添加自定義攔截器
                .addPathPatterns("/**");                                     // 攔截所有請求路徑
    }
}

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-registry-prometheus</artifactId>
</dependency>

spring:
  application:
    name: my-api-service                                          # 應(yīng)用名稱，作為 Prometheus 指標(biāo)的標(biāo)簽
management:
  endpoints:
    web:
      exposure:
        include: prometheus,metrics,health                        # 暴露 Prometheus、Metrics、Health 端點
  metrics:
    tags:
      application: ${spring.application.name}                     # 為所有指標(biāo)添加 application 標(biāo)簽
    distribution:
      percentiles-histogram:
        http.server.requests: true                                # 為 HTTP 請求指標(biāo)啟用百分位數(shù)直方圖
      slo:
        http.server.requests: 10ms, 50ms, 100ms, 200ms, 500ms, 1s  # 定義服務(wù)級別目標(biāo)（SLO）的耗時邊界

# HELP http_server_requests_seconds
# TYPE http_server_requests_seconds summary
http_server_requests_seconds_count{application="my-api-service",method="GET",outcome="SUCCESS",status="200",uri="/api/user/list"} 15.0
http_server_requests_seconds_sum{application="my-api-service",method="GET",outcome="SUCCESS",status="200",uri="/api/user/list"} 0.892
http_server_requests_seconds_max{application="my-api-service",method="GET",outcome="SUCCESS",status="200",uri="/api/user/list"} 0.124

package com.example.metrics;                                   // 包名根據(jù)實際項目調(diào)整
import io.micrometer.core.instrument.Counter;                  // 引入 Micrometer 計數(shù)器，用于統(tǒng)計調(diào)用次數(shù)
import io.micrometer.core.instrument.MeterRegistry;            // 引入 MeterRegistry，Micrometer 指標(biāo)注冊中心
import io.micrometer.core.instrument.Timer;                    // 引入 Micrometer 計時器，用于統(tǒng)計耗時
import lombok.extern.slf4j.Slf4j;                              // 引入 Slf4j 注解
import org.aspectj.lang.ProceedingJoinPoint;                   // 引入 ProceedingJoinPoint
import org.aspectj.lang.annotation.Around;                     // 引入環(huán)繞通知注解
import org.aspectj.lang.annotation.Aspect;                     // 引入切面注解
import org.aspectj.lang.annotation.Pointcut;                   // 引入切點注解
import org.springframework.stereotype.Component;                // 引入 Component 注解
import java.util.concurrent.TimeUnit;                          // 引入 TimeUnit，用于時間單位轉(zhuǎn)換
/**
 * Micrometer 自定義指標(biāo)切面
 *
 * 功能：統(tǒng)計每個接口的調(diào)用次數(shù)和耗時，以 Prometheus 指標(biāo)格式暴露
 *
 * Args:
 *     無
 *
 * Returns:
 *     無（指標(biāo)數(shù)據(jù)自動注冊到 MeterRegistry）
 *
 * Example:
 *     結(jié)合 Actuator + Prometheus + Grafana 實現(xiàn)可視化監(jiān)控
 */
@Slf4j
@Aspect
@Component
public class MicrometerMetricsAspect {
    private final MeterRegistry meterRegistry;                  // Micrometer 指標(biāo)注冊中心，用于創(chuàng)建和管理指標(biāo)
    /**
     * 構(gòu)造方法注入 MeterRegistry
     *
     * Args:
     *     meterRegistry: Spring Boot 自動配置的 MeterRegistry 實例
     *
     * Returns:
     *     無
     */
    public MicrometerMetricsAspect(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
    }
    /**
     * 定義切點：攔截所有 Controller 方法
     */
    @Pointcut("execution(* com.example.controller.*.*(..))")
    public void controllerPointcut() {}
    /**
     * 環(huán)繞通知：采集接口調(diào)用次數(shù)和耗時指標(biāo)
     *
     * Args:
     *     joinPoint: 連接點對象
     *
     * Returns:
     *     Object: 目標(biāo)方法的返回值
     */
    @Around("controllerPointcut()")
    public Object recordMetrics(ProceedingJoinPoint joinPoint) throws Throwable {
        // 獲取接口名稱，用于指標(biāo)標(biāo)簽
        String methodName = joinPoint.getTarget().getClass().getSimpleName() + "." + joinPoint.getSignature().getName();
        // 創(chuàng)建計時器：統(tǒng)計該接口的耗時分布
        // 數(shù)據(jù)流動：Timer.Sample 記錄開始 → 方法執(zhí)行 → sample.stop() 記錄結(jié)束 → 指標(biāo)注冊到 Prometheus
        Timer.Sample sample = Timer.start(meterRegistry);
        try {
            // 執(zhí)行目標(biāo)方法
            Object result = joinPoint.proceed();
            return result;
        } finally {
            // 停止計時器，并將指標(biāo)注冊到 MeterRegistry
            // 數(shù)據(jù)流動：sample.stop(timer) → /actuator/prometheus 暴露 → Prometheus 采集 → Grafana 展示
            sample.stop(Timer.builder("api.call.duration")           // 指標(biāo)名稱
                    .description("接口調(diào)用耗時")                       // 指標(biāo)描述
                    .tag("method", methodName)                        // 標(biāo)簽：接口方法名
                    .tag("class", joinPoint.getTarget().getClass().getSimpleName())  // 標(biāo)簽：類名
                    .register(meterRegistry));                        // 注冊到 MeterRegistry
            // 增加調(diào)用次數(shù)計數(shù)器
            // 數(shù)據(jù)流動：Counter.increment() → 指標(biāo)值 +1 → Prometheus 采集
            Counter counter = Counter.builder("api.call.count")      // 指標(biāo)名稱
                    .description("接口調(diào)用次數(shù)")                        // 指標(biāo)描述
                    .tag("method", methodName)                        // 標(biāo)簽：接口方法名
                    .register(meterRegistry);                        // 注冊到 MeterRegistry
            counter.increment();                                      // 計數(shù)器加 1
        }
    }
}

# HELP api_call_duration_seconds 接口調(diào)用耗時
# TYPE api_call_duration_seconds summary
api_call_duration_seconds_count{method="UserController.getUserList",} 5.0
api_call_duration_seconds_sum{method="UserController.getUserList",} 0.345

# HELP api_call_count_total 接口調(diào)用次數(shù)
# TYPE api_call_count_total counter
api_call_count_total{method="UserController.getUserList",} 5.0

package com.example.listener;                                  // 包名根據(jù)實際項目調(diào)整
import lombok.extern.slf4j.Slf4j;                              // 引入 Slf4j 注解
import org.springframework.context.ApplicationListener;         // 引入 ApplicationListener 接口
import org.springframework.stereotype.Component;                // 引入 Component 注解
import org.springframework.web.context.support.ServletRequestHandledEvent;  // 引入請求處理事件類
/**
 * 請求耗時事件監(jiān)聽器
 *
 * 功能：監(jiān)聽 ServletRequestHandledEvent 事件，記錄每個接口的調(diào)用耗時
 *       注意：此方案無法獲取請求參數(shù)和返回參數(shù)，僅能獲取 URL、方法、耗時
 *
 * Args:
 *     無
 *
 * Returns:
 *     無（通過 log 輸出監(jiān)控信息）
 *
 * Example:
 *     自動生效，無需額外配置
 */
@Slf4j
@Component
public class RequestTimeEventListener implements ApplicationListener<ServletRequestHandledEvent> {
    /**
     * 事件處理方法：ServletRequestHandledEvent 發(fā)布時自動調(diào)用
     *
     * Args:
     *     event: ServletRequestHandledEvent 事件對象，包含請求的 URL、方法、耗時、客戶端地址等信息
     *
     * Returns:
     *     無
     *
     * Example:
     *     請求完成后自動觸發(fā)，輸出：
     *     "clientAddress=127.0.0.1, requestUrl=/api/user/list, method=GET, costTime=45ms"
     */
    @Override
    public void onApplicationEvent(ServletRequestHandledEvent event) {
        // 獲取客戶端 IP 地址，示例："127.0.0.1"
        String clientAddress = event.getClientAddress();
        // 獲取請求 URL，示例："/api/user/list"
        String requestUrl = event.getRequestUrl();
        // 獲取 HTTP 方法類型，示例："GET"、"POST"
        String method = event.getMethod();
        // 獲取請求處理耗時，單位：毫秒
        // 數(shù)據(jù)流動：Spring 框架自動計時 → event.getProcessingTimeMillis() → 輸出日志
        long processingTimeMillis = event.getProcessingTimeMillis();
        // 獲取失敗原因（如果有異常）
        Throwable failureCause = event.getFailureCause();
        String failureMessage = failureCause == null ? "" : failureCause.getMessage();
        // 根據(jù)是否有異常，分別輸出不同級別的日志
        if (failureCause == null) {
            // 請求成功：輸出 INFO 級別日志
            log.info("clientAddress={}, requestUrl={}, method={}, costTime={}ms",
                    clientAddress, requestUrl, method, processingTimeMillis);
        } else {
            // 請求失?。狠敵?ERROR 級別日志，包含異常信息
            log.error("clientAddress={}, requestUrl={}, method={}, costTime={}ms, error={}",
                    clientAddress, requestUrl, method, processingTimeMillis, failureMessage);
        }
    }
}