Dubbo实战运用Demo、SpringBoot整合Dubbo、Dubbo中超时重试和负载均衡策略

Dubbo与SpringBoot整合

项目结构：

工程依赖POM

    
        
        
            org.springframework.boot
            spring-boot-dependencies
            ${spring-boot.version}
            pom
            import
        

        
        
            org.apache.dubbo
            dubbo-dependencies-bom
            ${dubbo-version}
            pom
            import
        

        
            org.apache.dubbo
            dubbo
            ${dubbo-version}
            
                
                    org.springframework
                    spring
                
                
                    javax.servlet
                    servlet-api
                
                
                    log4j
                    log4j
                
            
        
    



    
    
        org.apache.dubbo
        dubbo-spring-boot-starter
        ${dubbo-version}
    
    
    
        org.apache.dubbo
        dubbo
    
    
    
        org.springframework.boot
        spring-boot-starter-web
        ${spring-boot.version}
    
    
    
        org.apache.curator
        curator-framework
        4.0.1
    
    
    
        org.apache.dubbo
        dubbo-dependencies-zookeeper
        ${dubbo-version}
        pom
        
            
                org.slf4j
                slf4j-log4j12
            
        
    



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

接口服务

为便于客户端与服务端的RPC接口引用， 这里对RPC接口做统一封装。

提供的接口：

public interface OrderService {
	
	/**
	 * 获取订单详情
	 *
	 * @param orderId
	 * @return
	 */
	String getOrder(Long orderId);
}
1
2
3
4
5
6
7
8
9
10

服务端工程

pom文件依赖：

    
        com.yida
        dubbo-interface
        ${project.parent.version}
    

    
    
        org.apache.dubbo
        dubbo-spring-boot-starter
        ${dubbo-version}
    
    
    
        org.apache.dubbo
        dubbo
    


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

RPC接口服务

@DubboService(version = "${dubbo.spring.provider.version}")
public class OrderServiceImpl implements OrderService {
	/**
	 * 服务端口
	 */
	@Value("${server.port}")
	private String serverPort;
	
	@Value("${dubbo.spring.provider.version}")
	private String serviceVersion;
	
