Java统计接口耗时的六种常见方法

public class SimpleTimeTracker {
    public void processRequest() {
        long startTime = System.currentTimeMillis(); // 记录开始时间
        
        // 模拟业务处理：假设这里是一些核心逻辑
        try {
            Thread.sleep(100); // 模拟耗时操作，如数据库查询或外部API调用
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        long endTime = System.currentTimeMillis(); // 记录结束时间
        long duration = endTime - startTime; // 计算耗时
        
        System.out.println("接口耗时: " + duration + "ms");
    }
    
    public static void main(String[] args) {
        new SimpleTimeTracker().processRequest();
    }
}

public class NanoTimeTracker {
    public void processRequest() {
        long startTime = System.nanoTime(); // 纳秒级开始时间
        
        // 模拟业务处理
        try {
            Thread.sleep(100); // 注意：sleep单位是毫秒，实际业务可能是纳秒级操作
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        long endTime = System.nanoTime(); // 纳秒级结束时间
        long duration = (endTime - startTime) / 1_000_000; // 转换为毫秒
        
        System.out.println("接口耗时: " + duration + "ms");
    }
    
    public static void main(String[] args) {
        new NanoTimeTracker().processRequest();
    }
}

// 定义一个注解，用于标记需要统计耗时的方法
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public@interface TimeCost {
    String value() default "";
}

// 编写切面类
@Aspect
@Component
publicclass TimeCostAspect {
    privatestaticfinal Logger logger = LoggerFactory.getLogger(TimeCostAspect.class);
    
    // 定义切点：标注了@TimeCost注解的方法
    @Around("@annotation(timeCost)")
    public Object around(ProceedingJoinPoint joinPoint, TimeCost timeCost) throws Throwable {
        long startTime = System.currentTimeMillis();
        Object result = null;
        try {
            result = joinPoint.proceed(); // 执行目标方法
        } finally {
            long endTime = System.currentTimeMillis();
            long duration = endTime - startTime;
            logger.info("方法 {} 耗时: {}ms", joinPoint.getSignature().getName(), duration);
        }
        return result;
    }
}

// 在业务方法上使用注解
@Service
publicclass UserService {
    @TimeCost("获取用户信息")
    public User getUserById(Long id) {
        // 模拟业务逻辑
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        returnnew User(id, "用户" + id);
    }
}

// 自定义拦截器
@Component
publicclass TimeCostInterceptor implements HandlerInterceptor {
    privatestaticfinal Logger logger = LoggerFactory.getLogger(TimeCostInterceptor.class);
    privatestaticfinal String START_TIME_ATTRIBUTE = "startTime";
    
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        long startTime = System.currentTimeMillis();
        request.setAttribute(START_TIME_ATTRIBUTE, startTime); // 将开始时间存入请求属性
        returntrue; // 继续执行链
    }
    
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        long startTime = (Long) request.getAttribute(START_TIME_ATTRIBUTE);
        long endTime = System.currentTimeMillis();
        long duration = endTime - startTime;
        logger.info("接口 {} 耗时: {}ms, 状态码: {}", request.getRequestURI(), duration, response.getStatus());
    }
}

// 注册拦截器到Spring MVC
@Configuration
publicclass WebConfig implements WebMvcConfigurer {
    @Autowired
    private TimeCostInterceptor timeCostInterceptor;
    
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(timeCostInterceptor).addPathPatterns("/**"); // 拦截所有路径
    }
}

// 自定义过滤器
@Component
@Order(1) // 指定执行顺序，数字越小优先级越高
publicclass TimeCostFilter implements Filter {
    privatestaticfinal Logger logger = LoggerFactory.getLogger(TimeCostFilter.class);
    
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        long startTime = System.currentTimeMillis();
        try {
            chain.doFilter(request, response); // 继续执行过滤器链
        } finally {
            long endTime = System.currentTimeMillis();
            long duration = endTime - startTime;
            HttpServletRequest httpRequest = (HttpServletRequest) request;
            HttpServletResponse httpResponse = (HttpServletResponse) response;
            logger.info("过滤器统计 - 接口 {} 耗时: {}ms, 状态码: {}", httpRequest.getRequestURI(), duration, httpResponse.getStatus());
        }
    }
}
// 注意：在Spring Boot中，@Component会自动注册过滤器；非Spring项目需在web.xml配置

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

// 无需额外代码，Spring Boot自动集成Micrometer，通过Actuator端点暴露指标
// 在application.properties中启用Prometheus端点
management.endpoints.web.exposure.include=prometheus,metrics

@Service
publicclass OrderService {
    privatefinal MeterRegistry meterRegistry;
    privatefinal Timer orderProcessTimer;
    
    public OrderService(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
        this.orderProcessTimer = Timer.builder("order.process.time")
            .description("订单处理耗时")
            .register(meterRegistry);
    }
    
    public void processOrder(Order order) {
        orderProcessTimer.record(() -> {
            // 业务逻辑
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
    }
}