第259集接口响应慢，使用Arthas，3秒定位问题架构实战：Arthas接口诊断、性能分析与企业级响应优化设计

/**
 * 慢接口示例
 */
@RestController
@RequestMapping("/api/users")
public class UserController {

    @Autowired
    private UserService userService;

    @Autowired
    private OrderService orderService;

    @Autowired
    private ProductService productService;

    /**
     * 慢接口：获取用户详细信息
     */
    @GetMapping("/{id}/detail")
    public ResponseEntity<UserDetailVO> getUserDetail(@PathVariable Long id) {
        try {
            // 1. 获取用户基本信息（慢）
            User user = userService.getUserById(id);
            if (user == null) {
                return ResponseEntity.notFound().build();
            }

            // 2. 获取用户订单信息（慢）
            List<Order> orders = orderService.getOrdersByUserId(id);

            // 3. 获取用户产品信息（慢）
            List<Product> products = productService.getProductsByUserId(id);

            // 4. 组装返回数据
            UserDetailVO userDetail = new UserDetailVO();
            userDetail.setUser(user);
            userDetail.setOrders(orders);
            userDetail.setProducts(products);

            return ResponseEntity.ok(userDetail);

        } catch (Exception e) {
            log.error("获取用户详细信息失败", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }

    /**
     * 慢接口：批量获取用户信息
     */
    @PostMapping("/batch")
    public ResponseEntity<List<UserVO>> getBatchUsers(@RequestBody List<Long> userIds) {
        List<UserVO> users = new ArrayList<>();

        // 串行处理，导致响应慢
        for (Long userId : userIds) {
            User user = userService.getUserById(userId);
            if (user != null) {
                users.add(convertToVO(user));
            }
        }

        return ResponseEntity.ok(users);
    }

    /**
     * 慢接口：复杂查询
     */
    @GetMapping("/search")
    public ResponseEntity<PageResult<UserVO>> searchUsers(
            @RequestParam String keyword,
            @RequestParam(defaultValue = "0") int page,
            @RequestParam(defaultValue = "20") int size) {

        // 复杂的数据库查询
        PageResult<User> result = userService.searchUsers(keyword, page, size);

        // 数据转换
        List<UserVO> userVOs = result.getData().stream()
                .map(this::convertToVO)
                .collect(Collectors.toList());

        PageResult<UserVO> pageResult = new PageResult<>();
        pageResult.setData(userVOs);
        pageResult.setTotal(result.getTotal());
        pageResult.setPage(result.getPage());
        pageResult.setSize(result.getSize());

        return ResponseEntity.ok(pageResult);
    }

    private UserVO convertToVO(User user) {
        UserVO userVO = new UserVO();
        userVO.setId(user.getId());
        userVO.setName(user.getName());
        userVO.setEmail(user.getEmail());
        userVO.setCreateTime(user.getCreateTime());
        return userVO;
    }
}

/**
 * 数据库查询瓶颈示例
 */
@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    @Autowired
    private OrderMapper orderMapper;

    @Autowired
    private ProductMapper productMapper;

    /**
     * 慢查询：N+1问题
     */
    public List<UserVO> getUsersWithOrders() {
        // 1. 查询所有用户
        List<User> users = userMapper.findAll();

        // 2. 为每个用户查询订单（N+1问题）
        List<UserVO> userVOs = new ArrayList<>();
        for (User user : users) {
            UserVO userVO = convertToVO(user);
            List<Order> orders = orderMapper.findByUserId(user.getId());
            userVO.setOrders(orders);
            userVOs.add(userVO);
        }

        return userVOs;
    }

    /**
     * 慢查询：复杂关联查询
     */
    public List<UserVO> getUsersWithComplexQuery() {
        // 复杂的多表关联查询
        return userMapper.findUsersWithComplexQuery();
    }

    /**
     * 慢查询：缺少索引
     */
    public List<User> searchUsers(String keyword) {
        // 模糊查询，可能缺少索引
        return userMapper.findByNameLike("%" + keyword + "%");
    }

    /**
     * 慢查询：大数据量查询
     */
    public List<User> getAllUsers() {
        // 查询所有用户，数据量过大
        return userMapper.findAll();
    }
}

/**
 * 缓存问题示例
 */
@Service
public class ProductService {

