dubbo笔记

一、基础知识

1、分布式基础理论

　　dubbo是用于分布式系统的框架，所以先了解什么是分布式

1.1、什么是分布式系统？

　　分布式系统是若干独立计算机的集合，这些计算机对于用户来说就像单个相关系统

　　分布式系统是建立在网络之上的软件系统

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

1.2、发展演变

　　单一应用架构——>垂直应用架构——>分布式服务架构——>流动计算架构

　　（1）单一应用架构（ORM）

　　一个项目装到一个服务器当中，也可以运行多个服务器每一个服务器当中都装一个项目。

　　适用于小型网站，小型管理系统，将所有功能都部署到一个功能里，简单易用。

　　缺点：1.如果要添加某一个功能的话就要把一个项目重新打包，在分别部署到每一个服务器当中去。

　　　　　2.如果后期项目越来越大的话单台服务器跑一个项目压力会很大的。会不利于维护，开发和程序的性能。

　　（2）垂直应用架构（MVC）

　　将应用切割成几个互不相干的小应用，在将每个小应用独立放到一个服务器上，如果哪一个应用的访问数量多就多加几台服务器。

　　通过切分业务来实现各个模块独立部署，降低了维护和部署的难度，团队各司其职更易管理，性能扩展也更方便，更有针对性。

　　缺点：公用模块无法重复利用，开发性的浪费

　　（3）分布式服务架构（RPC）

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

　　（4）流动计算架构（SOA）

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

1.3、RPC简介

　　分布式应用架构(远程过程调用)：当垂直应用越来越多，应用之间交互不可避免，将核心业务抽取出来，作为独立的服务，逐渐形成稳定的服务中心，使前端应用能更快速的响应多变的市场需求。

　　（1）什么叫RPC

　　RPC【Remote Procedure Call】是指远程过程调用，是一种进程间通信方式，是一种技术的思想，而不是规范。它允许程序调用另一个地址空间（通常是共享网络的另一台机器上）的过程或者函数，而不是程序员显示编码这个远程调用的细节。即程序员无论是调用本地的还是远程的函数，本质上编写的调用代码基本相同。

　　（1）RPC工作原理

一次完整的RPC调用流程（同步调用，异步另说）如下： 
1）服务消费方（client）调用以本地调用方式调用服务； 
2）client stub接收到调用后负责将方法、参数等组装成能够进行网络传输的消息体； 
3）client stub找到服务地址，并将消息发送到服务端； 
4）server stub收到消息后进行解码； 
5）server stub根据解码结果调用本地的服务； 
6）本地服务执行并将结果返回给server stub； 
7）server stub将返回结果打包成消息并发送至消费方； 
8）client stub接收到消息，并进行解码； 
9）服务消费方得到最终结果。
RPC框架的目标就是要2~8这些步骤都封装起来，这些细节对用户来说是透明的，不可见的。

　　RPC 调用分以下两种：
　　同步调用：客户方等待调用执行完成并返回结果。
　　异步调用：客户方调用后不用等待执行结果返回，但依然可以通过回调通知等方式获取返回结果。若客户方不关心调用返回结果，则变成单向异步调用，单向调用不用返回结果。　　

　　RPC两个核心模块：通讯、序列化

2、dubbo核心概念

2.1、简介

　　Apache Dubbo (incubating) |ˈdʌbəʊ| 是一款高性能、轻量级的开源Java RPC框架，它提供了三大核心能力：

　　（1）面向接口的远程方法调用；

　　（2）智能容错和负载均衡；

　　（3）服务自动注册和发现；

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

2.2、基本概念

　　服务提供者（Provider）：暴露服务的服务提供方，服务提供者在启动时，向注册中心注册自己提供的服务。

　　服务消费者（Consumer）：调用远程服务的服务消费方，服务消费者在启动时，向注册中心订阅自己所需的服务，服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。

　　注册中心（Registry）：注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者。

　　监控中心（Monitor）：服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心。

调用关系说明

（1）服务容器负责启动，加载，运行服务提供者。
    
（2）服务提供者在启动时，向注册中心注册自己提供的服务。
     
（3）服务消费者在启动时，向注册中心订阅自己所需的服务。

（4）注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者。

（5）服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。

（6）服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心。（

3、dubbo的特性

3.1、服务注册中心　

1、相比Hessian类RPC框架，Dubbo有自己的服务中心， 写好的服务可以注册到服务中心， 客户端从服务中心寻找服务，然后再到相应的服务提供者机器获取服务。通过服务中心可以实现集群、负载均衡、高可用(容错) 等重要功能。

2、服务中心一般使用zookeeper实现，也有redis和其他一些方式。以使用zookeeper作为服务中心为例，服务提供者启动后会在zookeeper的/dubbo节点下创建提供的服务节点，包含服务提供者ip、port等信息。服务提供者关闭时会从zookeeper中移除对应的服务。

3、服务使用者会从注册中心zookeeper中寻找服务，同一个服务可能会有多个提供者，Dubbo会帮我们找到合适的服务提供者，也就是针对服务提供者的负载均衡。

3.2、负载均衡

当同一个服务有多个提供者在提供服务时，客户端如何正确的选择提供者实 现负载均衡呢？dubbo也给我们提供了几种方案：

1、random 随机选提供者，并可以给提供者设置权重

2、roundrobin 轮询选择提供者

3、leastactive 最少活跃调用数，相同活跃数的随机，活跃数：指调用前后计数差。使慢的提供者收到更少请求，因为越慢的提供者的调用前后计数差会越大。

4、consistenthash 一致性hash，相同参数的请求发到同一台机器上。

3.3、简化测试，允许直连提供者

