2. 首页 > IT综合教程 > 正文

250. Dubbo微服务框架培训

教程整理：风哥教程  |  更新时间：2026-01-27  |  教程分类：IT综合教程  |  文档学习：5

一、Dubbo概述

Dubbo是阿里巴巴开源的高性能RPC框架，提供高性能的远程服务调用、服务自动注册与发现、负载均衡、服务治理等能力。

1.1 Dubbo核心概念

  • Provider：服务提供者，暴露服务的应用
  • Consumer：服务消费者，调用远程服务的应用
  • Registry：注册中心，服务注册与发现
  • Monitor：监控中心，统计服务调用数据
  • Container：服务运行容器

1.2 Dubbo架构

Dubbo架构组件：
┌─────────────────────────────────────────────────┐
│                   Monitor                       │
└─────────────────────────────────────────────────┘
         ↑                           ↑
         │                           │
┌─────────────────┐         ┌─────────────────┐
│    Consumer     │ ←─────→ │    Registry     │
└─────────────────┘         └─────────────────┘
         │                           ↑
         │                           │
         └───────────────────────────┘
                     │
              ┌─────────────────┐
              │    Provider     │
              │   (Container)   │
              └─────────────────┘

二、Dubbo安装部署

2.1 ZooKeeper注册中心部署

# 下载ZooKeeper
wget https://archive.apache.org/dist/zookeeper/zookeeper-3.8.3/apache-zookeeper-3.8.3-bin.tar.gz

# 解压安装
tar -xzf apache-zookeeper-3.8.3-bin.tar.gz -C /opt/
ln -s /opt/apache-zookeeper-3.8.3-bin /opt/zookeeper

# 配置zoo.cfg
cd /opt/zookeeper/conf
cp zoo_sample.cfg zoo.cfg
vim zoo.cfg

tickTime=2000
initLimit=10
syncLimit=5
dataDir=/opt/zookeeper/data
clientPort=2181
server.1=192.168.1.101:2888:3888
server.2=192.168.1.102:2888:3888
server.3=192.168.1.103:2888:3888

# 创建myid文件
echo "1" > /opt/zookeeper/data/myid

# 启动ZooKeeper
/opt/zookeeper/bin/zkServer.sh start

# 查看状态
/opt/zookeeper/bin/zkServer.sh status
# 输出示例
ZooKeeper JMX enabled by default
Using config: /opt/zookeeper/bin/../conf/zoo.cfg
Mode: leader

2.2 Dubbo Admin部署

# 下载Dubbo Admin
git clone https://github.com/apache/dubbo-admin.git
cd dubbo-admin

# 配置注册中心
vim dubbo-admin-server/src/main/resources/application.properties

dubbo.registry.address=zookeeper://192.168.1.101:2181?backup=192.168.1.102:2181,192.168.1.103:2181
dubbo.config-center=zookeeper://192.168.1.101:2181
dubbo.metadata-report.address=zookeeper://192.168.1.101:2181

# 构建项目
mvn clean package -DskipTests

# 启动Admin
java -jar dubbo-admin-server/target/dubbo-admin-server-0.6.0.jar

# 访问Dubbo Admin
# http://fgedudb:8080
# 默认账号：root/root

三、服务提供者开发

3.1 Maven依赖配置

<!-- pom.xml -->
<properties>
    <dubbo.version>3.2.7</dubbo.version>
</properties>

<dependencies>
    <dependency>
        <groupId>org.apache.dubbo</groupId>
        <artifactId>dubbo-spring-boot-starter</artifactId>
        <version>${dubbo.version}</version>
    </dependency>
    <dependency>
        <groupId>org.apache.dubbo</groupId>
        <artifactId>dubbo-registry-zookeeper</artifactId>
        <version>${dubbo.version}</version>
    </dependency>
</dependencies>

3.2 服务接口定义

// UserService.java
package com.example.api;

public interface UserService {
    User getUserById(Long id);
    List<User> listUsers();
    boolean createUser(User user);
    boolean updateUser(User user);
    boolean deleteUser(Long id);
}

// User.java
package com.example.api;

import java.io.Serializable;

public class User implements Serializable {
    private Long id;
    private String name;
    private String email;
    private Integer age;
    
    // getters and setters
}

3.3 服务实现

// UserServiceImpl.java
package com.example.provider;

import org.apache.dubbo.config.annotation.DubboService;
import com.example.api.UserService;
import com.example.api.User;
import java.util.*;

@DubboService(
    version = "1.0.0",
    group = "user-service",
    timeout = 5000,
    retries = 2,
    loadbalance = "roundrobin"
)
public class UserServiceImpl implements UserService {
    
    private Map<Long, User> userMap = new HashMap<>();
    