    @Autowired
    private ProductMapper productMapper;

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 缓存失效问题
     */
    @Cacheable(value = "products", key = "#id")
    public Product getProductById(Long id) {
        // 缓存失效，每次都查询数据库
        return productMapper.findById(id);
    }

    /**
     * 缓存穿透问题
     */
    public Product getProductByIdWithCache(Long id) {
        String cacheKey = "product:" + id;
        Product product = (Product) redisTemplate.opsForValue().get(cacheKey);

        if (product == null) {
            // 缓存穿透，查询不存在的商品
            product = productMapper.findById(id);
            if (product != null) {
                redisTemplate.opsForValue().set(cacheKey, product, 3600, TimeUnit.SECONDS);
            }
        }

        return product;
    }

    /**
     * 缓存雪崩问题
     */
    public List<Product> getHotProducts() {
        String cacheKey = "hot:products";
        List<Product> products = (List<Product>) redisTemplate.opsForValue().get(cacheKey);

        if (products == null) {
            // 缓存雪崩，大量请求同时查询数据库
            products = productMapper.findHotProducts();
            redisTemplate.opsForValue().set(cacheKey, products, 3600, TimeUnit.SECONDS);
        }

        return products;
    }
}

/**
 * 数据库查询优化
 */
@Service
public class OptimizedUserService {

    @Autowired
    private UserMapper userMapper;

    /**
     * 优化1：使用批量查询
     */
    public List<UserVO> getUsersWithOrdersOptimized() {
        // 1. 查询所有用户
        List<User> users = userMapper.findAll();

        // 2. 批量查询订单
        List<Long> userIds = users.stream()
                .map(User::getId)
                .collect(Collectors.toList());
        Map<Long, List<Order>> ordersMap = orderMapper.findByUserIds(userIds);

        // 3. 组装数据
        return users.stream()
                .map(user -> {
                    UserVO userVO = convertToVO(user);
                    userVO.setOrders(ordersMap.get(user.getId()));
                    return userVO;
                })
                .collect(Collectors.toList());
    }

    /**
     * 优化2：使用分页查询
     */
    public PageResult<User> getUsersWithPagination(int page, int size) {
        // 使用分页查询，避免一次性查询大量数据
        PageHelper.startPage(page, size);
        List<User> users = userMapper.findAll();
        PageInfo<User> pageInfo = new PageInfo<>(users);

        PageResult<User> result = new PageResult<>();
        result.setData(users);
        result.setTotal(pageInfo.getTotal());
        result.setPage(page);
        result.setSize(size);

        return result;
    }

    /**
     * 优化3：使用索引优化查询
     */
    public List<User> searchUsersOptimized(String keyword) {
        // 使用索引优化的查询
        return userMapper.findByNameWithIndex(keyword);
    }

    /**
     * 优化4：使用缓存
     */
    @Cacheable(value = "users", key = "#id")
    public User getUserByIdCached(Long id) {
        return userMapper.findById(id);
    }
}

/**
 * 多级缓存优化
 */
@Service
public class MultiLevelCacheService {

    @Autowired
    private UserMapper userMapper;

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Autowired
    private CaffeineCache localCache;

    /**
     * 多级缓存：本地缓存 + Redis缓存 + 数据库
     */
    public User getUserWithMultiLevelCache(Long id) {
        // 1. 本地缓存
        User user = localCache.getIfPresent("user:" + id);
        if (user != null) {
            return user;
        }

        // 2. Redis缓存
        String redisKey = "user:" + id;
        user = (User) redisTemplate.opsForValue().get(redisKey);
        if (user != null) {
            localCache.put("user:" + id, user);
            return user;
        }

        // 3. 数据库查询
        user = userMapper.findById(id);
        if (user != null) {
            // 写入缓存
            redisTemplate.opsForValue().set(redisKey, user, 3600, TimeUnit.SECONDS);
            localCache.put("user:" + id, user);
        }

        return user;
    }

    /**
     * 缓存预热
     */
    @PostConstruct
    public void warmUpCache() {
        // 预热热点数据
        List<Long> hotUserIds = getHotUserIds();
        hotUserIds.parallelStream().forEach(id -> {
            User user = userMapper.findById(id);
            if (user != null) {
                String redisKey = "user:" + id;
                redisTemplate.opsForValue().set(redisKey, user, 3600, TimeUnit.SECONDS);
                localCache.put("user:" + id, user);
            }
        });
    }