在开发阶段为了方便测试，通常系统客户端能指定调用某个服务提供者，那么可以在引用服务时加一个url参数去指定服务提供者。 配置如下：

 <dubbo:reference id="xxxService"interface="com.alibaba.xxx.XxxService"url="dubbo://localhost:20890"/>

3.4、服务版本、服务分组

在Dubbo配置文件中可以通过制定版本实现连接制定提供者，也就是通过服务版本可以控制服务的不兼容升级；当同一个服务有多种实现时，可以使用服务分组进行区分。

4、dubbo和springcloud对比

5、dubbo环境搭建

（1）【Windows】—安装zookeeper

1、下载zookeeper

网址 https://archive.apache.org/dist/zookeeper/zookeeper-3.4.13/

2、解压zookeeper

解压运行zkServer.cmd ，初次运行会报错，没有zoo.cfg配置文件

3、修改zoo.cfg配置文件

将conf下的zoo_sample.cfg复制一份改名为zoo.cfg即可。

注意几个重要位置：

dataDir=./ 临时数据存储的目录（可写相对路径）

clientPort=2181 zookeeper的端口号

修改完成后再次启动zookeeper

4、使用zkCli.cmd测试

ls /：列出zookeeper根下保存的所有节点

create –e /atguigu 123：创建一个atguigu节点，值为123

get /atguigu：获取/atguigu节点的值

（2）【windows】-安装dubbo-admin管理控制台

　　dubbo本身并不是一个服务软件。它其实就是一个jar包能够帮你的java程序连接到zookeeper，并利用zookeeper消费、提供服务。所以你不用在Linux上启动什么dubbo服务。

　　但是为了让用户更好的管理监控众多的dubbo服务，官方提供了一个可视化的监控程序，不过这个监控即使不装也不影响使用。

1、下载dubbo-admin

https://github.com/apache/incubator-dubbo-ops

2、进入目录，修改dubbo-admin配置

修改 src\main\resources\application.properties 指定zookeeper地址

3、打包dubbo-admin

mvn clean package -Dmaven.test.skip=true

4、运行dubbo-admin（zookeeper需打开）

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

注意：【有可能控制台看着启动了，但是网页打不开，需要在控制台按下ctrl+c即可】

默认使用root/root 登陆

（3）【linux】-安装zookeeper

　1、安装jdk

1、下载jdk

http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html

不要使用wget命令获取jdk链接，这是默认不同意，导致下载来的jdk压缩内容错误

2、上传到服务器并解压

cd /opt/module/

ls

tar -zxvf jdk-8u212-linux-x64.tar.gz -C /opt/module/

3、设置环境变量

cd /etc/profile.d

sudo vim /etc/profile.d/my_env.sh

文件末尾加入下面配置

#JAVA_HOME
export JAVA_HOME=/opt/module/jdk1.8.0_212
export PATH=$PATH:$JAVA_HOME/bin

4、使环境变量生效&测试JDK

source /etc/profile

java -version

2、安装zookeeper

1、下载zookeeper

网址 https://archive.apache.org/dist/zookeeper/zookeeper-3.4.11/

wget https://archive.apache.org/dist/zookeeper/zookeeper-3.4.11/zookeeper-3.4.11.tar.gz

2、解压

cd /opt/software/

ls

tar -zxvf apache-zookeeper-3.5.7-bin.tar.gz -C /opt/module/

3、修改名称

cd /opt/module

#修改文件名称
mv apache-zookeeper-3.5.7-bin zookeeper-3.5.7

ls

3、配置zookeeper

1）-将/opt/module/zookeeper-3.5.7/conf 这个路径下的 zoo_sample.cfg 修改为 zoo.cfg；

cd /opt/module/zookeeper-3.5.7/conf/

mv zoo_sample.cfg  zoo.cfg

ll

2）-打开 zoo.cfg 文件，修改 dataDir 路径：

vim zoo.cfg

修改如下内容：

dataDir=/opt/module/zookeeper-3.5.7/zkData

保存退出

3）-在/opt/module/zookeeper-3.5.7/这个目录上创建zkData文件夹

cd /opt/module/zookeeper-3.5.7/

mkdir zkData

ll

4、操作Zookeeper

1）-启动Zookeeper

bin/zkServer.sh start

2）-查看进程是否启动

jps

3）-查看状态

bin/zkServer.sh status

4）-启动客户端

bin/zkCli.sh

5）-退出客户端

quit

6）停止zookeeper

#停止ZooKeeper
bin/zkServer.sh stop

#查看状态
bin/zkServer.sh status

（4）【linux】-安装dubbo-admin管理控制台

1、安装Tomcat8（旧版dubbo-admin是war，新版是jar不需要安装Tomcat）

二、Dubbo创建提供者和消费者工程

　　基于以下图实现服务提供者、消费者

在这里插入图片描述

1、服务提供者和消费者接口搭建

　　（1）创建Maven项目 => user-service-provider 服务提供者

UserAddress

package com.atguigu.gmall.bean;

import java.io.Serializable;

/**
 * 用户地址
 * @author lfy
 *
 */
public class UserAddress implements Serializable {
    
    private Integer id;
    private String userAddress; //用户地址
    private String userId; //用户id
    private String consignee; //收货人
    private String phoneNum; //电话号码
    private String isDefault; //是否为默认地址    Y-是     N-否
    
    public UserAddress() {
        super();
        // TODO Auto-generated constructor stub
    }
    
