dubbo知识概括

分布式基础理论与RPC

什么是分布式系统？

• 《分布式系统原理与范型》定义： “分布式系统是若干独立计算机的集合，这些计算机对于用户来说就像单个相关系统”分布式系统（distributed system）是建立在网络之上的软件系统。
• 随着互联网的发展，网站应用的规模不断扩大，常规的垂直应用架构已无法应对，分布式服务架构以及流动计算架构势在必行，亟需一个治理系统确保架构有条不紊的演进。

发展演变：

• 单一应用架构：当网站流量很小时，只需一个应用，将所有功能都部署在一起，以减少部署节点和成本。此时，用于简化增删改查工作量的数据访问框架(ORM)是关键。
  ①适用于小型网站，小型管理系统，将所有功能都部署到一个功能里，简单易用。
  ②特点：
  <1>所有的功能集成在一个项目工程中。
  <2>所有的功能打在一个war包部署到服务器。
  <3>通过部署应用集群和数据库集群来提高系统的性能。
  ③优点：
  <1>项目架构简单，前期开发成本低，周期短，小型项目的首选。
  <2>开发效率高，模块之间交互采用本地方法调用。
  <3>容易部署，运维成本小，直接打包为一个完整的包，拷贝到web容器的某个目录下即可运行。
  <4>容易测试：IDE都是为开发单个应用设计的、容易测试——在本地就可以启动完整的系统。
  ④缺点：
  <1>全部功能集成在一个工程中，对于大型项目不易开发、扩展及维护。
  <2>版本迭代速度逐渐变慢，修改一个地方就要将整个应用全部编译、部署、启动，开发及测试周期过长。
  <3>无法按需伸缩，通过集群的方式来实现水平扩展，无法针对某业务按需伸缩。
  

• 垂直应用架构：当访问量逐渐增大，单一应用增加机器带来的加速度越来越小，将应用拆成互不相干的几个应用，以提升效率。此时，用于加速前端页面开发的Web框架(MVC)是关键。
  ①通过切分业务来实现各个模块独立部署，降低了维护和部署的难度，团队各司其职更易管理，性能扩展也更方便，更有针对性。
  ②特点：
  <1>按业务垂直拆分成一个一个的单体系统，此架构也称为垂直架构。
  <2>系统与系统之间的存在数据冗余，耦合性较大，如下图中三个项目都存在客户信息。
  <3>系统之间的接口多为实现数据同步，如下图中三个项目要同步客户信息。
  ③优点：
  <1>通过垂直拆分，每个子系统变成小型系统，功能简单，前期开发成本低，周期短。
  <2>每个子系统可按需伸缩。
  <3>每个子系统可采用不同的技术。
  ④缺点：
  <1>子系统之间存在数据冗余、功能冗余，耦合性高。
  <2>按需伸缩粒度不够，对同一个子系统中的不同的业务无法实现，比如订单管理和用户管理。
  

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

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

什么叫RPC？

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

RPC基本原理：

• RPC两个核心模块：
  ①通讯
  ②序列化。
  
  

dubbo简介

简介：

• Apache Dubbo (incubating) |ˈdʌbəʊ| 是一款高性能、轻量级的开源JavaRPC框架，它提供了三大核心能力：面向接口的远程方法调用，智能容错和负载均衡，以及服务自动注册和发现。
• 链接：
  ①官网
  ②最强Dubbo面试题，附带超级详细答案
• 基本概念：
  
  ①服务提供者（Provider）：暴露服务的服务提供方，服务提供者在启动时，向注册中心注册自己提供的服务。
  ②服务消费者（Consumer）: 调用远程服务的服务消费方，服务消费者在启动时，向注册中心订阅自己所需的服务，服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。
  ③注册中心（Registry）：注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者
  ④监控中心（Monitor）：服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心
• 调用关系说明：
  ①服务容器负责启动，加载，运行服务提供者。
  ②服务提供者在启动时，向注册中心注册自己提供的服务。
  ③服务消费者在启动时，向注册中心订阅自己所需的服务。
  ④注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者。
  ⑤服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。
  ⑥服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心。