    /**
     * 缓存更新策略
     */
    @CacheEvict(value = "users", key = "#user.id")
    public void updateUser(User user) {
        userMapper.updateById(user);

        // 异步更新缓存
        CompletableFuture.runAsync(() -> {
            String redisKey = "user:" + user.getId();
            redisTemplate.opsForValue().set(redisKey, user, 3600, TimeUnit.SECONDS);
            localCache.put("user:" + user.getId(), user);
        });
    }
}

/**
 * 缓存配置优化
 */
@Configuration
@EnableCaching
public class CacheConfig {

    /**
     * Redis缓存配置
     */
    @Bean
    public RedisCacheManager redisCacheManager(RedisConnectionFactory connectionFactory) {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofMinutes(30))
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));

        return RedisCacheManager.builder(connectionFactory)
                .cacheDefaults(config)
                .build();
    }

    /**
     * 本地缓存配置
     */
    @Bean
    public CaffeineCacheManager caffeineCacheManager() {
        CaffeineCacheManager cacheManager = new CaffeineCacheManager();
        cacheManager.setCaffeine(Caffeine.newBuilder()
                .maximumSize(1000)
                .expireAfterWrite(10, TimeUnit.MINUTES)
                .expireAfterAccess(5, TimeUnit.MINUTES)
                .recordStats());
        return cacheManager;
    }
}

/**
 * 异步处理优化
 */
@Service
public class AsyncOptimizedService {

    @Autowired
    private UserService userService;

    @Autowired
    private OrderService orderService;

    @Autowired
    private ProductService productService;

    /**
     * 异步处理：并行获取数据
     */
    public CompletableFuture<UserDetailVO> getUserDetailAsync(Long id) {
        // 并行获取数据
        CompletableFuture<User> userFuture = CompletableFuture.supplyAsync(() -> 
            userService.getUserById(id));

        CompletableFuture<List<Order>> ordersFuture = CompletableFuture.supplyAsync(() -> 
            orderService.getOrdersByUserId(id));

        CompletableFuture<List<Product>> productsFuture = CompletableFuture.supplyAsync(() -> 
            productService.getProductsByUserId(id));

        // 等待所有任务完成
        return CompletableFuture.allOf(userFuture, ordersFuture, productsFuture)
                .thenApply(v -> {
                    UserDetailVO userDetail = new UserDetailVO();
                    userDetail.setUser(userFuture.join());
                    userDetail.setOrders(ordersFuture.join());
                    userDetail.setProducts(productsFuture.join());
                    return userDetail;
                });
    }

    /**
     * 异步处理：批量操作
     */
    public CompletableFuture<List<UserVO>> getBatchUsersAsync(List<Long> userIds) {
        // 并行处理批量请求
        List<CompletableFuture<UserVO>> futures = userIds.stream()
                .map(userId -> CompletableFuture.supplyAsync(() -> {
                    User user = userService.getUserById(userId);
                    return user != null ? convertToVO(user) : null;
                }))
                .collect(Collectors.toList());

        // 等待所有任务完成
        return CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))
                .thenApply(v -> futures.stream()
                        .map(CompletableFuture::join)
                        .filter(Objects::nonNull)
                        .collect(Collectors.toList()));
    }

    /**
     * 异步处理：缓存更新
     */
    @Async
    public void updateCacheAsync(Long userId) {
        // 异步更新缓存
        User user = userService.getUserById(userId);
        if (user != null) {
            // 更新缓存
            updateUserCache(user);
        }
    }

    private UserVO convertToVO(User user) {
        UserVO userVO = new UserVO();
        userVO.setId(user.getId());
        userVO.setName(user.getName());
        userVO.setEmail(user.getEmail());
        userVO.setCreateTime(user.getCreateTime());
        return userVO;
    }
}

/**
 * 异步配置
 */
@Configuration
@EnableAsync
public class AsyncConfig implements AsyncConfigurer {

    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(10);
        executor.setMaxPoolSize(50);
        executor.setQueueCapacity(200);
        executor.setThreadNamePrefix("Async-");
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.initialize();
        return executor;
    }

    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return new SimpleAsyncUncaughtExceptionHandler();
    }
}

/**
 * 接口监控指标收集
 */
@Component
public class InterfaceMetricsCollector {

    @Autowired
    private MeterRegistry meterRegistry;