    public UserAddress(Integer id, String userAddress, String userId, String consignee, String phoneNum,
            String isDefault) {
        super();
        this.id = id;
        this.userAddress = userAddress;
        this.userId = userId;
        this.consignee = consignee;
        this.phoneNum = phoneNum;
        this.isDefault = isDefault;
    }
    
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getUserAddress() {
        return userAddress;
    }
    public void setUserAddress(String userAddress) {
        this.userAddress = userAddress;
    }
    public String getUserId() {
        return userId;
    }
    public void setUserId(String userId) {
        this.userId = userId;
    }
    public String getConsignee() {
        return consignee;
    }
    public void setConsignee(String consignee) {
        this.consignee = consignee;
    }
    public String getPhoneNum() {
        return phoneNum;
    }
    public void setPhoneNum(String phoneNum) {
        this.phoneNum = phoneNum;
    }
    public String getIsDefault() {
        return isDefault;
    }
    public void setIsDefault(String isDefault) {
        this.isDefault = isDefault;
    }
}

UserService

package com.atguigu.gmall.service;

import java.util.List;

import com.atguigu.gmall.bean.UserAddress;

/**
 * 用户服务
 * @author lfy
 *
 */
public interface UserService {
    
    /**
     * 按照用户id返回所有的收货地址
     * @param userId
     * @return
     */
    public List<UserAddress> getUserAddressList(String userId);

}

UserServiceImpl

package com.atguigu.gmall.service.impl;

import java.util.Arrays;
import java.util.List;

import com.atguigu.gmall.bean.UserAddress;
import com.atguigu.gmall.service.UserService;

public class UserServiceImpl implements UserService {
    public List<UserAddress> getUserAddressList(String userId) {

        UserAddress address1 = new UserAddress(1, "河南省郑州巩义市宋陵大厦2F", "1", "安然", "150360313x", "Y");
        UserAddress address2 = new UserAddress(2, "北京市昌平区沙河镇沙阳路", "1", "情话", "1766666395x", "N");

        return Arrays.asList(address1,address2);
    }
}

　　（2）创建Maven项目=> order-service-consumer 服务消费者(订单服务)

OrderService

package com.atguigu.gmall.service;

public interface OrderService {
    /**
     * 初始化订单
     * @param userID
     */
    public void initOrder(String userID);
}

OrderServiceImpl

package com.atguigu.gmall.service.impl;

import com.atguigu.gmall.service.OrderService;

public class OrderServiceImpl implements OrderService {
    
    public void initOrder(String userID) {
        //查询用户的收货地址

    }
}

　　因服务消费者要拿到提供者的方法

　　将服务提供者中的实体类以及UserService复制到当前消费者同级文件中。

OrderServiceImpl

public class OrderServiceImpl implements OrderService {
    public UserService userService;
    public void initOrder(String userID) {
        //查询用户的收货地址
        List<UserAddress> userAddressList = userService.getUserAddressList(userID);
        System.out.println(userAddressList);
    }
}

　　此时我们调用userService肯定是要报错的。这种面向接口的方式，我们这里只是调用到了接口，而接口实际在另外一个项目中，如果我们两个项目工程都创建共同的实体类，太过于麻烦了，我们可以将服务接口、服务模型等单独放在一个项目中，更为方便调用

　　创建Maven项目=> gmail-interface 用于存放共同的服务接口

　　将提供者和消费者项目中的所有实体类复制到当前相关的文件包下，删除原有的实体类包以及service包，也就是将实体类及service放在了当前公共的项目中。

　　把服务提供者和消费者项目引入以下公共依赖，引入后项目不再报错

　　　<dependency>
          <groupId>com.atguigu.gmall</groupId>
          <artifactId>gmail-interface</artifactId>
          <version>0.0.1-SNAPSHOT</version>
      </dependency>

流程

1、将服务提供者注册到注册中心（暴露服务）
    （1）导入dubbo依赖（2.6.2）
　　 （2）配置服务提供者
　　 （3）编写一个启动类程序，金存管测试配置

2、让服务消费者去注册中心订阅服务提供者的服务地址

2、服务提供者配置及测试

　　将服务提供者注册到注册中心

　　（1）导入dubbo依赖：在 user-service-provider 服务提供者项目中引入依赖

　　　　<!-- 引入dubbo -->
        <!-- https://mvnrepository.com/artifact/com.alibaba/dubbo -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>dubbo</artifactId>
            <version>2.6.2</version>
        </dependency>
        
        <!-- 注册中心使用的是zookeeper，引入操作zookeeper的客户端 -->
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-framework</artifactId>
            <version>2.12.0</version>
        </dependency>

　　注意：dubbo2.6以前的版本引入zkclient操作zookeeper

　　　　　 dubbo2.6及以后的版本引入curator操作zookeeper

　　　　　所以下面两个zk客户端根据dubbo版本2选1即可

        <dependency>
            <groupId>com.101tec</groupId>
            <artifactId>zkclient</artifactId>
            <version>0.10</version>
        </dependency>
        <!-- curator-framework -->
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-framework</artifactId>
            <version>2.12.0</version>
        </dependency>

　　（2）配置服务提供者：在resource文件中创建provider.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://dubbo.apache.org/schema/dubbo http://dubbo.apache.org/schema/dubbo/dubbo.xsd
        http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
   
   <!--1、指定当前服务/应用的名字(同样的服务名字相同，不要和别的服务同名)-->
   <dubbo:application name="user-service-provider"></dubbo:application>
   
    <!--2、指定注册中心的位置-->
    <!--<dubbo:registry address="zookeeper://127.0.0.1:2181"></dubbo:registry>-->
    <dubbo:registry protocol="zookeeper" address="127.0.0.1:2181"></dubbo:registry>
    
    <!--3、指定通信规则（通信协议? 服务端口）-->
    <dubbo:protocol name="dubbo" port="20880"></dubbo:protocol>
    
    <!--4、暴露服务 让别人调用 ref指向服务的真正实现对象-->
    <dubbo:service interface="com.atguigu.gmall.service.UserService" ref="userServiceImpl"></dubbo:service>

    <!--服务的实现-->
    <bean id="userServiceImpl" class="com.atguigu.gmall.service.impl.UserServiceImpl"></bean>
   
