开发后端框架——Dubbo

Posted AmosTian

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了开发后端框架——Dubbo相关的知识,希望对你有一定的参考价值。

前置知识:

微服务

Dubbo是高性能的RPC框架,主要目的是支持远程调用

Dubbo

Dubbo是一个 高性能和透明化的RPC框架 ,主要目的是支持远程调用,是阿里巴巴SOA服务化治理方案的核心框架

最大的特点是按照分层的方式来 架构 ,使用这种方式可以使各个层之间解耦合(或者最大限度地松耦合)

服务模型 的角度来看,Dubbo采用的是一种生产者消费者的模型,要么是提供方提供服务,要么是消费方消费服务,所以基于这一点可以抽象出服务提供方(Provider)和服务消费方(Consumer)两个角色

RPC(Remote Procedure Call Protocal)——远程过程调用协议

  • 通过网络从远程计算机程序请求服务

  • 采用 客户机/服务器 模式。

    • 客户机:请求程序
    • 服务器:服务提供程序
  • 调用过程

    1. 客户机调用进程发送一个有参数的调用信息到服务进程,然后等待应答信息
    2. 服务端,进程保持睡眠状态直到调用信息到达为止。当一个调用信息到达,服务器获得进程参数,计算结果,发送答复信息,等待下一个调用信息
    3. 客户端调用进程接收答复信息,获得进程结果,调用执行继续进行

框架说明

文档地址

背景——网站应用的演进

单一应用架构

当网站流量很小,只需 一个应用将所有功能部署在一起 ,减少部署节点和成本。此时,用于简化CRUD的数据访问框架(ORM)是关键

垂直应用架构

访问量逐渐增大 ,单一应用通过增加机器带来的加速度越来越小,提高效率的方法之一是将应用拆成互不相干的几个应用。此时,用于加速前端页面开发的 Web框架(MVC)是关键

分布式服务架构

当垂直应用越来越多,应用之间交互不可避免,将 核心业务抽取出来作为独立的服务,逐渐形成稳定的服务中心 ,使前端应用能更快速的响应多变的市场需求。此时 用于提高业务复用及整合的分布式服务框架(RPC)是关键

流动计算框架

当服务越来越多,容量的评估、小服务资源的浪费等问题逐渐显现。此时,需增加一个调度中心基于访问中心压力,实时管理集群容量,提高集群利用率。此时用于提高机器利用率的资源调度和治理中心(SOA) 是关键

Dubbo解决的需求

在大规模服务化之前,应用可能只是通过 RMI 或 Hessian 等工具,简单的暴露和引用远程服务,通过配置服务的URL地址进行调用,通过 F5 等硬件进行负载均衡。

当服务越来越多时,服务 URL 配置管理变得非常困难,F5 硬件负载均衡器的单点压力也越来越大。 此时需要一个 服务注册中心动态地注册和发现服务,使服务的位置透明。并通过在消费方获取服务提供方地址列表,实现软负载均衡和 Failover,降低对 F5 硬件负载均衡器的依赖,也能减少部分成本。

当进一步发展,服务间依赖关系变得错踪复杂,甚至分不清哪个应用要在哪个应用之前启动,架构师都不能完整的描述应用的架构关系。 这时,需要 治理中心 自动画出应用间的依赖关系图,以帮助架构师理清关系。

接着,服务的调用量越来越大,服务的容量问题就暴露出来,这个服务需要多少机器支撑?什么时候该加机器? 为了解决这些问题,第一步,监控中心 要将服务现在每天的调用量,响应时间,都 统计 出来,作为容量规划的参考指标。其次 ,调度中心 要可以动态调整权重,在线上,将某台机器的权重一直加大,并在加大的过程中记录响应时间的变化,直到响应时间到达阈值,记录此时的访问量,再以此访问量乘以机器数反推总容量。

Dubbo架构

节点角色说明
Provider暴露服务的服务提供方
Consumer调用远程服务的服务消费方
Registry服务注册与发现的注册中心,支持ZooKeeper和Redis
Monitor统计服务的调用次数和调用时间的监控中心
Container服务运行容器
  1. 服务容器负责启动、加载、运行服务提供者
  2. 服务提供者在启动时,向注册中心注册自己提供的服务
  3. 服务消费者在启动时,向注册中心订阅自己所需的服务
  4. 注册中心返回服务提供者地址列表给消费者,如果有变更,注册中心将基于长连接推送变更数据给消费者。
  5. 服务消费者,从提供者地址列表中,基于软负载均衡算法,选一台提供者进行调用,如果调用失败,再选另一台调用。
  6. 服务消费者和提供者,在内存中累计调用次数和调用时间,定时每分钟发送一次统计数据到监控中心。