    /**
     * 收集接口性能指标
     */
    @EventListener
    public void collectInterfaceMetrics(InterfaceCallEvent event) {
        // 响应时间指标
        Timer.Sample sample = Timer.start(meterRegistry);
        sample.stop(Timer.builder("interface.response.time")
                .description("接口响应时间")
                .tag("interface", event.getInterfaceName())
                .tag("method", event.getMethod())
                .tag("status", String.valueOf(event.getStatus()))
                .register(meterRegistry));

        // 调用次数指标
        Counter.builder("interface.call.count")
                .description("接口调用次数")
                .tag("interface", event.getInterfaceName())
                .tag("method", event.getMethod())
                .tag("status", String.valueOf(event.getStatus()))
                .register(meterRegistry)
                .increment();

        // 错误率指标
        if (event.getStatus() >= 400) {
            Counter.builder("interface.error.count")
                    .description("接口错误次数")
                    .tag("interface", event.getInterfaceName())
                    .tag("method", event.getMethod())
                    .tag("status", String.valueOf(event.getStatus()))
                    .register(meterRegistry)
                    .increment();
        }
    }
}

/**
 * 全链路接口监控
 */
@Component
public class FullLinkInterfaceMonitor {

    @Autowired
    private MeterRegistry meterRegistry;

    /**
     * 接口调用监控
     */
    @EventListener
    public void monitorInterfaceCall(InterfaceCallEvent event) {
        // 记录接口调用链路
        recordInterfaceCallChain(event);

        // 记录接口性能指标
        recordInterfaceMetrics(event);

        // 记录接口错误信息
        if (event.getStatus() >= 400) {
            recordInterfaceError(event);
        }
    }

    /**
     * 记录接口调用链路
     */
    private void recordInterfaceCallChain(InterfaceCallEvent event) {
        // 记录调用链路信息
        CallChainInfo callChain = new CallChainInfo();
        callChain.setTraceId(event.getTraceId());
        callChain.setSpanId(event.getSpanId());
        callChain.setParentSpanId(event.getParentSpanId());
        callChain.setInterfaceName(event.getInterfaceName());
        callChain.setMethod(event.getMethod());
        callChain.setStartTime(event.getStartTime());
        callChain.setEndTime(event.getEndTime());
        callChain.setDuration(event.getDuration());

        // 保存调用链路信息
        saveCallChainInfo(callChain);
    }

    /**
     * 记录接口性能指标
     */
    private void recordInterfaceMetrics(InterfaceCallEvent event) {
        // 响应时间指标
        Timer.Sample sample = Timer.start(meterRegistry);
        sample.stop(Timer.builder("interface.response.time")
                .description("接口响应时间")
                .tag("interface", event.getInterfaceName())
                .tag("method", event.getMethod())
                .tag("status", String.valueOf(event.getStatus()))
                .register(meterRegistry));

        // 吞吐量指标
        Counter.builder("interface.throughput")
                .description("接口吞吐量")
                .tag("interface", event.getInterfaceName())
                .tag("method", event.getMethod())
                .register(meterRegistry)
                .increment();
    }
}

/**
 * 接口性能基线
 */
@Service
public class InterfacePerformanceBaseline {

    @Autowired
    private InterfaceMetricsRepository metricsRepository;

    /**
     * 建立接口性能基线
     */
    public void establishBaseline() {
        // 获取历史性能数据
        List<InterfaceMetrics> historicalData = metricsRepository.findHistoricalData(30); // 30天

        // 计算性能基线
        for (InterfaceMetrics metrics : historicalData) {
            PerformanceBaseline baseline = calculateBaseline(metrics);
            saveBaseline(baseline);
        }
    }

    /**
     * 计算性能基线
     */
    private PerformanceBaseline calculateBaseline(InterfaceMetrics metrics) {
        PerformanceBaseline baseline = new PerformanceBaseline();

        // 计算平均响应时间
        double avgResponseTime = metrics.getResponseTimes().stream()
                .mapToDouble(Double::doubleValue)
                .average()
                .orElse(0.0);
        baseline.setAvgResponseTime(avgResponseTime);

        // 计算P95响应时间
        List<Double> sortedResponseTimes = metrics.getResponseTimes().stream()
                .sorted()
                .collect(Collectors.toList());
        int p95Index = (int) (sortedResponseTimes.size() * 0.95);
        baseline.setP95ResponseTime(sortedResponseTimes.get(p95Index));

        // 计算P99响应时间
        int p99Index = (int) (sortedResponseTimes.size() * 0.99);
        baseline.setP99ResponseTime(sortedResponseTimes.get(p99Index));

        // 计算平均吞吐量
        double avgThroughput = metrics.getThroughputs().stream()
                .mapToDouble(Double::doubleValue)
                .average()
                .orElse(0.0);
        baseline.setAvgThroughput(avgThroughput);

        // 计算错误率
        double errorRate = (double) metrics.getErrorCount() / metrics.getTotalCount() * 100;
        baseline.setErrorRate(errorRate);

        return baseline;
    }
}