</beans>

　　（3）编写启动类程序 MailApplication，运行测试配置

package com.atguigu.gmall;

import java.io.IOException;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MailApplication {

    public static void main(String[] args) throws IOException {
        ClassPathXmlApplicationContext ioc = new ClassPathXmlApplicationContext("provider.xml");
        ioc.start();
        
        System.in.read();
    }
}

　　右键运行

　　注意：需要启动zookeeper注册中心的 zkServer.cmd 和 zkCli.cmd 服务

　　　　在dubbo-admin target中cmd运行 java -jar dubbo-admin-0.0.1-SNAPSHOT.jar

　　启动后，我们可以看到在zookeeper中已经发现服务提供者

　　至此，服务提供者的配置和测试完成

3、服务消费者配置及测试

　　让服务消费者去注册中心订阅服务提供者的服务地址

　　（1）导入dubbo依赖：在 order-service-consumer 服务消费者项目中引入依赖

<!--dubbo-->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>dubbo</artifactId>
        <version>2.6.2</version>
    </dependency>
    <!--注册中心是 zookeeper，引入zookeeper客户端-->
    <dependency>
        <groupId>org.apache.curator</groupId>
        <artifactId>curator-framework</artifactId>
        <version>2.12.0</version>
    </dependency>

　　（2）配置服务消费者：在resource文件中创建consumer.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:dubbo="http://dubbo.apache.org/schema/dubbo"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
        http://dubbo.apache.org/schema/dubbo http://dubbo.apache.org/schema/dubbo/dubbo.xsd
        http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
   
       <!--包扫描-->
    <context:component-scan base-package="com.atguigu.gmall.service.impl"/>

    <!--指定当前服务/应用的名字(同样的服务名字相同，不要和别的服务同名)-->
    <dubbo:application name="order-service-consumer"></dubbo:application>
    
    <!--指定注册中心的位置-->
    <dubbo:registry address="zookeeper://127.0.0.1:2181"></dubbo:registry>

    <!--调用远程暴露的服务，生成远程服务代理-->
    <dubbo:reference interface="com.atguigu.gmall.service.UserService" id="userService"></dubbo:reference>
</beans>

　　把当前OrderServiceImpl实现类上加上注解

package com.atguigu.gmall.service.impl;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.atguigu.gmall.bean.UserAddress;
import com.atguigu.gmall.service.OrderService;
import com.atguigu.gmall.service.UserService;

/**
 * 1、将服务提供者注册到注册中心（暴露服务）
 *     （1）导入dubbo依赖（2.6.2）
 *     （2）配置服务提供者
 * 2、让服务消费者去注册中心订阅服务提供者的服务地址
 * @author Administrator
 *
 */
@Service
public class OrderServiceImpl implements OrderService {
   
    @Autowired
    public UserService userService;
    
    public void initOrder(String userID) {
        
        //查询用户的收货地址
        List<UserAddress> userAddressList = userService.getUserAddressList(userID);
        
        //为了直观的看到得到的数据，以下内容也可不写
        System.out.println("当前接收到的userId=> "+userID);
        System.out.println("**********");
        System.out.println("查询到的所有地址为：");
        for (UserAddress userAddress : userAddressList) {
            //打印远程服务地址的信息
            System.out.println(userAddress.getUserAddress());
        }
    }
}

　　（3）编写启动类程序 MailApplication，运行测试配置

package com.atguigu.gmall;

import java.io.IOException;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.atguigu.gmall.service.OrderService;

public class MailApplication {

    public static void main(String[] args) throws IOException {
         ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("consumer.xml");
         OrderService orderService = applicationContext.getBean(OrderService.class);
         
         //调用方法查询出数据
         orderService.initOrder("1");
         System.out.println("调用完成...");
         System.in.read();
    }
}

　　注意：消费者的运行测试需要先启动提供者

　　启动服务提供者、消费者。以及zookeeper和dubbo-admin，查看监控信息

　　此时可以看到一个提供者、一个消费者的信息监控信息

三、dubbo监控中心

1、dubbo-admin　　

　　图形化的服务管理页面；安装时需要指定注册中心地址，即可从注册中心中获取到所有的提供者/消费者进行配置管理

2、dubbo-monitor-simple

　　简单的监控中心，操作流程如下：

　　进入dubbo-monitor-simple文件，执行cmd命令，mvn package打包成jar包

　　成功打包成target，target中有个jar包

　　将 dubbo-monitor-simple-2.0.0-assembly.tar.gz 压缩包解压到当前文件夹，并将其剪切到外层dubbo目录

　　查看解压后config文件中propertites的配置是否是本地的zookeeper

　　打开解压后的 assembly.bin 文件，点击start.bat 启动dubbo-monitor-simple监控中心

　　在浏览器 localhost:8080 ，可以看到一个监控中心。但是此时还没监控到我们的服务

　　在服务提供者和消费者的xml中配置以下内容，再次启动服务提供和消费者启动类。

    <!--dubbo-monitor-simple监控中心发现的配置-->
    <dubbo:monitor protocol="registry"></dubbo:monitor>
    <!--<dubbo:monitor address="127.0.0.1:7070"></dubbo:monitor>-->

　　可以看到，这个监控中心也捕获到了服务提供和消费者信息

四、dubbo与SpringBoot整合

1、整合服务提供者

　　创建Maven项目 boot-user-service-provider 服务提供者

1、导入依赖
2、配置application.properties
3、暴露dubbo服务
4、启动类配置

