Apache Dubbo 3.x 版本指南

官方介绍

Apache Dubbo 3.x 是 Apache 软件基金会的顶级项目，是下一代云原生微服务 RPC 框架。Dubbo 3.x 在 2.x 版本的基础上进行了全面重构和优化，引入了 Triple 协议、应用级服务发现、流量控制、熔断降级等现代化微服务治理能力。3.x 版本标志着 Dubbo 从传统的服务治理框架向云原生微服务体系的重要演进。

Dubbo 3.x 以其高性能、高可用性、云原生支持和丰富的生态著称，是构建现代化微服务架构的核心组件。

版本特性

核心特性

Triple 协议: 基于 HTTP/2 的新一代 RPC 协议，兼容 gRPC
应用级服务发现: 减少注册中心压力，提高服务发现效率
云原生支持: 原生支持 Kubernetes、Service Mesh 等云原生环境
流量治理: 内置流量控制、熔断降级、负载均衡等治理能力
多语言支持: 更好的跨语言互操作性
可观测性: 增强的指标监控、链路追踪和日志记录

3.x 版本演进

3.0.x: 初始版本，引入 Triple 协议和应用级服务发现
3.1.x: 增强了流量治理能力，改进了性能
3.2.x: 增强了对 Service Mesh 的支持，改进了可观测性
3.3.x: 最新版本，增加了对最新技术标准的更好支持

官方获取地址

xml

<!-- Maven 依赖 -->
<dependency>
    <groupId>org.apache.dubbo</groupId>
    <artifactId>dubbo</artifactId>
    <version>3.2.0</version>
</dependency>

或者通过官方网站下载：

访问 https://dubbo.apache.org/
下载指定版本的发布包

环境要求

Java: JDK 1.8 或更高版本（JDK 11+ 推荐）
依赖管理: Maven 3.6+ 或 Gradle 6.0+
注册中心: Nacos、Zookeeper、Etcd 等
操作系统: 跨平台支持（Linux、Windows、macOS）
容器环境: Docker 19+（可选，用于容器化部署）

部署方法

1. 项目初始化

bash

# 创建 Maven 项目
mvn archetype:generate -DgroupId=com.example \
    -DartifactId=dubbo3-provider \
    -DarchetypeArtifactId=maven-archetype-quickstart \
    -DinteractiveMode=false

2. 添加依赖

xml

<dependencies>
    <!-- Dubbo 3.x 核心依赖 -->
    <dependency>
        <groupId>org.apache.dubbo</groupId>
        <artifactId>dubbo</artifactId>
        <version>3.2.0</version>
    </dependency>
    
    <!-- 注册中心依赖，以 Nacos 为例 -->
    <dependency>
        <groupId>org.apache.dubbo</groupId>
        <artifactId>dubbo-registry-nacos</artifactId>
        <version>3.2.0</version>
    </dependency>
    
    <!-- 配置中心依赖 -->
    <dependency>
        <groupId>org.apache.dubbo</groupId>
        <artifactId>dubbo-configcenter-nacos</artifactId>
        <version>3.2.0</version>
    </dependency>
    
    <!-- 元数据中心依赖 -->
    <dependency>
        <groupId>org.apache.dubbo</groupId>
        <artifactId>dubbo-metadata-report-nacos</artifactId>
        <version>3.2.0</version>
    </dependency>
</dependencies>

3. 配置文件说明

Dubbo 3.x 使用以下配置文件：

dubbo-provider.xml

xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:dubbo="http://dubbo.apache.org/schema/dubbo"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://dubbo.apache.org/schema/dubbo
       http://dubbo.apache.org/schema/dubbo/dubbo.xsd">

    <!-- 提供方应用信息 -->
    <dubbo:application name="dubbo3-provider" 
                       metadata-type="remote"
                       register-mode="instance"/>

    <!-- 使用 Nacos 注册中心 -->
    <dubbo:registry address="nacos://127.0.0.1:8848"/>

    <!-- 使用 Triple 协议 -->
    <dubbo:protocol name="tri" port="50051"/>

    <!-- 声明需要暴露的服务接口 -->
    <dubbo:service interface="com.example.api.DemoService" ref="demoServiceImpl"/>

    <!-- 服务实现 -->
    <bean id="demoServiceImpl" class="com.example.service.DemoServiceImpl"/>
</beans>

dubbo-consumer.xml

xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:dubbo="http://dubbo.apache.org/schema/dubbo"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://dubbo.apache.org/schema/dubbo
       http://dubbo.apache.org/schema/dubbo/dubbo.xsd">

    <!-- 消费方应用信息 -->
    <dubbo:application name="dubbo3-consumer" metadata-type="remote"/>

    <!-- 使用 Nacos 注册中心 -->
    <dubbo:registry address="nacos://127.0.0.1:8848"/>

    <!-- 生成远程服务代理 -->
    <dubbo:reference id="demoService" interface="com.example.api.DemoService"/>
</beans>

4. 使用注解配置

ProviderConfig.java

java

package com.example.config;

import org.apache.dubbo.config.ApplicationConfig;
import org.apache.dubbo.config.ProtocolConfig;
import org.apache.dubbo.config.RegistryConfig;
import org.apache.dubbo.config.spring.context.annotation.EnableDubbo;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;

@Configuration
@EnableDubbo(scanBasePackages = "com.example.service")
@PropertySource("classpath:dubbo.properties")
public class ProviderConfig {

    @Bean
    public ApplicationConfig applicationConfig() {
        ApplicationConfig applicationConfig = new ApplicationConfig();
        applicationConfig.setName("dubbo3-provider");
        applicationConfig.setMetadataType("remote");
        applicationConfig.setRegisterMode("instance"); // 应用级服务发现
        return applicationConfig;
    }

    @Bean
    public RegistryConfig registryConfig() {
        RegistryConfig registryConfig = new RegistryConfig();
        registryConfig.setAddress("nacos://127.0.0.1:8848");
        return registryConfig;
    }

    @Bean
    public ProtocolConfig protocolConfig() {
        ProtocolConfig protocolConfig = new ProtocolConfig();
        protocolConfig.setName("tri"); // Triple 协议
        protocolConfig.setPort(50051);
        return protocolConfig;
    }
}

二次开发

定义服务接口

src/main/java/com/example/api/DemoService.java

java

package com.example.api;

public interface DemoService {
    String sayHello(String name);
    int calculate(int a, int b);
    void asyncProcess(String data);
}

实现服务

src/main/java/com/example/service/DemoServiceImpl.java

java

package com.example.service;

import org.apache.dubbo.config.annotation.DubboService;
import com.example.api.DemoService;

@DubboService(version = "1.0.0", 
              timeout = 5000, 
              protocol = {"tri"}) // 使用 Triple 协议
public class DemoServiceImpl implements DemoService {

    @Override
    public String sayHello(String name) {
        return "Hello " + name + ", Welcome to Dubbo 3.x!";
    }

    @Override
    public int calculate(int a, int b) {
        return a + b;
    }

    @Override
    public void asyncProcess(String data) {
        // 异步处理逻辑
        System.out.println("Processing async data: " + data + " in Dubbo 3.x");
    }
}

消费者端调用

src/main/java/com/example/consumer/Consumer.java

java

package com.example.consumer;

import org.apache.dubbo.config.annotation.DubboReference;
import com.example.api.DemoService;
import org.springframework.stereotype.Component;

@Component
public class Consumer {

    @DubboReference(version = "1.0.0", protocol = "tri")
    private DemoService demoService;

    public void test() {
        String result = demoService.sayHello("World");
        System.out.println(result);
        
        int sum = demoService.calculate(10, 20);
        System.out.println("Calculate result: " + sum);
        
        demoService.asyncProcess("test data");
    }
}

自定义过滤器

src/main/java/com/example/filter/CustomFilter.java

java

package com.example.filter;

import org.apache.dubbo.common.constants.CommonConstants;
import org.apache.dubbo.common.extension.Activate;
import org.apache.dubbo.rpc.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@Activate(group = {CommonConstants.PROVIDER, CommonConstants.CONSUMER})
public class CustomFilter implements Filter {

    private static final Logger logger = LoggerFactory.getLogger(CustomFilter.class);

    @Override
    public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
        long startTime = System.currentTimeMillis();
        
        try {
            logger.info("Dubbo 3.x - Invoking method: " + invocation.getMethodName());
            
            Result result = invoker.invoke(invocation);
            
            long duration = System.currentTimeMillis() - startTime;
            logger.info("Dubbo 3.x - Method execution took: " + duration + " ms");
            
            return result;
        } catch (Exception e) {
            logger.error("Dubbo 3.x - Error invoking method: " + invocation.getMethodName(), e);
            throw e;
        }
    }
}

配置示例

服务提供者配置

dubbo.properties

properties

# 应用配置
dubbo.application.name=dubbo3-provider
dubbo.application.owner=developer
dubbo.application.metadata-type=remote
dubbo.application.register-mode=instance