    @Override
    public User getUserById(Long id) {
        return userMap.get(id);
    }
    
    @Override
    public List<User> listUsers() {
        return new ArrayList<>(userMap.values());
    }
    
    @Override
    public boolean createUser(User user) {
        userMap.put(user.getId(), user);
        return true;
    }
    
    @Override
    public boolean updateUser(User user) {
        if (userMap.containsKey(user.getId())) {
            userMap.put(user.getId(), user);
            return true;
        }
        return false;
    }
    
    @Override
    public boolean deleteUser(Long id) {
        return userMap.remove(id) != null;
    }
}

3.4 服务提供者配置

# application.yml
server:
  port: 8081

dubbo:
  application:
    name: user-service-provider
    logger: slf4j
  registry:
    address: zookeeper://192.168.1.101:2181?backup=192.168.1.102:2181,192.168.1.103:2181
  protocol:
    name: dubbo
    port: 20880
    threads: 200
  provider:
    timeout: 5000
    retries: 2
    loadbalance: roundrobin
  scan:
    base-packages: com.example.provider

// 启动类
@SpringBootApplication
@EnableDubbo
public class ProviderApplication {
    public static void main(String[] args) {
        SpringApplication.run(ProviderApplication.class, args);
    }
}

四、服务消费者开发

4.1 服务引用

// UserController.java
package com.example.consumer;

import org.apache.dubbo.config.annotation.DubboReference;
import org.springframework.web.bind.annotation.*;
import com.example.api.UserService;
import com.example.api.User;
import java.util.List;

@RestController
@RequestMapping("/api/users")
public class UserController {
    
    @DubboReference(
        version = "1.0.0",
        group = "user-service",
        timeout = 5000,
        retries = 2,
        check = false,
        mock = "return null"
    )
    private UserService userService;
    
    @GetMapping("/{id}")
    public User getUser(@PathVariable Long id) {
        return userService.getUserById(id);
    }
    
    @GetMapping
    public List<User> listUsers() {
        return userService.listUsers();
    }
    
    @PostMapping
    public boolean createUser(@RequestBody User user) {
        return userService.createUser(user);
    }
    
    @PutMapping
    public boolean updateUser(@RequestBody User user) {
        return userService.updateUser(user);
    }
    
    @DeleteMapping("/{id}")
    public boolean deleteUser(@PathVariable Long id) {
        return userService.deleteUser(id);
    }
}

4.2 消费者配置

# application.yml
server:
  port: 8080

dubbo:
  application:
    name: user-service-consumer
    logger: slf4j
  registry:
    address: zookeeper://192.168.1.101:2181?backup=192.168.1.102:2181,192.168.1.103:2181
  consumer:
    timeout: 5000
    retries: 2
    check: false
    loadbalance: roundrobin
  scan:
    base-packages: com.example.consumer

// 启动类
@SpringBootApplication
@EnableDubbo
public class ConsumerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ConsumerApplication.class, args);
    }
}

五、负载均衡策略

5.1 负载均衡配置

// 服务端负载均衡配置
@DubboService(loadbalance = "roundrobin")
public class UserServiceImpl implements UserService {
    // ...
}

// 消费端负载均衡配置
@DubboReference(loadbalance = "random")
private UserService userService;

// 配置文件方式
dubbo:
  provider:
    loadbalance: roundrobin
  consumer:
    loadbalance: random

5.2 负载均衡策略说明

策略名称 说明 适用场景
random 随机，按权重设置随机概率 一般场景
roundrobin 轮询，按公约后的权重设置轮询比率 请求量均匀场景
leastactive 最少活跃调用数，相同活跃数的随机 性能差异大的场景
consistenthash 一致性Hash，相同参数的请求发到同一提供者 有状态服务场景

六、集群容错策略

6.1 容错模式配置

// Failover Cluster - 失败自动切换
@DubboReference(cluster = "failover", retries = 2)
private UserService userService;

// Failfast Cluster - 快速失败
@DubboReference(cluster = "failfast")
private OrderService orderService;

// Failsafe Cluster - 失败安全
@DubboReference(cluster = "failsafe")
private LogService logService;

// Failback Cluster - 失败自动恢复
@DubboReference(cluster = "failback")
private NotifyService notifyService;

// Forking Cluster - 并行调用
@DubboReference(cluster = "forking", forks = 3)
private SearchService searchService;

// Broadcast Cluster - 广播调用
@DubboReference(cluster = "broadcast")
private CacheService cacheService;

6.2 容错策略说明

策略名称 说明 适用场景
failover 失败自动切换，重试其他服务器 读操作
failfast 快速失败，只发起一次调用 非幂等写操作
failsafe 失败安全，出现异常直接忽略 日志、通知等
failback 失败自动恢复，后台记录失败请求 消息通知
forking 并行调用，只要一个成功即返回 实时性要求高
broadcast 广播调用所有提供者 缓存更新