　　（1）导入以下依赖

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.4.RELEASE</version>
        <relativePath />
    </parent>

    <dependencies>
        
        <dependency>
            <groupId>com.atguigu.gmall</groupId>
            <artifactId>gmail-interface</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>com.alibaba.boot</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
            <version>0.2.0</version>
        </dependency>
        
    </dependencies>

　　注意starter和dubbo的版本问题

　　（2）配置application.properties

dubbo.application.name=boot-user-service-provider
dubbo.registry.address=127.0.0.1:2181
dubbo.registry.protocol=zookeeper

dubbo.protocol.name=dubbo
dubbo.protocol.port=20880

#连接监控中心
dubbo.monitor.protocol=registry

　　（3）暴露服务

　　把 user-service-provider 中的service拿到此项目中。

　　注意：（1）以此方法为返回的需要更改 interface包中的void为 List

　　　　（2）加上dubbo的注解，暴露dubbo服务　

package com.atguigu.gmall.service.impl;

import java.util.Arrays;
import java.util.List;

import org.springframework.stereotype.Component;

import com.alibaba.dubbo.config.annotation.Service;
import com.atguigu.gmall.bean.UserAddress;
import com.atguigu.gmall.service.UserService;

@Service//dubbo的服务暴露
@Component
public class UserServiceImpl implements UserService {
    public List<UserAddress> getUserAddressList(String userId) {

        UserAddress address1 = new UserAddress(1, "河南省郑州巩义市宋陵大厦2F", "1", "安然", "150360313x", "Y");
        UserAddress address2 = new UserAddress(2, "北京市昌平区沙河镇沙阳路", "1", "情话", "1766666395x", "N");

        return Arrays.asList(address1,address2);
    }
}

　　（4）BootUserServiceProviderApplication启动类配置

package com.atguigu.gmall;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import com.alibaba.dubbo.config.spring.context.annotation.EnableDubbo;

/**
 * 1、导入依赖
 * 2、配置application.properties
 * 3、暴露dubbo服务
 * 4、启动程序
 * @author Administrator
 *
 */
@EnableDubbo//开启基于注解的dubbo功能
@SpringBootApplication
public class BootUserServiceProviderApplication {

    public static void main(String[] args) {
        SpringApplication.run(BootUserServiceProviderApplication.class, args);
    }
}

　　配置完毕，启动注册中心，启动当前服务提供者，可以在浏览器看到一个服务提供者

2、整合服务消费者

　　创建Maven项目 boot-order-service-consumer 服务消费者

1、导入依赖
2、配置application.properties
3、暴露dubbo服务
4、创建控制层
5、启动类配置

　　（1）导入以下依赖

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.4.RELEASE</version>
        <relativePath /> <!-- lookup parent from repository -->
    </parent>

    <dependencies>
    
        <dependency>
            <groupId>com.atguigu.gmall</groupId>
            <artifactId>gmail-interface</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>com.alibaba.boot</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
            <version>0.2.0</version>
        </dependency>
        
    </dependencies>

　　（2）配置application.properties

#因为dubbo监控中心默认是8080，我们修改自己的端口号为8081
server.port=8081

dubbo.application.name=boot-order-service-consumer
dubbo.registry.address=zookeeper://127.0.0.1:2181

#连接监控中心 注册中心协议
dubbo.monitor.protocol=registry

　　（3）暴露服务

　　把order-service-consumer项目中的service复制到当前项目。

　　注意：（1）以此方法为返回的需要更改 interface包中的void为 List

　　　　（2）加上dubbo的注解，暴露dubbo服务　

　　　　（3）加上@Reference注解引用远程提供者服务

package com.atguigu.gmall.service.impl;

import java.util.List;

import org.springframework.stereotype.Service;

import com.alibaba.dubbo.config.annotation.Reference;
import com.atguigu.gmall.bean.UserAddress;
import com.atguigu.gmall.service.OrderService;
import com.atguigu.gmall.service.UserService;

/**
 * 1、将服务提供者注册到注册中心（暴露服务）
 *     （1）导入dubbo依赖（2.6.2）
 *     （2）配置服务提供者
 * 2、让服务消费者去注册中心订阅服务提供者的服务地址
 * @author Administrator
 *
 */
@Service
public class OrderServiceImpl implements OrderService {
   
    //@Autowired
    @Reference//引用远程提供者服务
    public UserService userService;
    
    public List<UserAddress> initOrder(String userID) {
        
        //查询用户的收货地址
        List<UserAddress> userAddressList = userService.getUserAddressList(userID);
        return userAddressList;
    }
}

　　（4）创建OrderController控制器

package com.atguigu.gmall.controller;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import com.atguigu.gmall.bean.UserAddress;
import com.atguigu.gmall.service.OrderService;

@Controller
public class OrderController {

     @Autowired
     OrderService orderService;
     
     @ResponseBody
     @RequestMapping("initOrder")
     public List<UserAddress> initOrder(@RequestParam("uid")String userId) {
         return orderService.initOrder(userId);
     }
}

　　（5）BootOrderServiceProviderApplication 启动类配置

package com.atguigu.gmall;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import com.alibaba.dubbo.config.spring.context.annotation.EnableDubbo;

@EnableDubbo //开启基于注解的dubbo功能
@SpringBootApplication
public class BootOrderServiceProviderApplication {

    public static void main(String[] args) {
        SpringApplication.run(BootOrderServiceProviderApplication.class, args);
    }
}

　　配置完毕，此时启动zookeeper注册中心及监控

　　启动springboot配置的服务提供者和消费者

　　在浏览器输入 localhost:7001 查看结果

　　http://localhost:8081/initOrder?uid=1 查询到地址信息