# 注册中心配置
dubbo.registry.address=nacos://127.0.0.1:8848

# 协议配置 - 使用 Triple 协议
dubbo.protocols.tri.name=tri
dubbo.protocols.tri.port=50051

# 服务配置
dubbo.service.loadbalance=random
dubbo.service.timeout=5000
dubbo.service.retries=3

# 提供者配置
dubbo.provider.timeout=5000
dubbo.provider.retries=3
dubbo.provider.loadbalance=random
dubbo.provider.cluster=failover

# 流量控制配置
dubbo.provider.actives=100
dubbo.provider.executes=200

# 序列化配置
dubbo.provider.serialization=hessian2

服务消费者配置

consumer.properties

properties

# 应用配置
dubbo.application.name=dubbo3-consumer
dubbo.application.metadata-type=remote

# 注册中心配置
dubbo.registry.address=nacos://127.0.0.1:8848

# 消费者配置
dubbo.consumer.timeout=5000
dubbo.consumer.retries=3
dubbo.consumer.check=false
dubbo.consumer.loadbalance=random
dubbo.consumer.cluster=failover

# 配置中心
dubbo.config-center.address=nacos://127.0.0.1:8848

# 元数据中心
dubbo.metadata-report.address=nacos://127.0.0.1:8848

高级配置示例

dubbo-advanced.xml

xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:dubbo="http://dubbo.apache.org/schema/dubbo"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://dubbo.apache.org/schema/dubbo
       http://dubbo.apache.org/schema/dubbo/dubbo.xsd">

    <!-- 应用级服务发现配置 -->
    <dubbo:application name="dubbo3-provider" 
                       metadata-type="remote"
                       register-mode="instance"/>

    <!-- 服务提供者配置 -->
    <dubbo:provider timeout="5000" 
                    retries="3" 
                    connections="100" 
                    loadbalance="random"
                    cluster="failover"/>

    <!-- 服务消费者配置 -->
    <dubbo:consumer timeout="5000" 
                    retries="3" 
                    check="false" 
                    loadbalance="roundrobin"
                    cluster="failover"/>

    <!-- Triple 协议配置 -->
    <dubbo:protocol name="tri" 
                    port="50051" 
                    threads="200" 
                    accepts="500" 
                    payload="88388608"/>

    <!-- 监控配置 -->
    <dubbo:monitor protocol="registry"/>

    <!-- 元数据中心配置 -->
    <dubbo:metadata-report address="nacos://127.0.0.1:8848"/>
    
    <!-- 配置中心配置 -->
    <dubbo:config-center address="nacos://127.0.0.1:8848"/>
</beans>

Demo 示例

完整的 Provider 示例

src/main/java/com/example/provider/ProviderApplication.java

java

package com.example.provider;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class ProviderApplication {
    public static void main(String[] args) throws Exception {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("dubbo-provider.xml");
        context.start();
        
        System.out.println("Dubbo 3.x Provider started successfully!");
        System.out.println("Using Triple protocol on port 50051");
        System.out.println("Press Ctrl+C to stop...");
        
        synchronized (ProviderApplication.class) {
            while (true) {
                try {
                    ProviderApplication.class.wait();
                } catch (InterruptedException e) {
                    System.out.println("Dubbo 3.x Provider stopped.");
                    break;
                }
            }
        }
    }
}

完整的 Consumer 示例

src/main/java/com/example/consumer/ConsumerApplication.java

java

package com.example.consumer;

import com.example.api.DemoService;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class ConsumerApplication {
    public static void main(String[] args) throws Exception {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("dubbo-consumer.xml");
        context.start();
        
        DemoService demoService = (DemoService) context.getBean("demoService");
        
        // 测试调用
        String result = demoService.sayHello("Dubbo 3.x User");
        System.out.println("Response: " + result);
        
        int sum = demoService.calculate(100, 200);
        System.out.println("Calculation result: " + sum);
        
        System.out.println("Dubbo 3.x Consumer test completed!");
    }
}

使用 Spring Boot 的示例

pom.xml

xml

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
        <version>2.7.0</version>
    </dependency>
    
    <dependency>
        <groupId>org.apache.dubbo</groupId>
        <artifactId>dubbo-spring-boot-starter</artifactId>
        <version>3.2.0</version>
    </dependency>
</dependencies>

application.properties

properties

# Dubbo 配置
dubbo.application.name=dubbo3-springboot-provider
dubbo.application.metadata-type=remote
dubbo.application.register-mode=instance
dubbo.registry.address=nacos://127.0.0.1:8848
dubbo.protocol.name=tri
dubbo.protocol.port=50051

