2021最新版Dubbo入门教程

Dubbo

一 基本介绍

1.1 软件行业

1.1.1 软件分类

在如今的软件市场中，基于用户群体的不同，一般将软件行业分为两类，即传统软件行业和互联网软件行业

• ► 传统软件行业：面向企业开发应用软件，软件的最终使用者为企业内部员工。
• ► 互联网软件行业：面向广大互联网市场开发软件，软件的最终使用者为互联网的所有用户。
• ►基于面向的用户群体的不同，两类软件行业在实际的开发、部署、运维等过程中也存在着很大的区别。

1.1.2 架构分类

单体式架构

传统的企业级内部应用系统开发中，一般采用的多为单体式架构。所谓单体式架构，即将项目中的所有源码都放置于一个总项目中进行开发、部署和管理。项目可以分为多个模块，但多个模块的源码均属于一个项目，不同模块的开发者共同维护一份项目源码。

微服务架构

• 微服务架构即对原来庞大的项目进行切分，每一个切分后的模块独立形成一个新的项目（后称服务），拆分后的服务和服务之间可按照一定方式（分布式）进行通信的架构。

• 在微服务架构中，项目通信的方式一般有两种：一种是基于HTTP的RESTful风格的远程服务通信，另一种是基于RPC的远程服务通信。

• 我们把微服务架构中调用服务的一方称为Consumer（消费者），被调用的一方称为Provider（提供者）。另外在微服务架构中，分布式和集群也是常见的架构部署方式。

1.2 背景

随着互联网的发展，网站应用的规模不断扩大，常规的垂直应用架构已无法应对，分布式服务架构以及流动计算架构势在必行，亟需一个治理系统确保架构有条不紊的演进。

1.2.1 单一应用架构

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

1.2.2 垂直应用架构

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

1.2.3 分布式服务架构

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

1.2.4 流动计算架构

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

1.3 架构

1.3.1 节点角色说明

节点	角色说明
Provider	暴露服务的服务提供方
Consumer	调用远程服务的服务消费方
Registry	服务注册与发现的注册中心
Monitor	统计服务的调用次数和调用时间的监控中心
Container	服务运行容器

1.3.2 调用关系说明

1. 服务容器负责启动，加载，运行服务提供者。
2. 服务提供者在启动时，向注册中心注册自己提供的服务。
3. 服务消费者在启动时，向注册中心订阅自己所需的服务。
4. 注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者。
5. 服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。
6. 服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心。

Dubbo 架构具有以下几个特点，分别是连通性、健壮性、伸缩性、以及向未来架构的升级性。

1.3.3 连通性

• 注册中心负责服务地址的注册与查找，相当于目录服务，服务提供者和消费者只在启动时与注册中心交互，注册中心不转发请求，压力较小
• 监控中心负责统计各服务调用次数，调用时间等，统计先在内存汇总后每分钟一次发送到监控中心服务器，并以报表展示
• 服务提供者向注册中心注册其提供的服务，并汇报调用时间到监控中心，此时间不包含网络开销
• 服务消费者向注册中心获取服务提供者地址列表，并根据负载算法直接调用提供者，同时汇报调用时间到监控中心，此时间包含网络开销
• 注册中心，服务提供者，服务消费者三者之间均为长连接，监控中心除外
• 注册中心通过长连接感知服务提供者的存在，服务提供者宕机，注册中心将立即推送事件通知消费者
• 注册中心和监控中心全部宕机，不影响已运行的提供者和消费者，消费者在本地缓存了提供者列表
• 注册中心和监控中心都是可选的，服务消费者可以直连服务提供者

1.3.4 健状性

• 监控中心宕掉不影响使用，只是丢失部分采样数据
• 数据库宕掉后，注册中心仍能通过缓存提供服务列表查询，但不能注册新服务
• 注册中心对等集群，任意一台宕掉后，将自动切换到另一台
• 注册中心全部宕掉后，服务提供者和服务消费者仍能通过本地缓存通讯
• 服务提供者无状态，任意一台宕掉后，不影响使用
• 服务提供者全部宕掉后，服务消费者应用将无法使用，并无限次重连等待服务提供者恢复

