internal class DefaultRemoteExecutor : IRemoteExecutor
{
    private readonly IRemoteCaller _remoteCaller;
    private readonly IInvokePolicyBuilder _invokePolicyBuilder;

    public async Task<object> Execute(ServiceEntry serviceEntry, object[] parameters, string serviceKey = null)
    {
        // 1. 构建 RPC 调用消息
        var remoteInvokeMessage = new RemoteInvokeMessage()
        {
            ServiceEntryId = serviceEntry.ServiceEntryDescriptor.Id,
            ServiceId = serviceEntry.ServiceId,
            Parameters = _fileParameterConverter.Convert(parameters),
            ParameterType = ParameterType.Rpc,
        };

        // 2. 一致性哈希路由时确定 hashKey
        string hashKey = null;
        if (serviceEntry.GovernanceOptions.ShuntStrategy == ShuntStrategy.HashAlgorithm)
        {
            hashKey = GetHashKeyValue();
        }

        // 3. 构建 Polly 治理策略
        var policy = _invokePolicyBuilder.Build(serviceEntry.Id, parameters);

        // 4. 在策略保护下执行远程调用
        var result = await policy.ExecuteAsync(async () =>
            await _remoteCaller.InvokeAsync(remoteInvokeMessage,
                serviceEntry.GovernanceOptions.ShuntStrategy, hashKey));

        return result;
    }
}

IAsyncPolicy<object?> policy = Policy.NoOpAsync<object?>();

// Layer 1: 结果策略（如超时）
foreach (var p in _policyWithResultProviders)
    policy = policy.WrapAsync(p.Create(serviceEntryId));

// Layer 2: 普通策略（如重试）
foreach (var p in _policyProviders)
    policy = policy.WrapAsync(p.Create(serviceEntryId));

// Layer 3: 熔断策略
foreach (var p in _circuitBreakerPolicyProviders)
    policy = policy.WrapAsync(p.Create(serviceEntryId));

// Layer 4（运行时注入）: Fallback 策略（含业务 Fallback 方法）
foreach (var p in _invokeFallbackPolicyProviders)
    policy = policy.WrapAsync(p.Create(serviceEntryId, parameters));

public async Task<object?> InvokeAsync(RemoteInvokeMessage remoteInvokeMessage,
    ShuntStrategy shuntStrategy, string? hashKey = null)
{
    // 1. 从 ServerManager 中查找目标服务所有健康的 RPC 端点
    var rpcEndpoints = FindRpcEndpoint(remoteInvokeMessage);

    // 2. 按负载均衡策略选定一个端点
    var selectedRpcEndpoint = SelectedRpcEndpoint(
        rpcEndpoints, shuntStrategy, remoteInvokeMessage.ServiceEntryId, hashKey,
        out var confirmedShuntStrategy);

    // 3. 将选定端点信息写入 RpcContext（用于链路追踪和日志）
    RpcContext.Context.SetRcpInvokeAddressInfo(selectedRpcEndpoint.Descriptor);

    // 4. 监控埋点（如果启用了 Monitor）
    tracingTimestamp = _clientInvokeDiagnosticListener.TracingBefore(remoteInvokeMessage, messageId);
    clientInvokeInfo = invokeMonitor?.Monitor((remoteInvokeMessage.ServiceEntryId, selectedRpcEndpoint));

    // 5. 获取（或复用）DotNetty TransportClient
    var client = await _transportClientFactory.GetClient(selectedRpcEndpoint);

    // 6. 构建 RemoteInvoker（含客户端过滤器链）并执行
    remoteInvoker = _clientRemoteInvokerFactory.CreateInvoker(
        new ClientInvokeContext(remoteInvokeMessage, confirmedShuntStrategy, hashKey),
        client, messageId);
    await remoteInvoker.InvokeAsync();
}

private IReadOnlyCollection<ISilkyEndpoint> FindRpcEndpoint(RemoteInvokeMessage message)
{
    // 从 ServerManager 获取目标服务的所有在线实例端点
    var serviceDescriptor = _serverManager.GetServiceDescriptor(message.ServiceId);
    var rpcEndpoints = _serverManager.GetRpcEndpoints(serviceDescriptor,
        ServiceProtocol.Rpc);
    
    if (!rpcEndpoints.Any())
        throw new NotFindServiceEndPointException($"No available endpoint for {message.ServiceEntryId}");
    
    return rpcEndpoints;
}

private ISilkyEndpoint SelectedRpcEndpoint(
    IReadOnlyCollection<ISilkyEndpoint> endpoints,
    ShuntStrategy shuntStrategy,
    string serviceEntryId,
    string? hashKey,
    out ShuntStrategy confirmedShuntStrategy)
{
    var selector = _endpointSelectors[shuntStrategy]; // 按分流策略获取选择器
    return selector.Select(new RpcEndpointSelectContext(endpoints, serviceEntryId, hashKey),
        out confirmedShuntStrategy);
}

// ITransportClientFactory 维护按端点地址的连接池
var client = await _transportClientFactory.GetClient(selectedRpcEndpoint);

// 在服务接口上标注 HashShuntStrategy，指定哈希 key 的来源参数
[ServiceRoute]
public interface IOrderAppService
{
    [HashShuntStrategy("userId")]  // 以 userId 参数作为哈希 key
    Task<OrderDto> GetByUserIdAsync(long userId);
}

// 全局注册客户端过滤器
services.AddClientFilter<MyClientFilter>();

// 或在接口方法上标注（方法级）
[MyClientFilter]
Task<OrderDto> GetByIdAsync(long id);

public async Task<RemoteResultMessage> SendAndReceiveAsync(
    TransportMessage message, int timeoutMillSeconds)
{
    // 1. 注册响应等待（以 message.Id 为 key）
    var tcs = new TaskCompletionSource<TransportMessage>();
    m_resultDictionary[message.Id] = tcs;

    // 2. 检查提前到达缓冲区（处理响应先于请求注册的极端情况）
    if (_earlyMessageBuffer.TryRemove(message.Id, out var early))
    {
        tcs.TrySetResult(early.Message);
    }
    else
    {
        // 3. 通过 DotNetty Channel 发送消息
        await MessageSender.SendMessageAsync(message);
    }

    // 4. 带超时等待响应
    using var cts = new CancellationTokenSource(timeoutMillSeconds);
    cts.Token.Register(() => tcs.TrySetCanceled());
    var response = await tcs.Task;

    // 5. 解析为 RemoteResultMessage
    return response.GetContent<RemoteResultMessage>();
}