Spring Boot Provider

java

package com.example.springboot.provider;

import org.apache.dubbo.config.spring.context.annotation.EnableDubbo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@EnableDubbo
public class DubboProviderApplication {
    public static void main(String[] args) {
        SpringApplication.run(DubboProviderApplication.class, args);
        System.out.println("Dubbo 3.x Spring Boot Provider started!");
        System.out.println("Using Triple protocol on port 50051");
    }
}

常见问题和解决方案

1. Triple 协议连接问题

properties

# 确保使用正确的协议
dubbo.protocol.name=tri
dubbo.consumer.protocol=tri

2. 应用级服务发现问题

properties

# 正确配置应用级服务发现
dubbo.application.register-mode=instance
dubbo.application.metadata-type=remote

3. 注册中心连接问题

确保 Nacos 或其他注册中心服务正常运行：

bash

# 检查 Nacos 状态
curl http://127.0.0.1:8848/nacos/v1/ns/operator/metrics

4. 端口冲突问题

properties

# 修改默认端口
dubbo.protocol.port=50052

5. 序列化问题

xml

<!-- 指定序列化方式 -->
<dubbo:protocol name="tri" serialization="protobuf"/>

性能优化

连接池配置

properties

# 连接池配置
dubbo.protocol.connections=100
dubbo.consumer.connections=20

线程池配置

xml

<!-- 线程池配置 -->
<dubbo:protocol name="tri" threads="200" threadpool="fixed" queues="1000"/>

序列化优化

properties

# 使用高效的序列化方式
dubbo.protocol.serialization=protobuf

应用级服务发现优化

properties

# 优化应用级服务发现性能
dubbo.application.register-mode=all
dubbo.metadata-report.retry-times=3
dubbo.metadata-report.retry-period=3000

Docker 部署示例

Dockerfile

dockerfile

FROM openjdk:11-jre-slim

LABEL maintainer="Your Name <your.email@example.com>"

WORKDIR /app