七、服务降级与熔断

7.1 服务降级配置

// Mock降级配置
@DubboReference(
    mock = "com.example.api.UserServiceMock",
    mock = "return null",  // 返回null
    mock = "throw",  // 抛出异常
    mock = "force:return null"  // 强制返回null
)
private UserService userService;

// UserServiceMock.java
public class UserServiceMock implements UserService {
    @Override
    public User getUserById(Long id) {
        return User.builder()
            .id(id)
            .name("默认用户")
            .email("default@fgedu.net.cn")
            .build();
    }
    
    @Override
    public List<User> listUsers() {
        return Collections.emptyList();
    }
    
    // 其他方法实现...
}

7.2 Sentinel集成

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

# 配置Sentinel
dubbo:
  provider:
    filter: sentinel
  consumer:
    filter: sentinel

// 自定义Fallback
@DubboReference(
    fallback = "userServiceFallback"
)
private UserService userService;

@Component("userServiceFallback")
public class UserServiceFallback implements UserService {
    @Override
    public User getUserById(Long id) {
        return User.builder().id(id).name("服务降级").build();
    }
    // 其他方法...
}

八、服务治理

8.1 服务路由

// 条件路由
# 在Dubbo Admin中配置路由规则
scope: application
key: user-service
enabled: true
force: false
runtime: false
conditions:
  - => host != 192.168.1.100
  - => host = 192.168.1.101,192.168.1.102

// 标签路由
# 配置标签
dubbo.provider.tag=gray

# 消费端指定标签
@DubboReference(tag = "gray")
private UserService userService;

8.2 动态配置

// 通过Dubbo Admin动态调整参数
# 超时配置
key: user-service
config-type: timeout
timeout: 3000

# 负载均衡配置
key: user-service
config-type: loadbalance
loadbalance: leastactive

# 权重配置
key: 192.168.1.100:20880
config-type: weight
weight: 100

九、监控与运维

9.1 Dubbo Admin管理

# 查看服务列表
curl "http://fgedudb:8080/api/dev/service/list"

# 查看服务详情
curl "http://fgedudb:8080/api/dev/service/detail?service=user-service"

# 查看提供者列表
curl "http://fgedudb:8080/api/dev/service/providers?service=user-service"

# 查看消费者列表
curl "http://fgedudb:8080/api/dev/service/consumers?service=user-service"

# 动态配置
curl -X POST "http://fgedudb:8080/api/dev/config" \
-H "Content-Type: application/json" \
-d '{"key":"user-service","config":{"timeout":5000}}'

9.2 Prometheus监控

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

# 配置Prometheus
dubbo:
  metrics:
    protocol: prometheus
    enable: true
    port: 20882

# prometheus.yml配置
scrape_configs:
  - job_name: 'dubbo'
    static_configs:
      - targets: ['192.168.1.100:20882']

# 关键监控指标
dubbo_provider_qps  # 提供者QPS
dubbo_provider_rt  # 提供者响应时间
dubbo_consumer_qps  # 消费者QPS
dubbo_consumer_rt  # 消费者响应时间

十、最佳实践

10.1 配置建议

配置项 建议值 说明
timeout 3000-5000ms 根据业务调整
retries 2 读操作可重试
loadbalance roundrobin 均衡负载
cluster failover 读操作推荐

10.2 常见问题排查

# 查看ZooKeeper服务注册
/opt/zookeeper/bin/zkCli.sh
ls /dubbo/com.example.api.UserService/providers

# 查看服务连接
netstat -anp | grep 20880

# 查看Dubbo日志
tail -f logs/dubbo.log

# 测试服务连通性
telnet 192.168.1.100 20880
invoke com.example.api.UserService.getUserById(1)
注意事项：

  • 生产环境必须使用注册中心集群
  • 合理设置超时和重试次数
  • 配置服务降级策略
  • 定期备份服务配置

十一、总结

Dubbo是微服务架构中重要的RPC框架。通过本培训文档，您应该掌握了：

学习交流加群风哥微信: itpux-com

  • Dubbo架构和核心概念
  • 服务提供者和消费者的开发
  • 负载均衡和集群容错策略
  • 服务降级与熔断配置
  • 服务治理和监控运维
  • 最佳实践和问题排查
IT运维培训文档系列 | 第250篇 | Dubbo微服务框架培训

本文由风哥教程整理发布,仅用于学习测试使用,转载注明出处:http://www.fgedu.net.cn/10327.html

相关推荐

联系我们

在线咨询：点击这里给我发消息

微信号：itpux-com

工作日：9:30-18:30，节假日休息