注册中心

注册中心文档

流程说明

  • 服务提供者启动时:向 /dubbo/packageName/providers 目录下写入自己的URL地址
  • 服务消费者启动时:订阅 /dubbo/packageName/providers 目录下的提供者的URL地址,并向 /dubbo/packageName/consumers 目录下写入自己的URL地址
  • 监控中心启动时:订阅 /dubbo/packageName 目录下的所有提供者和消费者URL地址

功能

  • 注册中心 重启时,能自动恢复注册数据,以及订阅请求
  • 当提供者出现断电等异常停机时,注册中心能自动删除提供者信息
  • 当会话过期时,能自动恢复注册数据,以及订阅请求
  • 当设置 <dubbo:registry check="false" /> 时,记录失败注册和订阅请求,后台定时重试
  • 可通过 <dubbo:registry username="admin" password="1234" /> 设置 zookeeper 登录信息
  • 可通过 <dubbo:registry group="dubbo" /> 设置 zookeeper 的根节点,不配置将使用默认的根节点
  • 支持 * 号通配符 <dubbo:reference group="*" version="*" />,可订阅服务的所有分组和所有版本的提供者

docker——Zookeeper

#拉取zk镜像
docker pull zookeeper:3.4

#创建并启动容器
docker run -d --name zk -p 2181:2181 zookeeper:3.4

服务导出

  1. Dubbo会将带有Dubbo服务注解 @DubboService 或者 @Service 的类,进行解析,得到开发人员定义的服务参数,包括服务名称、服务接口、服务协议、服务超时时间等,得到一个ServiceBean

  2. 调用ServiceBean的 export() 方法进行导出

    导出过程会将服务信息注册到注册中心,对于多个协议多个注册中心的情况,会逐注册中心,逐协议进行注册

  3. 将服务信息注册到注册中心后,还会绑定一些监听器,监听动态配置中的变更

  4. 还会根据服务协议启动对应的Web服务器或网络框架,如Tomcat,Netty

1. 创建Maven工程

父工程

服务提供方子模块

2. 导入依赖

父工程的配置

<!--添加SpringBoot parent支持-->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.0.RELEASE</version>
</parent>

<dependencies>
    <!--添加SpringBoot测试-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <!--添加dubbo的springboot依赖-->
    <dependency>
        <groupId>com.alibaba.boot</groupId>
        <artifactId>dubbo-spring-boot-starter</artifactId>
        <version>0.2.0</version>
    </dependency>
    <!--添加dubbo依赖-->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>dubbo</artifactId>
        <version>2.6.4</version>
    </dependency>
</dependencies>

<build>
    <plugins>
        <!--添加springboot的maven插件-->
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

服务提供方的配置

<dependencies>
    <!--添加springboot依赖,非web项目-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <!--添加注册中心-->
    <dependency>
        <groupId>org.apache.zookeeper</groupId>
        <artifactId>zookeeper</artifactId>
        <version>3.4.13</version>
    </dependency>
    <dependency>
        <groupId>com.github.sgroschupf</groupId>
        <artifactId>zkclient</artifactId>
        <version>0.1</version>
    </dependency>
</dependencies>

3. 创建POJO——User对象

package com.mydubbo.pojo;

// 使用dubbo要求传输的对象必须实现序列化接口
public class User implements java.io.Serializable 

    private static final long serialVersionUID = -7341603933521593227L;

    private Long id;

    private String username;

    private String password;

    private Integer age;

    public Long getId() 
        return id;
    

    public void setId(Long id) 
        this.id = id;
    

    public String getUsername() 
        return username;
    

    public void setUsername(String username) 
        this.username = username;
    

    public String getPassword() 
        return password;
    

    public void setPassword(String password) 
        this.password = password;
    

    public Integer getAge() 
        return age;
    

    public void setAge(Integer age) 
        this.age = age;
    

4. 创建Service——UserService接口提供查询服务

package com.mydubbo.service;

import com.mydubbo.pojo.User;

import java.util.List;

public interface UserService 

    /**
     * 查询所有的用户数据
     *
     * @return
     */
    List<User> queryAll();

5. 编写 application.properties

服务端 resources下

# Spring boot application
spring.application.name = mydubbo-service
server.port = 9090

# Service version
dubbo.service.version = 1.0.0

# 服务扫描包
dubbo.scan.basePackages  = com.mydubbo.service