COPY target/*.jar app.jar

EXPOSE 50051

ENTRYPOINT ["java", "-jar", "/app/app.jar"]

Docker Compose 配置

yaml

version: '3.8'
services:
  nacos:
    image: nacos/nacos-server:v2.2.0
    ports:
      - "8848:8848"
      - "9848:9848"
    environment:
      - MODE=standalone
      - NACOS_AUTH_ENABLE=false
    networks:
      - dubbo3-net

  dubbo3-provider:
    build: .
    ports:
      - "50051:50051"
    environment:
      - DUBBO_REGISTRY_ADDRESS=nacos://nacos:8848
    depends_on:
      - nacos
    networks:
      - dubbo3-net

  dubbo3-consumer:
    build: .
    environment:
      - DUBBO_REGISTRY_ADDRESS=nacos://nacos:8848
      - ROLE=consumer
    depends_on:
      - nacos
      - dubbo3-provider
    networks:
      - dubbo3-net

networks:
  dubbo3-net:
    driver: bridge

Kubernetes 部署示例

Deployment 配置

yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: dubbo3-provider
  namespace: default
  labels:
    app: dubbo3-provider
spec:
  replicas: 3
  selector:
    matchLabels:
      app: dubbo3-provider
  template:
    metadata:
      labels:
        app: dubbo3-provider
    spec:
      containers:
      - name: dubbo
        image: dubbo3-provider:latest
        ports:
        - containerPort: 50051
        env:
        - name: DUBBO_REGISTRY_ADDRESS
          value: "nacos://nacos-service:8848"
        - name: DUBBO_PROTOCOL_NAME
          value: "tri"
        resources:
          requests:
            memory: "512Mi"
            cpu: "250m"
          limits:
            memory: "1Gi"
            cpu: "500m"
        livenessProbe:
          tcpSocket:
            port: 50051
          initialDelaySeconds: 60
          periodSeconds: 30
        readinessProbe:
          tcpSocket:
            port: 50051
          initialDelaySeconds: 30
          periodSeconds: 10
---
apiVersion: v1
kind: Service
metadata:
  name: dubbo3-provider-service
spec:
  selector:
    app: dubbo3-provider
  ports:
    - protocol: TCP
      port: 50051
      targetPort: 50051
  type: ClusterIP
---
apiVersion: v1
kind: Service
metadata:
  name: dubbo3-provider-external
spec:
  selector:
    app: dubbo3-provider
  ports:
    - protocol: TCP
      port: 50051
      targetPort: 50051
  type: LoadBalancer

Service Mesh 集成

Dubbo 3.x 原生支持 Service Mesh 架构：

Istio 集成示例

yaml

apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: dubbo3-vs
spec:
  hosts:
  - dubbo3-provider-service
  http:
  - match:
    - headers:
        canary: 
          exact: "true"
    route:
    - destination:
        host: dubbo3-provider-service
        subset: v2
      weight: 100
  - route:
    - destination:
        host: dubbo3-provider-service
        subset: v1
      weight: 100
---
apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
  name: dubbo3-dr
spec:
  host: dubbo3-provider-service
  subsets:
  - name: v1
    labels:
      version: v1
  - name: v2
    labels:
      version: v2

监控和管理

使用 Dubbo Admin

Dubbo Admin 支持 Dubbo 3.x 的新特性：

yaml

# docker-compose.yml
version: '3'
services:
  dubbo-admin:
    image: apache/dubbo-admin
    ports:
      - "8080:8080"
    environment:
      admin.registry.address: nacos://nacos:8848
      admin.config-center: nacos://nacos:8848
      admin.metadata-report.address: nacos://nacos:8848
    depends_on:
      - nacos

链路追踪配置

properties

# 集成 SkyWalking 进行链路追踪
dubbo.tracing.enabled=true
dubbo.tracing.type=opentelemetry
dubbo.tracing.opentelemetry.endpoint=http://otel-collector:4317

安全配置

TLS/SSL 配置

properties

# 启用 TLS
dubbo.protocol.ssl-enabled=true
dubbo.protocol.ssl-key-store=/path/to/keystore.jks
dubbo.protocol.ssl-key-store-password=changeit
dubbo.protocol.ssl-trust-store=/path/to/truststore.jks
dubbo.protocol.ssl-trust-store-password=changeit

总结

Apache Dubbo 3.x 是一个面向云原生时代的现代化 RPC 框架，通过 Triple 协议、应用级服务发现、流量治理等创新特性，为微服务架构提供了更高效、更可靠的服务治理能力。它不仅继承了 2.x 版本的高性能和稳定性，还增加了对云原生环境的原生支持，是构建下一代微服务系统的理想选择。

Apache Dubbo 3.x 版本指南 ​

官方介绍 ​

版本特性 ​

核心特性 ​

3.x 版本演进 ​

官方获取地址 ​

环境要求 ​

部署方法 ​

1. 项目初始化 ​

2. 添加依赖 ​

3. 配置文件说明 ​

4. 使用注解配置 ​

二次开发 ​

定义服务接口 ​

实现服务 ​

消费者端调用 ​

自定义过滤器 ​

配置示例 ​

服务提供者配置 ​

服务消费者配置 ​

高级配置示例 ​

Demo 示例 ​

完整的 Provider 示例 ​

完整的 Consumer 示例 ​

使用 Spring Boot 的示例 ​

常见问题和解决方案 ​

1. Triple 协议连接问题 ​

2. 应用级服务发现问题 ​

3. 注册中心连接问题 ​

4. 端口冲突问题 ​

5. 序列化问题 ​

性能优化 ​

连接池配置 ​

线程池配置 ​

序列化优化 ​

应用级服务发现优化 ​

Docker 部署示例 ​

Dockerfile ​

Docker Compose 配置 ​

Kubernetes 部署示例 ​

Deployment 配置 ​

Service Mesh 集成 ​

Istio 集成示例 ​

监控和管理 ​

使用 Dubbo Admin ​

链路追踪配置 ​

安全配置 ​

TLS/SSL 配置 ​

总结 ​

Apache Dubbo 3.x 版本指南

官方介绍

版本特性

核心特性

3.x 版本演进

官方获取地址

环境要求

部署方法

1. 项目初始化

2. 添加依赖

3. 配置文件说明

4. 使用注解配置

二次开发

定义服务接口

实现服务

消费者端调用

自定义过滤器

配置示例

服务提供者配置

服务消费者配置

高级配置示例

Demo 示例

完整的 Provider 示例

完整的 Consumer 示例

使用 Spring Boot 的示例

常见问题和解决方案

1. Triple 协议连接问题

2. 应用级服务发现问题

3. 注册中心连接问题

4. 端口冲突问题

5. 序列化问题

性能优化

连接池配置

线程池配置

序列化优化

应用级服务发现优化

Docker 部署示例

Dockerfile

Docker Compose 配置

Kubernetes 部署示例

Deployment 配置

Service Mesh 集成

Istio 集成示例

监控和管理

使用 Dubbo Admin

链路追踪配置

安全配置

TLS/SSL 配置

总结