　　在浏览器输入 http://localhost:8080/services.html　查看结果

　　至此，dubbo的springboot整合配置完成

　　总结一下，总共三个大的步骤：

1、pom.xm导入依赖包

2、application.properties配置

3、如果暴露服务，用@Service注解；如果是远程消费服务，用@Reference注解

五、Dubbo配置

　　dubbo配置官网参考：http://dubbo.apache.org/zh-cn/docs/user/references/xml/dubbo-service.html

1、配置原则

　　加载顺序：

　　（1）JVM 启动 -D 参数优先，这样可以使用户在部署和启动时进行参数重写，比如在启动时需改变协议的端口。

　　（2）XML 次之，如果在 XML 中有配置，则 dubbo.properties 中的相应配置项无效。

　　（3）Properties 最后，相当于缺省值，只有 XML 没有配置时，dubbo.properties 的相应配置项才会生效，通常用于共享公共配置，比如应用名。

2、启动时检查

　　（1）Dubbo 缺省会在启动时检查依赖的服务是否可用，不可用时会抛出异常，阻止 Spring 初始化完成，以便上线时，能及早发现问题，默认 check=“true”。

　　例如，只启动order-service-consumer，默认检查依赖的服务user-service-provider是否可用

　　（2）可以通过 check=“false” 关闭检查，比如，测试时，有些服务不关心，或者出现了循环依赖，必须有一方先启动。

　　例如，修改order-service-consumer的consumer.xml中的配置check为false，默认是为true的

　　修改后，就可以正常启动了，以order-service-consumer消费者为例，在consumer.xml中添加配置，可以统一配置，不用针对每一个调用的服务单独设置

<!--配置当前消费者的统一规则,当前所有的服务都不启动时检查-->
 <dubbo:consumer check="false"></dubbo:consumer>

　　添加后，即使服务提供者不启动，启动当前的消费者，也不会出现错误。　　

　　（3）另外，如果你的 Spring 容器是懒加载的，或者通过 API 编程延迟引用服务，请关闭 check，否则服务临时不可用时，会抛出异常，拿到 null 引用，如果 check=“false”，总是会返回引用，当服务恢复时，能自动连上。

3、超时&配置覆盖关系

　　默认超时1000毫秒

　　注意：

　　（1）dubbo推荐在Provider上尽量多配置Consumer端属性

1、作为服务的提供者，比服务使用方更清楚服务性能参数，如调用的超时时间，合理的重试次数，等等
2、在Provider配置后，Consumer不配置则会使用Provider的配置值，即Provider配置可以作为Consumer的缺省值。否则，Consumer会使用Consumer端的全局设置，这对于Provider不可控的，并且往往是不合理的

　　（2）配置的覆盖规则：

1、方法级配置别 优于 接口级别 优于 全局配置 ，即小Scope优先
2、级别一样，则Consumer端配置 优于 Provider配置
3、其中，服务提供方配置，通过URL经由注册中心传递给消费方
4、最后是Dubbo Hard Code的配置值（见配置文档）

4、重试次数

　　Dubbo 服务在尝试调用一次之后，如出现非业务异常(服务突然不可用、超时等)，Dubbo 默认会进行额外的最多2次重试.

　　重试次数支持两种自定义配置：

1.通过注解/xml进行固定配置；
<dubbo:consumer retries="2"></dubbo:consumer>
　　　　
2.通过上下文进行运行时动态配置，优先级高于注解/xml进行的固定配置
// dubbo服务调用前，通过RpcContext动态设置本次调用的重试次数
RpcContext rpcContext = RpcContext.getContext();
rpcContext.setAttachment("retries", 5);

　重复原则：建议幂等（设置重试次数）【查询、删除】，非幂等（不能设置重试次数）【新增】

5、多版本

　　当一个接口实现，出现不兼容升级时，可以用版本号过渡，版本号不同的服务相互间不引用。

　　可以按照以下的步骤进行版本迁移：

在低压力时间段，先升级一半提供者为新版本
再将所有消费者升级为新版本
然后将剩下的一半提供者升级为新版本

老版本服务提供者配置：
<dubbo:service interface="com.foo.BarService" version="1.0.0" />
新版本服务提供者配置：
<dubbo:service interface="com.foo.BarService" version="2.0.0" />
老版本服务消费者配置：
<dubbo:reference id="barService" interface="com.foo.BarService" version="1.0.0" />
新版本服务消费者配置：
<dubbo:reference id="barService" interface="com.foo.BarService" version="2.0.0" />

如果不需要区分版本，可以按照以下的方式配置 [^1]：
<dubbo:reference id="barService" interface="com.foo.BarService" version="*" />
注意：2.2.0 以上版本支持

6、本地存根

　　远程服务后，客户端通常只剩下接口，而实现全在服务器端，但提供方有些时候想在客户端也执行部分逻辑，比如：做 ThreadLocal 缓存，提前验证参数，调用失败后伪造容错数据等等，此时就需要在 API 中带上 Stub，客户端生成 Proxy 实例，会把 Proxy 通过构造函数传给 Stub 1，然后把 Stub 暴露给用户，Stub 可以决定要不要去调 Proxy。

在 spring 配置文件中按以下方式配置：
<dubbo:service interface="com.foo.BarService" stub="true" />
或
<dubbo:service interface="com.foo.BarService" stub="com.foo.BarServiceStub" />

提供 Stub 的实现 
package com.foo;
public class BarServiceStub implements BarService {
    private final BarService barService;
    
    // 构造函数传入真正的远程代理对象
    public BarServiceStub(BarService barService){
        this.barService = barService;
    }
 
