Spring Boot如何实现耗时统计七种方法方式性能优化必备

在开发Spring Boot项目时，咱们常常会遇到性能方面的问题。要想精准定位并解决这些问题，统计方法的执行时间就显得尤为重要。通过了解各个方法的耗时情况，我们能够快速找出性能瓶颈，进而优化系统响应速度。今天，我就来给大家分享在Spring Boot框架里实现方法耗时统计的七种实用方法。

一、手动使用StopWatch

在众多统计方法耗时的方式中，手动使用Spring提供的StopWatch类是最直接的一种。这种方法简单易懂，特别适合做临时性的性能测试。

import org.springframework.util.StopWatch; @Service public class UserService { public User findUserById(Long id) { // 创建StopWatch实例，用于记录时间 StopWatch stopWatch = new StopWatch(); // 开始计时 stopWatch.start(); // 业务逻辑，从数据库中根据id查找用户 User user = userRepository.findById(id).orElse(null); // 停止计时 stopWatch.stop(); // 输出方法执行耗时 System.out.println("findUserById方法耗时：" + stopWatch.getTotalTimeMillis() + "ms"); return user; } }

这种方式的优点很明显，它简单直观，不需要额外配置其他东西。但缺点也不容忽视，它会侵入业务代码，使代码看起来不够优雅。而且，如果要监控多个方法的耗时，就需要在每个方法里都手动添加这些代码，工作量较大。

二、借助AOP实现全局方法耗时统计

AOP，也就是面向切面编程，用它来统计方法耗时是个很不错的选择。使用AOP，我们可以在不改动原有业务代码的基础上，统一处理耗时统计的逻辑。

首先，要在项目中添加AOP依赖，在pom.xml文件中添加如下代码：

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

添加完依赖后，接着创建切面类：

import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.Around; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Pointcut; import org.springframework.stereotype.Component; import org.springframework.util.StopWatch; @Aspect @Component public class MethodTimeAspect { // 定义切点，这里表示匹配com.example.demo.service包下所有类的所有方法 @Pointcut("execution(* com.example.demo.service.*.*(..))") public void serviceMethodPointcut() {} // 环绕通知，在目标方法执行前后进行计时 @Around("serviceMethodPointcut()") public Object timeAround(ProceedingJoinPoint joinPoint) throws Throwable { // 创建StopWatch实例 StopWatch stopWatch = new StopWatch(); // 开始计时 stopWatch.start(); // 执行目标方法 Object result = joinPoint.proceed(); // 停止计时 stopWatch.stop(); // 获取目标方法的名称 String methodName = joinPoint.getSignature().getName(); // 输出方法执行耗时 System.out.println("方法[" + methodName + "]耗时：" + stopWatch.getTotalTimeMillis() + "ms"); return result; } }

这种方式的优势在于，代码没有侵入性，所有的耗时统计逻辑都可以统一管理，配置起来也很灵活。不过，它也有不足的地方，对于一些特定方法的定制化需求，实现起来不是那么方便。

三、自定义注解+AOP实现精细化控制

如果想要更精确地控制哪些方法需要进行耗时统计，我们可以把自定义注解和AOP结合起来使用。

先创建自定义注解：

import java.lang.annotation.*; @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface TimeLog { // 注解的值，用于描述方法，默认为空 String value() default ""; }

然后，创建切面类来处理带有该注解的方法：

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.springframework.stereotype.Component; import org.springframework.util.StopWatch; @Aspect @Component public class TimeLogAspect { @Around("@annotation(com.example.demo.annotation.TimeLog)") public Object timeLogAround(ProceedingJoinPoint joinPoint) throws Throwable { // 获取方法签名 MethodSignature signature = (MethodSignature) joinPoint.getSignature(); // 获取方法上的TimeLog注解 TimeLog timeLog = signature.getMethod().getAnnotation(TimeLog.class); // 根据注解的值来确定方法描述，如果注解值为空，则使用方法名 String methodDesc = timeLog.value().isEmpty() ? signature.getMethod().getName() : timeLog.value(); // 创建StopWatch实例 StopWatch stopWatch = new StopWatch(); // 开始计时 stopWatch.start(); // 执行目标方法 Object result = joinPoint.proceed(); // 停止计时 stopWatch.stop(); // 输出方法执行耗时 System.out.println("方法[" + methodDesc + "]耗时：" + stopWatch.getTotalTimeMillis() + "ms"); return result; } }

使用示例如下：

@Service public class ProductService { @TimeLog("查询商品详情") public Product getProductDetail(Long id) { // 业务逻辑，从数据库中根据id查找商品详情 return productRepository.findById(id).orElse(null); } }

这种方法的好处是可以进行更精细的控制，注解还能携带更多信息，方便我们根据不同需求进行定制。但缺点是需要手动在每个要监控的方法上添加注解。

四、利用拦截器统计Controller接口耗时

要是我们只关心Controller层接口的耗时情况，那么使用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 { // 使用ThreadLocal来存储请求开始时间，避免多线程环境下的数据冲突 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(); // 获取请求的URI String uri = request.getRequestURI(); // 输出接口执行耗时 System.out.println("接口[" + uri + "]耗时：" + executionTime + "ms"); // 移除ThreadLocal中的数据，避免内存泄漏 startTime.remove(); } }

别忘了注册拦截器：

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/"); } }

这种方式专注于Web接口的性能监控，可以对接口进行统一管理。但它只能监控Controller层的方法，对于内部服务方法的耗时监控就无能为力了。

五、借助Actuator + Micrometer实现细粒度监控

Spring Boot Actuator和Micrometer集成后，可以实现更专业的性能指标收集。

先添加相关依赖：

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

接着，使用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; } }

最后，配置Actuator暴露指标：

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

这种方式可以收集专业的性能指标，还能和Prometheus、Grafana等监控系统集成，非常适合生产环境。不过，它的配置相对复杂一些，需要我们花点时间去学习和理解。

六、通过Filter实现请求耗时统计

创建一个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; // 获取请求的URI String requestUri = ((HttpServletRequest) request).getRequestURI(); // 输出请求执行耗时 System.out.println("请求[" + requestUri + "]耗时：" + executionTime + "ms"); } @Override public void init(FilterConfig filterConfig) throws ServletException {} @Override public void destroy() {} }

这种方式可以全局监控所有Web请求的耗时情况，实现起来也比较简单。但它只能提供整体请求的耗时信息，没办法深入到具体业务逻辑的执行时间。

七、利用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) { // 输出请求的URL和处理时间 System.out.println("请求[" + event.getRequestUrl() + "]耗时：" + event.getProcessingTimeMillis() + "ms"); } }

这种方法的优点是不需要修改现有代码，就能实现全局请求的耗时监控。但它不支持对请求进行自定义粒度的控制。