1.3.5 伸缩性

• 注册中心为对等集群，可动态增加机器部署实例，所有客户端将自动发现新的注册中心
• 服务提供者无状态，可动态增加机器部署实例，注册中心将推送新的服务提供者信息给消费者

1.3.6 升级性

当服务集群规模进一步扩大，带动IT治理结构进一步升级，需要实现动态部署，进行流动计算，现有分布式服务架构不会带来阻力。下图是未来可能的一种架构：

1.3.7 节点角色说明

节点	角色说明
Deployer	自动部署服务的本地代理
Repository	仓库用于存储服务应用发布包
Scheduler	调度中心基于访问压力自动增减服务提供者
Admin	统一管理控制台
Registry	服务注册与发现的注册中心
Monitor	统计服务的调用次数和调用时间的监控中心

二 Zookeeper

2.1 工作机制

• Zookeeper是一个开源的分布式的，为分布式框架提供协调服务的 Apache项目。

• Zookeeper是基于观察者模式设计的分布式服务管理框架，它负责存储和管理大家都关心的数据，然 后接受观察者的注册，一旦这些数据的状态发生变化，Zookeeper 就 将负责通知已经在Zookeeper上注册的那些观察 者做出相应的反应。

)]

• Subject（被观察者或目标，抽象主题）：被观察的对象。当需要被观察的状态发生变化时，需要通知队列中所有观察者对象。Subject需要维持（添加，删除，通知）一个观察者对象的队列列表。
• ConcreteSubject（具体被观察者或目标，具体主题）：被观察者的具体实现。包含一些基本的属性状态及其他操作。
• Observer（观察者）：接口或抽象类。当Subject的状态发生变化时，Observer对象将通过一个callback函数得到通知。
• ConcreteObserver（具体观察者）：观察者的具体实现。得到通知后将完成一些具体的业务逻辑处理

2.2 特点

• Zookeeper：一个领导者（Leader），多个跟随者（Follower）组成的集群。
• 集群中只要有半数以上节点存活，Zookeeper集群就能正常服务。所以Zookeeper适合安装奇数台服务器。
• 全局数据一致：每个Server保存一份相同的数据副本，Client无论连接到哪个Server，数据都是一致的。
• 更新请求顺序执行，来自同一个Client的更新请求按其发送顺序依次执行。
• 数据更新原子性，一次数据更新要么成功，要么失败。
• 实时性，在一定时间范围内，Client能读到最新数据。

2.3 应用场景

提供的服务包括：统一命名服务、统一配置管理、统一集群管理、服务器节点动态上下 线、软负载均衡等

2.4 下载与安装

• 首页：Apache ZooKeeper
• 安装

# 解压 
tar -zxvf apache-zookeeper-3.7.0-bin.tar.gz
# 修改配置文件
cd conf
cp coo_sample.cfg zoo.cfg
vim zoo.cfg
#启动
bin/zkServer.sh start
#查看
jps
#状态查看
bin/zkServer.sh status
#停止
bin/zkServer.sh stop
#启动客户端
bin/zkCli.sh
#退出
quit

2.5 配置参数解释

• tickTime = 2000：通信心跳时间，Zookeeper服务器与客户端心跳时间，单位毫秒
• initLimit = 10：LF初始通信时限，Leader和Follower初始连接时能容忍的最多心跳数（tickTime的数量）
• syncLimit = 5：LF同步通信时限，Leader和Follower之间通信时间如果超过syncLimit * tickTime，Leader认为Follwer死 掉，从服务器列表中删除Follwer。
• dataDir：保存Zookeeper中的数据，注意：默认的tmp目录，容易被Linux系统定期删除，所以一般不用默认的tmp目录。
• clientPort = 2181:客户端连接端口，通常不做修改。

三 基本环境搭建