	@Override
	public String getOrder(Long orderId) {
		// try {
		// 	Thread.sleep(1500);
		// } catch (InterruptedException e) {
		// 	e.printStackTrace();
		// }
		// System.out.println(1/0);
		String result = "get order detail ,orderId=" + orderId + ",serverPort=" + serverPort + ",serviceVersion=" + serviceVersion + "\t" + UUID.randomUUID();
		System.out.println(result);
		return result;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

通过DubboService注解， 声明为RPC服务，version可以标识具体的版本号， 消费端需匹配保持一致。

配置文件

server:
  port: 18081

spring:
  application:
    name: dubbo-springboot-demo-provider

dubbo:
  scan:
    base-packages: com.yida
  protocol:
    name: dubbo  # Dubbo 通讯协议
    port: -1  # Dubbo服务提供的端口， 配置为-1，代表为随机端口 默认20880
  registry:
    address: zookeeper://112.124.**.**:2181
    file: ${user.home}/dubbo-cache/${spring.application.name}/dubbo.cache
  metadata-report:
    timeout: 90000
  config-center:
    timeout: 90000
  spring:
    provider:
      version: 1.0.0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

Spring Boot启动程序

@SpringBootApplication
public class DubboProviderApplication {
	public static void main(String[] args) {
		SpringApplication.run(DubboProviderApplication.class, args);
	}
}
1
2
3
4
5
6

---

消费端工程

pom文件依赖：

    
        com.yida
        dubbo-interface
        ${project.parent.version}
    

    
    
        org.apache.dubbo
        dubbo-spring-boot-starter
        ${dubbo-version}
    


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

消费端控制器

@Controller
@RequestMapping("/order")
public class OrderController {
	
	private final Logger logger = LoggerFactory.getLogger(getClass());
	
	
	/**
	 * 订单服务接口
	 */
	@DubboReference(version = "${dubbo.spring.provider.version}",timeout = 1000,retries = 3,loadbalance = "roundrobin")
	private OrderService orderService;
	
	/**
	 * 获取订单详情接口
	 *
	 * @param orderId
	 * @return
	 */
	@RequestMapping("/getOrder")
	@ResponseBody
	public String getOrder(Long orderId) {
		String result = null;
		try {
			result = orderService.getOrder(orderId);
		} catch (Exception e) {
			logger.error(e.getMessage(), e);
		}
		return result;
	}
	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

配置文件

server:
  port: 18084

spring:
  application:
    name: dubbo-spring-consumer

dubbo:
  spring:
    provider:
      version: 1.0.0
  registry:
    address: zookeeper://112.124.**.**:2181
    file: ${user.home}/dubbo-cache/${spring.application.name}/dubbo.cache
  metadata-report:
    timeout: 90000
  config-center:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

timeout: 90000
1

---

工程调用

1. 启动ZK注册中心
2. 启动服务端， 运行DubboSpringProviderApplication
3. 启动消费端， 运行DubboSpringConsumerApplication
4. 请求获取订单接口， 地址：http://localhost:18084/order/getOrder?orderId=1234

调用成功：

---

不同配置覆盖关系

关于配置参看官方文档：https://dubbo.apache.org/zh/docsv2.7/user/configuration/

演示：
1、通过ProviderConfig配置全局超时（可通过yml配置覆盖）
2、在@DubboService注解上配置接口超时
3、在@DubboService注解上配置接口方法超时
4、在消费方进行配置，查看覆盖情况

配置规则：

• 方法级优先，接口级次之，全局配置再次之。
• 如果级别一样，则消费方优先，提供方次之。

Dubbo消费超时在客户端设置：

增加配置类：

/**
 * 设置超时时间
 */
@Configuration
public class DubboCustomerConfig {
	
	@Bean
	public ProviderConfig registryConfig() {
		ProviderConfig providerConfig = new ProviderConfig();
		providerConfig.setTimeout(1000);
		
		return providerConfig;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

同时可以在接口、服务、方法中设置超时时间，优先级关系看上面配置规则

_/**

• 订单服务接口
  */
  @DubboReference(version = “${dubbo.spring.provider.version}”,timeout = 1000,retries = 3,loadbalance = “roundrobin”)
  _private OrderService orderService;

---

重试与容错处理机制

容错机制：

• Failfast Cluster快速失败，只发起一次调用，失败立即报错。通常用于非幂等性的写操作，比如新增记录。
• Failsafe Cluster失败安全，出现异常时，直接忽略。通常用于写入审计日志等操作。
• Failback Cluster失败自动恢复，后台记录失败请求，定时重发。通常用于消息通知操作。
• Forking Cluster并行调用多个服务器，只要一个成功即返回。通常用于实时性要求较高的读操作，但需要浪费更多服务资源。可通过 forks=“2” 来设置最大并行数。
• Broadcast Cluster广播调用所有提供者，逐个调用，任意一台报错则报错。通常用于通知所有提供者更新缓存或日志等本地资源信息。

:::warning
调整客户端重试次数：
/**
* 订单服务接口
*/
@DubboReference(version = “${dubbo.spring.provider.version}”,retries = 3)
private OrderService orderService;
:::

负载均衡机制

Dubbo默认采用的是随机负载策略。

• Random LoadBalance：默认随机，按权重设置随机概率。在一个截面上碰撞的概率高，但调用量越大分布越均匀，而且按概率使用权重后也比较均匀，有利于动态调整提供者权重。
• RoundRobin LoadBalance加权轮询负载均衡，按公约后的权重设置轮询比率。存在慢的提供者累积请求的问题，比如：第二台机器很慢，但没挂，当请求调到第二台时就卡在那，久而久之，所有请求都卡在调到第二台上。
• LeastActive LoadBalance最少活跃调用数，相同活跃数的随机，活跃数指调用前后计数差。活跃数其实就是在当前这个服务调用者中当前这个时刻 某个invoker（某个服务提供者的某个接口）某个方法的调用并发数，在调用之前+1 调用之后-1的一个计数器，如果出现多个活跃数相等invoker的时候使用随机算法来选取一个
• ConsistentHash LoadBalance一致性 Hash，相同参数的请求总是发到同一提供者。当某一台提供者挂时，原本发往该提供者的请求，基于虚拟节点，平摊到其它提供者，不会引起剧烈变动。
• ShortestResponseLoadBalance 最短响应时间负载均衡。从多个服务提供者中选择出调用成功的且响应时间最短的服务提供者，由于满足这样条件的服务提供者有可能有多个。所以当选择出多个服务提供者后要根据他们的权重做分析，如果权重一样，则随机。