后端稳定性｜容错四大金刚：超时（四）OpenFeign & gRPC 全链路超时、Deadline 统一治理实战

feign:
  okhttp:
    enabled: true
    connectTimeout: 4000
    readTimeout: 3000
    maxIdleConnections: 200
    keepAliveDuration: 30
    dispatcher:
      maxRequests: 500000
      maxRequestsPerHost: 50000
      fixedThreadPool: 100
  client:
    config:
      # 全局默认兜底配置，所有未单独定义FeignClient共享
      default:
        connectTimeout: 4000
        readTimeout: 3000
        executor:
          corePoolSize: 50
          maximumPoolSize: 200
          keepAliveTime: 30s

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;

// contextId 匹配配置中的 rpc-image-service
@FeignClient(value = "image-service", contextId = "rpc-image-service", configuration = FeignCommonConfig.class)
public interface ImageRemoteClient {
    // 无自定义方法参数，复用类级别超时
    @PostMapping("/file/query")
    FileResp queryFile(@RequestBody FileQueryReq);
}

feign:
  client:
    config:
      default:
        connectTimeout: 4000
        readTimeout: 3000
      # 对应 contextId="rpc-image-service" 接口类
      rpc-image-service:
        connectTimeout: 100
        readTimeout: 100
      # 订单业务RPC类示例
      rpc-order-service:
        connectTimeout: 1500
        readTimeout: 800

import feign.Request;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;

@FeignClient(value = "image-service", contextId = "rpc-image-service", configuration = FeignCommonConfig.class)
public interface ImageRemoteClient {
    // 普通接口：复用类级100ms超时
    @PostMapping("/file/query")
    FileResp queryFile(@RequestBody FileQueryReq);

    // 重载接口：新增Options，方法超时覆盖类配置
    @PostMapping("/file/upload")
    UploadResp uploadFile(@RequestBody UploadReq, Request.Options options);
}

import feign.Request;
import java.util.concurrent.TimeUnit;

// 大文件上传单独自定义超时，无视类级配置
public UploadResp uploadBizFile(UploadReq req) {
    Request.Options customOpt = new Request.Options(
            1, TimeUnit.SECONDS,
            500, TimeUnit.MILLISECONDS,
            true
    );
    return imageRemoteClient.uploadFile(req, customOpt);
}

if (delegate.connectTimeoutMillis() != options.connectTimeoutMillis()
        || delegate.readTimeoutMillis() != options.readTimeoutMillis()) {
    // 方法超时与当前客户端不一致，重建OkHttp覆盖参数
    requestScoped = delegate.newBuilder()
            .connectTimeout(options.connectTimeout(), TimeUnit.MILLISECONDS)
            .readTimeout(options.readTimeout(), TimeUnit.MILLISECONDS)
            .build();
}

import java.util.concurrent.TimeUnit;

// 只读查询接口，放宽截止时间
BatchQueryResp batchQuery(BatchQueryReq req) {
    return dataRpcServiceStub
            .withDeadlineAfter(2000, TimeUnit.MILLISECONDS)
            .batchQuery(req);
}

// 支付写入接口，收紧截止时间，避免长时间占用线程
ModifyPayResp modifyPay(ModifyReq req) {
    return dataRpcServiceStub
            .withDeadlineAfter(800, TimeUnit.MILLISECONDS)
            .modifyPay(req);
}

import io.grpc.Context;
import io.grpc.Deadline;
import io.grpc.stub.StreamObserver;

public void handleBatchQuery(BatchQueryReq req, StreamObserver<BatchQueryResp> observer) {
    Deadline deadline = Context.current().getDeadline();
    // 已过期直接返回，不再执行业务SQL
    if (deadline != null && deadline.isExpired()) {
        observer.onError(Status.DEADLINE_EXCEEDED.asRuntimeException());
        return;
    }
    // 未过期执行业务逻辑
}

// 发起重试前校验截止时间
if (callOptions.getDeadline() != null && callOptions.getDeadline().isExpired()) {
    log.warn("gRPC重试终止：截止时间已过期，方法={}", method.getFullMethodName());
    completed = true;
    responseListener.onClose(Status.DEADLINE_EXCEEDED, trailers);
    return;
}
// 异步退避调度前二次校验
RETRY_SCHEDULER.schedule(() -> {
    if (callOptions.getDeadline() != null && callOptions.getDeadline().isExpired()) {
        completed = true;
        responseListener.onClose(Status.DEADLINE_EXCEEDED, trailers);
        return;
    }
    attempt();
}, backoff, TimeUnit.MILLISECONDS);

import net.devh.boot.grpc.client.channels.GrpcChannelConfigurer;
import net.devh.boot.grpc.client.netty.NettyChannelBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class GrpcChannelAutoConfig {
    @Bean
    public GrpcChannelConfigurer channelConfigurer() {
        return (channelBuilder, name) -> {
            if (channelBuilder instanceof NettyChannelBuilder) {
                // 全局禁用底层原生重试，仅保留自研双条件重试
                ((NettyChannelBuilder) channelBuilder).disableRetry();
            }
        };
    }
}