zookeeper环境搭建：

• windows下安装zookeeper：
  ①下载zookeeper，链接：zookeeper地址
• 解压zookeeper：解压运行zkServer.cmd ，初次运行会报错，没有zoo.cfg配置文件
• 修改zoo.cfg配置文件：将conf下的zoo_sample.cfg复制一份改名为zoo.cfg即可。
  ①注意几个重要位置：
  <1>dataDir=./ 临时数据存储的目录（可写相对路径）
  <2>clientPort=2181 zookeeper的端口号
  ②修改完成后再次启动zookeeper
• 使用zkCli.cmd测试
  ①ls /：列出zookeeper根下保存的所有节点
  ②create –e /atguigu 123：创建一个atguigu节点，值为123
  ③get /atguigu：获取/atguigu节点的值

dubbo-admin环境搭建：

• 链接：
  ①dubbo管理工具之dubbo-admin教程
  ②新版dubbo-admin安装教程
• windows下安装dubbo-admin管理控制台：图形化的服务管理页面；安装时需要指定注册中心地址，即可从注册中心中获取到所有的提供者/消费者进行配置管理
• dubbo本身并不是一个服务软件。它其实就是一个jar包能够帮你的java程序连接到zookeeper，并利用zookeeper消费、提供服务。所以你不用在Linux上启动什么dubbo服务。但是为了让用户更好的管理监控众多的dubbo服务，官方提供了一个可视化的监控程序，不过这个监控即使不装也不影响使用。
• 下载dubbo-admin，链接：dubbo-admin地址
• 进入目录，修改dubbo-admin配置，修改 src\main\resources\application.properties 指定zookeeper地址

spring.guest.password=guest
dubbo.registry.address=zookeeper://127.0.0.1:2181

• 打包dubbo-admin

mvn clean package -Dmaven.test.skip=true 

• 运行dubbo-admin
  ①注意：【有可能控制台看着启动了，但是网页打不开，需要在控制台按下ctrl+c即可】
  默认使用root/root 登陆

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

dubbo-monitor-simple环境搭建：

• 链接：Dubbo：搭建监控中心(dubbo-monitor-simple)教程
• 简单的监控中心；
• 下载 dubbo-ops，链接：dubbo-ops地址
• Operations（OPS）：运维的意思。
• 修改配置指定注册中心地址，进入 dubbo-monitor-simple\src\main\resources\conf。修改 dubbo.properties文件

dubbo.container=log4j,spring,registry,jetty
dubbo.application.name=simple-monitor
dubbo.application.owner=dubbo
#dubbo.registry.address=multicast://224.5.6.7:1234
dubbo.registry.address=zookeeper://118.24.44.169:2181#注册中心地址
#dubbo.registry.address=redis://127.0.0.1:6379 
#dubbo.registry.address=dubbo://127.0.0.1:9090
dubbo.protocol.port=7070
dubbo.jetty.port=8080 #http访问端口

• 打包dubbo-monitor-simple

mvn clean package -Dmaven.test.skip=true

• 解压 tar.gz 文件，并运行start.bat
  注意：如果缺少servlet-api，自行导入servlet-api再访问监控中心
• 启动访问8080
• 监控中心配置：所有服务配置连接监控中心，进行监控统计
  ①Simple Monitor 挂掉不会影响到 Consumer 和 Provider 之间的调用，所以用于生产环境不会有风险。
  ②Simple Monitor 采用磁盘存储统计信息，请注意安装机器的磁盘限制，如果要集群，建议用mount共享磁盘。

<dubbo:monitor protocol="registry">dubbo:monitor>

dubbo入门案例

分析：

• 提出需求：某个电商系统，订单服务需要调用用户服务获取某个用户的所有地址；我们现在需要创建两个服务模块进行测试