• Apache Dubbo 是一款微服务开发框架，它提供了 RPC通信 与 微服务治理 两大关键能力。这意味着，使用 Dubbo 开发的微服务，将具备相互之间的远程发现与通信能力， 同时利用 Dubbo 提供的丰富服务治理能力，可以实现诸如服务发现、负载均衡、流量调度等服务治理诉求。同时 Dubbo 是高度可扩展的，用户几乎可以在任意功能点去定制自己的实现，以改变框架的默认行为来满足自己的业务需求。

• 服务是 Dubbo 中的核心概念，一个服务代表一组 RPC 方法的集合，服务是面向用户编程、服务发现机制等的基本单位。Dubbo 开发的基本流程是：用户定义 RPC 服务，通过约定的配置 方式将 RPC 声明为 Dubbo 服务，然后就可以基于服务 API 进行编程了。对服务提供者来说是提供 RPC 服务的具体实现，而对服务消费者来说则是使用特定数据发起服务调用。

3.1 Dubbo admin的搭建

Dubbo官网：https://dubbo.apache.org/zh/

Dubbo admin:https://dubbo.apache.org/docs/v2.7/admin/install/provider-demo/

3.1.1 修改配置

3.1.2 打包发布

nohup java -jar dubbo-admin-0.0.1-SNAPSHOT.jar & 

3.1.3 访问测试

• 注意：

spring.root.password=root 账号：root,密码root
spring.guest.password=guest 账号：guest,guest

3.2 SpringBoot +Dubbo

3.2.1 版本选择

3.2.2 结构

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>org.example</groupId>
    <artifactId>DubboDemo</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>Common</module>
        <module>Provider</module>
        <module>Consumer</module>
    </modules>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.4</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba.boot</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
            <version>0.2.0</version>
        </dependency>
    </dependencies>
</project>

3.2.3 实体类

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Date;

/**
 * @Author shu
 * @Date: 2021/10/08/ 20:35
 * @Description 用户信息实体类
 **/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class UserInfo {
    private int UserId;
    private String UserName;
    private String PassWord;
    private String Phone;
    private Date LastLoginTime;
    private String Avatar;
    private int isEnable;
    private int isDelete;
     private List<Role> roles = new ArrayList<>();
}

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Date;

/**
 * @Author shu
 * @Date: 2021/10/03/ 19:21
 * @Description 用户角色信息
 **/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Role {
    private int RoleId;
    private String RoleName;
    private String Description;
    private int OperationID;
    private Date UpdateTime;
    private Date CreatTime;
    private int isDelete;
}

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Date;
import java.util.List;

/**
 * @Author shu
 * @Date: 2021/10/03/ 19:47
 * @Description 菜单信息
 **/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Menu {
    private int MenuId;
    private String MenuName;
    private String Icon;
    private String path;
    private int isEnable;
    private Date CreatTime;
    private List<Role> roles;
}

3.2.4 注入依赖

	<dependencies>
        <dependency>
            <groupId>org.example</groupId>
            <artifactId>Common</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>

3.3 服务提供者

• 目标：提供用户的身份信息，菜单信息

3.3.1 sql语句