    public String sayHello(String name) {
        // 此代码在客户端执行, 你可以在客户端做ThreadLocal本地缓存，或预先验证参数是否合法，等等
        try {
            return barService.sayHello(name);
        } catch (Exception e) {
            // 你可以容错，可以做任何AOP拦截事项
            return "容错数据";
        }
    }
}

注意：
1、Stub 必须有可传入 Proxy 的构造函数。
2、在 interface 旁边放一个 Stub 实现，它实现 BarService 接口，并有一个传入远程 BarService 实例的构造函数

六、Dubbo与SpringBoot整合的三种方式

1、application.properties模式

　　导入duboo-starter和zookeeper客户端，在application.properties配置属性，使用@service【暴露服务】，使用@Reference【引用服务】，需要用@EnableDubbo开启基于注解的dubbo功能

2、xml配置文件模式

　　导入duboo-starter和zookeeper客户端，保留dubbo的xml配置文件，需要用@ImportResource（locations="classpath:****.xml"）导入资源配置xml文件，不再使用@service【暴露服务】

3、注解API方式模式

　　使用注解API方式，将每一个组件手动创建到容器中，让dubbo来扫描其他的组件

七、高可用场景

1、zookeeper宕机与dubbo直连

现象：
    zookeeper注册中心宕机，还可以消费dubbo暴露的服务。

原因：
    健壮性
    （1）监控中心宕掉不影响使用，只是丢失部分采样数据
    （2）数据库宕掉后，注册中心仍然能通过缓存提供服务查询列表查询，但是不能注册新服务
    （3）注册中心对等集群，任意一台宕掉后，将自动切换到另一台
    （4）注册中心全部宕掉后，服务提供者和消费者仍然能通过本地缓存通讯
    （5）服务提供者无状态，任意一台宕掉后，不影响使用
    （6）服务提供者全部宕掉后，任意消费者应用将无法使用，并无限次重连等待服务提供者恢复高可用：通过设计，减少系统不能提供服务的时间

2、集群下dubbo负载均衡配置

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

　　负载均衡策略如下：

　　（1）Random LoadBalance 基于权重的随机负载均衡机制

　　随机，按权重设置随机概率。在一个截面上碰撞的概率高，但调用量越大分布越均匀，而且按概率使用权重后也比较均匀，有利于动态调整提供者权重。

　　（2）RoundRobin LoadBalance 基于权重的轮询负载均衡机制

　　轮循，按公约后的权重设置轮循比率。存在慢的提供者累积请求的问题，比如：第二台机器很慢，但没挂，当请求调到第二台时就卡在那，久而久之，所有请求都卡在调到第二台上。

　　（3）LeastActive LoadBalance最少活跃数负载均衡机制

　　最少活跃调用数，相同活跃数的随机，活跃数指调用前后计数差。使慢的提供者收到更少请求，因为越慢的提供者的调用前后计数差会越大。

　　（4）ConsistentHash LoadBalance一致性hash 负载均衡机制

　　一致性 Hash，相同参数的请求总是发到同一提供者。当某一台提供者挂时，原本发往该提供者的请求，基于虚拟节点，平摊到其它提供者，不会引起剧烈变动

3、整合hystrix，服务熔断与降级处理

（1）服务降级

　　什么是服务降级？

　　当服务器压力剧增的情况下，根据实际业务情况及流量，对一些服务和页面有策略的不处理或换种简单的方式处理，从而释放服务器资源以保证核心交易正常运作或高效运作。

　　可以通过服务降级功能临时屏蔽某个出错的非关键服务，并定义降级后的返回策略。

　　向注册中心写入动态配置覆盖规则：

RegistryFactory registryFactory = ExtensionLoader.getExtensionLoader(RegistryFactory.class).getAdaptiveExtension();
Registry registry = registryFactory.getRegistry(URL.valueOf("zookeeper://10.20.153.10:2181"));
registry.register(URL.valueOf("override://0.0.0.0/com.foo.BarService?category=configurators&dynamic=false&application=foo&mock=force:return+null"));

　　其中：

　　mock=force:return+null 表示消费方对该服务的方法调用都直接返回 null 值，不发起远程调用。用来屏蔽不重要服务不可用时对调用方的影响。

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

（2）集群容错

　　在集群调用失败时，Dubbo 提供了多种容错方案，缺省为 failover 重试。

　　集群容错模式：

Failover Cluster
失败自动切换，当出现失败，重试其它服务器。通常用于读操作，但重试会带来更长延迟。可通过 retries="2" 来设置重试次数(不含第一次)。

重试次数配置如下：
<dubbo:service retries="2" />
或
<dubbo:reference retries="2" />
或
<dubbo:reference>
    <dubbo:method name="findFoo" retries="2" />
</dubbo:reference>

Failfast Cluster
快速失败，只发起一次调用，失败立即报错。通常用于非幂等性的写操作，比如新增记录。

Failsafe Cluster
失败安全，出现异常时，直接忽略。通常用于写入审计日志等操作。

Failback Cluster
失败自动恢复，后台记录失败请求，定时重发。通常用于消息通知操作。

Forking Cluster
并行调用多个服务器，只要一个成功即返回。通常用于实时性要求较高的读操作，但需要浪费更多服务资源。可通过 forks="2" 来设置最大并行数。

Broadcast Cluster
广播调用所有提供者，逐个调用，任意一台报错则报错 [2]。通常用于通知所有提供者更新缓存或日志等本地资源信息。

集群模式配置
按照以下示例在服务提供方和消费方配置集群模式
<dubbo:service cluster="failsafe" />
或
<dubbo:reference cluster="failsafe" />

（3）整合hystrix

　　Hystrix 旨在通过控制那些访问远程系统、服务和第三方库的节点，从而对延迟和故障提供更强大的容错能力。Hystrix具备拥有回退机制和断路器功能的线程和信号隔离，请求缓存和请求打包，以及监控和配置等功能