模块	功能
订单服务web模块	创建订单等
用户服务service模块	查询用户地址等

• 测试预期结果：订单服务web模块在A服务器，用户服务模块在B服务器，A可以远程调用B的功能。
• 分包：建议将服务接口，服务模型，服务异常等均放在 API 包中，因为服务模型及异常也是 API 的一部分，同时，这样做也符合分包原则：重用发布等价原则(REP)，共同重用原则(CRP)。
  ①如果需要，也可以考虑在 API 包中放置一份 spring 的引用配置，这样使用方，只需在 spring 加载过程中引用此配置即可，配置建议放在模块的包目录下，以免冲突，如：com/alibaba/china/xxx/dubbo-reference.xml。
• 粒度：服务接口尽可能大粒度，每个服务方法应代表一个功能，而不是某功能的一个步骤，否则将面临分布式事务问题，Dubbo 暂未提供分布式事务支持。
  ①服务接口建议以业务场景为单位划分，并对相近业务做抽象，防止接口数量爆炸。
  ②不建议使用过于抽象的通用接口，如：Map query(Map)，这样的接口没有明确语义，会给后期维护带来不便。
  

创建公共接口层模块：

• gmall-interface：公共接口层（model，service，exception…） 作用：定义公共接口，也可以导入公共依赖
• Bean模型

public class UserAddress implements Serializable{
    private Integer id;
    private String userAddress;
    private String userId;
    private String consignee;
    private String phoneNum;
    private String isDefault;
}

• Service接口

public interface UserService{
	List<UserAddress> getUserAddressList(String userId);
}

创建用户模块层模块：

• gmall-user：用户模块（对用户接口的实现）
• pom.xml

  <dependencies>
  	<dependency>
  		<groupId>com.atguigu.dubbogroupId>
  		<artifactId>gmall-interfaceartifactId>
  		<version>0.0.1-SNAPSHOTversion>
  	dependency>
  dependencies>

• Service

public class UserServiceImpl implements UserService {
	@Override
	public List<UserAddress> getUserAddressList(String userId) {
		// TODO Auto-generated method stub
		return userAddressDao.getUserAddressById(userId);
	}
}

创建订单模块层模块：

• gmall-order-web：订单模块（调用用户模块）
• pom.xml

<dependencies>
  	<dependency>
  		<groupId>com.atguigu.dubbogroupId>
  		<artifactId>gmall-interfaceartifactId>
  		<version>0.0.1-SNAPSHOTversion>
  	dependency>
   dependencies>

• 测试

public class OrderService {	
	private UserService userService;	
	/**
	 * 初始化订单，查询用户的所有地址并返回
	 * @param userId
	 * @return
	 */
	public List<UserAddress> initOrder(String userId){
		return userService.getUserAddressList(userId);
	}
}

• 现在这样是无法进行调用的。我们gmall-order-web引入了gmall-interface，但是interface的实现是gmall-user，我们并没有引入，而且实际他可能还在别的服务器中。

Curator简介：

• Curator是Netflix公司开源的一套zookeeper客户端框架，解决了很多Zookeeper客户端非常底层的细节开发工作，包括连接重连、反复注册Watcher和NodeExistsException异常等等。Patrixck Hunt（Zookeeper）以一句“Guava is to Java that Curator to Zookeeper”给Curator予高度评价。
• Curator的maven依赖：

<dependency>
    <groupId>org.apache.curatorgroupId>
    <artifactId>curator-frameworkartifactId>
    <version>2.12.0version>
dependency>

<dependency>
    <groupId>org.apache.curatorgroupId>
    <artifactId>curator-recipesartifactId>
    <version>2.12.0version>
dependency>

• 链接：Curator入门

使用dubbo改造：

• 改造gmall-user作为服务提供者
• 引入dubbo

<dependency>
	<groupId>com.alibabagroupId>
	<artifactId>dubboartifactId>
	<version>2.6.2version>
dependency>


<dependency>
	<groupId>com.101tecgroupId>
	<artifactId>zkclientartifactId>
	<version>0.10version>
