服务发布和引用的实践

// api 模块：服务接口定义
package com.example.dubbo.api;

public interface UserService {
    /**
     * 获取用户信息
     * @param userId 用户 ID
     * @return 用户信息
     */
    UserInfo getUser(long userId);

    /**
     * 批量获取用户信息
     * @param userIds 用户 ID 列表
     * @return 用户信息映射
     */
    Map<Long, UserInfo> batchGetUsers(long[] userIds);

    /**
     * 服务端流式通信（Triple 协议特性）
     * @param request 查询请求
     * @param responseObserver 响应流观察者
     */
    void streamUsers(UserQuery request, StreamObserver<UserInfo> responseObserver);
}

// 数据模型
public class UserInfo implements Serializable {
    private long id;
    private String name;
    private String email;
    // getters & setters
}

public class UserQuery implements Serializable {
    private String keyword;
    private int limit;
    // getters & setters
}

syntax = "proto3";
option java_multiple_files = true;
package com.example.dubbo.api;

message GetUserRequest {
  int64 user_id = 1;
}

message UserInfo {
  int64 id = 1;
  string name = 2;
  string email = 3;
}

message BatchGetUsersRequest {
  repeated int64 user_ids = 1;
}

message BatchGetUsersResponse {
  map<int64, UserInfo> users = 1;
}

message UserQuery {
  string keyword = 1;
  int32 limit = 2;
}

service UserService {
  // Unary 调用
  rpc getUser(GetUserRequest) returns (UserInfo);
  rpc batchGetUsers(BatchGetUsersRequest) returns (BatchGetUsersResponse);
  // Server Stream
  rpc streamUsers(UserQuery) returns (stream UserInfo);
}

<plugin>
    <groupId>org.apache.dubbo</groupId>
    <artifactId>dubbo-maven-plugin</artifactId>
    <version>3.3.6</version>
    <configuration>
        <outputDir>build/generated/source/proto/main/java</outputDir>
    </configuration>
</plugin>

@DubboService(
    version = "1.0.0",
    group = "production",
    timeout = 3000,
    retries = 0,
    loadbalance = "adaptive",
    protocol = "tri"           // Triple 协议
)
public class UserServiceImpl implements UserService {

    @Override
    public UserInfo getUser(long userId) {
        return userRepository.findById(userId);
    }

    @Override
    public Map<Long, UserInfo> batchGetUsers(long[] userIds) {
        return userRepository.findByIds(userIds);
    }

    @Override
    public void streamUsers(UserQuery request, StreamObserver<UserInfo> responseObserver) {
        List<UserInfo> users = userRepository.search(request.getKeyword(), request.getLimit());
        for (UserInfo user : users) {
            responseObserver.onNext(user);
        }
        responseObserver.onCompleted();
    }
}

// 继承 protoc 自动生成的基类
public class UserServiceImpl extends DubboUserServiceTriple.UserServiceImplBase {

    @Override
    public UserInfo getUser(GetUserRequest request) {
        return UserInfo.newBuilder()
            .setId(request.getUserId())
            .setName("User-" + request.getUserId())
            .build();
    }

    @Override
    public void streamUsers(UserQuery request, StreamObserver<UserInfo> responseObserver) {
        List<UserInfo> users = searchUsers(request.getKeyword(), request.getLimit());
        for (UserInfo user : users) {
            responseObserver.onNext(user);
        }
        responseObserver.onCompleted();
    }
}

# application.yaml
dubbo:
  application:
    name: user-service-provider
    logger: slf4j
  protocol:
    name: tri                          # Triple 协议
    port: 50052
  registry:
    address: nacos://127.0.0.1:8848    # Nacos 注册中心
    username: nacos
    password: nacos
  provider:                            # 全局 Provider 默认配置
    timeout: 3000
    retries: 0
    loadbalance: adaptive
  metrics:
    protocol: prometheus               # Prometheus 指标暴露
  tracing:
    enabled: true                      # OpenTelemetry Tracing
    sampling:
      probability: 0.1                 # 采样率 10%

@Component
public class UserConsumer {

    @DubboReference(
        version = "1.0.0",
        group = "production",
        timeout = 5000,           // 消费者侧超时覆盖
        retries = 2,              // 失败重试次数
        check = false,            // 启动时不检查
        loadbalance = "adaptive",
        protocol = "tri"
    )
    private UserService userService;

    public UserInfo getUser(long userId) {
        return userService.getUser(userId);
    }
}

# application.yaml - 全局默认
dubbo:
  provider:
    timeout: 3000           # 应用级：3 秒

// 服务级覆盖
@DubboService(timeout = 5000)   // 服务级：5 秒
public class UserServiceImpl implements UserService {

    // 方法级覆盖（通过方法配置）
}

# 通过 JVM 参数设置
-Ddubbo.config.mode=override_if_absent

# 或通过环境变量
DUBBO_CONFIG_MODE=override_if_absent

@DubboService(
    version = "1.0.0",
    timeout = 3000,               // 服务级默认超时
    retries = 0,                  // 服务级默认不重试
    loadbalance = "adaptive"      // 服务级默认负载均衡
)
public class UserServiceImpl implements UserService {

    // 写操作：超时 5 秒，不重试
    // 读操作：超时 3 秒，可重试 2 次
}

@DubboReference(
    version = "1.0.0",
    timeout = 5000,               // Consumer 侧覆盖超时
    methods = {
        @Method(name = "getUser", timeout = 1000, retries = 2),        // 读操作：短超时+重试
        @Method(name = "updateUser", timeout = 5000, retries = 0)      // 写操作：长超时+不重试
    }
)
private UserService userService;

# Nacos 配置中心 - 运行时动态覆盖
dubbo.service.UserService.getUser.timeout=2000
dubbo.service.UserService.getUser.retries=3

// REST 注解增强
@RestController
@RequestMapping("/api/v1/users")
public interface UserService {

    @GetMapping(value = "/{userId}")
    @Operation(summary = "获取用户信息", description = "根据用户 ID 获取用户详细信息")
    UserInfo getUser(@PathVariable long userId);

    @PostMapping(value = "/batch")
    @Operation(summary = "批量获取用户信息")
    Map<Long, UserInfo> batchGetUsers(@RequestBody long[] userIds);
}

// 向后兼容的接口演进示例
message GetUserRequest {
  int64 user_id = 1;
  // 新增字段使用新编号，不破坏旧版本
  repeated string fields = 2;  // 字段掩码，v2 新增
}

dubbo:
  protocols:
    - name: dubbo        # 保留旧协议
      port: 20880
    - name: tri          # 新增 Triple 协议
      port: 50052
  registry:
    address: nacos://127.0.0.1:8848

@DubboReference(protocol = "tri")   // 新 Consumer 使用 Triple
private UserService userService;

dubbo:
  protocols:
    - name: tri          # 仅保留 Triple
      port: 50052

dubbo:
  application:
    name: user-service
  registry:
    address: nacos://127.0.0.1:8848
    # 迁移策略：INTERFACE → APPLICATION
    # 可选值：INTERFACE_ONLY / APPLICATION_ONLY / INTERFACE_FIRST / APPLICATION_FIRST
    register-mode: APPLICATION_FIRST