TCP与UDP选择策略：微服务场景的协议决策指南

@RestController
public class UserController {
    @Autowired
    private RestTemplate restTemplate;  // 基于TCP的HTTP客户端

    @GetMapping("/users/{id}")
    public User getUser(@PathVariable Long id) {
        // 调用订单服务（HTTP over TCP）
        Order order = restTemplate.getForObject(
            "http://order-service/api/orders?userId=" + id,
            Order.class
        );
        // ...
    }
}

# Spring Boot配置
server:
  tomcat:
    max-connections: 10000  # TCP最大连接数
    accept-count: 200       # TCP全连接队列大小

# Feign配置
feign:
  httpclient:
    enabled: true  # 启用连接池
    max-connections: 200
    max-connections-per-route: 50

// gRPC服务定义
service UserService {
  rpc GetUser(GetUserRequest) returns (User);          // 一元RPC
  rpc ListUsers(Empty) returns (stream User);          // 服务器流
  rpc CreateUsers(stream User) returns (Summary);      // 客户端流
  rpc ChatUsers(stream Message) returns (stream Message);  // 双向流
}

// gRPC底层使用TCP + HTTP/2
// 一个TCP连接，支持多个并发请求（多路复用）

// gRPC连接池配置
ManagedChannel channel = ManagedChannelBuilder
    .forAddress("user-service", 9090)
    .usePlaintext()
    .maxInboundMessageSize(10 * 1024 * 1024)  // 最大接收10MB
    .keepAliveTime(30, TimeUnit.SECONDS)       // Keep-Alive 30秒
    .build();

// Dubbo服务提供者
@Service(protocol = "dubbo")  // 使用TCP协议
public class UserServiceImpl implements UserService {
    @Override
    public User getUser(Long id) {
        // ...
    }
}

// Dubbo消费者
@Reference  // 远程调用，底层使用TCP长连接
private UserService userService;

public void test() {
    User user = userService.getUser(123L);
}

<!-- Dubbo协议配置 -->
<dubbo:protocol name="dubbo" port="20880"
                threads="200"           # 线程池大小
                connections="10"        # 每个服务的TCP连接数
                payload="8388608" />    # 最大消息8MB

// Eureka客户端配置
eureka:
  client:
    register-with-eureka: true      # TCP注册
    fetch-registry: true            # TCP获取注册表
  instance:
    lease-renewal-interval-in-seconds: 30  # UDP心跳间隔30秒

# Consul支持TCP和UDP心跳
consul:
  host: localhost
  port: 8500
  discovery:
    heartbeat:
      enabled: true
      use-scheduler-health-indicator: false

# Fluentd配置（支持UDP和TCP）
<source>
  @type forward
  port 24224
  bind 0.0.0.0
  transport tcp    # 可靠传输：tcp，高性能：udp
</source>

# 应用程序发送日志
logger.info("User {} logged in", userId);
# 通过UDP发送到Fluentd

// Micrometer上报指标（UDP）
@Autowired
private MeterRegistry meterRegistry;

public void recordMetric() {
    Counter counter = meterRegistry.counter("api.requests", "endpoint", "/users");
    counter.increment();

    // 定期通过UDP发送到监控系统
}

<!-- 高性能内网调用 -->
<dubbo:protocol name="dubbo" port="20880" />

<!-- 跨语言调用 -->
<dubbo:protocol name="grpc" port="50051" />

<!-- 兼容老系统 -->
<dubbo:protocol name="hessian" port="8080" server="jetty" />

// gRPC客户端连接池
List<ManagedChannel> channels = new ArrayList<>();
for (int i = 0; i < 10; i++) {  // 创建10个连接
    ManagedChannel channel = ManagedChannelBuilder
        .forAddress("user-service", 9090)
        .usePlaintext()
        .build();
    channels.add(channel);
}

// 轮询使用连接（简单负载均衡）
int index = requestCount++ % channels.size();
UserServiceGrpc.UserServiceBlockingStub stub = UserServiceGrpc
    .newBlockingStub(channels.get(index));
User user = stub.getUser(request);

// Thrift服务器（使用TCP）
TServerSocket serverTransport = new TServerSocket(9090);
UserService.Processor<UserServiceImpl> processor =
    new UserService.Processor<>(new UserServiceImpl());

TThreadPoolServer server = new TThreadPoolServer(
    new TThreadPoolServer.Args(serverTransport)
        .processor(processor)
);

server.serve();

// HttpClient连接池配置
PoolingHttpClientConnectionManager connectionManager =
    new PoolingHttpClientConnectionManager();
connectionManager.setMaxTotal(200);  // 最大连接数
connectionManager.setDefaultMaxPerRoute(20);  // 每个路由最大连接数

HttpClient httpClient = HttpClients.custom()
    .setConnectionManager(connectionManager)
    .setKeepAliveStrategy((response, context) -> 30000)  // 30秒
    .build();

# gRPC客户端配置
grpc:
  client:
    user-service:
      address: user-service:9090
      pool-size: 10  # 每个服务10个连接
      max-inbound-message-size: 10MB