dependency>

<dependency>
	<groupId>org.apache.curatorgroupId>
	<artifactId>curator-frameworkartifactId>
	<version>2.12.0version>
dependency>

• 配置提供者

<dubbo:application name="gmall-user">dubbo:application>

<dubbo:registry address="zookeeper://118.24.44.169:2181" />

<dubbo:protocol name="dubbo" port="20880" />

<dubbo:service interface="com.atguigu.gmall.service.UserService" 
ref="userServiceImpl" />

• 启动服务

public static void main(String[] args) throws IOException {
	ClassPathXmlApplicationContext context = 
			new ClassPathXmlApplicationContext("classpath:spring-beans.xml");		
	System.in.read(); 
}

改造gmall-order-web作为服务消费者：

• 引入dubbo

		
		<dependency>
			<groupId>com.alibabagroupId>
			<artifactId>dubboartifactId>
			<version>2.6.2version>
		dependency>
	
		<dependency>
			<groupId>com.101tecgroupId>
			<artifactId>zkclientartifactId>
			<version>0.10version>
		dependency>
		
		<dependency>
			<groupId>org.apache.curatorgroupId>
			<artifactId>curator-frameworkartifactId>
			<version>2.12.0version>
		dependency>

• 配置消费者信息

<dubbo:application name="gmall-order-web">dubbo:application>

<dubbo:registry address="zookeeper://118.24.44.169:2181" />

<dubbo:reference id="userService" interface="com.atguigu.gmall.service.UserService">dubbo:reference>

• 测试调用

访问gmall-order-web的initOrder请求，会调用UserService获取用户地址；
调用成功。说明我们order已经可以调用远程的UserService了；

注解版：

• 服务提供方

<dubbo:application name="gmall-user">dubbo:application>
<dubbo:registry address="zookeeper://118.24.44.169:2181" />
<dubbo:protocol name="dubbo" port="20880" />
<dubbo:annotation package="com.atguigu.gmall.user.impl"/>

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

@Service //使用dubbo提供的service注解，注册暴露服务
public class UserServiceImpl implements UserService {

	@Autowired
	UserAddressMapper userAddressMapper;

• 服务消费方

<dubbo:application name="gmall-order-web">dubbo:application>
<dubbo:registry address="zookeeper://118.24.44.169:2181" />
<dubbo:annotation package="com.atguigu.gmall.order.controller"/>

@Controller
public class OrderController {
	