# 应用名称
dubbo.application.name = dubbo-provider-demo

# 协议及端口
dubbo.protocol.name = dubbo
dubbo.protocol.port = 20882

# zk注册中心
dubbo.registry.address = zookeeper://8.140.130.91:2181
dubbo.registry.client = zkclient

6. 创建ServiceImpl——UserServiceImpl实现类

package com.mydubbo.service.impl;

import java.util.ArrayList;
import java.util.List;

import com.alibaba.dubbo.config.annotation.Service;
import com.mydubbo.pojo.User;
import com.mydubbo.service.UserService;

@Service(version = "$dubbo.service.version") //声明这是一个dubbo服务
public class UserServiceImpl implements UserService 

    /**
     * 实现查询,这里做模拟实现,不做具体的数据库查询
     */
    public List<User> queryAll() 
        List<User> list = new ArrayList<User>();
        for (int i = 0; i < 10; i++) 
            User user = new User();
            user.setAge(10 + i);
            user.setId(Long.valueOf(i + 1));
            user.setPassword("123456");
            user.setUsername("username_" + i);
            list.add(user);
        
        System.out.println("---------Service 3------------");
        return list;
    

7. 编写启动类

POJO,Service包与启动类同级

package com.mydubbo;

import org.springframework.boot.WebApplicationType;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;

@SpringBootApplication
public class DubboProvider 
    public static void main(String[] args) 
        new SpringApplicationBuilder(DubboProvider.class)
            .web(WebApplicationType.NONE) // 非 Web 应用
            .run(args);
    

服务引入

  1. 使用 @Reference 这个注解引入注解,Dubbo会将注解和服务的信息解析出来,得到想当前引用的服务名,服务接口等信息
  2. 然后从注册中心,查询服务信息,得到服务提供者的信息,并在存在注册中心的消费者目录中
  3. 根据查询到的服务提供者信息,生成一个服务提供方的代理对象,放入Spring容器中作为Bean

1. 创建工程

2. 导入依赖

<dependencies>
    <!--添加springboot依赖,非web项目-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>org.apache.zookeeper</groupId>
        <artifactId>zookeeper</artifactId>
        <version>3.4.13</version>
    </dependency>
    <dependency>
        <groupId>com.github.sgroschupf</groupId>
        <artifactId>zkclient</artifactId>
        <version>0.1</version>
    </dependency>
    
    <!--引入服务提供方的依赖-->
    <dependency>
        <groupId>com.mydubbo</groupId>
        <artifactId>dubbo-service</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>
</dependencies>

3. application.properties配置文件

# Spring boot application
spring.application.name = mydubbo-consumer
server.port = 9091

# 应用名称
dubbo.application.name = dubbo-consumer-demo

# zk注册中心
dubbo.registry.address = zookeeper://8.140.130.91:2181
dubbo.registry.client = zkclient

4. 编写测试用例

package com.mydubbo;

import com.alibaba.dubbo.config.annotation.Reference;
import com.mydubbo.pojo.User;
import com.mydubbo.service.UserService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.List;

@RunWith(SpringRunner.class)
@SpringBootTest
public class TestUserService 
    @Reference(version = "1.0.0")
    private UserService userService;

    @Test
    public void testQueryAll()
        List<User> users = this.userService.queryAll();

        for (User user : users) 
            System.out.println(user);
        
    

5. 测试

Dubbo admin&monitor

Dubbo提供了可视化的界面管理工具,方便我们对服务进行管理

官网链接

1. 配置jdk+docker镜像

不配置 docker 镜像

1. 本地下载 tar.gz

华为镜像

OpenJDK镜像

2. 解压到/opt/java/jdk8
tar -xzvf jdk-8u151-linux-x64.tar.gz -C /opt/java/jdk8
3. 配置环境变量
vim /etc/profile

export JAVA_HOME=/opt/java/jdk8/jdk1.8.0_151  #jdk安装目录
export JRE_HOME=$JAVA_HOME/jre
export CLASSPATH=.:$JAVA_HOME/lib:$JRE_HOME/lib:$CLASSPATH
export JAVA_PATH=$JAVA_HOME/bin:$JRE_HOME/bin
export PATH=$PATH:$JAVA_PATH
4. 测试

构建docker镜像

1. 新建 /dc/jdk8
2. 将JDK tar 包放入

3. 创建并编写 Dockerfile 配置文件
FROM docker.io/jeanblanchard/alpine-glibc
MAINTAINER zoe
RUN mkdir -p /usr/local/java/jdk
WORKDIR /usr/local/java/jdk
ADD jdk-8u151-linux-x64.tar.gz /usr/local/java/jdk
ENV JAVA_HOME /usr/local/java/jdk/jdk1.8.0_151
ENV PATH $PATH:$JAVA_HOME/bin