　　（a）配置spring-cloud-starter-netflix-hystrix

　　spring boot官方提供了对hystrix的集成，直接在pom.xml里加入依赖：

     <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
            <version>1.4.4.RELEASE</version>
        </dependency>

　　然后在Application类上增加@EnableHystrix来启用hystrix starter：

@SpringBootApplication
@EnableHystrix
public class ProviderApplication {

　　（b）配置Provider端

　　在Dubbo的Provider上增加@HystrixCommand配置，这样子调用就会经过Hystrix代理。

@Service(version = "1.0.0")
public class HelloServiceImpl implements HelloService {
    @HystrixCommand(commandProperties = {
     @HystrixProperty(name = "circuitBreaker.requestVolumeThreshold", value = "10"),
     @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "2000") })
    @Override
    public String sayHello(String name) {
        // System.out.println("async provider received: " + name);
        // return "annotation: hello, " + name;
        throw new RuntimeException("Exception to show hystrix enabled.");
    }
}

　　（c）配置Consumer端

　　对于Consumer端，则可以增加一层method调用，并在method上配置@HystrixCommand。当调用出错时，会走到fallbackMethod = "reliable"的调用里。

　　@Reference(version = "1.0.0")
    private HelloService demoService;

    @HystrixCommand(fallbackMethod = "reliable")
    public String doSayHello(String name) {
        return demoService.sayHello(name);
    }
    public String reliable(String name) {
        return "hystrix fallback value";
    }

八、dubbo原理

1、RPC原理

一次完整的RPC调用流程（同步调用，异步另说）如下： 
1）服务消费方（client）调用以本地调用方式调用服务； 
2）client stub接收到调用后负责将方法、参数等组装成能够进行网络传输的消息体； 
3）client stub找到服务地址，并将消息发送到服务端； 
4）server stub收到消息后进行解码； 
5）server stub根据解码结果调用本地的服务； 
6）本地服务执行并将结果返回给server stub； 
7）server stub将返回结果打包成消息并发送至消费方； 
8）client stub接收到消息，并进行解码； 
9）服务消费方得到最终结果。
RPC框架的目标就是要2~8这些步骤都封装起来，这些细节对用户来说是不透明的，不可见的。

2、netty通信原理

　　Netty是一个异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。它极大地简化并简化了TCP和UDP套接字服务器等网络编程。

　　BIO：(Blocking IO)

　　NIO (Non-Blocking IO)

　　Selector 一般称为选择器 ，也可以翻译为 多路复用器，

　　Connect（连接就绪）、Accept（接受就绪）、Read（读就绪）、Write（写就绪）

　　Netty基本原理：

3、dubbo原理

3.1、框架设计

config 配置层：对外配置接口，以 ServiceConfig, ReferenceConfig 为中心，可以直接初始化配置类，也可以通过 spring 解析配置生成配置类
proxy 服务代理层：服务接口透明代理，生成服务的客户端 Stub 和服务器端 Skeleton, 以 ServiceProxy 为中心，扩展接口为 ProxyFactory
registry 注册中心层：封装服务地址的注册与发现，以服务 URL 为中心，扩展接口为 RegistryFactory, Registry, RegistryService
cluster 路由层：封装多个提供者的路由及负载均衡，并桥接注册中心，以 Invoker 为中心，扩展接口为 Cluster, Directory, Router, LoadBalance
monitor 监控层：RPC 调用次数和调用时间监控，以 Statistics 为中心，扩展接口为 MonitorFactory, Monitor, MonitorService
protocol 远程调用层：封装 RPC 调用，以 Invocation, Result 为中心，扩展接口为 Protocol, Invoker, Exporter
exchange 信息交换层：封装请求响应模式，同步转异步，以 Request, Response 为中心，扩展接口为 Exchanger, ExchangeChannel, ExchangeClient, ExchangeServer
transport 网络传输层：抽象 mina 和 netty 为统一接口，以 Message 为中心，扩展接口为 Channel, Transporter, Client, Server, Codec
serialize 数据序列化层：可复用的一些工具，扩展接口为 Serialization, ObjectInput, ObjectOutput, ThreadPool

3.2、启动解析、加载配置信息

3.3、服务暴露

3.4、服务引用

3.5、服务调用

posted @ 2021-10-30 13:38 沧海一粟hr 阅读(144) 评论(0) 编辑收藏举报

刷新页面返回顶部

沧海一粟11

dubbo笔记

一、基础知识

1、分布式基础理论

2、dubbo核心概念

3、dubbo的特性

4、dubbo和springcloud对比

5、dubbo环境搭建

二、Dubbo创建提供者和消费者工程

1、服务提供者和消费者接口搭建

2、服务提供者配置及测试

3、服务消费者配置及测试

三、dubbo监控中心

1、dubbo-admin

2、dubbo-monitor-simple

四、dubbo与SpringBoot整合

1、整合服务提供者

2、整合服务消费者

五、Dubbo配置

1、配置原则

2、启动时检查

3、超时&配置覆盖关系

4、重试次数

5、多版本

6、本地存根

六、Dubbo与SpringBoot整合的三种方式

1、application.properties模式

2、xml配置文件模式

3、注解API方式模式

七、高可用场景

1、zookeeper宕机与dubbo直连

2、集群下dubbo负载均衡配置

3、整合hystrix，服务熔断与降级处理

八、dubbo原理

1、RPC原理

2、netty通信原理

3、dubbo原理

3.1、框架设计

3.2、启动解析、加载配置信息

3.3、服务暴露

3.4、服务引用

3.5、服务调用

公告

1、dubbo-admin　　