如何用Micrometer @Timed注解获取同流程方法净时长并上报CloudWatch？

针对你的需求，以下是几种无需手动日志、自动将Step1净时长上报至CloudWatch的可行方案：

方案1：自定义AOP切面（推荐，无业务代码侵入） #

利用Spring AOP拦截带@Timed注解的方法调用，跟踪单次调用链中各步骤的执行时长，在Step1执行完成后自动计算净时长并上报Metrics。

实现代码 #

import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.core.instrument.Timer;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;

@Aspect
@Component
public class StepDurationAspect {

    private final Timer step1NetTimer;
    // 用ThreadLocal存储单次调用链中的步骤时长，避免并发干扰
    private final ThreadLocal<Map<String, Long>> stepDurations = ThreadLocal.withInitial(HashMap::new);

    @Autowired
    public StepDurationAspect(MeterRegistry meterRegistry) {
        // 初始化净时长Timer，指定指标名称用于CloudWatch上报
        this.step1NetTimer = Timer.builder("step1.net")
                .description("Step1净执行时长（总时长 - Step2自身时长 - Step3时长）")
                .register(meterRegistry);
    }

    // 拦截Step1方法，计算并上报净时长
    @Around("@annotation(io.micrometer.core.annotation.Timed) && execution(* *.step1(..))")
    public Object trackStep1(ProceedingJoinPoint joinPoint) throws Throwable {
        long step1Start = System.nanoTime();
        try {
            Object result = joinPoint.proceed();
            long step1TotalDuration = System.nanoTime() - step1Start;
            
            // 从ThreadLocal中获取Step2和Step3的单次执行时长
            long step2Total = stepDurations.get().getOrDefault("step2", 0L);
            long step3Duration = stepDurations.get().getOrDefault("step3", 0L);
            
            // 计算Step2自身逻辑时长（排除Step3的耗时）
            long step2SelfDuration = step2Total - step3Duration;
            // 计算Step1净时长
            long step1NetDuration = step1TotalDuration - step2SelfDuration - step3Duration;
            
            // 自动上报至CloudWatch
            step1NetTimer.record(step1NetDuration, TimeUnit.NANOSECONDS);
            return result;
        } finally {
            // 清理ThreadLocal，避免内存泄漏
            stepDurations.remove();
        }
    }

    // 拦截Step2方法，记录总时长
    @Around("@annotation(io.micrometer.core.annotation.Timed) && execution(* *.step2(..))")
    public Object trackStep2(ProceedingJoinPoint joinPoint) throws Throwable {
        long step2Start = System.nanoTime();
        Object result = joinPoint.proceed();
        stepDurations.get().put("step2", System.nanoTime() - step2Start);
        return result;
    }

    // 拦截Step3方法，记录时长
    @Around("@annotation(io.micrometer.core.annotation.Timed) && execution(* *.step3(..))")
    public Object trackStep3(ProceedingJoinPoint joinPoint) throws Throwable {
        long step3Start = System.nanoTime();
        Object result = joinPoint.proceed();
        stepDurations.get().put("step3", System.nanoTime() - step3Start);
        return result;
    }
}

优势 #

• 完全无业务代码侵入，无需修改现有方法逻辑
• 自动处理并发调用（ThreadLocal隔离请求上下文）
• Micrometer会自动将step1.net指标同步至CloudWatch（需提前配置CloudWatch MeterRegistry）

方案2：手动控制Timer生命周期（侵入性低，适合简单场景） #

在Step1方法中手动跟踪自身逻辑的执行时间，排除Step2和Step3的耗时，直接上报净时长。

实现代码 #

import io.micrometer.core.annotation.Timed;
import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.core.instrument.Timer;
import org.springframework.beans.factory.annotation.Autowired;

public class BusinessService {

    private final Timer step1NetTimer;

    @Autowired
    public BusinessService(MeterRegistry meterRegistry) {
        this.step1NetTimer = Timer.builder("step1.net")
                .register(meterRegistry);
    }

    @Timed("step1")
    public void step1() {
        long netStart = System.nanoTime();
        
        // Step1自身前置逻辑
        // some logic
        
        // 执行Step2（不计入净时长）
        long step2Start = System.nanoTime();
        step2();
        long step2Total = System.nanoTime() - step2Start;
        
        // Step1自身后置逻辑
        // some logic
        
        long step1Total = System.nanoTime() - netStart + step2Total;
        // 假设Step3时长已包含在Step2总时长中，若需单独减Step3，需在Step2中返回Step3时长
        long step1NetDuration = step1Total - step2Total;
        
        step1NetTimer.record(step1NetDuration, java.util.concurrent.TimeUnit.NANOSECONDS);
    }

    @Timed("step2")
    public void step2() {
        // some logic
        step3();
        // some logic
    }

    @Timed("step3")
    public void step3() {
        // some logic
    }
}

注意事项 #

• 若需严格按照Step1总时长 - Step2时长 - Step3时长计算，需在Step2中单独记录Step3的执行时间并返回
• 代码侵入性低，仅需在Step1中添加少量统计逻辑

关键配置前提 #

确保已正确配置Micrometer CloudWatch Registry，示例配置（Spring Boot）：

management:
  metrics:
    export:
      cloudwatch:
        enabled: true
        namespace: your-app-namespace
        access-key: your-access-key
        secret-key: your-secret-key
        region: your-region

内容的提问来源于stack exchange，提问作者Deepak Samria