4. 构建镜像
docker build -t jdk8 .

5. 查看镜像
docker image list

6. 运行jdk8镜像
docker run -di --name=jdk8 jdk8

#查看jdk在容器内部是否生效,需进入容器内部执行。
docker exec -it jdk8 /bin/sh

此时在宿主机上执行“java -version”发现jdk并未生效,因为jdk只运行在容器内,这也说明了容器内的环境与外界环境无关联

2. 使用maven构建项目

解压maven安装包

yum -y install wget

wget http://mirrors.cnnic.cn/apache/maven/maven-3/3.6.3/binaries/apache-maven-3.6.3-bin.tar.gz

tar -zxvf apache-maven-3.6.3-bin.tar.gz -C /opt

配置环境变量

vim /etc/profile
# 写入以下内容
export MVN_HOME=/root/apache-maven-3.6.3
export PATH=$VN_HOME/bin:$PATH

编译

source /etc/profile

查看mvn版本

mvn -version

3. 克隆dubbo-admin项目到主机

git clone https://github.com/apache/dubbo-admin.git

# 国内镜像
git clone https://github.com.cnpmjs.org/apache/dubbo-admin.git

4. 配置注册中心

dubbo-admin-server/src/main/resources/application.properties 中指定注册中心地址

dubbo.registry.address=zookeeper://8.140.130.91:2181

5. mvn构建

# 进入项目录
cd /opt/incubator-dubbo-ops/

# 清理包
mvn clean package -Dmaven.test.skip=true

6. 通过mvn插件启动程序

mvn --projects dubbo-admin-server spring-boot:run

7. 访问dubbo-admin

8.140.130.91:8080

# Default username and password is root

服务的负载均衡

在集群负载均衡时,Dubbo 提供了多种均衡策略,缺省为 random 随机调用

文档

负载均衡策略

Random LoadBalance
  • 随机,按权重设置随机概率。
  • 在一个截面上碰撞的概率高,但调用量越大分布越均匀,而且按概率使用权重后也比较均匀,有利于动态调整提供者权重。
RoundRobin LoadBalance
  • 轮询,按公约后的权重设置轮询比率。
  • 存在慢的提供者累积请求的问题,比如:第二台机器很慢,但没挂,当请求调到第二台时就卡在那,久而久之,所有请求都卡在调到第二台上。
LeastActive LoadBalance
  • 最少活跃调用数,相同活跃数的随机,活跃数指 调用前后计数差
  • 使慢的提供者收到更少请求,因为越慢的提供者的调用前后计数差会越大。
ConsistentHash LoadBalance
  • 一致性 Hash,相同参数的请求总是发到同一提供者
  • 当某一台提供者挂时,原本发往该提供者的请求,基于虚拟节点,平摊到其它提供者,不会引起剧烈变动。
  • 算法参见:http://en.wikipedia.org/wiki/Consistent_hashing
  • 缺省只对第一个参数 Hash,如果要修改,请配置 <dubbo:parameter key="hash.arguments" value="0,1" />
  • 缺省用 160 份虚拟节点,如果要修改,请配置 <dubbo:parameter key="hash.nodes" value="320" />

指定负载均衡策略

消费者注解

@Reference(version = "1.0.0", loadbalance = "roundrobin")

测试

修改线程接口配置

将项目设置为多线程模式

idea默认的是单例模式


跑一下 看控制台输出

dubbo-admin查看

协议

链接

dubbo协议【推荐】

Dubbo 缺省协议采用 单一长连接NIO 异步通讯适合

  • 小数据量大并发的服务调用
  • 服务消费者机器数远大于服务提供者机器数的情况。

反之,Dubbo 缺省协议 不适合

  • 传送大数据量的服务,比如传文件,传视频等

  • Transporter(传输): mina, netty, grizzy
  • Serialization(序列化): dubbo, hessian2, java, json
  • Dispatcher(分发调度): all, direct, message, execution, connection
  • ThreadPool(线程池): fixed, cached

以上是关于开发后端框架——Dubbo的主要内容,如果未能解决你的问题,请参考以下文章

Java的后端开发框架

新兵日记---java语法初体验

JAVA面试潜规则大公开,能帮你多拿5k薪资

如何用java进行移动端后台开发

前后端分离Java后端主流开发环境框架20200622

java开发天天写接口,内含福利