/*
 Navicat Premium Data Transfer

 Source Server         : mysql
 Source Server Type    : MySQL
 Source Server Version : 80022
 Source Host           : localhost:3306
 Source Schema         : auth

 Target Server Type    : MySQL
 Target Server Version : 80022
 File Encoding         : 65001

 Date: 05/10/2021 12:56:18
*/

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for menu
-- ----------------------------
DROP TABLE IF EXISTS `menu`;
CREATE TABLE `menu`  (
  `MenuId` int NOT NULL COMMENT '菜单id',
  `MenuName` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '菜单名称',
  `Icon` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '菜单图标',
  `path` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '菜单url',
  `isEnable` int NULL DEFAULT NULL COMMENT '是否可用',
  `CreatTime` datetime(0) NULL DEFAULT NULL COMMENT '时间',
  PRIMARY KEY (`MenuId`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of menu
-- ----------------------------
INSERT INTO `menu` VALUES (1, '个性推荐', 'icon-airec-zhinengtuijian', '/home/individuation', 0, '2021-10-03 16:34:30');
INSERT INTO `menu` VALUES (2, '歌单推荐', 'icon-yinyue', '/home/playlist', 0, '2021-10-03 16:36:49');
INSERT INTO `menu` VALUES (3, '最新音乐', 'icon-yinyue', '/home/songs', 0, '2021-10-03 16:37:34');
INSERT INTO `menu` VALUES (4, '最新mv', 'icon-MV', '/home/mv', 0, '2021-10-03 16:38:24');
INSERT INTO `menu` VALUES (5, '排行榜', 'icon-yinyue', '/home/leaderboard', 0, '2021-10-03 16:39:56');
INSERT INTO `menu` VALUES (6, '歌手', 'icon-geshou', '/home/singer', 0, '2021-10-03 16:39:58');
INSERT INTO `menu` VALUES (7, '个人中心', 'icon-yinyue', '/home/userinfo', 0, '2021-10-03 16:40:36');

-- ----------------------------
-- Table structure for menu_role
-- ----------------------------
DROP TABLE IF EXISTS `menu_role`;
CREATE TABLE `menu_role`  (
  `Id` int NOT NULL,
  `RoleId` int NULL DEFAULT NULL,
  `MenuId` int NULL DEFAULT NULL,
  PRIMARY KEY (`Id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of menu_role
-- ----------------------------
INSERT INTO `menu_role` VALUES (1, 1, 1);
INSERT INTO `menu_role` VALUES (2, 1, 2);
INSERT INTO `menu_role` VALUES (3, 1, 3);
INSERT INTO `menu_role` VALUES (4, 1, 4);
INSERT INTO `menu_role` VALUES (5, 1, 5);
INSERT INTO `menu_role` VALUES (6, 2, 1);
INSERT INTO `menu_role` VALUES (7, 2, 2);

-- ----------------------------
-- Table structure for role
-- ----------------------------
DROP TABLE IF EXISTS `role`;
CREATE TABLE `role`  (
  `RoleId` int NOT NULL COMMENT '角色id',
  `RoleName` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '角色身份',
  `Description` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '角色描述',
  `OperationID` int NULL DEFAULT NULL COMMENT '操作用户信息id',
  `UpdateTime` datetime(0) NULL DEFAULT NULL COMMENT '修改时间',
  `CreatTime` datetime(0) NOT NULL COMMENT '时间',
  `isDelete` int NOT NULL COMMENT '是否删除',
  PRIMARY KEY (`RoleId`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of role
-- ----------------------------
INSERT INTO `role` VALUES (1, 'role_admin', '超级管理员', NULL, NULL, '2021-10-03 16:22:53', 0);
INSERT INTO `role` VALUES (2, 'role_test', '测试人员', NULL, NULL, '2021-10-03 16:23:27', 0);
INSERT INTO `role` VALUES (3, 'role_user', '普通用户', NULL, NULL, '2021-10-03 16:24:17', 0);
INSERT INTO `role` VALUES (4, 'role_publish', '发布人员', NULL, NULL, '2021-10-03 16:25:29', 0);
INSERT INTO `role` VALUES (5, 'role_manger', '后台管理员', NULL, NULL, '2021-10-03 16:26:00', 0);

-- ----------------------------
-- Table structure for user_role
-- ----------------------------
DROP TABLE IF EXISTS `user_role`;
CREATE TABLE `user_role`  (
  `id` int NOT NULL,
  `UersId` int NULL DEFAULT NULL,
  `RoleId` int NULL DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of user_role
-- ----------------------------
INSERT INTO `user_role` VALUES (1, 1, 1);
INSERT INTO `user_role` VALUES (2, 1, 5);

-- ----------------------------
-- Table structure for userinfo
-- ----------------------------
DROP TABLE IF EXISTS `userinfo`;
CREATE TABLE `userinfo`  (
  `UserId` int NOT NULL AUTO_INCREMENT COMMENT '用户自增id',
  `UserName` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '用户账号',
  `PassWord` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '用户密码',
  `Phone` varchar(11) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '用户手机号',
  `LastLoginTime` datetime(0) NULL DEFAULT NULL COMMENT '最后登录时间',
  `Avatar` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '头像',
  `isEnable` int NULL DEFAULT NULL COMMENT '是否可用',
  `isDeleted` int NULL DEFAULT NULL COMMENT '是否删除',
  PRIMARY KEY (`UserId`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 1 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of userinfo
-- ----------------------------
INSERT INTO `userinfo` VALUES (1, 'admin', '$2a$10$86p0WLdb6ZMFM7YVLYTIq.nBSHjUGupKjy2bOwImvYeUJMbXMJnRO', '000000000000', NULL, NULL, 0, 0);

SET FOREIGN_KEY_CHECKS = 1;

3.3.2 mapper编写

• MenuInfoMapper

import com.music.pojo.Menu;
import org.apache.ibatis.annotations.*;
import org.springframework.stereotype.Repository;

import java.util.List;

/**
 * @Author shu
 * @Date: 2021/10/03/ 20:13
 * @Description
 **/
@Mapper
@Repository
public interface MenuInfoMapper {

    /**
     * 查询菜单下的权限
     * @return
     */
    @Select("select m.* from menu m\n" +
            "inner join menu_role mr where mr.MenuId=m.MenuId")
    @Results({
            @Result(property = "roles", column = "MenuId",javaType = List.class,
                    many = @Many(select = "com.dubbo.mapper.RoleMapper.findByMenuId"))
    })
    List<Menu> getAllMenu();
}

• RoleMapper

import com.music.pojo.Role;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import org.springframework.stereotype.Repository;

import java.util.List;

/**
 * @Author shu
 * @Date: 2021/10/05/ 9:43
 * @Description 角色mapper
 **/
@Mapper
@Repository
public interface RoleMapper {

    /**
     * 通过userid查询角色
     * @param UserId
     * @return
     */
    @Select("select r.* from role r \n" +
            "inner join user_role ur on r.RoleId=ur.RoleId\n" +
            "where ur.UersId=#{UserId}")
    List<Role> findByUid(@Param("UserId") int UserId);


    /**
     * 通过MenuId查看角色
     * @param MenuId
     * @return
     */
    @Select("select r.* from role r \n" +
            "inner join menu_role mr on mr.RoleId=r.RoleId\n" +
            "where mr.MenuId=#{MenuId}")
    List<Role> findByMenuId(@Param("MenuId") int MenuId);
}

• UserInfoMapper

import com.music.pojo.UserInfo;
import org.apache.ibatis.annotations.*;
import org.springframework.stereotype.Repository;

import java.util.List;

/**
 * @Author shu
 * @Date: 2021/10/03/ 19:37
 * @Description 用户mapper
 **/
@Mapper
@Repository
public interface UserInfoMapper {
      /**
       * 用户基本信息
       * @param username
       */
      @Select("select u.* from userinfo  u\n" +
              "where u.UserName=#{username}")
      @Results({
              @Result(property = "roles", column = "UserId",javaType = List.class,
                      many = @Many(select = "com.dubbo.mapper.RoleMapper.findByUid"))
      })
      UserInfo loadUserByUsername(@Param("username") String username);
}

3.3.3 对外提供服务

• 查询用户信息服务
• 查询菜单权限服务

package com.dubbo.service;

import com.alibaba.dubbo.config.annotation.Service;
import com.dubbo.mapper.UserInfoMapper;
import com.dubbo.pojo.UserInfo;
import com.dubbo.service.interfaces.UserInfoInterface;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;

/**
 * @Author shu
 * @Date: 2021/10/08/ 20:59
 * @Description
 **/
@Component
@Service //注意是dubbo中的
public class UserService implements UserInfoInterface {
    @Autowired
    private UserInfoMapper userInfoMapper;

    /**
     * 返回用户信息
     * @param username
     * @return
     */
    @Override
    public UserInfo getUserInfo(String username) {
        return userInfoMapper.loadUserByUsername(username);
    }
}

package com.dubbo.service;

import com.alibaba.dubbo.config.annotation.Service;
import com.dubbo.mapper.MenuInfoMapper;
import com.dubbo.pojo.Menu;
import com.dubbo.service.interfaces.MenuInfoInterface;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;

/**
 * @Author shu
 * @Date: 2021/10/08/ 20:59
 * @Description
 **/
@Component
@Service //注意是dubbo中的
public class MenuService implements MenuInfoInterface {

    @Autowired
    private MenuInfoMapper menuInfoMapper;

    /**
     * 菜单信息
     * @return
     */
    @Override
    public List<Menu> getMenuInfo() {
        return menuInfoMapper.getAllMenu();
    }
}

3.3.4 配置文件

server.port=6010
#开启sql日志
logging.level.com.music.mapper=debug
# dubbo配置
dubbo.application.name=provider-service
# zookeeper中心
dubbo.registry.address=自己服务器地址:2181

dubbo.registry.protocol=zookeeper
#dubbo协议
dubbo.protocol.name=dubbo
#duboo端口号
dubbo.protocol.port=8083
#连接监控中心
dubbo.monitor.protocol=registry

3.3.5 启动类

package com.dubbo;

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

/**
 * @Author shu
 * @Date: 2021/10/08/ 20:58
 * @Description
 **/
@SpringBootApplication
@EnableDubbo //开启Dubbo
public class ProvideApplication {
    public static void main(String[] args) {
        SpringApplication.run(ProvideApplication.class,args);
    }
}

3.3.6 结果

3.4 服务消费者

3.4.1 服务消费者的接口

• 注意接口与服务提供者保持一致

package com.dubbo.service.interfaces;
import com.dubbo.pojo.UserInfo;

/**
 * @Author shu
 * @Date: 2021/10/08/ 21:15
 * @Description
 **/
public interface UserInfoInterface {
    UserInfo getUserInfo(String username);
}

package com.dubbo.service.interfaces;

import com.dubbo.pojo.Menu;

import java.util.List;

/**
 * @Author shu
 * @Date: 2021/10/08/ 21:16
 * @Description
 **/
public interface MenuInfoInterface {
    List<Menu> getMenuInfo();
}

3.4.2 远程调用服务

package com.dubbo.service;

import com.alibaba.dubbo.config.annotation.Reference;
import com.dubbo.pojo.Menu;
import com.dubbo.service.interfaces.MenuInfoInterface;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @Author shu
 * @Date: 2021/10/08/ 20:59
 * @Description
 **/
@Service
public class MenuServiceConsumer implements MenuInfoInterface {

    /**
     * 远程调用
     */
    @Reference
    MenuInfoInterface MenuInfoInterface;

    /**
     * 菜单信息
     * @return
     */
    @Override
    public List<Menu> getMenuInfo() {
        return MenuInfoInterface.getMenuInfo();
    }

}

package com.dubbo.service;

import com.alibaba.dubbo.config.annotation.Reference;
import com.dubbo.pojo.UserInfo;
import com.dubbo.service.interfaces.UserInfoInterface;
import org.springframework.stereotype.Service;

/**
 * @Author shu
 * @Date: 2021/10/08/ 20:59
 * @Description
 **/
@Service
public class UserServiceConsumer implements UserInfoInterface {
    /**
     * 运程调用
     */
    @Reference
    UserInfoInterface UserInfoInterface;

    /**
     * 返回用户信息
     * @param username
     * @return
     */
    @Override
    public UserInfo getUserInfo(String username) {
        return UserInfoInterface.getUserInfo(username);
    }

}

3.4.3 访问层

package com.dubbo.controller;

import com.dubbo.pojo.UserInfo;
import com.dubbo.service.UserServiceConsumer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @Author shu
 * @Date: 2021/10/09/ 9:29
 * @Description
 **/
@RestController
public class UserController {

    @Autowired
    private UserServiceConsumer  userServiceConsumer;

    @GetMapping("/userinfo")
    public UserInfo GetUserInfo(){
        return userServiceConsumer.getUserInfo("admin");
    }
}


package com.dubbo.controller;

import com.dubbo.pojo.Menu;
import com.dubbo.service.MenuServiceConsumer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

/**
 * @Author shu
 * @Date: 2021/10/09/ 9:29
 * @Description
 **/
@RestController
public class MenuController {
    @Autowired
    MenuServiceConsumer menuServiceConsumer;

    @GetMapping("/menu")
    public List<Menu> GetMenuInfo(){
        return menuServiceConsumer.getMenuInfo();
    }
}

3.4.4 启动类

package com.dubbo;

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

/**
 * @Author shu
 * @Date: 2021/10/09/ 9:18
 * @Description
 **/
@SpringBootApplication
@EnableDubbo
public class ConsumerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ConsumerApplication.class,args);
    }
}

# 配置
server.port=6011

# dubbo配置
dubbo.application.name=consumer-service
# zookeeper中心
dubbo.registry.address=自己的服务器:2181
dubbo.registry.protocol=zookeeper
#dubbo协议
dubbo.protocol.name=dubbo

3.4.5 测试

四 知识讲解

4.1 服务发现

4.1.1 服务架构

• 服务发现，即消费端自动发现服务地址列表的能力，是微服务框架需要具备的关键能力，借助于自动化的服务发现，微服务之间可以在无需感知对端部署位置与 IP 地址的情况下实现通信。

• 实现服务发现的方式有很多种，Dubbo 提供的是一种 Client-Based 的服务发现机制，通常还需要部署额外的第三方注册中心组件来协调服务发现过程，如常用的 Nacos、Consul、Zookeeper 等，Dubbo 自身也提供了对多种注册中心组件的对接，用户可以灵活选择。

4.1.2 升级

• Dubbo3 应用级服务发现，以应用粒度组织地址数据

• Dubbo2 接口级服务发现，以接口粒度组织地址数据

• Dubbo2 的服务发现模型：Provider 注册服务地址，Consumer 经过注册中心协调并发现服务地址，进而对地址发起通信，这是被绝大多数微服务框架的经典服务发现流程。而 Dubbo2 的特殊之处在于，它把 “RPC 接口”的信息也融合在了地址发现过程中，而这部分信息往往是和具体的业务定义密切相关的。

• Dubbo3 需要在原有服务发现流程中抽象出通用的、与业务逻辑无关的地址映射模型，并确保这部分模型足够合理，以支持将地址的注册行为和存储委托给下层基础设施 Dubbo3 特有的业务接口同步机制，是 Dubbo3 需要保留的优势，需要在 1 中定义的新地址模型之上，通过框架内的自有机制予以解决。

4.2 协议

4.2.1 Http2

HTTP/1.1 存在的问题

• TCP 连接数限制:对于同一个域名，浏览器最多只能同时创建 6~8 个 TCP 连接 (不同浏览器不一样)。为了解决数量限制，出现了 域名分片 技术，其实就是资源分域，将资源放在不同域名下 (比如二级子域名下)，这样就可以针对不同域名创建连接并请求，以一种讨巧的方式突破限制，但是滥用此技术也会造成很多问题，比如每个 TCP 连接本身需要经过 DNS 查询、三步握手、慢启动等，还占用额外的 CPU 和内存，对于服务器来说过多连接也容易造成网络拥挤、交通阻塞等

• 线头阻塞问题:每个 TCP 连接同时只能处理一个请求 - 响应，浏览器按 FIFO 原则处理请求，如果上一个响应没返回，后续请求 - 响应都会受阻。为了解决此问题，出现了 管线化 - pipelining 技术，但是管线化存在诸多问题，比如第一个响应慢还是会阻塞后续响应、服务器为了按序返回相应需要缓存多个响应占用更多资源、浏览器中途断连重试服务器可能得重新处理多个请求、还有必须客户端 - 代理 - 服务器都支持管线化

• Header 内容多，而且每次请求 Header 不会变化太多，没有相应的压缩传输优化方案

• 延迟问题：为了尽可能减少请求数，需要做合并文件、雪碧图、资源内联等优化工作，但是这无疑造成了单个请求内容变大延迟变高的问题，且内嵌的资源不能有效地使用缓存机制

• 明文传输不安全

HTTP2 的优势

• 二进制分帧层 (Binary Framing Layer):帧是数据传输的最小单位，以二进制传输代替原本的明文传输，原本的报文消息被划分为更小的数据帧
• 多路复用 (MultiPlexing):在一个 TCP 连接上，我们可以向对方不断发送帧，每帧的 stream identifier 的标明这一帧属于哪个流，然后在对方接收时，根据 stream identifier 拼接每个流的所有帧组成一整块数据。
• 服务端推送 (Server Push)：浏览器发送一个请求，服务器主动向浏览器推送与这个请求相关的资源，这样浏览器就不用发起后续请求。
• Header 压缩 (HPACK)：使用 HPACK 算法来压缩首部内容

参考资料：https://www.jianshu.com/p/e57ca4fec26f

4.2.2 通信协议

• Dubbo3 提供了 Triple(Dubbo3)、Dubbo2 协议，这是 Dubbo 框架的原生协议。除此之外，Dubbo3 也对众多第三方协议进行了集成，并将它们纳入 Dubbo 的编程与服务治理体系， 包括 gRPC、Thrift、JsonRPC、Hessian2、REST 等。以下重点介绍 Triple 与 Dubbo2 协议

• 协议的内容包含三部分

  • 数据交换格式： 定义 RPC 的请求和响应对象在网络传输中的字节流内容，也叫作序列化方式
  • 协议结构： 定义包含字段列表和各字段语义以及不同字段的排列方式
  • 协议通过定义规则、格式和语义来约定数据如何在网络间传输。一次成功的 RPC 需要通信的两端都能够按照协议约定进行网络字节流的读写和对象转换。如果两端对使用的协议不能达成一致，就会出现鸡同鸭讲，无法满足远程通信的需求

• 最终我们选择了兼容 gRPC ，以 HTTP2 作为传输层构建新的协议，也就是 Triple

4.2 配置

参考官网：https://dubbo.apache.org/zh/docs/references/xml/

4.1 基本配置

#application 应用配置
# 当前应用名称，用于注册中心计算应用间依赖关系，注意：消费者和提供者应用名不要一样
dubbo.application.name=consumer-service
# 当前应用的版本
dubbo.application.version=1.0
# 日志输出方式，可选：slf4j,jcl,log4j,log4j2,jdk
dubbo.application.logger=slf4j

# registry 注册配置
# 注册中心服务器地址
dubbo.registry.address=ip地址:2181
# 注册中心地址协议，支持dubbo, multicast, zookeeper, redis, consul(2.7.1), sofa(2.7.2), etcd(2.7.2), nacos(2.7.2)
dubbo.registry.protocol=zookeeper
# 注册中心请求超时时间(毫秒)
dubbo.registry.timeout=10000
# 注册中心不存在时，是否报错(默认)
dubbo.registry.register=true

# consumer 服务消费者
# 超时设置 (默认1s)
# (全局配置)
dubbo.consumer.timeout=5000
# 负载均衡算法（random,roundrobin,leastactive），分别表示：随机，轮询，最少活跃调用，当然也可以自定义算法
dubbo.consumer.loadbalance=random
# 重试次数(默认2)
dubbo.consumer.retries=4

4.2 可配置项

• 可以配置官方文档：https://dubbo.apache.org/zh/docs/advanced/

• 具体配置官方文档：https://dubbo.apache.org/zh/docs/references/xml/

• 注意：当我们需要配置某些配置时，比如超时设置，负载均衡，直连提供者等等，我们可以参考官方文档