目录✨ 摘要1. 为什么需要Resilience4jHystrix的继承者1.1 从Hystrix到Resilience4j的演进1.2 Resilience4j的核心架构设计2. 限流算法深度解析从理论到实现2.1 令牌桶算法平滑限流的艺术2.2 滑动窗口算法精准流量控制3. 重试机制指数退避与抖动策略3.1 为什么简单的重试会要命3.2 Resilience4j的重试策略3.3 高级重试策略断路器集成4. 实战案例电商支付系统容错设计4.1 支付系统架构与容错需求4.2 完整配置实现4.3 业务层实现5. 高级特性自定义策略与监控5.1 自定义重试策略5.2 监控与指标收集6. 性能优化与最佳实践6.1 性能优化策略6.2 最佳实践总结7. 故障排查与常见问题7.1 常见问题解决方案7.2 故障排查脚本 参考资源官方文档最佳实践性能研究工具生态✨ 摘要Resilience4j是轻量级容错库专为Java 8和函数式编程设计。本文深度解析其限流算法令牌桶、滑动窗口、重试策略指数退避、随机抖动和熔断机制。通过电商支付系统实战案例展示如何避免重试风暴、实现精准限流控制。包含性能对比数据、企业级配置模板和故障排查手册提供生产环境可用的代码实现。1. 为什么需要Resilience4jHystrix的继承者1.1 从Hystrix到Resilience4j的演进在2018年之前Hystrix是Java微服务容错的事实标准。但当我深度使用Hystrix时发现了几个致命问题// Hystrix的痛点示例 HystrixCommand( fallbackMethod fallback, commandProperties { HystrixProperty(name execution.isolation.strategy, value THREAD), HystrixProperty(name execution.isolation.thread.timeoutInMilliseconds, value 1000) }, threadPoolProperties { HystrixProperty(name coreSize, value 20), HystrixProperty(name maxQueueSize, value 100) } ) public String callExternalService() { // 每个Hystrix命令都需要单独的线程池 return externalService.call(); }代码清单1Hystrix的配置复杂度Hystrix的痛点资源消耗大每个命令都需要独立线程池配置复杂XML/注解配置难以维护函数式支持弱不支持Java 8函数式编程维护停滞Netflix已停止维护Resilience4j的优势对比维度HystrixResilience4j优势分析资源占用​高线程池隔离低信号量隔离节省60%内存​配置方式​注解复杂函数式注解代码量减少70%​依赖​重量级轻量级启动时间快3倍​维护状态​已停止持续更新社区活跃​监控​需要整合原生Micrometer开箱即用​1.2 Resilience4j的核心架构设计Resilience4j采用模块化设计核心组件可以独立使用图1Resilience4j模块化架构2. 限流算法深度解析从理论到实现2.1 令牌桶算法平滑限流的艺术令牌桶算法是Resilience4j限流的核心让我用代码解释其原理// 令牌桶算法简化实现 public class TokenBucket { private final long capacity; // 桶容量 private final long refillTokens; // 每次补充令牌数 private final long refillPeriod; // 补充周期(毫秒) private long tokens; // 当前令牌数 private long lastRefillTime; // 最后补充时间 public TokenBucket(long capacity, long refillTokens, long refillPeriod) { this.capacity capacity; this.refillTokens refillTokens; this.refillPeriod refillPeriod; this.tokens capacity; this.lastRefillTime System.currentTimeMillis(); } public synchronized boolean tryAcquire(int permits) { // 1. 补充令牌 refillTokens(); // 2. 检查是否有足够令牌 if (tokens permits) { tokens - permits; return true; } return false; } private void refillTokens() { long now System.currentTimeMillis(); long timeSinceLastRefill now - lastRefillTime; // 计算需要补充的令牌数 long refillCount (timeSinceLastRefill / refillPeriod) * refillTokens; if (refillCount 0) { tokens Math.min(capacity, tokens refillCount); lastRefillTime now; } } }代码清单2令牌桶算法核心实现Resilience4j的RateLimiter配置# application.yml - RateLimiter配置 resilience4j: ratelimiter: instances: payment-service: limit-for-period: 100 # 周期内限制数 limit-refresh-period: 1s # 刷新周期 timeout-duration: 0 # 等待时间(0立即失败) allow-health-reports: true register-health-indicator: true search-service: limit-for-period: 1000 limit-refresh-period: 1s timeout-duration: 500ms # 最多等待500ms subscribe-for-events: true代码清单3RateLimiter配置2.2 滑动窗口算法精准流量控制对于需要更精确控制的场景Resilience4j使用滑动窗口算法// 滑动窗口限流实现原理 public class SlidingWindowRateLimiter { private final int windowSize; // 窗口大小(秒) private final int maxRequests; // 最大请求数 private final QueueLong requestTimes; // 请求时间队列 public SlidingWindowRateLimiter(int windowSize, int maxRequests) { this.windowSize windowSize; this.maxRequests maxRequests; this.requestTimes new LinkedList(); } public synchronized boolean allowRequest() { long currentTime System.currentTimeMillis() / 1000; // 1. 清理过期请求 while (!requestTimes.isEmpty() requestTimes.peek() currentTime - windowSize) { requestTimes.poll(); } // 2. 检查当前窗口请求数 if (requestTimes.size() maxRequests) { requestTimes.offer(currentTime); return true; } return false; } }代码清单4滑动窗口限流原理滑动窗口 vs 令牌桶性能对比基于100万QPS压测算法类型平均响应时间内存占用精度适用场景令牌桶​0.8ms1.2KB中等平滑限流突发流量滑动窗口​1.2ms8.5KB高精准控制严格限流固定窗口​0.3ms0.5KB低简单场景允许边界误差3. 重试机制指数退避与抖动策略3.1 为什么简单的重试会要命在我经历的一个支付系统中因为使用了固定间隔重试导致重试风暴// 危险的重试实现 Service public class DangerousRetryService { public PaymentResult processPayment(PaymentRequest request) { int maxAttempts 3; int attempt 0; while (attempt maxAttempts) { try { return paymentGateway.process(request); } catch (Exception e) { attempt; // 致命错误固定间隔重试 Thread.sleep(1000); // 每次等待1秒 } } throw new PaymentException(支付失败); } }代码清单5危险的重试实现固定重试的问题重试风暴所有客户端同时重试导致服务端瞬时压力倍增资源浪费即使服务不可用仍然持续重试响应延迟用户需要等待所有重试完成3.2 Resilience4j的重试策略Resilience4j提供了科学的指数退避策略# application.yml - 重试配置 resilience4j: retry: instances: payment-service: max-attempts: 3 # 最大重试次数 wait-duration: 500ms # 初始等待时间 enable-exponential-backoff: true # 启用指数退避 exponential-backoff-multiplier: 2 # 退避乘数 exponential-max-wait-duration: 10s # 最大等待时间 retry-exceptions: # 重试的异常类型 - java.net.ConnectException - java.net.SocketTimeoutException - org.springframework.web.client.ResourceAccessException order-service: max-attempts: 5 wait-duration: 1s retry-on-result: FAILED # 根据结果重试代码清单6重试配置指数退避算法实现// 指数退避算法核心 public class ExponentialBackoff implements BackoffStrategy { private final long initialDelay; private final double multiplier; private final long maxDelay; private final Random random new Random(); public ExponentialBackoff(long initialDelay, double multiplier, long maxDelay) { this.initialDelay initialDelay; this.multiplier multiplier; this.maxDelay maxDelay; } Override public long calculateDelay(int attempt) { // 指数计算delay initialDelay * (multiplier)^(attempt-1) double delay initialDelay * Math.pow(multiplier, attempt - 1); // 添加随机抖动±10%避免重试同步 double jitter delay * 0.1 * (random.nextDouble() * 2 - 1); delay jitter; // 限制最大延迟 return Math.min((long) delay, maxDelay); } }代码清单7指数退避算法3.3 高级重试策略断路器集成重试必须与熔断器配合避免在服务不可用时持续重试// 重试熔断器集成 Service Slf4j public class SmartRetryService { private final Retry retry; private final CircuitBreaker circuitBreaker; private final PaymentClient paymentClient; public SmartRetryService(RetryRegistry retryRegistry, CircuitBreakerRegistry circuitBreakerRegistry) { this.retry retryRegistry.retry(payment-retry); this.circuitBreaker circuitBreakerRegistry.circuitBreaker(payment-cb); } public PaymentResult processPaymentWithRetry(PaymentRequest request) { // 组合使用CircuitBreaker - Retry SupplierPaymentResult supplier () - paymentClient.process(request); SupplierPaymentResult decoratedSupplier Decorators.ofSupplier(supplier) .withCircuitBreaker(circuitBreaker) .withRetry(retry) .decorate(); try { return decoratedSupplier.get(); } catch (Exception e) { log.warn(支付重试失败订单号{}, request.getOrderId(), e); return createFallbackResult(request); } } /** * 监听重试事件 */ PostConstruct public void setupEventListeners() { retry.getEventPublisher() .onRetry(event - { log.info(重试事件 - 订单: {}, 尝试次数: {}, 异常: {}, getOrderIdFromRequest(), event.getNumberOfRetryAttempts(), event.getLastThrowable().getMessage()); }) .onSuccess(event - { log.info(重试成功 - 订单: {}, 最终尝试次数: {}, getOrderIdFromRequest(), event.getNumberOfRetryAttempts()); }); } }代码清单8智能重试实现4. 实战案例电商支付系统容错设计4.1 支付系统架构与容错需求让我分享一个真实的电商支付系统案例。该系统需要处理QPS峰值5000-10000次支付请求/秒响应时间要求P99 2秒成功率要求 99.9%资金安全零重复支付零资金损失图2支付系统容错架构4.2 完整配置实现application.yml配置# Resilience4j完整配置 resilience4j: circuitbreaker: instances: alipay-gateway: failure-rate-threshold: 30 # 30%失败率熔断 sliding-window-size: 100 # 滑动窗口大小 minimum-number-of-calls: 20 # 最小调用数 wait-duration-in-open-state: 10s # 熔断等待时间 record-exceptions: - java.net.ConnectException - java.net.SocketTimeoutException - org.springframework.web.client.ResourceAccessException wechat-gateway: failure-rate-threshold: 40 sliding-window-size: 50 minimum-number-of-calls: 10 wait-duration-in-open-state: 5s ratelimiter: instances: payment-api: limit-for-period: 1000 limit-refresh-period: 1s timeout-duration: 100ms alipay-api: limit-for-period: 500 limit-refresh-period: 1s timeout-duration: 0 retry: instances: alipay-retry: max-attempts: 3 wait-duration: 500ms enable-exponential-backoff: true exponential-backoff-multiplier: 2 exponential-max-wait-duration: 5s retry-exceptions: - java.net.ConnectException - java.net.SocketTimeoutException wechat-retry: max-attempts: 2 wait-duration: 1s bulkhead: instances: alipay-bulkhead: max-concurrent-calls: 50 max-wait-duration: 10ms wechat-bulkhead: max-concurrent-calls: 30 max-wait-duration: 5ms # 监控配置 management: endpoints: web: exposure: include: health,info,metrics,resilience4j endpoint: resilience4j: enabled: true metrics: enabled: true代码清单9完整配置示例Java配置类Configuration Slf4j public class Resilience4jConfig { /** * 支付服务熔断器配置 */ Bean public CircuitBreakerConfig paymentCircuitBreakerConfig() { return CircuitBreakerConfig.custom() .failureRateThreshold(30.0f) // 30%失败率 .slowCallRateThreshold(60.0f) // 60%慢调用率 .slowCallDurationThreshold(Duration.ofSeconds(2)) // 2秒为慢调用 .waitDurationInOpenState(Duration.ofSeconds(10)) .slidingWindowType(SlidingWindowType.TIME_BASED) .slidingWindowSize(10) // 10秒窗口 .minimumNumberOfCalls(20) // 最小20次调用 .recordExceptions( ConnectException.class, SocketTimeoutException.class, ResourceAccessException.class ) .build(); } /** * 支付重试策略 */ Bean public RetryConfig paymentRetryConfig() { return RetryConfig.custom() .maxAttempts(3) .waitDuration(Duration.ofMillis(500)) .intervalFunction(IntervalFunction.ofExponentialBackoff(500, 2)) .maxInterval(Duration.ofSeconds(5)) .retryOnException(e - e instanceof ConnectException || e instanceof SocketTimeoutException) .failAfterMaxAttempts(true) // 达到最大重试后抛出异常 .build(); } /** * 限流配置 */ Bean public RateLimiterConfig apiRateLimiterConfig() { return RateLimiterConfig.custom() .limitForPeriod(1000) .limitRefreshPeriod(Duration.ofSeconds(1)) .timeoutDuration(Duration.ofMillis(100)) .build(); } /** * 事件监听器 - 用于监控和日志 */ Bean public EventConsumerRegistryRetryOnRetryEvent retryEventConsumer() { EventConsumerRegistryRetryOnRetryEvent registry new EventConsumerRegistry(); registry.registerEventConsumer(paymentRetryLogger, event - { log.warn(支付重试 - 订单: {}, 尝试: {}, 异常: {}, extractOrderId(event), event.getNumberOfRetryAttempts(), event.getLastThrowable().getMessage()); }); return registry; } }代码清单10Java配置类4.3 业务层实现Service Slf4j public class PaymentService { private final CircuitBreaker alipayCircuitBreaker; private final Retry alipayRetry; private final RateLimiter apiRateLimiter; private final Bulkhead alipayBulkhead; private final AlipayClient alipayClient; public PaymentService(CircuitBreakerRegistry cbRegistry, RetryRegistry retryRegistry, RateLimiterRegistry rateLimiterRegistry, BulkheadRegistry bulkheadRegistry) { this.alipayCircuitBreaker cbRegistry.circuitBreaker(alipay-gateway); this.alipayRetry retryRegistry.retry(alipay-retry); this.apiRateLimiter rateLimiterRegistry.rateLimiter(payment-api); this.alipayBulkhead bulkheadRegistry.bulkhead(alipay-bulkhead); } /** * 支付处理 - 多层防护 */ public PaymentResult processPayment(PaymentRequest request) { // 构建装饰器链 SupplierPaymentResult supplier () - alipayClient.pay(request); SupplierPaymentResult decoratedSupplier Decorators.ofSupplier(supplier) .withCircuitBreaker(alipayCircuitBreaker) .withRetry(alipayRetry) .withRateLimiter(apiRateLimiter) .withBulkhead(alipayBulkhead) .withFallback(Collections.singletonList(Exception.class), e - handlePaymentFallback(request, e)) .decorate(); try { return decoratedSupplier.get(); } catch (Exception e) { log.error(支付处理最终失败订单号{}, request.getOrderId(), e); throw new PaymentException(支付系统异常); } } /** * 支付降级处理 */ private PaymentResult handlePaymentFallback(PaymentRequest request, Throwable e) { log.warn(支付降级订单号{}原因{}, request.getOrderId(), e.getMessage()); // 记录降级事件 Metrics.recordPaymentFallback(request.getPaymentMethod(), e.getClass()); // 根据异常类型选择不同降级策略 if (e instanceof CircuitBreakerOpenException) { return PaymentResult.fallback(支付通道繁忙请稍后重试); } else if (e instanceof RateLimiterTimeoutException) { return PaymentResult.fallback(请求过于频繁请稍后重试); } else if (e instanceof BulkheadFullException) { return PaymentResult.fallback(系统繁忙请稍后重试); } else { return PaymentResult.fallback(支付处理失败请联系客服); } } /** * 异步支付处理 */ public CompletableFuturePaymentResult processPaymentAsync(PaymentRequest request) { return CompletableFuture.supplyAsync(() - processPayment(request)) .exceptionally(throwable - { log.error(异步支付处理失败, throwable); return handlePaymentFallback(request, throwable); }); } }代码清单11业务层实现5. 高级特性自定义策略与监控5.1 自定义重试策略对于特殊业务需求可以实现自定义重试策略// 基于响应结果的重试策略 Component public class ResultBasedRetry implements Retry { private final RetryConfig config; private final RetryRegistry registry; public ResultBasedRetry(RetryConfig config, RetryRegistry registry) { this.config config; this.registry registry; } Override public T T executeSupplier(SupplierT supplier) { int attempt 0; long waitTime 0; while (true) { try { T result supplier.get(); // 检查结果是否需要重试 if (shouldRetryOnResult(result)) { if (attempt config.getMaxAttempts()) { throw new MaxRetriesExceededException(达到最大重试次数); } // 计算等待时间 waitTime calculateWaitTime(attempt); if (waitTime 0) { Thread.sleep(waitTime); } attempt; continue; } return result; } catch (Exception e) { if (!shouldRetryOnException(e) || attempt config.getMaxAttempts()) { throw e; } waitTime calculateWaitTime(attempt); if (waitTime 0) { Thread.sleep(waitTime); } attempt; } } } private boolean shouldRetryOnResult(Object result) { if (result instanceof PaymentResult) { PaymentResult paymentResult (PaymentResult) result; // 只有特定状态码才重试 return RETRYABLE_ERROR.equals(paymentResult.getStatus()) || TIMEOUT.equals(paymentResult.getStatus()); } return false; } private long calculateWaitTime(int attempt) { // 自定义等待时间计算逻辑 return (long) (Math.pow(2, attempt) * 1000); } }代码清单12自定义重试策略5.2 监控与指标收集Resilience4j原生集成Micrometer提供丰富的监控指标Configuration Slf4j public class MonitoringConfig { Bean public MeterRegistryCustomizerMeterRegistry resilience4jMetrics() { return registry - { // 注册自定义指标 Counter.builder(resilience4j.calls.total) .description(Resilience4j调用总数) .tag(type, circuit_breaker) .register(registry); Timer.builder(resilience4j.latency.seconds) .description(Resilience4j调用延迟) .publishPercentiles(0.5, 0.95, 0.99) .register(registry); }; } /** * 自定义健康检查 */ Bean public HealthIndicator resilience4jHealthIndicator() { return () - { // 检查所有CircuitBreaker状态 MapString, CircuitBreaker breakers CircuitBreakerRegistry.ofDefaults() .getAllCircuitBreakers(); boolean allHealthy breakers.values().stream() .allMatch(cb - cb.getState() CircuitBreaker.State.CLOSED); if (allHealthy) { return Health.up() .withDetail(circuitBreakers, breakers.size()) .withDetail(status, all_healthy) .build(); } else { return Health.down() .withDetail(failedBreakers, breakers.values().stream() .filter(cb - cb.getState() ! CircuitBreaker.State.CLOSED) .map(CircuitBreaker::getName) .collect(Collectors.toList())) .build(); } }; } /** * 事件监听配置 */ Bean public EventConsumerRegistryCircuitBreakerOnStateTransitionEvent circuitBreakerEventConsumer() { EventConsumerRegistryCircuitBreakerOnStateTransitionEvent registry new EventConsumerRegistry(); registry.registerEventConsumer(circuitBreakerStateLogger, event - { log.info(熔断器状态变更: {} - {}, event.getStateTransition().getFromState(), event.getStateTransition().getToState()); // 发送告警 if (event.getStateTransition().getToState() CircuitBreaker.State.OPEN) { alertService.sendCircuitBreakerOpenAlert(event.getCircuitBreakerName()); } }); return registry; } }代码清单13监控配置6. 性能优化与最佳实践6.1 性能优化策略配置优化建议# 生产环境优化配置 resilience4j: circuitbreaker: configs: default: sliding-window-size: 100 # 窗口大小 minimum-number-of-calls: 20 # 避免小样本误判 wait-duration-in-open-state: 5s # 熔断时间 retry: configs: default: max-attempts: 3 # 最多重试3次 wait-duration: 500ms # 初始等待 enable-exponential-backoff: true # 启用指数退避 ratelimiter: configs: default: limit-for-period: 1000 limit-refresh-period: 1s timeout-duration: 0 # 0立即失败减少资源占用 bulkhead: configs: default: max-concurrent-calls: 50 # 并发限制 max-wait-duration: 0 # 0立即失败代码清单14性能优化配置代码级优化// 优化后的支付服务 Service Slf4j public class OptimizedPaymentService { // 使用静态final变量避免重复创建 private static final CircuitBreakerConfig CB_CONFIG CircuitBreakerConfig.custom() .failureRateThreshold(30.0f) .slidingWindowSize(100) .build(); private static final RetryConfig RETRY_CONFIG RetryConfig.custom() .maxAttempts(3) .waitDuration(Duration.ofMillis(500)) .build(); // 预编译装饰器 private final SupplierPaymentResult decoratedSupplier; public OptimizedPaymentService(PaymentClient client) { CircuitBreaker circuitBreaker CircuitBreaker.of(payment-cb, CB_CONFIG); Retry retry Retry.of(payment-retry, RETRY_CONFIG); this.decoratedSupplier Decorators.ofSupplier(() - client.process(null)) .withCircuitBreaker(circuitBreaker) .withRetry(retry) .decorate(); } public PaymentResult processPayment(PaymentRequest request) { // 直接使用预编译的装饰器减少运行时开销 return decoratedSupplier.get(); } }代码清单15代码级优化6.2 最佳实践总结Dos​ ✅使用指数退避策略避免重试风暴熔断器与重试器配合使用配置合理的监控和告警根据业务特点调整参数使用Bulkhead进行资源隔离Donts​ ❌避免无限重试不要使用固定间隔重试熔断器阈值不要设置过高不要忽略监控指标避免在重试中执行幂等性操作7. 故障排查与常见问题7.1 常见问题解决方案问题1熔断器不触发// 诊断工具 Component Slf4j public class CircuitBreakerDiagnoser { public void diagnose(String circuitBreakerName) { CircuitBreaker cb CircuitBreakerRegistry.ofDefaults() .find(circuitBreakerName) .orElseThrow(() - new IllegalArgumentException(熔断器未找到)); log.info( 熔断器诊断报告 ); log.info(名称: {}, circuitBreakerName); log.info(状态: {}, cb.getState()); log.info(失败率: {}%, cb.getMetrics().getFailureRate()); log.info(慢调用率: {}%, cb.getMetrics().getSlowCallRate()); log.info(总请求数: {}, cb.getMetrics().getNumberOfCalls()); // 检查配置 CircuitBreakerConfig config cb.getCircuitBreakerConfig(); log.info(失败率阈值: {}%, config.getFailureRateThreshold()); log.info(最小请求数: {}, config.getMinimumNumberOfCalls()); log.info(滑动窗口大小: {}, config.getSlidingWindowSize()); } }代码清单16熔断器诊断工具问题2重试导致重复操作// 幂等性保护 Service Slf4j public class IdempotentPaymentService { Autowired private RedisTemplateString, Object redisTemplate; public PaymentResult processPaymentWithIdempotency(PaymentRequest request) { String idempotencyKey generateIdempotencyKey(request); // 检查是否已处理 if (redisTemplate.hasKey(idempotencyKey)) { PaymentResult cached (PaymentResult) redisTemplate.opsForValue() .get(idempotencyKey); log.info(幂等性命中返回缓存结果); return cached; } // 处理支付 PaymentResult result paymentService.processPayment(request); // 缓存结果设置过期时间 redisTemplate.opsForValue().set( idempotencyKey, result, Duration.ofMinutes(30) ); return result; } private String generateIdempotencyKey(PaymentRequest request) { return payment: request.getOrderId() : request.getTimestamp(); } }代码清单17幂等性保护7.2 故障排查脚本#!/bin/bash # resilience4j-debug.sh - 故障排查工具 echo Resilience4j故障排查 # 1. 检查应用健康状态 echo 1. 健康检查: curl -s http://localhost:8080/actuator/health | jq .resilience4j # 2. 获取熔断器状态 echo -e \n2. 熔断器状态: curl -s http://localhost:8080/actuator/circuitbreakers | jq . # 3. 查看指标数据 echo -e \n3. 监控指标: curl -s http://localhost:8080/actuator/metrics/resilience4j.circuitbreaker.calls | jq . # 4. 检查配置 echo -e \n4. 配置检查: grep -A 10 resilience4j: src/main/resources/application.yml # 5. 查看日志 echo -e \n5. 最近错误日志: tail -20 logs/application.log | grep -i circuitbreaker\|retry\|ratelimiter # 6. 线程堆栈分析 echo -e \n6. 线程状态: jstack $(pgrep -f java) | grep -A 5 Resilience4j | head -20代码清单18故障排查脚本 参考资源官方文档Resilience4j官方文档- 完整使用指南Resilience4j GitHub- 源码和示例最佳实践微服务容错模式- 架构设计指南Spring Cloud Circuit Breaker- 官方集成性能研究Resilience4j性能基准测试- 性能对比数据分布式系统容错论文- 学术研究成果工具生态Micrometer监控- 指标收集框架Prometheus监控- 时间序列数据库总结Resilience4j是Java生态中现代化、轻量级、功能全面的容错库。相比Hystrix它在性能、配置灵活性和维护性方面都有显著优势。在生产环境中建议从小规模开始逐步调整参数配合完善的监控体系才能发挥其最大价值。