Dubbo

Dubbo

Dubbo

Posted by John Doe on 2021-12-05
Words 1.9k and Reading Time 8 Minutes
Viewed Times

Dubbo 概述

Dubbo概念

  • Dubbo是阿里巴巴公司开源的一个高性能、轻量级的 Java RPC 框架。

  • 致力于提供高性能和透明化的 RPC 远程服务调用方案，以及 SOA 服务治理方案。

  • 官网：http://dubbo.apache.org

Dubbo架构

节点角色说明

  • Provider：暴露服务的服务提供方

  • Container：服务运行容器

  • Consumer：调用远程服务的服务消费方

  • Registry：服务注册与发现的注册中心

  • Monitor：统计服务的调用次数和调用时间的监控中心

Demo地址

Dubbo-demo[https://github.com/raineddown/Dubbo-demo]

Dubbo快速入门项目结构：

实现步骤

①启动zookeeper

②创建服务提供者Provider模块

③创建服务消费者Consumer模块

④在服务提供者模块编写 UserServiceImpl 提供服务

⑤在服务消费者中的 UserController 远程调用UserServiceImpl 提供的服务

⑥配置zookeeper地址，分别启动两个服务，测试

代码:

client:

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
import com.itheima.pojo.User;
import com.itheima.service.UserService;
import org.apache.dubbo.config.annotation.Reference;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/user")
public class UserController {

    //注入Service
    //@Autowired//本地注入

    /*
        1. 从zookeeper注册中心获取userService的访问url
        2. 进行远程调用RPC
        3. 将结果封装为一个代理对象。给变量赋值

     */

    @Reference//远程注入
    private UserService userService;


    @RequestMapping("/sayHello")
    public String sayHello(){
        return userService.sayHello();
    }

    /**
     * 根据id查询用户信息
     * @param id
     * @return
     */

    @RequestMapping("/find")
    public User find(int id){
        return userService.findUserById(id);
    }

}

server:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import com.itheima.pojo.User;
import com.itheima.service.UserService;
import org.apache.dubbo.config.annotation.Service;


//@Service//将该类的对象创建出来，放到Spring的IOC容器中  bean定义

@Service//将这个类提供的方法（服务）对外发布,Dubbo的注解不是spring的注解。将访问的地址 ip，端口，路径注册到注册中心中
public class UserServiceImpl implements UserService {

    public String sayHello() {
        return "hello dubbo hello!~";
    }


    public User findUserById(int id) {
        //查询User对象
        User user = new User(1,"zhangsan","123");

        return user;
    }
}

Dubbo高级特性

Dubbo高级特性超时与重试

  • 服务消费者在调用服务提供者的时候发生了阻塞、等待的情形，这个时候，服务消费者会一直等待下去。

  • 在某个峰值时刻，大量的请求都在同时请求服务消费者，会造成线程的大量堆积，势必会造成雪崩。

  • dubbo 利用超时机制来解决这个问题，设置一个超时时间，在这个时间段内，无法完成服务访问，则自动断开连接。

  • 使用timeout属性配置超时时间，默认值1000，单位毫秒。

client:

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
   @RestController
@RequestMapping("/user")
public class UserController {

    //注入Service
    //@Autowired//本地注入

    /*
        1. 从zookeeper注册中心获取userService的访问url
        2. 进行远程调用RPC
        3. 将结果封装为一个代理对象。给变量赋值

     */

    @Reference(timeout = 1000)//远程注入，客户端超时配置会覆盖服务端配置(服务端3秒配置被覆盖)
    private UserService userService;


    @RequestMapping("/sayHello")
    public String sayHello(){
        return userService.sayHello();
    }

    /**
     * 根据id查询用户信息
     * @param id
     * @return
     */
    int i = 1;
    @RequestMapping("/find")
    public User find(int id){

        new Thread(new Runnable() {
            public void run() {
                while (true){
                    System.out.println(i++);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();


        return userService.findUserById(id);
    }

}

server:

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
import org.apache.dubbo.config.annotation.Service;

//将这个类提供的方法（服务）对外发布。将访问的地址 ip，端口，路径注册到注册中心中
@Service(timeout = 3000,retries = 2)//当前服务3秒超时,重试2次，一共3次
public class UserServiceImpl implements UserService {

    int i = 1;
    public String sayHello() {
        return "hello dubbo hello!~";
    }


    public User findUserById(int id) {
        System.out.println("服务被调用了："+i++);
        //查询User对象
        User user = new User(1,"zhangsan","123");
        //数据库查询很慢，查了5秒

        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return user;
    }
}

客户端，@Reference(timeout = 1000)注解存在，控制台输出1后报错，1秒超时。客户端超时配置会覆盖服务端配置(服务端3秒配置被覆盖)

服务端，若客户端@Reference没有超时配置，控制台输出3后超时报错。

重试

控制台输出：

服务被调用了: 1

服务被调用了: 2

服务被调用了: 3

服务被调用三次，retries不写默认为2。

Dubbo高级特性多版本

server1:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import org.apache.dubbo.config.annotation.Service;

//将这个类提供的方法（服务）对外发布。将访问的地址 ip，端口，路径注册到注册中心中
@Service(version = "v1.0")
public class UserServiceImpl implements UserService {

    public String sayHello() {
        return "hello dubbo hello!~";
    }


    public User findUserById(int id) {
        System.out.println("old...");
        //查询User对象
        User user = new User(1,"zhangsan","123");

        return user;
    }
}

server2:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import org.apache.dubbo.config.annotation.Service;

//将这个类提供的方法（服务）对外发布。将访问的地址 ip，端口，路径注册到注册中心中
@Service(version = "v2.0")
public class UserServiceImpl2 implements UserService {

    public String sayHello() {
        return "hello dubbo hello!~";
    }


    public User findUserById(int id) {
        System.out.println("new....");
        //查询User对象
        User user = new User(1,"zhangsan","123");

        return user;
    }
}

client:

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
@RestController
@RequestMapping("/user")
public class UserController {

    /*
        1. 从zookeeper注册中心获取userService的访问url
        2. 进行远程调用RPC
        3. 将结果封装为一个代理对象。给变量赋值

     */

    @Reference(version = "v2.0")//远程注入
    private UserService userService;


    @RequestMapping("/sayHello")
    public String sayHello(){
        return userService.sayHello();
    }

    /**
     * 根据id查询用户信息
     * @param id
     * @return
     */

    @RequestMapping("/find")
    public User find(int id){

        return userService.findUserById(id);
    }

}

根据版本选择对应的接口实现类，类似于spring @Qualifier(“Version”)和@Resource（name=”Version”）注解。

Dubbo高级特性负载均衡

负载均衡策略（4种）：

•Random ：按权重随机，默认使用该策略。按权重设置随机概率。

•RoundRobin ：按权重轮询。

•LeastActive：最少活跃调用数，相同活跃数的随机。

•ConsistentHash：一致性 Hash，相同参数的请求总是发到同一提供者。

client:

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
@RestController
@RequestMapping("/user")
public class UserController {

    @Reference(loadbalance = "random")//远程注入，loadbalance策略
    private UserService userService;


    @RequestMapping("/sayHello")
    public String sayHello(){
        return userService.sayHello();
    }

    /**
     * 根据id查询用户信息
     * @param id
     * @return
     */

    @RequestMapping("/find")
    public User find(int id){

        return userService.findUserById(id);
    }

}

server:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Service(weight = 100) //weight权重
public class UserServiceImpl implements UserService {

    public String sayHello() {
        return "3......";
    }


    public User findUserById(int id) {
        System.out.println("old...");
        //查询User对象
        User user = new User(1,"zhangsan","123");

        return user;
    }
}

Dubbo高级特性集群容错

client:

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
@RestController
@RequestMapping("/user")
public class UserController {

    //注入Service
    //@Autowired//本地注入

    /*
        1. 从zookeeper注册中心获取userService的访问url
        2. 进行远程调用RPC
        3. 将结果封装为一个代理对象。给变量赋值

     */

    @Reference(cluster = "failover")//远程注入
    private UserService userService;


    @RequestMapping("/sayHello")
    public String sayHello(){
        return userService.sayHello();
    }

    /**
     * 根据id查询用户信息
     * @param id
     * @return
     */

    @RequestMapping("/find")
    public User find(int id){

        return userService.findUserById(id);
    }

}

server:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
@Service
public class UserServiceImpl implements UserService {

    public String sayHello() {
        return "hello dubbo hello!~";
    }


    public User findUserById(int id) {
        System.out.println("3...");
        //查询User对象
        User user = new User(1,"zhangsan","123");
/*
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }*/

        return user;
    }
}

Dubbo服务降级

官网地址[https://dubbo.apache.org/zh/docs/advanced/service-downgrade/]

  • mock=force:return null 表示消费方对该服务的方法调用都直接返回 null 值，不发起远程调用。用来屏蔽不重要服务不可用时对调用方的影响。
  • 还可以改为 mock=fail:return null 表示消费方对该服务的方法调用在失败后，再返回 null 值，不抛异常。用来容忍不重要服务不稳定时对调用方的影响。

client：

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
@RestController
@RequestMapping("/user")
public class UserController {

    @Reference(mock=force:return null)//不再去调用userService服务
    private UserService userService;


    @RequestMapping("/sayHello")
    public String sayHello(){
        return userService.sayHello();
    }

    /**
     * 根据id查询用户信息
     * @param id
     * @return
     */

    @RequestMapping("/find")
    public User find(int id){

        return userService.findUserById(id);
    }

}

This is copyright.

...

...

00:00
00:00
FEATURED TAGS
Dubbo
FRIENDS