/**
 * 接口分层优化策略
 */
@Service
public class LayeredInterfaceOptimization {

    /**
     * 控制器层优化
     */
    public void optimizeControllerLayer() {
        // 1. 参数验证优化
        optimizeParameterValidation();

        // 2. 响应格式优化
        optimizeResponseFormat();

        // 3. 异常处理优化
        optimizeExceptionHandling();

        // 4. 日志记录优化
        optimizeLogging();
    }

    /**
     * 服务层优化
     */
    public void optimizeServiceLayer() {
        // 1. 业务逻辑优化
        optimizeBusinessLogic();

        // 2. 数据转换优化
        optimizeDataTransformation();

        // 3. 缓存策略优化
        optimizeCacheStrategy();

        // 4. 异步处理优化
        optimizeAsyncProcessing();
    }

    /**
     * 数据访问层优化
     */
    public void optimizeDataAccessLayer() {
        // 1. 数据库查询优化
        optimizeDatabaseQueries();

        // 2. 连接池优化
        optimizeConnectionPool();

        // 3. 事务管理优化
        optimizeTransactionManagement();

        // 4. 缓存集成优化
        optimizeCacheIntegration();
    }
}

/**
 * 接口持续优化策略
 */
@Component
public class ContinuousInterfaceOptimization {

    @Autowired
    private InterfacePerformanceMonitor performanceMonitor;

    @Autowired
    private OptimizationRecommendationService recommendationService;

    /**
     * 持续接口优化
     */
    @Scheduled(fixedRate = 300000) // 5分钟执行一次
    public void continuousOptimization() {
        // 1. 收集接口性能数据
        InterfacePerformanceData data = performanceMonitor.collectPerformanceData();

        // 2. 分析性能趋势
        InterfacePerformanceTrend trend = analyzePerformanceTrend(data);

        // 3. 识别优化机会
        List<OptimizationOpportunity> opportunities = identifyOptimizationOpportunities(trend);

        // 4. 生成优化建议
        List<OptimizationRecommendation> recommendations = 
                recommendationService.generateRecommendations(opportunities);

        // 5. 执行自动优化
        executeAutomaticOptimizations(recommendations);

        // 6. 记录优化结果
        recordOptimizationResults(recommendations);
    }

    /**
     * 分析性能趋势
     */
    private InterfacePerformanceTrend analyzePerformanceTrend(InterfacePerformanceData data) {
        InterfacePerformanceTrend trend = new InterfacePerformanceTrend();

        // 分析响应时间趋势
        trend.setResponseTimeTrend(analyzeResponseTimeTrend(data.getResponseTimeData()));

        // 分析吞吐量趋势
        trend.setThroughputTrend(analyzeThroughputTrend(data.getThroughputData()));

        // 分析错误率趋势
        trend.setErrorRateTrend(analyzeErrorRateTrend(data.getErrorRateData()));

        return trend;
    }

    /**
     * 识别优化机会
     */
    private List<OptimizationOpportunity> identifyOptimizationOpportunities(InterfacePerformanceTrend trend) {
        List<OptimizationOpportunity> opportunities = new ArrayList<>();

        // 响应时间优化机会
        if (trend.getResponseTimeTrend().isIncreasing()) {
            opportunities.add(new OptimizationOpportunity(
                    OptimizationType.RESPONSE_TIME, 
                    "响应时间持续增加", 
                    OptimizationPriority.HIGH));
        }

        // 吞吐量优化机会
        if (trend.getThroughputTrend().isDecreasing()) {
            opportunities.add(new OptimizationOpportunity(
                    OptimizationType.THROUGHPUT, 
                    "吞吐量持续下降", 
                    OptimizationPriority.MEDIUM));
        }

        // 错误率优化机会
        if (trend.getErrorRateTrend().isIncreasing()) {
            opportunities.add(new OptimizationOpportunity(
                    OptimizationType.ERROR_RATE, 
                    "错误率持续增加", 
                    OptimizationPriority.HIGH));
        }

        return opportunities;
    }
}

