Dubbo (Apache Dubbo) 技术概念解析

// 1. 定义服务接口（放在公共模块中供消费者和提供者共享）
public interface InventoryService {
    /**
     * 检查商品库存
     * @param productId 商品ID
     * @param quantity 数量
     * @return 是否有足够库存
     */
    boolean checkStock(Long productId, Integer quantity);
    
    /**
     * 扣减库存
     * @param productId 商品ID
     * @param quantity 数量
     * @return 操作结果
     */
    boolean reduceStock(Long productId, Integer quantity);
}

// 2. 服务提供者实现（库存服务）
@DubboService(version = "1.0.0")
public class InventoryServiceImpl implements InventoryService {
    
    @Override
    public boolean checkStock(Long productId, Integer quantity) {
        // 实际业务逻辑：检查数据库中的库存
        System.out.println("检查商品ID: " + productId + " 库存, 请求数量: " + quantity);
        return true; // 示例返回
    }
    
    @Override
    public boolean reduceStock(Long productId, Integer quantity) {
        // 实际业务逻辑：在数据库中扣减库存
        System.out.println("扣减商品ID: " + productId + " 库存, 数量: " + quantity);
        return true; // 示例返回
    }
}

// 3. 服务消费者调用（订单服务）
@RestController
@RequestMapping("/orders")
public class OrderController {
    
    @DubboReference(version = "1.0.0", check = false)
    private InventoryService inventoryService;
    
    @PostMapping("/create")
    public String createOrder(@RequestBody OrderDTO orderDTO) {
        // 检查库存
        boolean hasStock = inventoryService.checkStock(orderDTO.getProductId(), orderDTO.getQuantity());
        if (!hasStock) {
            return "库存不足";
        }
        
        // 扣减库存
        boolean reduced = inventoryService.reduceStock(orderDTO.getProductId(), orderDTO.getQuantity());
        if (!reduced) {
            return "扣减库存失败";
        }
        
        // 创建订单等其他逻辑...
        return "订单创建成功";
    }
}
                

// 1. 添加Dubbo依赖到项目中
<dependency>
    <groupId>org.apache.dubbo</groupId>
    <artifactId>dubbo</artifactId>
    <version>3.2.0</version>
</dependency>

// 2. 配置服务限流（application.properties或application.yml）
dubbo:
  application:
    name: payment-service
  registry:
    address: zookeeper://127.0.0.1:2181
  protocol:
    name: dubbo
    port: 20880
  provider:
    filter: myRateLimiter

// 3. 自定义限流过滤器
@Activate(group = {CommonConstants.PROVIDER})
public class RateLimiterFilter implements Filter {
    
    // 使用Google Guava的RateLimiter实现限流
    private static final RateLimiter RATE_LIMITER = RateLimiter.create(100.0); // 每秒允许100个请求
    
    @Override
    public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
        // 尝试获取令牌，如果在1秒内无法获取，则拒绝请求
        if (!RATE_LIMITER.tryAcquire(1, 1, TimeUnit.SECONDS)) {
            throw new RpcException("系统繁忙，请稍后再试");
        }
        
        // 继续调用
        return invoker.invoke(invocation);
    }
}

// 4. 在SPI配置文件中声明过滤器
// 在resources/META-INF/dubbo/org.apache.dubbo.rpc.Filter文件中添加：
myRateLimiter=com.example.filter.RateLimiterFilter
                

// Java端暴露多协议服务
@Configuration
public class DubboConfig {
    
    @Bean
    public ProtocolConfig dubboProtocol() {
        // 配置dubbo协议
        ProtocolConfig protocolConfig = new ProtocolConfig();
        protocolConfig.setName("dubbo");
        protocolConfig.setPort(20880);
        protocolConfig.setThreads(200);
        return protocolConfig;
    }
    
    @Bean
    public ProtocolConfig tripleProtocol() {
        // 配置Triple协议（基于HTTP/2的新一代RPC协议）
        ProtocolConfig protocolConfig = new ProtocolConfig();
        protocolConfig.setName("tri");
        protocolConfig.setPort(50051);
        return protocolConfig;
    }
    
    @Bean
    public ProtocolConfig restProtocol() {
        // 配置REST协议（HTTP）
        ProtocolConfig protocolConfig = new ProtocolConfig();
        protocolConfig.setName("rest");
        protocolConfig.setPort(8080);
        protocolConfig.setServer("netty");
        return protocolConfig;
    }
}

// 服务实现类
@DubboService(protocols = {"dubbo", "tri", "rest"})
public class UserServiceImpl implements UserService {
    // 服务实现
}

// Go语言客户端调用示例
package main

import (
    "context"
    "fmt"
    "time"

    "dubbo.apache.org/dubbo-go/v3/config"
    _ "dubbo.apache.org/dubbo-go/v3/imports"
)

type UserService struct {
    GetUser func(ctx context.Context, req *GetUserRequest) (*GetUserResponse, error)
}

func main() {
    // 初始化消费者配置
    config.SetConsumerService(&UserService{})
    if err := config.Load(); err != nil {
        panic(err)
    }
    
    // 获取服务
    var userService *UserService
    config.GetConsumerService(&userService)
    
    // 调用服务
    req := &GetUserRequest{Id: 1}
    resp, err := userService.GetUser(context.Background(), req)
    if err != nil {
        panic(err)
    }
    fmt.Printf("Response: %v\n", resp)
}
                

1. Dubbo与Spring Cloud有什么区别？

Dubbo专注于高性能RPC通信和服务治理，而Spring Cloud是完整的微服务解决方案。Dubbo性能更高但偏重Java生态，Spring Cloud基于HTTP，对前端友好且易于集成，但性能略低。Dubbo 3.0后增加了Triple协议支持多语言互通。

2. Dubbo支持哪些注册中心？

Dubbo支持多种注册中心，包括Zookeeper、Nacos、Consul、etcd、Redis、Eureka等。其中Zookeeper和Nacos是最常用的选择。

3. Dubbo的负载均衡策略有哪些？

Dubbo内置了多种负载均衡策略，包括随机(Random)、轮询(RoundRobin)、最少活跃调用数(LeastActive)、一致性哈希(ConsistentHash)、最短响应时间(ShortestResponse)等，默认为Random随机策略。

4. Dubbo如何保证服务高可用？

Dubbo通过注册中心自动感知服务上下线，提供集群容错策略（如失败自动重试、快速失败等），支持服务降级和限流，以及健康检查机制，共同保障服务的高可用性。