007-计算方法耗时六种实现方式

一、自定义注解+AOP

优点：更精细的控制，注解可携带更多信息，便于定制
缺点：需要手动在方法上添加注解

1、引入依赖

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

2、创建注解

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface TimeConsume {
}

3、创建切面

@Slf4j
@Aspect
@Component
public class TimeConsumeAspect {

    @Around("@annotation(org.example.annotation.TimeConsume)")
    public Object executionTimeLogger(ProceedingJoinPoint joinPoint) {
        try {
            long startTime = System.currentTimeMillis();
            Object proceed = joinPoint.proceed();
            long executionTime = (System.currentTimeMillis() - startTime);
            log.info("{}方法在{}毫秒内执行完毕", joinPoint.getSignature(), executionTime);
            return proceed;
        } catch (Throwable e) {
            log.error("在计算{}方法执行时间时出错", joinPoint.getSignature(), e);
            return null;
        }
    }

}

4、controller测试

@RestController
public class TestSpiController {

    @TimeConsume
    @GetMapping("/test")
    public void myMethod() {
        try {
            Thread.sleep(20000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

5、结果输出

二、手动使用 StopWatch

优点：简单直观，无需额外配置
缺点：侵入业务代码，不够优雅，需要手动添加到每个需要监控的方法

1.Spring 提供的 StopWatch 类（直接使用，不需要额外引入依赖）

2.Hutool 提供的 StopWatch 类（需要额外引入 Hutool 依赖包）

<!--hutool 工具类-->
<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.8.25</version>
</dependency>

@SpringBootTest
class TestController {

    @Autowired
    private IInOutRecordDaoService inOutRecordDaoService;

    @Test
    void test(){
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        System.out.println("=========test============"+
                inOutRecordDaoService.selectInRecordListByPage(1, 10, null));
        stopWatch.stop();
        System.out.println("test方法耗时：" + stopWatch.getTotalTimeMillis() + "ms");
    }

}

三、拦截器的方式

优点：专注于Web接口性能，对接口进行统一监控
缺点：只能监控Controller层方法，无法监控内部服务方法

1.Spring的拦截器：

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

@Component
public class ApiTimeInterceptor implements HandlerInterceptor {
    
    private ThreadLocal<Long> startTime = new ThreadLocal<>();
    
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        startTime.set(System.currentTimeMillis());
        return true;
    }
    
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) {
        long endTime = System.currentTimeMillis();
        long executionTime = endTime - startTime.get();
        String uri = request.getRequestURI();
        System.out.println("接口[" + uri + "]耗时：" + executionTime + "ms");
        startTime.remove();
    }
}

2.注册拦截器：

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebConfig implements WebMvcConfigurer {
    
    private final ApiTimeInterceptor apiTimeInterceptor;
    
    public WebConfig(ApiTimeInterceptor apiTimeInterceptor) {
        this.apiTimeInterceptor = apiTimeInterceptor;
    }
    
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(apiTimeInterceptor).addPathPatterns("/api/");
    }
}

四、使用Actuator + Micrometer实现细粒度监控

优点：专业的性能指标收集，可与Prometheus、Grafana等监控系统集成，适合生产环境
缺点：配置使用相对复杂

Spring Boot Actuator提供了与Micrometer的集成，可以实现更专业的性能指标收集：

1.添加依赖：

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

2.使用Micrometer进行方法计时：

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

@Service
public class OrderService {
    
    private final MeterRegistry meterRegistry;
    
    public OrderService(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
    }
    
    public Order createOrder(OrderRequest request) {
        Timer.Sample sample = Timer.start(meterRegistry);
        
        // 业务逻辑
        Order order = processOrder(request);
        
        sample.stop(meterRegistry.timer("order.creation.time"));
        
        return order;
    }
}

3.配置Actuator暴露指标：

management:
  endpoints:
    web:
      exposure:
        include: metrics,prometheus
  metrics:
    export:
      prometheus:
        enabled: true

五、使用Filter实现请求耗时统计

优点：可以全局监控所有Web请求的耗时。
缺点：只提供整体请求的耗时，无法深入到具体业务逻辑的执行时间。

创建一个Filter实现类，可以记录每次HTTP请求的开始时间和结束时间，从而计算出请求的整体耗时。

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import java.io.IOException;

@Component
public class TimingFilter implements Filter {
    
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) 
            throws IOException, ServletException {
        long startTime = System.currentTimeMillis();
        
        // 继续处理请求
        chain.doFilter(request, response);
        
        long endTime = System.currentTimeMillis();
        long executionTime = endTime - startTime;
        String requestUri = ((HttpServletRequest) request).getRequestURI();
        System.out.println("请求[" + requestUri + "]耗时：" + executionTime + "ms");
    }
    
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {}
    
    @Override
    public void destroy() {}
}

六、使用ServletRequestHandledEvent统计请求处理耗时

优点：不需要修改现有代码，监控全局请求的耗时
缺点：不支持自定义请求的粒度控制

Spring Boot提供了ServletRequestHandledEvent事件，可以用来监控HTTP请求的处理时间。这种方式适合于全局监控所有的请求。
首先，创建事件监听器：

import org.springframework.context.ApplicationListener;
import org.springframework.web.context.request.ServletRequestHandledEvent;
import org.springframework.stereotype.Component;

@Component
public class RequestTimingListener implements ApplicationListener<ServletRequestHandledEvent> {

    @Override
    public void onApplicationEvent(ServletRequestHandledEvent event) {
        System.out.println("请求[" + event.getRequestUrl() + "]耗时：" + event.getProcessingTimeMillis() + "ms");
    }
}

这种方法会自动监听处理结果，不需要在每个Controller中进行显式的耗时统计。

七、总结与对比

在SpringBoot中，以上七种方法各有优缺点，可以根据不同的场景选择合适的方案：

1. 自定义注解+AOP：适合精细化控制，只监控关键方法
2. StopWatch手动统计：适合临时测试，快速实现
3. 拦截器：适合Web接口监控
4. Actuator+Micrometer：适合生产环境，与专业监控系统集成
5. Filter：适合全局请求监控，轻量级实现
6. ServletRequestHandledEvent：全局监控HTTP请求处理时间，不需改动代码