一、引言：为什么需要统计方法耗时？

在微服务架构或复杂业务系统中，方法执行效率直接影响用户体验和系统稳定性。统计方法耗时可以帮助开发者：

• 定位性能瓶颈：快速识别执行缓慢的核心链路
• 优化资源分配：为数据库查询、远程调用等操作设置合理超时时间
• 建立监控体系：作为服务SLA（服务等级协议）的重要指标

本文将从简单日志打印到AOP切面编程，再到集成Micrometer监控框架，逐步讲解在Spring Boot中统计方法耗时的最佳实践。

二、基础方法：手动计时（适合简单场景）

通过在方法执行前后记录时间戳，计算时间差并打印日志。
优点：直观易懂，无需额外依赖
缺点：代码侵入性强，重复代码多，难以统一维护

实现步骤：

1. 在方法开始前获取当前时间

   long startTime = System.currentTimeMillis();

2. 在方法结束后计算耗时并打印

   long endTime = System.currentTimeMillis();
   log.info("Method [{}] executed in {}ms", methodName, endTime - startTime);

示例代码：

@Service
public class UserService {
    private static final Logger log = LoggerFactory.getLogger(UserService.class);

    public User getUserById(Long userId) {
        long startTime = System.currentTimeMillis();
        // 模拟数据库查询
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        long endTime = System.currentTimeMillis();
        log.info("getUserById耗时: {}ms", endTime - startTime);
        return new User(userId, "John Doe");
    }
}

三、进阶优化：AOP切面编程（推荐中大型项目）

利用Spring AOP（面向切面编程）实现无侵入式耗时统计，通过自定义注解标记需要监控的方法。
核心思路：

1. 定义自定义注解：用于标记目标方法
2. 编写切面类：通过@Around环绕通知捕获方法执行过程
3. 配置切面规则：指定切入点表达式匹配目标方法

1. 定义自定义注解@MethodTimeCost

import java.lang.annotation.*;

@Target(ElementType.METHOD) // 作用于方法
@Retention(RetentionPolicy.RUNTIME) // 运行时生效
@Documented
public @interface MethodTimeCost {
    String value() default ""; // 可选参数，用于描述方法
}

2. 编写切面类TimeCostAspect

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class TimeCostAspect {
    private static final Logger log = LoggerFactory.getLogger(TimeCostAspect.class);

    // 切入点：匹配所有被@MethodTimeCost标记的方法
    @Around("@annotation(com.example.annotation.MethodTimeCost)")
    public Object logTimeCost(ProceedingJoinPoint joinPoint) throws Throwable {
        long startTime = System.currentTimeMillis();

        // 执行目标方法
        Object result = joinPoint.proceed();

        long endTime = System.currentTimeMillis();
        long duration = endTime - startTime;

        // 获取方法名
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        String methodName = signature.getMethod().getName();
        // 获取注解描述
        MethodTimeCost annotation = signature.getMethod().getAnnotation(MethodTimeCost.class);
        String description = annotation.value();

        log.info("Method [{}] {} executed in {}ms", methodName, description, duration);
        return result;
    }
}

3. 在目标方法上添加注解

@Service
public class OrderService {
    @MethodTimeCost("创建订单") // 可选描述信息
    public Order createOrder(OrderRequest request) {
        // 模拟业务逻辑
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return new Order(request.getUserId(), "ORDER_123");
    }
}

4. 日志输出效果

2025-05-06 14:30:00 INFO  TimeCostAspect:45 - Method [createOrder] 创建订单 executed in 202ms

四、异步方法处理：结合CompletableFuture

当统计@Async异步方法时，需注意耗时统计应包含整个异步执行周期，而非仅方法提交时间。

实现要点：

1. 在异步方法返回的CompletableFuture中添加回调
2. 使用AOP捕获异步方法的执行过程

示例代码：

@Service
public class AsyncService {
    @Async("asyncExecutor") // 自定义线程池
    @MethodTimeCost("异步任务处理")
    public CompletableFuture<Void> processAsyncTask() {
        return CompletableFuture.runAsync(() -> {
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
    }
}

// 切面类中无需额外修改，AOP会自动处理异步方法的环绕通知

五、分布式场景：集成Micrometer（进阶监控）

对于微服务架构，需将方法耗时纳入统一监控体系。Spring Boot内置Micrometer框架，可无缝对接Prometheus、Grafana等工具。

1. 添加依赖

<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-core</artifactId>
</dependency>
<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-registry-prometheus</artifactId> <!-- 可选，用于Prometheus监控 -->
</dependency>

2. 使用@Timed注解统计耗时

import io.micrometer.core.annotation.Timed;
import io.micrometer.core.instrument.MeterRegistry;
import org.springframework.stereotype.Service;

@Service
public class PaymentService {
    private final MeterRegistry meterRegistry;

    public PaymentService(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
    }

    // 自动创建名为"payment.process"的计时器
    @Timed(value = "payment.process", description = "支付处理耗时")
    public void processPayment(PaymentRequest request) {
        // 模拟支付逻辑
        try {
            Thread.sleep(150);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

3. 监控指标查看

通过Micrometer生成的指标可在以下场景使用：

• Prometheus：抓取/actuator/prometheus端点数据
• Grafana：配置仪表盘显示平均耗时、95%分位数等指标

六、四种方案对比与适用场景

七、最佳实践与注意事项

1. 避免过度监控：仅对核心业务方法（如数据库操作、第三方接口调用）添加耗时统计，避免性能损耗
2. 异常处理：在切面中添加try-catch，确保方法抛出异常时仍能正确记录耗时
3. 性能优化：
   • 使用System.nanoTime()替代System.currentTimeMillis()获取更高精度（纳秒级）
   • 对高频调用方法，采用异步日志（如Logback异步Appender）避免I/O阻塞
4. 分布式追踪：结合OpenTelemetry或SkyWalking，在统计耗时的同时关联请求链路ID

八、总结：选择适合你的耗时统计方案

统计方法耗时的核心目标是以最小成本获取最大价值：

• 小型项目或临时调试：直接使用手动计时或Spring自带的@Timed注解
• 中大型项目：通过AOP自定义注解实现无侵入式监控，统一管理日志格式
• 微服务架构：集成Micrometer+Prometheus+Grafana，构建完整的性能监控体系

通过合理选择工具和架构，开发者可以将耗时统计从“临时需求”转化为“系统性保障”，为系统的稳定性和可维护性打下坚实基础。尝试在你的下一个Spring Boot项目中应用AOP切面吧——代码简洁度和可维护性的提升会让你惊喜。

资源推荐

1. Spring AOP官方文档
2. Micrometer官方文档
3. Prometheus监控入门指南
4. OpenTelemetry分布式追踪

合理的耗时统计是性能优化的第一步，也是系统健康度的“体温计”。掌握这些方法后，你将对系统的每一次调用了如指掌，让性能问题无处遁形。