/**
 * 接口压力测试
 */
@Component
public class InterfaceStressTest {

    @Autowired
    private RestTemplate restTemplate;

    /**
     * 接口压力测试
     */
    public StressTestResult stressTest(String interfaceUrl, int threadCount, int durationSeconds) {
        ExecutorService executor = Executors.newFixedThreadPool(threadCount);
        CountDownLatch latch = new CountDownLatch(threadCount);
        AtomicLong requestCount = new AtomicLong(0);
        AtomicLong errorCount = new AtomicLong(0);
        List<Long> responseTimes = Collections.synchronizedList(new ArrayList<>());

        long startTime = System.currentTimeMillis();

        for (int i = 0; i < threadCount; i++) {
            executor.submit(() -> {
                try {
                    while (System.currentTimeMillis() - startTime < durationSeconds * 1000) {
                        long requestStart = System.currentTimeMillis();

                        try {
                            ResponseEntity<String> response = restTemplate.getForEntity(interfaceUrl, String.class);

                            if (response.getStatusCode().is2xxSuccessful()) {
                                requestCount.incrementAndGet();
                            } else {
                                errorCount.incrementAndGet();
                            }
                        } catch (Exception e) {
                            errorCount.incrementAndGet();
                        }

                        long responseTime = System.currentTimeMillis() - requestStart;
                        responseTimes.add(responseTime);

                        // 控制请求频率
                        Thread.sleep(10);
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    latch.countDown();
                }
            });
        }

        try {
            latch.await();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        executor.shutdown();

        return buildStressTestResult(requestCount.get(), errorCount.get(), responseTimes);
    }

    /**
     * 构建压力测试结果
     */
    private StressTestResult buildStressTestResult(long requestCount, long errorCount, List<Long> responseTimes) {
        StressTestResult result = new StressTestResult();
        result.setTotalRequests(requestCount);
        result.setErrorCount(errorCount);
        result.setSuccessRate((double) (requestCount - errorCount) / requestCount * 100);

        if (!responseTimes.isEmpty()) {
            Collections.sort(responseTimes);
            result.setMinResponseTime(responseTimes.get(0));
            result.setMaxResponseTime(responseTimes.get(responseTimes.size() - 1));
            result.setAvgResponseTime(responseTimes.stream().mapToLong(Long::longValue).average().orElse(0));
            result.setP95ResponseTime(responseTimes.get((int) (responseTimes.size() * 0.95)));
            result.setP99ResponseTime(responseTimes.get((int) (responseTimes.size() * 0.99)));
        }

        return result;
    }
}

/**
 * 接口性能基准测试
 */
@Component
public class InterfaceBenchmarkTest {

    /**
     * 建立接口性能基准
     */
    public InterfaceBenchmark establishBenchmark() {
        InterfaceBenchmark benchmark = new InterfaceBenchmark();

        // 响应时间基准
        benchmark.setResponseTimeBaseline(measureResponseTimeBaseline());

        // 吞吐量基准
        benchmark.setThroughputBaseline(measureThroughputBaseline());

        // 并发性能基准
        benchmark.setConcurrencyBaseline(measureConcurrencyBaseline());

        // 资源使用基准
        benchmark.setResourceUsageBaseline(measureResourceUsageBaseline());

        return benchmark;
    }

    /**
     * 测量响应时间基准
     */
    private ResponseTimeBaseline measureResponseTimeBaseline() {
        ResponseTimeBaseline baseline = new ResponseTimeBaseline();

        // 测量不同负载下的响应时间
        for (int load = 10; load <= 100; load += 10) {
            long responseTime = measureResponseTimeUnderLoad(load);
            baseline.addResponseTime(load, responseTime);
        }

        return baseline;
    }

    /**
     * 测量吞吐量基准
     */
    private ThroughputBaseline measureThroughputBaseline() {
        ThroughputBaseline baseline = new ThroughputBaseline();

        // 测量不同并发下的吞吐量
        for (int concurrency = 10; concurrency <= 100; concurrency += 10) {
            double throughput = measureThroughputUnderConcurrency(concurrency);
            baseline.addThroughput(concurrency, throughput);
        }

        return baseline;
    }
}