	@Reference  //使用dubbo提供的reference注解引用远程服务
	UserService userService;

dubbo整合SpringBoot

简介：

• 引入spring-boot-starter以及dubbo和curator的依赖，注意starter版本适配：

<dependency>
    <groupId>com.alibaba.bootgroupId>
    <artifactId>dubbo-spring-boot-starterartifactId>
    <version>0.2.0version>
dependency>

<groupId>com.alibabagroupId>
	<artifactId>dubboartifactId>
	<version>2.6.2version>
dependency>

<dependency>
	<groupId>com.101tecgroupId>
	<artifactId>zkclientartifactId>
	<version>0.10version>
dependency>

• 配置application.properties：

----------------------------提供者配置：----------------------------
#服务名，不能跟别的dubbo提供端重复
dubbo.application.name=gmall-user
#指定注册中心协议
dubbo.registry.protocol=zookeeper
#注册中心的地址加端口号
dubbo.registry.address=zookeeper://192.168.67.159:2181
#注解方式要扫描的包
dubbo.scan.base-package=com.atguigu.gmall
#分布式固定是dubbo,不要改
dubbo.protocol.name=dubbo
#服务发现端口
dubbo.protocol.port=20880

----------------------------消费者配置：----------------
#服务名，不能跟别的dubbo消费端重复
dubbo.application.name=gmall-order-web
#指定注册中心协议
dubbo.registry.protocol=zookeeper
#注册中心的地址加端口号
dubbo.registry.address=zookeeper://192.168.67.159:2181
#注解方式要扫描的包
dubbo.scan.base-package=com.atguigu.gmall
#分布式固定是dubbo,不要改
dubbo.protocol.name=dubbo
#服务发现端口
dubbo.protocol.port=20881

• 注意：
  ①如果没有在配置中写dubbo.scan.base-package,还需要使用@EnableDubbo注解来启动自动扫描。
  ②dubbo.registry.address：注册中心服务器地址(必填)，如果地址没有端口缺省为9090，同一集群内的多个地址用逗号分隔，如：ip:port,ip:port，不同集群的注册中心，请配置多个标签。
  ③dubbo.protocol.name：协议名称(必填)。
  ④dubbo.protocol.port：协议名称(可选)，dubbo协议缺省端口为20880，rmi协议缺省端口为1099，http和hessian协议缺省端口为80；如果没有配置port，则自动采用默认端口，如果配置为-1，则会分配一个没有被占用的端口。Dubbo 2.4.0+，分配的端口在协议缺省端口的基础上增长，确保端口段可控。
  ⑤dubbo.registry.protocol：注册中心地址协议(可选)，支持dubbo, multicast, zookeeper, redis, consul(2.7.1), sofa(2.7.2), etcd(2.7.2), nacos(2.7.2)等协议。
  ⑥dubbo.application.name：当前应用名称(必填)，用于注册中心计算应用间依赖关系，注意：消费者和提供者应用名不要一样，此参数不是匹配条件，你当前项目叫什么名字就填什么，和提供者消费者角色无关，比如：kylin应用调用了morgan应用的服务，则kylin项目配成kylin，morgan项目配成morgan，可能kylin也提供其它服务给别人使用，但kylin项目永远配成kylin，这样注册中心将显示kylin依赖于morgan。

Dubbo注解：

• 注解@DubboService和@DubboReference对应着xml配置的和。
  ①将所有 @DubboService 的 class 提升为 Spring bean。
  ②为使用 @DubboReference 注解的字段或方法注入代理对象。
  ③注意： 2.7.7开始才增加这两个注解，之前使用的是@Service和@Reference。因为有开发者提议这个@Service和Spring中的@Service太容易混淆，建议调整为 @DubboService 和 @DubboReference。
• @EnableDubbo注解也是启动dubbo服务，它整合了@EnableDubboConfig和@DubboComponentScan。 @EnableDubboConfiguration在生产端和消费端加上此注解来表示使用dubbo服务(但这个注解属于旧版本的)。
  ①@DubboComponentScan 作为 Dubbo 2.5.7 新增的 Annotation，是XML 元素dubbo:annotation 的替代方案。
  ②@DubboComponentScan在扫描的时候 只需关注 @Service和@Reference两个注解，它除了将Dubbo @Service 类暴露 Dubbo 服务外，还把 Spring Bean @Reference字段或者方法注入了 Dubbo服务代理。@Reference字段所在的声明类不是 Spring Bean 的话， @DubboComponentScan 不会处理@Reference注入，其原理与 Spring @Autowired 一致。
  ③@EnableDubboConfig 提供外部化配置属性与 Dubbo 配置类之间的绑定。multiple：表示是否支持多Dubbo 配置 Bean 绑定但是2.5.9版本默认multipe是false。

@EnableDubboConfig
@DubboComponentScan
public @interface EnableDubbo {
}

@Import (DubboComponentScanRegistrar.class)
public @interface DubboComponentScan {
}

@Import(DubboConfigConfigurationRegistrar.class)
public @interface EnableDubboConfig {
}

• 链接：
  ①Dubbo注解方式与spring的整合原理即@DubboService的机制
  ②Dubbo整合Spring原理之@Reference和@DubboReference生效机制(3)
  

dubbo配置

配置原则:

• JVM 启动 -D 参数优先，这样可以使用户在部署和启动时进行参数重写，比如在启动时需改变协议的端口。
• XML 次之，如果在 XML 中有配置，则 dubbo.properties 中的相应配置项无效。
• Properties 最后，相当于缺省值，只有 XML 没有配置时，dubbo.properties的相应配置项才会生效，通常用于共享公共配置，比如应用名。

重试次数:

• 失败自动切换，当出现失败，重试其它服务器，但重试会带来更长延迟。可通过 retries=“2” 来设置重试次数(不含第一次)。
• 缺省值为2，不需要重试请设为0。
• 重试次数配置如下：

<dubbo:service retries="2" />
或
<dubbo:reference retries="2" />
或
<dubbo:reference>
    <dubbo:method name="findFoo" retries="2" />
dubbo:reference>

超时时间:

• 由于网络或服务端不可靠，会导致调用出现一种不确定的中间状态（超时）。为了避免超时导致客户端资源（线程）挂起耗尽，必须设置超时时间。
• Dubbo消费端：

全局超时配置
<dubbo:consumer timeout="5000" />

指定接口以及特定方法超时配置
<dubbo:reference interface="com.foo.BarService" timeout="2000">
    <dubbo:method name="sayHello" timeout="3000" />
dubbo:reference>

• Dubbo服务端：

全局超时配置
<dubbo:provider timeout="5000" />

指定接口以及特定方法超时配置
<dubbo:provider interface="com.foo.BarService" timeout="2000">
    <dubbo:method name="sayHello" timeout="3000" />
dubbo:provider>

• 配置原则：dubbo推荐在Provider上尽量多配置Consumer端属性：
  ①作服务的提供者，比服务使用方更清楚服务性能参数，如调用的超时时间，合理的重试次数，等等
  ②在Provider配置后，Consumer不配置则会使用Provider的配置值，即Provider配置可以作为Consumer的缺省值。否则，Consumer会使用Consumer端的全局设置，这对于Provider不可控的，并且往往是不合理的
• 配置的覆盖规则：
  ①方法级配置别优于接口级别，即小Scope优先
  ② Consumer端配置 优于 Provider配置 优于 全局配置，
  ③ 最后是Dubbo Hard Code的配置值（见配置文档）
  

版本号:

• 当一个接口实现，出现不兼容升级时，可以用版本号过渡，版本号不同的服务相互间不引用。 可以按照以下的步骤进行版本迁移：
  ①在低压力时间段，先升级一半提供者为新版本
  ②再将所有消费者升级为新版本
  ③然后将剩下的一半提供者升级为新版本
• 缺省值为0.0.0，建议使用两位数字版本，如：1.0。

老版本服务提供者配置：
<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" />

如果不需要区分版本，可以按照以下的方式配置：
<dubbo:reference id="barService" interface="com.foo.BarService" version="*" />

分组：

• group：当一个接口有多个实现，可以用分组区分。
• 例如：group = “group1”

总结：

• 链接：Dubbo配置参考手册

dubbo应用详解

dubbo开发常见知识：

• 调用Dubbo报错com.alibaba.dubbo.rpc.RpcException: Failed to invoke the
  method问题原因和解决办法：
  ①需要进行序列化的POJO类没有进行序列化，多是入参中的一些参数实体类。这个原因是最容易发现的，因为未序列化的类会在异常信息中显示，在日志信息中搜索“Serializable”，即可找到对应的类，再将其实现序列化即可。
  ②Dubbo Provider 服务部署存在问题。检查你服务器上的dubbo服务是否正常，检查服务器是否存在问题（比如服务器上是否存在虚拟机网络）。最好尝试重新部署dubbo，通过invoke命令调用一下确认服务没有问题。
  ③防火墙对应端口没有开启, 这种情况一般出现在外网调用时。dubbo默认端口是20880（这个可以通过修改配置更改）。
  <1>在 /etc/sysconfig/iptables中添加下边内容（以下命令是开启20880端口，有可能还需开启其他端口）：-A INPUT -m state --state NEW -m tcp -p tcp --dport 20880 -j ACCEPT，表示开启20880端口，然后:service iptables restart 重启防火墙即可。
  <2>Windows开启方法：控制面板—防火墙—高级—入站规则—新建规则—填写—下一步…
  ④invoke方法代码执行过程中出现异常导致（也有可能是切面中存在异常，小心）。

dubbo调试invoke详解：

• 系统中的telnet客户端是关闭状态，即Win10默认没有安装telnet功能。解决方法：将系统中的telnet客户端打开即可，控制面板 -> 程序 -> 启用或关闭Windows功能 -> 勾选Telnet客户端 -> 确定。
• 首先使用telnet命令进入控制台，命令：telnet ip 端口。端口为dubbo.protocol.port。
• invoke文档：
  ①invoke XxxService.xxxMethod(1234, “abcd”, {“prop” : “value”}): 调用服务的方法
  ②invoke com.xxx.XxxService.XxxService.xxxMethod(1234, “abcd”, {“prop” : “value”}): 调用全路径服务的方法
  ③invoke xxxMethod(1234, “abcd”, {“prop” : “value”}): 调用服务的方法(自动查找包含此方法的服务)
  ④invoke xxxMethod({“name”:“zhangsan”,“age”:12,“class”:“org.apache.dubbo.qos.legacy.service.Person”}) :当有参数重载，或者类型转换失败的时候，可以通过增加class属性指定需要转换类
  ⑤invoke com.xxx.xxxApiService({“3”:0.123, “class”:“java.util.HashMap”})：当参数为Map，key的类型为Integer时，建议指定类型
• 链接：
  ①dubbo命令行详解
  ②dubbo中invoke多种调用入参方式

Dubbo 线程池满异常：

• 链接：Arthas | 定位线上 Dubbo线程池满异常
• 简单归纳下 Dubbo 默认的线程模型：Dubbo 服务端每次接收到一个 Dubbo 请求，便交给一个线程池处理，该线程池默认有 200 个线程，若是 200 个线程都不处于空闲状态，则客户端会报出以下异常：

Caused by: java.util.concurrent.ExecutionException: org.apache.dubbo.remoting.RemotingException:
Server side(192.168.1.101,20880) threadpool is exhausted ...

• 引起该异常的缘由主要有如下几点：
  ①客户端/服务端超时时间设置不合理，致使请求无限等待，耗尽了线程数；
  ②客户端请求量过大，服务端没法及时处理，耗尽了线程数；
  ③服务端因为 fullgc 等缘由致使处理请求较慢，耗尽了线程数；
  ④服务端因为数据库、Redis、网络 IO 阻塞问题，耗尽了线程数；
  ⑤…
• 紧接着针对本身的业务场景对 Dubbo 进行调优：
  ①调整 Provider 端的 dubbo.provider.threads 参数大小，默认 200，能够适当提升。多大算合适？至少 700 不算大；不建议调的过小，容易出现上述问题；
  ②调整 Consumer 端的 dubbo.consumer.actives 参数，控制消费者调用的速率。这个实践中不多使用，仅仅一提；
  ③客户端限流；
  ④服务端扩容；
  ⑤Dubbo 目前不支持给某个 Service 单独配置一个隔离的线程池，用于保护服务，可能在之后的版本中会增长这个特性。

dubbo超时重试与异常处理：

• 超时是针对消费端还是服务端？
  ①如果是针对消费端，那么当消费端发起一次请求后，如果在规定时间内未得到服务端的响应则直接返回超时异常，但服务端的代码依然在执行。
  ②如果是针对服务端，那么当消费端发起一次请求后，一直等待服务端的响应，服务端在方法执行到指定时间后如果未执行完，此时返回一个超时异常给到消费端。
  ③如果是针对服务端，那么当消费端发起一次请求后，一直等待服务端的响应，服务端在方法执行到指定时间后如果未执行完，此时返回一个超时异常给到消费端。
• 超时在哪设置及优先级？
  ①服务端的超时配置是消费端的缺省配置，即如果服务端设置了超时，任务消费端可以不设置超时时间，简化了配置。
  ②针对控制的粒度，dubbo支持了接口级别也支持方法级别，可以根据不同的实际情况精确控制每个方法的超时时间。所以最终的优先顺序为：客户端方法级>服务端方法级>客户端接口级>服务端接口级>客户端全局>服务端全局。
• dubbo超时配置详解：
  ①全局配置：dubbo:provider以及 dubbo:consumer 。
  ②接口类配置：dubbo:service以及dubbo:reference。
  ③方法配置：dubbo:method。
• 超时的实现原理是什么？
  ①dubbo默认采用了netty做为网络组件，它属于一种NIO的模式。消费端发起远程请求后，线程不会阻塞等待服务端的返回，而是马上得到一个ResponseFuture，消费端通过不断的轮询机制判断结果是否有返回。因为是通过轮询，轮询有个需要特别注要的就是避免死循环，所以为了解决这个问题就引入了超时机制，只在一定时间范围内做轮询，如果超时时间就返回超时异常。
• 超时解决的是什么问题？
  ①对调用的服务设置超时时间，是为了避免因为某种原因导致线程被长时间占用，最终出现线程池用完返回拒绝服务的异常。
• Dubbo超时和重连机制：
  ①dubbo启动时默认有重试机制和超时机制。
  ②超时机制的规则是如果在一定的时间内，provider没有返回，则认为本次调用失败。
  ③重试机制在出现调用失败时，会再次调用。如果在配置的调用次数内都失败，则认为此次请求异常，抛出异常。
• 链接：dubbo超时重试和异常处理

dubbo高可用

zookeeper宕机与dubbo直连:

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

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

• 高可用：通过设计，减少系统不能提供服务的时间；

集群下dubbo负载均衡配置:

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

public class OrderServiceImpl implements OrderService {

	//@Autowired
	@Reference( loadbalance="random") l / dubbo直连UserService userservice;
	@override
	public List<UserAddress> initOrder(String userId){
		//TODO Auto-generated method stub
		System.out.print1n("用户id. "+userId);
		//1、查询用户的收货地址
		List<UserAddress> addressList = userService.getuserAddressList(userId);
		return addressList;
}

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

• 什么是服务降级？
  ①当服务器压力剧增的情况下，根据实际业务情况及流量，对一些服务和页面有策略的不处理或换种简单的方式处理，从而释放服务器资源以保证核心交易正常运作或高效运作。
  ②可以通过服务降级功能临时屏蔽某个出错的非关键服务，并定义降级后的返回策略。
  ③向注册中心写入动态配置覆盖规则：

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 值，不抛异常。用来容忍不重要服务不稳定时对调用方的影响。
• 集群容错：在集群调用失败时，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" />

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

整合hystrix详解：

• 配置spring-cloud-starter-netflix-hystrix，spring boot官方提供了对hystrix的集成，直接在pom.xml里加入依赖：

        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-netflix-hystrixartifactId>
            <version>1.4.4.RELEASEversion>
        dependency>

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

@SpringBootApplication
@EnableHystrix
public class ProviderApplication {

• 配置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.");
    }
}

• 配置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原理

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这些步骤都封装起来，这些细节对用户来说是透明的，不可见的。

netty通信原理：

• Netty是一个异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。它极大地简化并简化了TCP和UDP套接字服务器等网络编程。
• BIO：(Blocking IO)
  
• NIO (Non-Blocking IO)：
  ①Selector 一般称 为选择器 ，也可以翻译为 多路复用器，
  ②Connect（连接就绪）、Accept（接受就绪）、Read（读就绪）、Write（写就绪）
• Netty基本原理：
  

dubbo原理：

• dubbo原理 -框架设计：
  

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

• dubbo原理 -启动解析、加载配置信息：
  
• dubbo原理 -服务暴露：
  
• dubbo原理 -服务引用：
  
• dubbo原理 -服务调用：