单一应用架构
- 当网站流量很小时，只需一个应用，将所有功能都部署在一起，以减少部署节点和成本。
- 此时，用于简化增删改查工作量的 数据访问框架(ORM) 是关键。
垂直应用架构
- 当访问量逐渐增大，单一应用增加机器带来的加速度越来越小，将应用拆成互不相干的几个应用，以提升效率。
- 此时，用于加速前端页面开发的 Web框架(MVC) 是关键。
分布式服务架构
- 当垂直应用越来越多，应用之间交互不可避免，将核心业务抽取出来，作为独立的服务，逐渐形成稳定的服务中心，使前端应用能更快速的响应多变的市场需求。
- 此时，用于提高业务复用及整合的 分布式服务框架(RPC) 是关键。
流动计算架构
- 当服务越来越多，容量的评估，小服务资源的浪费等问题逐渐显现，此时需增加一个调度中心基于访问压力实时管理集群容量，提高集群利用率。
- 此时，用于提高机器利用率的 资源调度和治理中心(SOA) 是关键。

需求

(#)

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

(1) 当服务越来越多时，服务URL配置管理变得非常困难，F5硬件负载均衡器的单点压力也越来越大。

此时需要一个服务注册中心，动态的注册和发现服务，使服务的位置透明。

并通过在消费方获取服务提供方地址列表，实现软负载均衡和Failover，降低对F5硬件负载均衡器的依赖，也能减少部分成本。

(2) 当进一步发展，服务间依赖关系变得错踪复杂，甚至分不清哪个应用要在哪个应用之前启动，架构师都不能完整的描述应用的架构关系。

这时，需要自动画出应用间的依赖关系图，以帮助架构师理清理关系。

(3) 接着，服务的调用量越来越大，服务的容量问题就暴露出来，这个服务需要多少机器支撑？什么时候该加机器？

为了解决这些问题，第一步，要将服务现在每天的调用量，响应时间，都统计出来，作为容量规划的参考指标。

其次，要可以动态调整权重，在线上，将某台机器的权重一直加大，并在加大的过程中记录响应时间的变化，直到响应时间到达阀值，记录此时的访问量，再以此访问量乘以机器数反推总容量。

以上是Dubbo最基本的几个需求，更多服务治理问题参见：

http://code.alibabatech.com/blog/experience_1402/service-governance-process.html

架构

(#)

节点角色说明：

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

调用关系说明：

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

(1) 连通性：

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

(2) 健状性：

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

(3) 伸缩性：

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

(4) 升级性：

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

Deployer: 自动部署服务的本地代理。
Repository: 仓库用于存储服务应用发布包。
Scheduler: 调度中心基于访问压力自动增减服务提供者。
Admin: 统一管理控制台。

用法

(#)

本地服务：(Spring配置)

local.xml

           <beanid=“xxxService” class=“com.xxx.XxxServiceImpl” /> 
         
           <beanid=“xxxAction” class=“com.xxx.XxxAction”> 
         
               <propertyname=“xxxService” ref=“xxxService” /> 
         
           </bean>

远程服务：(Spring配置)

在本地服务的基础上，只需做简单配置，即可完成远程化：

将上面的local.xml配置拆分成两份，将服务定义部分放在服务提供方remote-provider.xml，将服务引用部分放在服务消费方remote-consumer.xml。
并在提供方增加暴露服务配置<dubbo:service>，在消费方增加引用服务配置<dubbo:reference>。

如下：

remote-provider.xml

           <beanid=“xxxService” class=“com.xxx.XxxServiceImpl” /><!-- 和本地服务一样实现远程服务 --> 
         
           <dubbo:serviceinterface=“com.xxx.XxxService” ref=“xxxService” /><!-- 增加暴露远程服务配置 -->

remote-consumer.xml

           <dubbo:referenceid=“xxxService” interface=“com.xxx.XxxService” /><!-- 增加引用远程服务配置 --> 
         
           <beanid=“xxxAction” class=“com.xxx.XxxAction”><!-- 和本地服务一样使用远程服务 --> 
         
               <propertyname=“xxxService” ref=“xxxService” /> 
         
           </bean>

快速启动

(+) (#)

Dubbo采用全Spring配置方式，透明化接入应用，对应用没有任何API侵入，只需用Spring加载Dubbo的配置即可，Dubbo基于Spring的Schema扩展进行加载。

如果不想使用Spring配置，而希望通过API的方式进行调用（不推荐），请参见：API配置 (+)

服务提供者

(#)

完整安装步骤，请参见：示例提供者安装 (+)

定义服务接口: (该接口需单独打包，在服务提供方和消费方共享)

DemoService.java

           packagecom.alibaba.dubbo.demo; 
         
           publicinterfaceDemoService { 
         
               String sayHello(String name); 
         
           }

在服务提供方实现接口：(对服务消费方隐藏实现)

DemoServiceImpl.java

           packagecom.alibaba.dubbo.demo.provider; 
         
           importcom.alibaba.dubbo.demo.DemoService; 
         
           publicclassDemoServiceImplimplementsDemoService { 
         
               publicString sayHello(String name) { 
         
                   return"Hello "+ name; 
         
               } 
         
           }

用Spring配置声明暴露服务：

provider.xml

           <?xmlversion="1.0"encoding="UTF-8"?> 
         
           <beansxmlns=" 
          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://code.alibabatech.com/schema/dubbo        
          http://code.alibabatech.com/schema/dubbo/dubbo.xsd"> 
         
               <!-- 提供方应用信息，用于计算依赖关系 --> 
         
               <dubbo:applicationname="hello-world-app" /> 
         
               <!-- 使用multicast广播注册中心暴露服务地址 --> 
         
               <dubbo:registryaddress="multicast://224.5.6.7:1234"/> 
         
               <!-- 用dubbo协议在20880端口暴露服务 --> 
         
               <dubbo:protocolname="dubbo"port="20880"/> 
         
               <!-- 声明需要暴露的服务接口 --> 
         
               <dubbo:serviceinterface="com.alibaba.dubbo.demo.DemoService"ref="demoService"/> 
         
               <!-- 和本地bean一样实现服务 --> 
         
               <beanid="demoService"class="com.alibaba.dubbo.demo.provider.DemoServiceImpl"/> 
         
           </beans>

加载Spring配置：

Provider.java

           importorg.springframework.context.support.ClassPathXmlApplicationContext; 
         
           publicclassProvider { 
         
               publicstaticvoidmain(String[] args)throwsException { 
         
                   ClassPathXmlApplicationContext context =newClassPathXmlApplicationContext(newString[] {" 
          http://10.20.160.198/wiki/display/dubbo/provider.xml"}); 
         
                   context.start(); 
         
                   System.in.read();// 按任意键退出 
         
               } 
         
           }

服务消费者

(#)

完整安装步骤，请参见：示例消费者安装 (+)

通过Spring配置引用远程服务：

consumer.xml

           <?xmlversion="1.0"encoding="UTF-8"?> 
         
           <beansxmlns=" 
          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://code.alibabatech.com/schema/dubbo        
          http://code.alibabatech.com/schema/dubbo/dubbo.xsd"> 
         
               <!-- 消费方应用名，用于计算依赖关系，不是匹配条件，不要与提供方一样 --> 
         
               <dubbo:applicationname="consumer-of-helloworld-app" /> 
         
               <!-- 使用multicast广播注册中心暴露发现服务地址 --> 
         
               <dubbo:registryaddress="multicast://224.5.6.7:1234"/> 
         
               <!-- 生成远程服务代理，可以和本地bean一样使用demoService --> 
         
               <dubbo:referenceid="demoService"interface="com.alibaba.dubbo.demo.DemoService"/> 
         
           </beans>

加载Spring配置，并调用远程服务：(也可以使用IoC注入)

Consumer.java

           importorg.springframework.context.support.ClassPathXmlApplicationContext; 
         
           importcom.alibaba.dubbo.demo.DemoService; 
         
           publicclassConsumer { 
         
               publicstaticvoidmain(String[] args)throwsException { 
         
                   ClassPathXmlApplicationContext context =newClassPathXmlApplicationContext(newString[] {" 
          http://10.20.160.198/wiki/display/dubbo/consumer.xml"}); 
         
                   context.start(); 
         
                   DemoService demoService = (DemoService)context.getBean("demoService");// 获取远程服务代理 
         
                   String hello = demoService.sayHello("world");// 执行远程方法 
         
                   System.out.println( hello );// 显示调用结果 
         
               } 
         
           }

依赖

(+) (#)

必需依赖

JDK1.5+

理论上Dubbo可以只依赖JDK，不依赖于任何三方库运行，只需配置使用JDK相关实现策略。

缺省依赖

通过mvn dependency:tree > dep.log命令分析，Dubbo缺省依赖以下三方库：

           [INFO] +- com.alibaba:dubbo:jar:2.1.2:compile 
         
           [INFO] |  +- log4j:log4j:jar:1.2.16:compile 
         
           [INFO] |  +- org.javassist:javassist:jar:3.15.0-GA:compile 
         
           [INFO] |  +- org.springframework:spring:jar:2.5.6.SEC03:compile 
         
           [INFO] |  +- commons-logging:commons-logging:jar:1.1.1:compile 
         
           [INFO] |  \- org.jboss.netty:netty:jar:3.2.5.Final:compile

这里所有依赖都是换照Dubbo缺省配置选的，这些缺省值是基于稳定性和性能考虑的。

log4j.jar和commons-logging.jar日志输出包。
- 可以直接去掉，dubbo本身的日志会自动切换为JDK的java.util.logging输出。
- 但如果其它三方库比如spring.jar间接依赖commons-logging，则不能去掉。
javassist.jar 字节码生成。
- 如果<dubbo:provider proxy="jdk" />或<dubbo:consumer proxy="jdk" />，以及<dubbo:application compiler="jdk" />，则不需要。
spring.jar 配置解析。
- 如果用ServiceConfig和ReferenceConfig的API调用，则不需要。
netty.jar 网络传输。
- 如果<dubbo:protocol server="mina"/>或<dubbo:protocol server="grizzly"/>，则换成mina.jar或grizzly.jar。
- 如果<protocol name="rmi"/>，则不需要。

可选依赖

以下依赖，在主动配置使用相应实现策略时用到，需自行加入依赖。

mina: 1.1.7
grizzly: 2.1.4
httpclient: 4.1.2
hessian_lite: 3.2.1-fixed
xstream: 1.4.1
fastjson: 1.1.8
zookeeper: 3.3.3
jedis: 2.0.0
xmemcached: 1.3.6
jfreechart: 1.0.13
hessian: 4.0.7
jetty: 6.1.26
hibernate-validator: 4.2.0.Final
zkclient: 0.1
curator: 1.1.10
cxf: 2.6.1
thrift: 0.8.0

JEE:

servlet: 2.5
bsf: 3.1
validation-api: 1.0.0.GA
jcache: 0.4

成熟度

(+) (#)

功能成熟度

(#)

Feature	Maturity	Strength	Problem	Advise	User
并发控制	Tested	并发控制		试用
连接控制	Tested	连接数控制		试用
直连提供者	Tested	点对点直连服务提供方，用于测试		测试环境使用	Alibaba
分组聚合	Tested	分组聚合返回值，用于菜单聚合等服务	特殊场景使用	可用于生产环境
参数验证	Tested	参数验证，JSR303验证框架集成	对性能有影响	试用	LaiWang
结果缓存	Tested	结果缓存，用于加速请求		试用
泛化引用	Stable	泛化调用，无需业务接口类进行远程调用，用于测试平台，开放网关桥接等		可用于生产环境	Alibaba
泛化实现	Stable	泛化实现，无需业务接口类实现任意接口，用于Mock平台		可用于生产环境	Alibaba
回声测试	Tested	回声测试		试用
隐式传参	Stable	附加参数		可用于生产环境
异步调用	Tested	不可靠异步调用		试用
本地调用	Tested	本地调用		试用
参数回调	Tested	参数回调	特殊场景使用	试用	Registry
事件通知	Tested	事件通知，在远程调用执行前后触发		试用
本地存根	Stable	在客户端执行部分逻辑		可用于生产环境	Alibaba
本地伪装	Stable	伪造返回结果，可在失败时执行，或直接执行，用于服务降级	需注册中心支持	可用于生产环境	Alibaba
延迟暴露	Stable	延迟暴露服务，用于等待应用加载warmup数据，或等待spring加载完成		可用于生产环境	Alibaba
延迟连接	Tested	延迟建立连接，调用时建立		试用	Registry
粘滞连接	Tested	粘滞连接，总是向同一个提供方发起请求，除非此提供方挂掉，再切换到另一台		试用	Registry
令牌验证	Tested	令牌验证，用于服务授权	需注册中心支持	试用
路由规则	Tested	动态决定调用关系	需注册中心支持	试用
配置规则	Tested	动态下发配置，实现功能的开关	需注册中心支持	试用
访问日志	Tested	访问日志，用于记录调用信息	本地存储，影响性能，受磁盘大小限制	试用
分布式事务	Research	JTA/XA三阶段提交事务	不稳定	不可用

策略成熟度

(#)

Feature	Maturity	Strength	Problem	Advise	User
Zookeeper注册中心	Stable	支持基于网络的集群方式，有广泛周边开源产品，建议使用dubbo-2.3.3以上版本（推荐使用）	依赖于Zookeeper的稳定性	可用于生产环境
Redis注册中心	Stable	支持基于客户端双写的集群方式，性能高	要求服务器时间同步，用于检查心跳过期脏数据	可用于生产环境
Multicast注册中心	Tested	去中心化，不需要安装注册中心	依赖于网络拓普和路由，跨机房有风险	小规模应用或开发测试环境
Simple注册中心	Tested	Dogfooding，注册中心本身也是一个标准的RPC服务	没有集群支持，可能单点故障	试用
Feature	Maturity	Strength	Problem	Advise	User
Simple监控中心	Stable	支持JFreeChart统计报表	没有集群支持，可能单点故障，但故障后不影响RPC运行	可用于生产环境
Feature	Maturity	Strength	Problem	Advise	User
Dubbo协议	Stable	采用NIO复用单一长连接，并使用线程池并发处理请求，减少握手和加大并发效率，性能较好（推荐使用）	在大文件传输时，单一连接会成为瓶颈	可用于生产环境	Alibaba
Rmi协议	Stable	可与原生RMI互操作，基于TCP协议	偶尔会连接失败，需重建Stub	可用于生产环境	Alibaba
Hessian协议	Stable	可与原生Hessian互操作，基于HTTP协议	需hessian.jar支持，http短连接的开销大	可用于生产环境
Feature	Maturity	Strength	Problem	Advise	User
Netty Transporter	Stable	JBoss的NIO框架，性能较好（推荐使用）	一次请求派发两种事件，需屏蔽无用事件	可用于生产环境	Alibaba
Mina Transporter	Stable	老牌NIO框架，稳定	待发送消息队列派发不及时，大压力下，会出现FullGC	可用于生产环境	Alibaba
Grizzly Transporter	Tested	Sun的NIO框架，应用于GlassFish服务器中	线程池不可扩展，Filter不能拦截下一Filter	试用
Feature	Maturity	Strength	Problem	Advise	User
Hessian Serialization	Stable	性能较好，多语言支持（推荐使用）	Hessian的各版本兼容性不好，可能和应用使用的Hessian冲突，Dubbo内嵌了hessian3.2.1的源码	可用于生产环境	Alibaba
Dubbo Serialization	Tested	通过不传送POJO的类元信息，在大量POJO传输时，性能较好	当参数对象增加字段时，需外部文件声明	试用
Json Serialization	Tested	纯文本，可跨语言解析，缺省采用FastJson解析	性能较差	试用
Java Serialization	Stable	Java原生支持	性能较差	可用于生产环境
Feature	Maturity	Strength	Problem	Advise	User
Javassist ProxyFactory	Stable	通过字节码生成代替反射，性能比较好（推荐使用）	依赖于javassist.jar包，占用JVM的Perm内存，Perm可能要设大一些：java -XX:PermSize=128m	可用于生产环境	Alibaba
Jdk ProxyFactory	Stable	JDK原生支持	性能较差	可用于生产环境
Feature	Maturity	Strength	Problem	Advise	User
Failover Cluster	Stable	失败自动切换，当出现失败，重试其它服务器，通常用于读操作（推荐使用）	重试会带来更长延迟	可用于生产环境	Alibaba
Failfast Cluster	Stable	快速失败，只发起一次调用，失败立即报错,通常用于非幂等性的写操作	如果有机器正在重启，可能会出现调用失败	可用于生产环境	Alibaba
Failsafe Cluster	Stable	失败安全，出现异常时，直接忽略，通常用于写入审计日志等操作	调用信息丢失	可用于生产环境	Monitor
Failback Cluster	Tested	失败自动恢复，后台记录失败请求，定时重发，通常用于消息通知操作	不可靠，重启丢失	可用于生产环境	Registry
Forking Cluster	Tested	并行调用多个服务器，只要一个成功即返回，通常用于实时性要求较高的读操作	需要浪费更多服务资源	可用于生产环境
Broadcast Cluster	Tested	广播调用所有提供者，逐个调用，任意一台报错则报错，通常用于更新提供方本地状态	速度慢，任意一台报错则报错	可用于生产环境
Feature	Maturity	Strength	Problem	Advise	User
Random LoadBalance	Stable	随机，按权重设置随机概率（推荐使用）	在一个截面上碰撞的概率高，重试时，可能出现瞬间压力不均	可用于生产环境	Alibaba
RoundRobin LoadBalance	Stable	轮循，按公约后的权重设置轮循比率	存在慢的机器累积请求问题，极端情况可能产生雪崩	可用于生产环境
LeastActive LoadBalance	Stable	最少活跃调用数，相同活跃数的随机，活跃数指调用前后计数差，使慢的机器收到更少请求	不支持权重，在容量规划时，不能通过权重把压力导向一台机器压测容量	可用于生产环境
ConsistentHash LoadBalance	Stable	一致性Hash，相同参数的请求总是发到同一提供者，当某一台提供者挂时，原本发往该提供者的请求，基于虚拟节点，平摊到其它提供者，不会引起剧烈变动	压力分摊不均	可用于生产环境
Feature	Maturity	Strength	Problem	Advise	User
条件路由规则	Stable	基于条件表达式的路由规则，功能简单易用	有些复杂多分支条件情况，规则很难描述	可用于生产环境	Alibaba
脚本路由规则	Tested	基于脚本引擎的路由规则，功能强大	没有运行沙箱，脚本能力过于强大，可能成为后门	试用
Feature	Maturity	Strength	Problem	Advise	User
Spring Container	Stable	自动加载META-INF/spring目录下的所有Spring配置		可用于生产环境	Alibaba
Jetty Container	Stable	启动一个内嵌Jetty，用于汇报状态	大量访问页面时，会影响服务器的线程和内存	可用于生产环境	Alibaba
Log4j Container	Stable	自动配置log4j的配置，在多进程启动时，自动给日志文件按进程分目录	用户不能控制log4j的配置，不灵活	可用于生产环境	Alibaba

配置

(+) (#)

Xml配置

(+) (#)

配置项说明
详细配置项，请参见：配置参考手册 (+)

API使用说明
如果不想使用Spring配置，而希望通过API的方式进行调用，请参见：API配置 (+)

配置使用说明
想知道如何使用配置，请参见：快速启动 (+)

示例：

provider.xml

           <?xmlversion="1.0"encoding="UTF-8"?> 
         
           <beansxmlns=" 
          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://code.alibabatech.com/schema/dubbo        
          http://code.alibabatech.com/schema/dubbo/dubbo.xsd"> 
         
               <dubbo:applicationname="hello-world-app" /> 
         
               <dubbo:registryaddress="multicast://224.5.6.7:1234"/> 
         
               <dubbo:protocolname="dubbo"port="20880"/> 
         
               <dubbo:serviceinterface="com.alibaba.dubbo.demo.DemoService"ref="demoServiceLocal"/> 
         
               <dubbo:referenceid="demoServiceRemote"interface="com.alibaba.dubbo.demo.DemoService"/> 
         
           </beans>

所有标签者支持自定义参数，用于不同扩展点实现的特殊配置。

如：

           <dubbo:protocolname="jms"> 
         
               <dubbo:parameterkey="queue"value=" 
          http://10.20.160.198/wiki/display/dubbo/10.20.31.22"/> 
         
           </dubbo:protocol>

或：(2.1.0开始支持)

注意声明：xmlns:p="http://www.springframework.org/schema/p"

           <beansxmlns=" 
          http://www.springframework.org/schema/beans" 
         
               xmlns:xsi=" 
          http://www.w3.org/2001/XMLSchema-instance" 
         
               xmlns:dubbo=" 
          http://code.alibabatech.com/schema/dubbo" 
         
               xmlns:p=" 
          http://www.springframework.org/schema/p" 
         
               xsi:schemaLocation=" 
          http://www.springframework.org/schema/beans        
          http://www.springframework.org/schema/beans/spring-beans.xsd        
          http://code.alibabatech.com/schema/dubbo        
          http://code.alibabatech.com/schema/dubbo/dubbo.xsd"> 
         
               <dubbo:protocolname="jms"p:queue=" 
          http://10.20.160.198/wiki/display/dubbo/10.20.31.22"/> 
         
           </beans>

Configuration Relation:

<dubbo:service/> 服务配置，用于暴露一个服务，定义服务的元信息，一个服务可以用多个协议暴露，一个服务也可以注册到多个注册中心。
<dubbo:reference/> 引用配置，用于创建一个远程服务代理，一个引用可以指向多个注册中心。
<dubbo:protocol/> 协议配置，用于配置提供服务的协议信息，协议由提供方指定，消费方被动接受。
<dubbo:application/> 应用配置，用于配置当前应用信息，不管该应用是提供者还是消费者。
<dubbo:module/> 模块配置，用于配置当前模块信息，可选。
<dubbo:registry/> 注册中心配置，用于配置连接注册中心相关信息。
<dubbo:monitor/> 监控中心配置，用于配置连接监控中心相关信息，可选。
<dubbo:provider/> 提供方的缺省值，当ProtocolConfig和ServiceConfig某属性没有配置时，采用此缺省值，可选。
<dubbo:consumer/> 消费方缺省配置，当ReferenceConfig某属性没有配置时，采用此缺省值，可选。
<dubbo:method/> 方法配置，用于ServiceConfig和ReferenceConfig指定方法级的配置信息。
<dubbo:argument/> 用于指定方法参数配置。

Configuration Override:

上图中以timeout为例，显示了配置的查找顺序，其它retries, loadbalance, actives等类似。
- 方法级优先，接口级次之，全局配置再次之。
- 如果级别一样，则消费方优先，提供方次之。
其中，服务提供方配置，通过URL经由注册中心传递给消费方。
建议由服务提供方设置超时，因为一个方法需要执行多长时间，服务提供方更清楚，如果一个消费方同时引用多个服务，就不需要关心每个服务的超时设置。
理论上ReferenceConfig的非服务标识配置，在ConsumerConfig，ServiceConfig, ProviderConfig均可以缺省配置。

属性配置

(+) (#)

如果公共配置很简单，没有多注册中心，多协议等情况，或者想多个Spring容器想共享配置，可以使用dubbo.properties作为缺省配置。

Dubbo将自动加载classpath根目录下的dubbo.properties，可以通过JVM启动参数：-Ddubbo.properties.file=xxx.properties 改变缺省配置位置。

如果classpath根目录下存在多个dubbo.properties，比如多个jar包中有dubbo.properties，Dubbo会任意加载，并打印Error日志，后续可能改为抛异常。

映射规则：

将XML配置的标签名，加属性名，用点分隔，多个属性拆成多行：
- 比如：dubbo.application.name=foo等价于<dubbo:application name="foo" />
- 比如：dubbo.registry.address=10.20.153.10:9090等价于<dubbo:registry address="10.20.153.10:9090" />
如果XML有多行同名标签配置，可用id号区分，如果没有id号将对所有同名标签生效：
- 比如：dubbo.protocol.rmi.port=1234等价于<dubbo:protocol id="rmi" name="rmi" port="1099" /> (协议的id没配时，缺省使用协议名作为id)
- 比如：dubbo.registry.china.address=10.20.153.10:9090等价于<dubbo:registry id="china" address="10.20.153.10:9090" />

典型配置如：

dubbo.properties

           dubbo.application.name=foo 
         
           dubbo.application.owner=bar 
         
           dubbo.registry.address=10.20.153.10:9090

覆盖策略：

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

注解配置

(+) (#)

2.2.1以上版本支持

服务提供方注解：

           importcom.alibaba.dubbo.config.annotation.Service; 
         
           @Service(version="1.0.0") 
         
           publicclassFooServiceImplimplementsFooService { 
         
               // ...... 
         
           }

服务提供方配置：

           <!-- 公共信息，也可以用dubbo.properties配置 --> 
         
           <dubbo:applicationname="annotation-provider"/> 
         
           <dubbo:registryaddress="127.0.0.1:4548"/> 
         
           <!-- 扫描注解包路径，多个包用逗号分隔，不填pacakge表示扫描当前ApplicationContext中所有的类 --> 
         
           <dubbo:annotationpackage="com.foo.bar.service"/>

服务消费方注解：

           importcom.alibaba.dubbo.config.annotation.Reference; 
         
           importorg.springframework.stereotype.Component; 
         
           @Component 
         
           publicclassBarAction { 
         
               @Reference(version="1.0.0") 
         
               privateFooService fooService; 
         
           }

服务消费方配置：

           <!-- 公共信息，也可以用dubbo.properties配置 --> 
         
           <dubbo:applicationname="annotation-consumer"/> 
         
           <dubbo:registryaddress="127.0.0.1:4548"/> 
         
           <!-- 扫描注解包路径，多个包用逗号分隔，不填pacakge表示扫描当前ApplicationContext中所有的类 --> 
         
           <dubbo:annotationpackage="com.foo.bar.action"/>

也可以使用：(等价于前面的：<dubbo:annotation package="com.foo.bar.service" />)

           <dubbo:annotation/> 
         
           <context:component-scanbase-package="com.foo.bar.service"> 
         
               <context:include-filtertype="annotation"expression="com.alibaba.dubbo.config.annotation.Service"/> 
         
           </context:component-scan>

Spring2.5及以后版本支持component-scan，如果用的是Spring2.0及以前版本，需配置：

                <!-- Spring2.0支持@Service注解配置，但不支持package属性自动加载bean的实例，需人工定义bean的实例。--> 
              
                <dubbo:annotation/> 
              
                <beanid="barService"class="com.foo.BarServiceImpl"/>

API配置

(+) (#)

API使用范围
API仅用于OpenAPI, ESB, Test, Mock等系统集成，普通服务提供方或消费方，请采用配置方式使用Dubbo，请参见：Xml配置 (+)

API属性含义参考
API属性与配置项一对一，各属性含义，请参见：配置参考手册 (+)，
比如：ApplicationConfig.setName("xxx") 对应 <dubbo:application name="xxx" />

(1) 服务提供者：

           importcom.alibaba.dubbo.rpc.config.ApplicationConfig; 
         
           importcom.alibaba.dubbo.rpc.config.RegistryConfig; 
         
           importcom.alibaba.dubbo.rpc.config.ProviderConfig; 
         
           importcom.alibaba.dubbo.rpc.config.ServiceConfig; 
         
           importcom.xxx.XxxService; 
         
           importcom.xxx.XxxServiceImpl; 
         
           // 服务实现 
         
           XxxService xxxService =newXxxServiceImpl(); 
         
           // 当前应用配置 
         
           ApplicationConfig application =newApplicationConfig(); 
         
           application.setName("xxx"); 
         
           // 连接注册中心配置 
         
           RegistryConfig registry =newRegistryConfig(); 
         
           registry.setAddress("10.20.130.230:9090"); 
         
           registry.setUsername("aaa"); 
         
           registry.setPassword("bbb"); 
         
           // 服务提供者协议配置 
         
           ProtocolConfig protocol =newProtocolConfig(); 
         
           protocol.setName("dubbo"); 
         
           protocol.setPort(12345); 
         
           protocol.setThreads(200); 
         
           // 注意：ServiceConfig为重对象，内部封装了与注册中心的连接，以及开启服务端口 
         
           // 服务提供者暴露服务配置 
         
           ServiceConfig<XxxService> service =newServiceConfig<XxxService>();// 此实例很重，封装了与注册中心的连接，请自行缓存，否则可能造成内存和连接泄漏 
         
           service.setApplication(application); 
         
           service.setRegistry(registry);// 多个注册中心可以用setRegistries() 
         
           service.setProtocol(protocol);// 多个协议可以用setProtocols() 
         
           service.setInterface(XxxService.class); 
         
           service.setRef(xxxService); 
         
           service.setVersion("1.0.0"); 
         
           // 暴露及注册服务 
         
           service.export();

(2) 服务消费者：

           importcom.alibaba.dubbo.rpc.config.ApplicationConfig; 
         
           importcom.alibaba.dubbo.rpc.config.RegistryConfig; 
         
           importcom.alibaba.dubbo.rpc.config.ConsumerConfig; 
         
           importcom.alibaba.dubbo.rpc.config.ReferenceConfig; 
         
           importcom.xxx.XxxService; 
         
           // 当前应用配置 
         
           ApplicationConfig application =newApplicationConfig(); 
         
           application.setName("yyy"); 
         
           // 连接注册中心配置 
         
           RegistryConfig registry =newRegistryConfig(); 
         
           registry.setAddress("10.20.130.230:9090"); 
         
           registry.setUsername("aaa"); 
         
           registry.setPassword("bbb"); 
         
           // 注意：ReferenceConfig为重对象，内部封装了与注册中心的连接，以及与服务提供方的连接 
         
           // 引用远程服务 
         
           ReferenceConfig<XxxService> reference =newReferenceConfig<XxxService>();// 此实例很重，封装了与注册中心的连接以及与提供者的连接，请自行缓存，否则可能造成内存和连接泄漏 
         
           reference.setApplication(application); 
         
           reference.setRegistry(registry);// 多个注册中心可以用setRegistries() 
         
           reference.setInterface(XxxService.class); 
         
           reference.setVersion("1.0.0"); 
         
           // 和本地bean一样使用xxxService 
         
           XxxService xxxService = reference.get();// 注意：此代理对象内部封装了所有通讯细节，对象较重，请缓存复用

(3) 特殊场景

注：下面只列出不同的地方，其它参见上面的写法

(3.1) 方法级设置：

           ... 
         
           // 方法级配置 
         
           List<MethodConfig> methods =newArrayList<MethodConfig>(); 
         
           MethodConfig method =newMethodConfig(); 
         
           method.setName("createXxx"); 
         
           method.setTimeout(10000); 
         
           method.setRetries(0); 
         
           methods.add(method); 
         
           // 引用远程服务 
         
           ReferenceConfig<XxxService> reference =newReferenceConfig<XxxService>();// 此实例很重，封装了与注册中心的连接以及与提供者的连接，请自行缓存，否则可能造成内存和连接泄漏 
         
           ... 
         
           reference.setMethods(methods);// 设置方法级配置 
         
           ...

(3.2) 点对点直连：

           ... 
         
           ReferenceConfig<XxxService> reference =newReferenceConfig<XxxService>();// 此实例很重，封装了与注册中心的连接以及与提供者的连接，请自行缓存，否则可能造成内存和连接泄漏 
         
           // 如果点对点直连，可以用reference.setUrl()指定目标地址，设置url后将绕过注册中心， 
         
           // 其中，协议对应provider.setProtocol()的值，端口对应provider.setPort()的值， 
         
           // 路径对应service.setPath()的值，如果未设置path，缺省path为接口名 
         
           reference.setUrl("dubbo://10.20.130.230:20880/com.xxx.XxxService"); 
         
           ...

示例

(+) (#)

想完整的运行起来，请参见：快速启动 (+)，这里只列出各种场景的配置方式

以下示例全部使用基于Spring的Xml配置 (+)作为参考，如果不想使用Spring，而希望通过API的方式进行调用，请参见：API配置 (+)

启动时检查

(+) (#)

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

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

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

关闭某个服务的启动时检查：(没有提供者时报错)

           <dubbo:referenceinterface="com.foo.BarService"check="false"/> 
         

关闭所有服务的启动时检查：(没有提供者时报错)

           <dubbo:consumercheck="false"/> 
         

关闭注册中心启动时检查：(注册订阅失败时报错)

           <dubbo:registrycheck="false"/> 
         

也可以用dubbo.properties配置：

dubbo.properties

           dubbo.reference.com.foo.BarService.check=false 
         
           dubbo.reference.check=false 
         
           dubbo.consumer.check=false 
         
           dubbo.registry.check=false

也可以用-D参数：

           java -Ddubbo.reference.com.foo.BarService.check=false 
         
           java -Ddubbo.reference.check=false 
         
           java -Ddubbo.consumer.check=false 
         
           java -Ddubbo.registry.check=false

注意区别

dubbo.reference.check=false，强制改变所有reference的check值，就算配置中有声明，也会被覆盖。
dubbo.consumer.check=false，是设置check的缺省值，如果配置中有显式的声明，如：<dubbo:reference check="true"/>，不会受影响。
dubbo.registry.check=false，前面两个都是指订阅成功，但提供者列表是否为空是否报错，如果注册订阅失败时，也允许启动，需使用此选项，将在后台定时重试。

引用缺省是延迟初始化的，只有引用被注入到其它Bean，或被getBean()获取，才会初始化。
如果需要饥饿加载，即没有人引用也立即生成动态代理，可以配置：

           <dubbo:referenceinterface="com.foo.BarService"init="true"/> 
         

集群容错

(+) (#)

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

各节点关系：

这里的Invoker是Provider的一个可调用Service的抽象，Invoker封装了Provider地址及Service接口信息。
Directory代表多个Invoker，可以把它看成List<Invoker>，但与List不同的是，它的值可能是动态变化的，比如注册中心推送变更。
Cluster将Directory中的多个Invoker伪装成一个Invoker，对上层透明，伪装过程包含了容错逻辑，调用失败后，重试另一个。
Router负责从多个Invoker中按路由规则选出子集，比如读写分离，应用隔离等。
LoadBalance负责从多个Invoker中选出具体的一个用于本次调用，选的过程包含了负载均衡算法，调用失败后，需要重选。

集群容错模式：

可以自行扩展集群容错策略，参见：集群扩展

Failover Cluster

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

Failfast Cluster

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

Failsafe Cluster

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

Failback Cluster

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

Forking Cluster

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

Broadcast Cluster

广播调用所有提供者，逐个调用，任意一台报错则报错。(2.1.0开始支持)
通常用于通知所有提供者更新缓存或日志等本地资源信息。

重试次数配置如：(failover集群模式生效)

           <dubbo:serviceretries="2"/> 
         

或：

           <dubbo:referenceretries="2"/> 
         

或：

           <dubbo:reference> 
         
               <dubbo:methodname="findFoo"retries="2"/> 
         
           </dubbo:reference>

集群模式配置如：

           <dubbo:servicecluster="failsafe"/> 
         

或：

           <dubbo:referencecluster="failsafe"/> 
         

负载均衡

(+) (#)

在集群负载均衡时，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" />

配置如：

           <dubbo:serviceinterface="..."loadbalance="roundrobin"/> 
         

或：

           <dubbo:referenceinterface="..."loadbalance="roundrobin"/> 
         

或：

           <dubbo:serviceinterface="..."> 
         
               <dubbo:methodname="..."loadbalance="roundrobin"/> 
         
           </dubbo:service>

或：

           <dubbo:referenceinterface="..."> 
         
               <dubbo:methodname="..."loadbalance="roundrobin"/> 
         
           </dubbo:reference>

线程模型

(+) (#)

事件处理线程说明

如果事件处理的逻辑能迅速完成，并且不会发起新的IO请求，比如只是在内存中记个标识，则直接在IO线程上处理更快，因为减少了线程池调度。
但如果事件处理逻辑较慢，或者需要发起新的IO请求，比如需要查询数据库，则必须派发到线程池，否则IO线程阻塞，将导致不能接收其它请求。
如果用IO线程处理事件，又在事件处理过程中发起新的IO请求，比如在连接事件中发起登录请求，会报“可能引发死锁”异常，但不会真死锁。

Dispatcher
- all 所有消息都派发到线程池，包括请求，响应，连接事件，断开事件，心跳等。
- direct 所有消息都不派发到线程池，全部在IO线程上直接执行。
- message 只有请求响应消息派发到线程池，其它连接断开事件，心跳等消息，直接在IO线程上执行。
- execution 只请求消息派发到线程池，不含响应，响应和其它连接断开事件，心跳等消息，直接在IO线程上执行。
- connection 在IO线程上，将连接断开事件放入队列，有序逐个执行，其它消息派发到线程池。

ThreadPool
- fixed 固定大小线程池，启动时建立线程，不关闭，一直持有。(缺省)
- cached 缓存线程池，空闲一分钟自动删除，需要时重建。
- limited 可伸缩线程池，但池中的线程数只会增长不会收缩。(为避免收缩时突然来了大流量引起的性能问题)。

配置如：

           <dubbo:protocolname="dubbo"dispatcher="all"threadpool="fixed"threads="100"/> 
         

直连提供者

(+) (#)

在开发及测试环境下，经常需要绕过注册中心，只测试指定服务提供者，这时候可能需要点对点直连，
点对点直联方式，将以服务接口为单位，忽略注册中心的提供者列表，
A接口配置点对点，不影响B接口从注册中心获取列表。

(1) 如果是线上需求需要点对点，可在<dubbo:reference>中配置url指向提供者，将绕过注册中心，多个地址用分号隔开，配置如下：(1.0.6及以上版本支持)

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

(2) 在JVM启动参数中加入-D参数映射服务地址，如：
(key为服务名，value为服务提供者url，此配置优先级最高，1.0.15及以上版本支持)

           java -Dcom.alibaba.xxx.XxxService=dubbo://localhost:20890 
         

注意
为了避免复杂化线上环境，不要在线上使用这个功能，只应在测试阶段使用。

(3) 如果服务比较多，也可以用文件映射，如：
(用-Ddubbo.resolve.file指定映射文件路径，此配置优先级高于<dubbo:reference>中的配置，1.0.15及以上版本支持)
(2.0以上版本自动加载${user.home}/dubbo-resolve.properties文件，不需要配置)

           java -Ddubbo.resolve.file=xxx.properties 
         

然后在映射文件xxx.properties中加入：
(key为服务名，value为服务提供者url)

           com.alibaba.xxx.XxxService=dubbo://localhost:20890 
         

注意
为了避免复杂化线上环境，不要在线上使用这个功能，只应在测试阶段使用。

只订阅

(+) (#)

问题
为方便开发测试，经常会在线下共用一个所有服务可用的注册中心，这时，如果一个正在开发中的服务提供者注册，可能会影响消费者不能正常运行。

解决方案
可以让服务提供者开发方，只订阅服务(开发的服务可能依赖其它服务)，而不注册正在开发的服务，通过直连测试正在开发的服务。

禁用注册配置：

           <dubbo:registryaddress="10.20.153.10:9090"register="false"/> 
         

或者：

           <dubbo:registryaddress="10.20.153.10:9090?register=false"/> 
         

只注册

(+) (#)

问题
如果有两个镜像环境，两个注册中心，有一个服务只在其中一个注册中心有部署，另一个注册中心还没来得及部署，而两个注册中心的其它应用都需要依赖此服务，所以需要将服务同时注册到两个注册中心，但却不能让此服务同时依赖两个注册中心的其它服务。

解决方案
可以让服务提供者方，只注册服务到另一注册中心，而不从另一注册中心订阅服务。

禁用订阅配置：

           <dubbo:registryid="hzRegistry"address="10.20.153.10:9090"/> 
         
           <dubbo:registryid="qdRegistry"address="10.20.141.150:9090"subscribe="false"/>

或者：

           <dubbo:registryid="hzRegistry"address="10.20.153.10:9090"/> 
         
           <dubbo:registryid="qdRegistry"address="10.20.141.150:9090?subscribe=false"/>

静态服务

(+) (#)

有时候希望人工管理服务提供者的上线和下线，此时需将注册中心标识为非动态管理模式。

           <dubbo:registryaddress="10.20.141.150:9090"dynamic="false"/> 
         

或者：

           <dubbo:registryaddress="10.20.141.150:9090?dynamic=false"/> 
         

服务提供者初次注册时为禁用状态，需人工启用，断线时，将不会被自动删除，需人工禁用。

如果是一个第三方独立提供者，比如memcached等，可以直接向注册中心写入提供者地址信息，消费者正常使用：
(通常由脚本监控中心页面等调用)

           RegistryFactory registryFactory = ExtensionLoader.getExtensionLoader(RegistryFactory.class).getAdaptiveExtension(); 
         
           Registry registry = registryFactory.getRegistry(URL.valueOf("zookeeper://10.20.153.10:2181")); 
         
           registry.register(URL.valueOf("memcached://10.20.153.11/com.foo.BarService?category=providers&dynamic=false&application=foo"));

多协议

(+) (#)

可以自行扩展协议，参见：协议扩展

(1) 不同服务不同协议

比如：不同服务在性能上适用不同协议进行传输，比如大数据用短连接协议，小数据大并发用长连接协议。

consumer.xml

           <?xmlversion="1.0"encoding="UTF-8"?> 
         
           <beansxmlns=" 
          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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://code.alibabatech.com/schema/dubbohttp://code.alibabatech.com/schema/dubbo/dubbo.xsd"> 
         
               <dubbo:applicationname="world" /> 
         
               <dubbo:registryid="registry"address="10.20.141.150:9090"username="admin"password="hello1234"/> 
         
               <!-- 多协议配置 --> 
         
               <dubbo:protocolname="dubbo"port="20880"/> 
         
               <dubbo:protocolname="rmi"port="1099"/> 
         
               <!-- 使用dubbo协议暴露服务 --> 
         
               <dubbo:serviceinterface="com.alibaba.hello.api.HelloService"version="1.0.0"ref="helloService"protocol="dubbo"/> 
         
               <!-- 使用rmi协议暴露服务 --> 
         
               <dubbo:serviceinterface="com.alibaba.hello.api.DemoService"version="1.0.0"ref="demoService"protocol="rmi"/> 
         
           </beans>

(2) 多协议暴露服务

比如：需要与http客户端互操作

consumer.xml

           <?xmlversion="1.0"encoding="UTF-8"?> 
         
           <beansxmlns=" 
          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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://code.alibabatech.com/schema/dubbohttp://code.alibabatech.com/schema/dubbo/dubbo.xsd"> 
         
               <dubbo:applicationname="world" /> 
         
               <dubbo:registryid="registry"address="10.20.141.150:9090"username="admin"password="hello1234"/> 
         
               <!-- 多协议配置 --> 
         
               <dubbo:protocolname="dubbo"port="20880"/> 
         
               <dubbo:protocolname="hessian"port="8080"/> 
         
               <!-- 使用多个协议暴露服务 --> 
         
               <dubbo:serviceid="helloService"interface="com.alibaba.hello.api.HelloService"version="1.0.0"protocol="dubbo,hessian"/> 
         
           </beans>

多注册中心

(+) (#)

可以自行扩展注册中心，参见：注册中心扩展

(1) 多注册中心注册

比如：中文站有些服务来不及在青岛部署，只在杭州部署，而青岛的其它应用需要引用此服务，就可以将服务同时注册到两个注册中心。

consumer.xml

           <?xmlversion="1.0"encoding="UTF-8"?> 
         
           <beansxmlns=" 
          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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://code.alibabatech.com/schema/dubbohttp://code.alibabatech.com/schema/dubbo/dubbo.xsd"> 
         
               <dubbo:applicationname="world" /> 
         
               <!-- 多注册中心配置 --> 
         
               <dubbo:registryid="hangzhouRegistry"address="10.20.141.150:9090"/> 
         
               <dubbo:registryid="qingdaoRegistry"address="10.20.141.151:9010"default="false"/> 
         
               <!-- 向多个注册中心注册 --> 
         
               <dubbo:serviceinterface="com.alibaba.hello.api.HelloService"version="1.0.0"ref="helloService"registry="hangzhouRegistry,qingdaoRegistry"/> 
         
           </beans>

(2) 不同服务使用不同注册中心

比如：CRM有些服务是专门为国际站设计的，有些服务是专门为中文站设计的。

consumer.xml

           <?xmlversion="1.0"encoding="UTF-8"?> 
         
           <beansxmlns=" 
          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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://code.alibabatech.com/schema/dubbohttp://code.alibabatech.com/schema/dubbo/dubbo.xsd"> 
         
               <dubbo:applicationname="world" /> 
         
               <!-- 多注册中心配置 --> 
         
               <dubbo:registryid="chinaRegistry"address="10.20.141.150:9090"/> 
         
               <dubbo:registryid="intlRegistry"address="10.20.154.177:9010"default="false"/> 
         
               <!-- 向中文站注册中心注册 --> 
         
               <dubbo:serviceinterface="com.alibaba.hello.api.HelloService"version="1.0.0"ref="helloService"registry="chinaRegistry"/> 
         
               <!-- 向国际站注册中心注册 --> 
         
               <dubbo:serviceinterface="com.alibaba.hello.api.DemoService"version="1.0.0"ref="demoService"registry="intlRegistry"/> 
         
           </beans>

(3) 多注册中心引用

比如：CRM需同时调用中文站和国际站的PC2服务，PC2在中文站和国际站均有部署，接口及版本号都一样，但连的数据库不一样。

consumer.xml

           <?xmlversion="1.0"encoding="UTF-8"?> 
         
           <beansxmlns=" 
          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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://code.alibabatech.com/schema/dubbohttp://code.alibabatech.com/schema/dubbo/dubbo.xsd"> 
         
               <dubbo:applicationname="world" /> 
         
               <!-- 多注册中心配置 --> 
         
               <dubbo:registryid="chinaRegistry"address="10.20.141.150:9090"/> 
         
               <dubbo:registryid="intlRegistry"address="10.20.154.177:9010"default="false"/> 
         
               <!-- 引用中文站服务 --> 
         
               <dubbo:referenceid="chinaHelloService"interface="com.alibaba.hello.api.HelloService"version="1.0.0"registry="chinaRegistry"/> 
         
               <!-- 引用国际站站服务 --> 
         
               <dubbo:referenceid="intlHelloService"interface="com.alibaba.hello.api.HelloService"version="1.0.0"registry="intlRegistry"/> 
         
           </beans>

如果只是测试环境临时需要连接两个不同注册中心，使用竖号分隔多个不同注册中心地址：

consumer.xml

           <?xmlversion="1.0"encoding="UTF-8"?> 
         
           <beansxmlns=" 
          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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://code.alibabatech.com/schema/dubbohttp://code.alibabatech.com/schema/dubbo/dubbo.xsd"> 
         
               <dubbo:applicationname="world" /> 
         
               <!-- 多注册中心配置，竖号分隔表示同时连接多个不同注册中心，同一注册中心的多个集群地址用逗号分隔 --> 
         
               <dubbo:registryaddress="10.20.141.150:9090|10.20.154.177:9010"/> 
         
               <!-- 引用服务 --> 
         
               <dubbo:referenceid="helloService"interface="com.alibaba.hello.api.HelloService"version="1.0.0"/> 
         
           </beans>

服务分组

(+) (#)

当一个接口有多种实现时，可以用group区分。

           <dubbo:servicegroup="feedback"interface="com.xxx.IndexService"/> 
         
           <dubbo:servicegroup="member"interface="com.xxx.IndexService"/>

           <dubbo:referenceid="feedbackIndexService"group="feedback"interface="com.xxx.IndexService"/> 
         
           <dubbo:referenceid="memberIndexService"group="member"interface="com.xxx.IndexService"/>

任意组：(2.2.0以上版本支持，总是只调一个可用组的实现)

           <dubbo:referenceid="barService"interface="com.foo.BarService"group="*"/> 
         

多版本

(+) (#)

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

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

           <dubbo:serviceinterface="com.foo.BarService"version="1.0.0"/> 
         

           <dubbo:serviceinterface="com.foo.BarService"version="2.0.0"/> 
         

           <dubbo:referenceid="barService"interface="com.foo.BarService"version="1.0.0"/> 
         

           <dubbo:referenceid="barService"interface="com.foo.BarService"version="2.0.0"/> 
         

不区分版本：(2.2.0以上版本支持)

           <dubbo:referenceid="barService"interface="com.foo.BarService"version="*"/> 
         

分组聚合

(+) (#)

按组合并返回结果，比如菜单服务，接口一样，但有多种实现，用group区分，现在消费方需从每种group中调用一次返回结果，合并结果返回，这样就可以实现聚合菜单项。

从2.1.0版本开始支持

代码参见：https://github.com/alibaba/dubbo/tree/master/dubbo-test/dubbo-test-examples/src/main/java/com/alibaba/dubbo/examples/merge

配置如：(搜索所有分组)

           <dubbo:referenceinterface="com.xxx.MenuService"group="*"merger="true"/> 
         

或：(合并指定分组)

           <dubbo:referenceinterface="com.xxx.MenuService"group="aaa,bbb"merger="true"/> 
         

或：(指定方法合并结果，其它未指定的方法，将只调用一个Group)

           <dubbo:referenceinterface="com.xxx.MenuService"group="*"> 
         
               <dubbo:methodname="getMenuItems"merger="true"/> 
         
           </dubbo:service>

或：(某个方法不合并结果，其它都合并结果)

           <dubbo:referenceinterface="com.xxx.MenuService"group="*"merger="true"> 
         
               <dubbo:methodname="getMenuItems"merger="false"/> 
         
           </dubbo:service>

或：(指定合并策略，缺省根据返回值类型自动匹配，如果同一类型有两个合并器时，需指定合并器的名称)
参见：[合并结果扩展]

           <dubbo:referenceinterface="com.xxx.MenuService"group="*"> 
         
               <dubbo:methodname="getMenuItems"merger="mymerge"/> 
         
           </dubbo:service>

或：(指定合并方法，将调用返回结果的指定方法进行合并，合并方法的参数类型必须是返回结果类型本身)

           <dubbo:referenceinterface="com.xxx.MenuService"group="*"> 
         
               <dubbo:methodname="getMenuItems"merger=".addAll"/> 
         
           </dubbo:service>

参数验证

(+) (#)

参数验证功能是基于JSR303实现的，用户只需标识JSR303标准的验证Annotation，并通过声明filter来实现验证。

2.1.0以上版本支持

完整示例代码参见：https://github.com/alibaba/dubbo/tree/master/dubbo-test/dubbo-test-examples/src/main/java/com/alibaba/dubbo/examples/validation

验证方式可扩展，参见：Validation扩展点

参数标注示例：

           importjava.io.Serializable; 
         
           importjava.util.Date; 
         
           importjavax.validation.constraints.Future; 
         
           importjavax.validation.constraints.Max; 
         
           importjavax.validation.constraints.Min; 
         
           importjavax.validation.constraints.NotNull; 
         
           importjavax.validation.constraints.Past; 
         
           importjavax.validation.constraints.Pattern; 
         
           importjavax.validation.constraints.Size; 
         
           publicclassValidationParameterimplementsSerializable { 
         
               privatestaticfinallongserialVersionUID = 7158911668568000392L; 
         
               @NotNull// 不允许为空 
         
               @Size(min =1, max =20)// 长度或大小范围 
         
               privateString name; 
         
               @NotNull(groups = ValidationService.Save.class)// 保存时不允许为空，更新时允许为空 ，表示不更新该字段 
         
               @Pattern(regexp ="^\\s*\\w+(?:\\.{0,1}[\\w-]+)*@[a-zA-Z0-9]+(?:[-.][a-zA-Z0-9]+)*\\.[a-zA-Z]+\\s*$") 
         
               privateString email; 
         
               @Min(18)// 最小值 
         
               @Max(100)// 最大值 
         
               privateintage; 
         
               @Past// 必须为一个过去的时间 
         
               privateDate loginDate; 
         
               @Future// 必须为一个未来的时间 
         
               privateDate expiryDate; 
         
               publicString getName() { 
         
                   returnname; 
         
               } 
         
               publicvoidsetName(String name) { 
         
                   this.name = name; 
         
               } 
         
               publicString getEmail() { 
         
                   returnemail; 
         
               } 
         
               publicvoidsetEmail(String email) { 
         
                   this.email = email; 
         
               } 
         
               publicintgetAge() { 
         
                   returnage; 
         
               } 
         
               publicvoidsetAge(intage) { 
         
                   this.age = age; 
         
               } 
         
               publicDate getLoginDate() { 
         
                   returnloginDate; 
         
               } 
         
               publicvoidsetLoginDate(Date loginDate) { 
         
                   this.loginDate = loginDate; 
         
               } 
         
               publicDate getExpiryDate() { 
         
                   returnexpiryDate; 
         
               } 
         
               publicvoidsetExpiryDate(Date expiryDate) { 
         
                   this.expiryDate = expiryDate; 
         
               } 
         
           }

分组验证示例：

           publicinterfaceValidationService {// 缺省可按服务接口区分验证场景，如：@NotNull(groups = ValidationService.class) 
         
               @interfaceSave{}// 与方法同名接口，首字母大写，用于区分验证场景，如：@NotNull(groups = ValidationService.Save.class)，可选 
         
               voidsave(ValidationParameter parameter); 
         
               voidupdate(ValidationParameter parameter); 
         
           }

关联验证示例：

           importjavax.validation.GroupSequence; 
         
           publicinterfaceValidationService { 
         
               @GroupSequence(Update.class)// 同时验证Update组规则 
         
               @interfaceSave{} 
         
               voidsave(ValidationParameter parameter); 
         
               @interfaceUpdate{} 
         
               voidupdate(ValidationParameter parameter); 
         
           }

参数验证示例：

           importjavax.validation.constraints.Min; 
         
           importjavax.validation.constraints.NotNull; 
         
           publicinterfaceValidationService { 
         
               voidsave(@NotNullValidationParameter parameter);// 验证参数不为空 
         
               voiddelete(@Min(1)intid);// 直接对基本类型参数验证 
         
           }

在客户端验证参数：

           <dubbo:referenceid="validationService"interface="com.alibaba.dubbo.examples.validation.api.ValidationService"validation="true"/> 
         

在服务器端验证参数：

           <dubbo:serviceinterface="com.alibaba.dubbo.examples.validation.api.ValidationService"ref="validationService"validation="true"/> 
         

验证异常信息：

           importjavax.validation.ConstraintViolationException; 
         
           importjavax.validation.ConstraintViolationException; 
         
           importorg.springframework.context.support.ClassPathXmlApplicationContext; 
         
           importcom.alibaba.dubbo.examples.validation.api.ValidationParameter; 
         
           importcom.alibaba.dubbo.examples.validation.api.ValidationService; 
         
           importcom.alibaba.dubbo.rpc.RpcException; 
         
           publicclassValidationConsumer { 
         
               publicstaticvoidmain(String[] args)throwsException { 
         
                   String config = ValidationConsumer.class.getPackage().getName().replace('.','/') +"/validation-consumer.xml"; 
         
                   ClassPathXmlApplicationContext context =newClassPathXmlApplicationContext(config); 
         
                   context.start(); 
         
                   ValidationService validationService = (ValidationService)context.getBean("validationService"); 
         
                   // Error 
         
                   try{ 
         
                       parameter =newValidationParameter(); 
         
                       validationService.save(parameter); 
         
                       System.out.println("Validation ERROR"); 
         
                   }catch(RpcException e) {// 抛出的是RpcException 
         
                       ConstraintViolationException ve = (ConstraintViolationException) e.getCause();// 里面嵌了一个ConstraintViolationException 
         
                       Set<ConstraintViolation<?>> violations = ve.getConstraintViolations();// 可以拿到一个验证错误详细信息的集合 
         
                       System.out.println(violations); 
         
                   } 
         
               } 
         
           }

需要加入依赖：

           <dependency> 
         
               <groupId>javax.validation</groupId> 
         
               <artifactId>validation-api</artifactId> 
         
               <version>1.0.0.GA</version> 
         
           </dependency> 
         
           <dependency> 
         
               <groupId>org.hibernate</groupId> 
         
               <artifactId>hibernate-validator</artifactId> 
         
               <version>4.2.0.Final</version> 
         
           </dependency>

结果缓存

(+) (#)

结果缓存，用于加速热门数据的访问速度，Dubbo提供声明式缓存，以减少用户加缓存的工作量。

2.1.0以上版本支持

示例代码：https://github.com/alibaba/dubbo/tree/master/dubbo-test/dubbo-test-examples/src/main/java/com/alibaba/dubbo/examples/cache

lru 基于最近最少使用原则删除多余缓存，保持最热的数据被缓存。
threadlocal 当前线程缓存，比如一个页面渲染，用到很多portal，每个portal都要去查用户信息，通过线程缓存，可以减少这种多余访问。
jcache 与JSR107集成，可以桥接各种缓存实现。

缓存类型可扩展，参见：CacheFactory扩展点

配置如：

           <dubbo:referenceinterface="com.foo.BarService"cache="lru"/> 
         

或：

           <dubbo:referenceinterface="com.foo.BarService"> 
         
               <dubbo:methodname="findBar"cache="lru"/> 
         
           </dubbo:reference>

泛化引用

(+) (#)

泛接口调用方式主要用于客户端没有API接口及模型类元的情况，参数及返回值中的所有POJO均用Map表示，通常用于框架集成，比如：实现一个通用的服务测试框架，可通过GenericService调用所有服务实现。

           <dubbo:referenceid="barService"interface="com.foo.BarService"generic="true"/> 
         

           GenericService barService = (GenericService) applicationContext.getBean("barService"); 
         
           Object result = barService.$invoke("sayHello",newString[] {"java.lang.String"},newObject[] {"World"});

           importcom.alibaba.dubbo.rpc.service.GenericService; 
         
           ... 
         
           // 引用远程服务 
         
           ReferenceConfig<GenericService> reference =newReferenceConfig<GenericService>();// 该实例很重量，里面封装了所有与注册中心及服务提供方连接，请缓存 
         
           reference.setInterface("com.xxx.XxxService");// 弱类型接口名 
         
           reference.setVersion("1.0.0"); 
         
           reference.setGeneric(true);// 声明为泛化接口 
         
           GenericService genericService = reference.get();// 用com.alibaba.dubbo.rpc.service.GenericService可以替代所有接口引用 
         
           // 基本类型以及Date,List,Map等不需要转换，直接调用 
         
           Object result = genericService.$invoke("sayHello",newString[] {"java.lang.String"},newObject[] {"world"}); 
         
           // 用Map表示POJO参数，如果返回值为POJO也将自动转成Map 
         
           Map<String, Object> person =newHashMap<String, Object>(); 
         
           person.put("name","xxx"); 
         
           person.put("password","yyy"); 
         
           Object result = genericService.$invoke("findPerson",newString[]{"com.xxx.Person"},newObject[]{person});// 如果返回POJO将自动转成Map 
         
           ...

假设存在POJO如：

           packagecom.xxx; 
         
           publicclassPersonImplimplementsPerson { 
         
           privateString name; 
         
           privateString password; 
         
           publicString getName() { 
         
           returnname; 
         
           } 
         
           publicvoidsetName(String name) { 
         
           this.name = name; 
         
           } 
         
           publicString getPassword() { 
         
           returnpassword; 
         
           } 
         
           publicvoidsetPassword(String password) { 
         
           this.password= password; 
         
           } 
         
           }

则POJO数据：

           Person person =newPersonImpl(); 
         
           person.setName("xxx"); 
         
           person.setPassword("yyy");

可用下面Map表示：

           Map<String, Object> map =newHashMap<String, Object>(); 
         
           map.put("class","com.xxx.PersonImpl");// 注意：如果参数类型是接口，或者List等丢失泛型，可通过class属性指定类型。 
         
           map.put("name","xxx"); 
         
           map.put("password","yyy");

泛化实现

(+) (#)

泛接口实现方式主要用于服务器端没有API接口及模型类元的情况，参数及返回值中的所有POJO均用Map表示，通常用于框架集成，比如：实现一个通用的远程服务Mock框架，可通过实现GenericService接口处理所有服务请求。

           <beanid="genericService"class="com.foo.MyGenericService"/> 
         
           <dubbo:serviceinterface="com.foo.BarService"ref="genericService"/>

           packagecom.foo; 
         
           publicclassMyGenericServiceimplementsGenericService { 
         
               publicObject $invoke(String methodName, String[] parameterTypes, Object[] args)throwsGenericException { 
         
                   if("sayHello".equals(methodName)) { 
         
                       return"Welcome "+ args[0]; 
         
                   } 
         
               } 
         
           }

           ... 
         
           GenericService xxxService =newXxxGenericService();// 用com.alibaba.dubbo.rpc.service.GenericService可以替代所有接口实现 
         
           ServiceConfig<GenericService> service =newServiceConfig<GenericService>();// 该实例很重量，里面封装了所有与注册中心及服务提供方连接，请缓存 
         
           service.setInterface("com.xxx.XxxService");// 弱类型接口名 
         
           service.setVersion("1.0.0"); 
         
           service.setRef(xxxService);// 指向一个通用服务实现 
         
           // 暴露及注册服务 
         
           service.export();

回声测试

(+) (#)

回声测试用于检测服务是否可用，回声测试按照正常请求流程执行，能够测试整个调用是否通畅，可用于监控。

所有服务自动实现EchoService接口，只需将任意服务引用强制转型为EchoService，即可使用。

           <dubbo:referenceid="memberService"interface="com.xxx.MemberService"/> 
         

           MemberService memberService = ctx.getBean("memberService");// 远程服务引用 
         
           EchoService echoService = (EchoService) memberService;// 强制转型为EchoService 
         
           String status = echoService.$echo("OK");// 回声测试可用性 
         
           assert(status.equals("OK"))

上下文信息

(+) (#)

上下文中存放的是当前调用过程中所需的环境信息。

所有配置信息都将转换为URL的参数，参见《配置项一览表》中的“对应URL参数”一列。

注意
RpcContext是一个ThreadLocal的临时状态记录器，当接收到RPC请求，或发起RPC请求时，RpcContext的状态都会变化。
比如：A调B，B再调C，则B机器上，在B调C之前，RpcContext记录的是A调B的信息，在B调C之后，RpcContext记录的是B调C的信息。

(1) 服务消费方

           xxxService.xxx();// 远程调用 
         
           booleanisConsumerSide = RpcContext.getContext().isConsumerSide();// 本端是否为消费端，这里会返回true 
         
           String serverIP = RpcContext.getContext().getRemoteHost();// 获取最后一次调用的提供方IP地址 
         
           String application = RpcContext.getContext().getUrl().getParameter("application");// 获取当前服务配置信息，所有配置信息都将转换为URL的参数 
         
           // ... 
         
           yyyService.yyy();// 注意：每发起RPC调用，上下文状态会变化 
         
           // ...

(2) 服务提供方

           publicclassXxxServiceImplimplementsXxxService { 
         
               publicvoidxxx() {// 服务方法实现 
         
                   booleanisProviderSide = RpcContext.getContext().isProviderSide();// 本端是否为提供端，这里会返回true 
         
                   String clientIP = RpcContext.getContext().getRemoteHost();// 获取调用方IP地址 
         
                   String application = RpcContext.getContext().getUrl().getParameter("application");// 获取当前服务配置信息，所有配置信息都将转换为URL的参数 
         
                   // ... 
         
                   yyyService.yyy();// 注意：每发起RPC调用，上下文状态会变化 
         
                   booleanisProviderSide = RpcContext.getContext().isProviderSide();// 此时本端变成消费端，这里会返回false 
         
                   // ... 
         
               } 
         
           }

隐式传参

(+) (#)

注：path,group,version,dubbo,token,timeout几个key有特殊处理，请使用其它key值。

(1) 服务消费方

           RpcContext.getContext().setAttachment("index","1");// 隐式传参，后面的远程调用都会隐式将这些参数发送到服务器端，类似cookie，用于框架集成，不建议常规业务使用 
         
           xxxService.xxx();// 远程调用 
         
           // ...

【注】 setAttachment设置的KV，在完成下面一次远程调用会被清空。即多次远程调用要多次设置。

(2) 服务提供方

           publicclassXxxServiceImplimplementsXxxService { 
         
               publicvoidxxx() {// 服务方法实现 
         
                   String index = RpcContext.getContext().getAttachment("index");// 获取客户端隐式传入的参数，用于框架集成，不建议常规业务使用 
         
                   // ... 
         
               } 
         
           }

异步调用

(+) (#)

基于NIO的非阻塞实现并行调用，客户端不需要启动多线程即可完成并行调用多个远程服务，相对多线程开销较小。

2.0.6及其以上版本支持

配置声明：

consumer.xml

           <dubbo:referenceid="fooService"interface="com.alibaba.foo.FooService"> 
         
                 <dubbo:methodname="findFoo"async="true"/> 
         
           </dubbo:reference> 
         
           <dubbo:referenceid="barService"interface="com.alibaba.bar.BarService"> 
         
                 <dubbo:methodname="findBar"async="true"/> 
         
           </dubbo:reference>

调用代码：

           fooService.findFoo(fooId);// 此调用会立即返回null 
         
           Future<Foo> fooFuture = RpcContext.getContext().getFuture();// 拿到调用的Future引用，当结果返回后，会被通知和设置到此Future。 
         
           barService.findBar(barId);// 此调用会立即返回null 
         
           Future<Bar> barFuture = RpcContext.getContext().getFuture();// 拿到调用的Future引用，当结果返回后，会被通知和设置到此Future。 
         
           // 此时findFoo和findBar的请求同时在执行，客户端不需要启动多线程来支持并行，而是借助NIO的非阻塞完成。 
         
           Foo foo = fooFuture.get();// 如果foo已返回，直接拿到返回值，否则线程wait住，等待foo返回后，线程会被notify唤醒。 
         
           Bar bar = barFuture.get();// 同理等待bar返回。 
         
           // 如果foo需要5秒返回，bar需要6秒返回，实际只需等6秒，即可获取到foo和bar，进行接下来的处理。

你也可以设置是否等待消息发出：(异步总是不等待返回)

sent="true" 等待消息发出，消息发送失败将抛出异常。
sent="false" 不等待消息发出，将消息放入IO队列，即刻返回。

<dubbo:methodname="findFoo"async="true"sent="true"/>

如果你只是想异步，完全忽略返回值，可以配置return="false"，以减少Future对象的创建和管理成本：

           <dubbo:methodname="findFoo"async="true"return="false"/> 
         

本地调用

(+) (#)

本地调用，使用了Injvm协议，是一个伪协议，它不开启端口，不发起远程调用，只在JVM内直接关联，但执行Dubbo的Filter链。

Define injvm protocol:

           <dubbo:protocolname="injvm"/> 
         

Set default protocol:

           <dubbo:providerprotocol="injvm"/> 
         

Set service protocol:

           <dubbo:serviceprotocol="injvm"/> 
         

Use injvm first:

           <dubbo:consumerinjvm="true".../> 
         
           <dubbo:providerinjvm="true".../>

或

           <dubbo:referenceinjvm="true".../> 
         
           <dubbo:serviceinjvm="true".../>

注意：服务暴露与服务引用都需要声明injvm="true"

自动暴露、引用本地服务

从 dubbo 2.2.0 开始，每个服务默认都会在本地暴露；在引用服务的时候，默认优先引用本地服务；如果希望引用远程服务可以使用一下配置强制引用远程服务。

           ... 
         
               <dubbo:reference...scope="remote"/> 
         
           ...

参数回调

(+) (#)

参数回调方式与调用本地callback或listener相同，只需要在Spring的配置文件中声明哪个参数是callback类型即可，Dubbo将基于长连接生成反向代理，这样就可以从服务器端调用客户端逻辑。

2.0.6及其以上版本支持

代码参见：https://github.com/alibaba/dubbo/tree/master/dubbo-test/dubbo-test-examples/src/main/java/com/alibaba/dubbo/examples/callback

(1) 共享服务接口：

服务接口示例：

CallbackService.java

           packagecom.callback; 
         
           publicinterfaceCallbackService { 
         
               voidaddListener(String key, CallbackListener listener); 
         
           }

CallbackListener.java

           packagecom.callback; 
         
           publicinterfaceCallbackListener { 
         
               voidchanged(String msg); 
         
           }

(2) 服务提供者：

服务提供者接口实现示例：

CallbackServiceImpl.java

           packagecom.callback.impl; 
         
           importjava.text.SimpleDateFormat; 
         
           importjava.util.Date; 
         
           importjava.util.Map; 
         
           importjava.util.concurrent.ConcurrentHashMap; 
         
           importcom.callback.CallbackListener; 
         
           importcom.callback.CallbackService; 
         
           publicclassCallbackServiceImplimplementsCallbackService { 
         
               privatefinalMap<String, CallbackListener> listeners =newConcurrentHashMap<String, CallbackListener>(); 
         
               publicCallbackServiceImpl() { 
         
                   Thread t =newThread(newRunnable() { 
         
                       publicvoidrun() { 
         
                           while(true) { 
         
                               try{ 
         
                                   for(Map.Entry<String, CallbackListener> entry : listeners.entrySet()){ 
         
                                      try{ 
         
                                          entry.getValue().changed(getChanged(entry.getKey())); 
         
                                      }catch(Throwable t) { 
         
                                          listeners.remove(entry.getKey()); 
         
                                      } 
         
                                   } 
         
                                   Thread.sleep(5000);// 定时触发变更通知 
         
                               }catch(Throwable t) {// 防御容错 
         
                                   t.printStackTrace(); 
         
                               } 
         
                           } 
         
                       } 
         
                   }); 
         
                   t.setDaemon(true); 
         
                   t.start(); 
         
               } 
         
               publicvoidaddListener(String key, CallbackListener listener) { 
         
                   listeners.put(key, listener); 
         
                   listener.changed(getChanged(key));// 发送变更通知 
         
               } 
         
               privateString getChanged(String key) { 
         
                   return"Changed: "+newSimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(newDate()); 
         
               } 
         
           }

服务提供者配置示例：

           <beanid="callbackService"class="com.callback.impl.CallbackServiceImpl"/> 
         
           <dubbo:serviceinterface="com.callback.CallbackService"ref="callbackService"connections="1"callbacks="1000"> 
         
               <dubbo:methodname="addListener"> 
         
                   <dubbo:argumentindex="1"callback="true"/> 
         
                   <!--也可以通过指定类型的方式--> 
         
                   <!--<dubbo:argument type="com.demo.CallbackListener" callback="true" />--> 
         
               </dubbo:method> 
         
           </dubbo:service>

(2) 服务消费者：

服务消费者配置示例：

consumer.xml

           <dubbo:referenceid="callbackService"interface="com.callback.CallbackService"/> 
         

服务消费者调用示例：

CallbackServiceTest.java

           ClassPathXmlApplicationContext context =newClassPathXmlApplicationContext("classpath:consumer.xml"); 
         
           context.start(); 
         
           CallbackService callbackService = (CallbackService) context.getBean("callbackService"); 
         
           callbackService.addListener(" 
          http://10.20.160.198/wiki/display/dubbo/foo.bar",newCallbackListener(){ 
         
               publicvoidchanged(String msg) { 
         
                   System.out.println("callback1:"+ msg); 
         
               } 
         
           });

事件通知

(+) (#)

在调用之前，调用之后，出现异常时，会触发oninvoke, onreturn, onthrow三个事件，可以配置当事件发生时，通知哪个类的哪个方法。

支持版本：2.0.7之后

(1) 服务提供者与消费者共享服务接口：

IDemoService.java

           interfaceIDemoService { 
         
               publicPerson get(intid); 
         
           }

(2) 服务提供者实现：

DemoServiceImpl.java

           classNormalDemoServiceimplementsIDemoService { 
         
               publicPerson get(intid) { 
         
                   returnnewPerson(id,"charles`son",4); 
         
               } 
         
           }

(3) 服务提供者配置：

provider.xml

           <dubbo:applicationname="rpc-callback-demo"/> 
         
           <dubbo:registryaddress=" 
          http://10.20.160.198/wiki/display/dubbo/10.20.153.186"/> 
         
           <beanid="demoService"class="com.alibaba.dubbo.callback.implicit.NormalDemoService"/> 
         
           <dubbo:serviceinterface="com.alibaba.dubbo.callback.implicit.IDemoService"ref="demoService"version="1.0.0"group="cn"/>

(4) 服务消费者Callback接口及实现：

Nofify.java

           interfaceNofify { 
         
               publicvoidonreturn(Person msg, Integer id); 
         
               publicvoidonthrow(Throwable ex, Integer id); 
         
           }

NofifyImpl.java

           classNofifyImplimplementsNofify { 
         
               publicMap<Integer, Person>    ret    =newHashMap<Integer, Person>(); 
         
               publicMap<Integer, Throwable> errors =newHashMap<Integer, Throwable>(); 
         
               publicvoidonreturn(Person msg, Integer id) { 
         
                   System.out.println("onreturn:"+ msg); 
         
                   ret.put(id, msg); 
         
               } 
         
               publicvoidonthrow(Throwable ex, Integer id) { 
         
                   errors.put(id, ex); 
         
               } 
         
           }

(5) 服务消费者Callback接口及实现：

consumer.xml

           <beanid="demoCallback"class="com.alibaba.dubbo.callback.implicit.NofifyImpl"/> 
         
           <dubbo:referenceid="demoService"interface="com.alibaba.dubbo.callback.implicit.IDemoService"version="1.0.0"group="cn"> 
         
                 <dubbo:methodname="get"async="true"onreturn="demoCallback.onreturn"onthrow="demoCallback.onthrow"/> 
         
           </dubbo:reference>

注：
callback与async功能正交分解：
async=true，表示结果是否马上返回.
onreturn 表示是否需要回调.

组合情况：(async=false 默认)
异步回调模式：async=true onreturn="xxx"
同步回调模式：async=false onreturn="xxx"
异步无回调：async=true
同步无回调：async=false

(6) TEST CASE：

Test.java

           IDemoService demoService = (IDemoService) context.getBean("demoService"); 
         
           NofifyImpl notify = (NofifyImpl) context.getBean("demoCallback"); 
         
           intrequestId =2; 
         
           Person ret = demoService.get(requestId); 
         
           Assert.assertEquals(null, ret); 
         
           //for Test：只是用来说明callback正常被调用，业务具体实现自行决定. 
         
           for(inti =0; i <10; i++) { 
         
               if(!notify.ret.containsKey(requestId)) { 
         
                   Thread.sleep(200); 
         
               }else{ 
         
                   break; 
         
               } 
         
           } 
         
           Assert.assertEquals(requestId, notify.ret.get(requestId).getId());

本地存根

(+) (#)

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

Stub必须有可传入Proxy的构造函数。

           <dubbo:serviceinterface="com.foo.BarService"stub="true"/> 
         

Or:

           <dubbo:serviceinterface="com.foo.BarService"stub="com.foo.BarServiceStub"/> 
         

api.jar:

           com.foo.BarService 
         
           com.foo.BarServiceStub // 在API旁边放一个Stub实现，它实现BarService接口，并有一个传入远程BarService实例的构造函数

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

本地伪装

(+) (#)

Mock通常用于服务降级，比如某验权服务，当服务提供方全部挂掉后，客户端不抛出异常，而是通过Mock数据返回授权失败。

Mock是Stub的一个子集，便于服务提供方在客户端执行容错逻辑，因经常需要在出现RpcException(比如网络失败，超时等)时进行容错，而在出现业务异常(比如登录用户名密码错误)时不需要容错，如果用Stub，可能就需要捕获并依赖RpcException类，而用Mock就可以不依赖RpcException，因为它的约定就是只有出现RpcException时才执行。

           <dubbo:serviceinterface="com.foo.BarService"mock="true"/> 
         

Or:

           <dubbo:serviceinterface="com.foo.BarService"mock="com.foo.BarServiceMock"/> 
         

api.jar:

           com.foo.BarService 
         
           com.foo.BarServiceMock // 在API旁边放一个Mock实现，它实现BarService接口，并有一个无参构造函数

           packagecom.foo 
         
           publicclassBarServiceMockimplementsBarService { 
         
               publicString sayHello(String name) { 
         
                   // 你可以伪造容错数据，此方法只在出现RpcException时被执行 
         
                   return"容错数据"; 
         
               } 
         
           }

如果服务的消费方经常需要try-catch捕获异常，如：

           Offer offer =null; 
         
           try{ 
         
               offer = offerService.findOffer(offerId); 
         
           }catch(RpcException e) { 
         
              logger.error(e); 
         
           }

请考虑改为Mock实现，并在Mock中return null。

如果只是想简单的忽略异常，在2.0.11以上版本可用：

           <dubbo:serviceinterface="com.foo.BarService"mock="return null"/> 
         

延迟暴露

(+) (#)

如果你的服务需要Warmup时间，比如初始化缓存，等待相关资源就位等，可以使用delay进行延迟暴露。

延迟5秒暴露服务：

           <dubbo:servicedelay="5000"/> 
         

延迟到Spring初始化完成后，再暴露服务：(基于Spring的ContextRefreshedEvent事件触发暴露)

           <dubbo:servicedelay="-1"/> 
         

Spring2.x初始化死锁问题
在Spring解析到<dubbo:service />时，就已经向外暴露了服务，而Spring还在接着初始化其它Bean。
如果这时有请求进来，并且服务的实现类里有调用applicationContext.getBean()的用法。

1. 请求线程的applicationContext.getBean()调用，先同步singletonObjects判断Bean是否存在，不存在就同步beanDefinitionMap进行初始化，并再次同步singletonObjects写入Bean实例缓存。

2. 而Spring初始化线程，因不需要判断Bean的存在，直接同步beanDefinitionMap进行初始化，并同步singletonObjects写入Bean实例缓存。

这样就导致getBean线程，先锁singletonObjects，再锁beanDefinitionMap，再次锁singletonObjects。
而Spring初始化线程，先锁beanDefinitionMap，再锁singletonObjects。
反向锁导致线程死锁，不能提供服务，启动不了。

规避办法
1. 强烈建议不要在服务的实现类中有applicationContext.getBean()的调用，全部采用IoC注入的方式使用Spring的Bean。
2. 如果实在要调getBean()，可以将Dubbo的配置放在Spring的最后加载。
3. 如果不想依赖配置顺序，可以使用<dubbo:provider deplay=”-1” />，使Dubbo在Spring容器初始化完后，再暴露服务。
4. 如果大量使用getBean()，相当于已经把Spring退化为工厂模式在用，可以将Dubbo的服务隔离单独的Spring容器。

并发控制

(+) (#)

限制com.foo.BarService的每个方法，服务器端并发执行（或占用线程池线程数）不能超过10个：

           <dubbo:serviceinterface="com.foo.BarService"executes="10"/> 
         

限制com.foo.BarService的sayHello方法，服务器端并发执行（或占用线程池线程数）不能超过10个：

           <dubbo:serviceinterface="com.foo.BarService"> 
         
               <dubbo:methodname="sayHello"executes="10"/> 
         
           </dubbo:service>

限制com.foo.BarService的每个方法，每客户端并发执行（或占用连接的请求数）不能超过10个：

           <dubbo:serviceinterface="com.foo.BarService"actives="10"/> 
         

Or:

           <dubbo:referenceinterface="com.foo.BarService"actives="10"/> 
         

限制com.foo.BarService的sayHello方法，每客户端并发执行（或占用连接的请求数）不能超过10个：

           <dubbo:serviceinterface="com.foo.BarService"> 
         
               <dubbo:methodname="sayHello"actives="10"/> 
         
           </dubbo:service>

Or:

           <dubbo:referenceinterface="com.foo.BarService"> 
         
               <dubbo:methodname="sayHello"actives="10"/> 
         
           </dubbo:service>

如果<dubbo:service>和<dubbo:reference>都配了actives，<dubbo:reference>优先，参见：配置的覆盖策略。

Load Balance均衡：

配置服务的客户端的loadbalance属性为leastactive，此Loadbalance会调用并发数最小的Provider（Consumer端并发数）。

           <dubbo:referenceinterface="com.foo.BarService"loadbalance="leastactive"/> 
         

Or:

           <dubbo:serviceinterface="com.foo.BarService"loadbalance="leastactive"/> 
         

连接控制

(+) (#)

限制服务器端接受的连接不能超过10个：（以连接在Server上，所以配置在Provider上）

           <dubbo:providerprotocol="dubbo"accepts="10"/> 
         

           <dubbo:protocolname="dubbo"accepts="10"/> 
         

限制客户端服务使用连接连接数：(如果是长连接，比如Dubbo协议，connections表示该服务对每个提供者建立的长连接数)

           <dubbo:referenceinterface="com.foo.BarService"connections="10"/> 
         

Or:

           <dubbo:serviceinterface="com.foo.BarService"connections="10"/> 
         

如果<dubbo:service>和<dubbo:reference>都配了connections，<dubbo:reference>优先，参见：配置的覆盖策略。

延迟连接

(+) (#)

延迟连接，用于减少长连接数，当有调用发起时，再创建长连接。

只对使用长连接的dubbo协议生效。

           <dubbo:protocolname="dubbo"lazy="true"/> 
         

粘滞连接

(+) (#)

粘滞连接用于有状态服务，尽可能让客户端总是向同一提供者发起调用，除非该提供者挂了，再连另一台。

粘滞连接将自动开启延迟连接，以减少长连接数，参见：延迟连接 (+)

           <dubbo:protocolname="dubbo"sticky="true"/> 
         

令牌验证

(+) (#)

防止消费者绕过注册中心访问提供者
在注册中心控制权限，以决定要不要下发令牌给消费者
注册中心可灵活改变授权方式，而不需修改或升级提供者

可以全局设置开启令牌验证：

           <!--随机token令牌，使用UUID生成--> 
         
           <dubbo:providerinterface="com.foo.BarService"token="true"/>

           <!--固定token令牌，相当于密码--> 
         
           <dubbo:providerinterface="com.foo.BarService"token="123456"/>

也可在服务级别设置：

           <!--随机token令牌，使用UUID生成--> 
         
           <dubbo:serviceinterface="com.foo.BarService"token="true"/>

           <!--固定token令牌，相当于密码--> 
         
           <dubbo:serviceinterface="com.foo.BarService"token="123456"/>

还可在协议级别设置：

           <!--随机token令牌，使用UUID生成--> 
         
           <dubbo:protocolname="dubbo"token="true"/>

           <!--固定token令牌，相当于密码--> 
         
           <dubbo:protocolname="dubbo"token="123456"/>

路由规则

(+) (#)

2.2.0以上版本支持

路由规则扩展点：路由扩展

向注册中心写入路由规则：(通常由监控中心或治理中心的页面完成)

           RegistryFactory registryFactory = ExtensionLoader.getExtensionLoader(RegistryFactory.class).getAdaptiveExtension(); 
         
           Registry registry = registryFactory.getRegistry(URL.valueOf("zookeeper://10.20.153.10:2181")); 
         
           registry.register(URL.valueOf("condition://0.0.0.0/com.foo.BarService?category=routers&dynamic=false&rule="+ URL.encode(" 
          http://10.20.160.198/wiki/display/dubbo/host = 10.20.153.10 => host = 10.20.153.11") + "));

其中：

condition://
- 表示路由规则的类型，支持条件路由规则和脚本路由规则，可扩展，必填。
0.0.0.0
- 表示对所有IP地址生效，如果只想对某个IP的生效，请填入具体IP，必填。
com.foo.BarService
- 表示只对指定服务生效，必填。
category=routers
- 表示该数据为动态配置类型，必填。
dynamic=false
- 表示该数据为持久数据，当注册方退出时，数据依然保存在注册中心，必填。
enabled=true
- 覆盖规则是否生效，可不填，缺省生效。
force=false
- 当路由结果为空时，是否强制执行，如果不强制执行，路由结果为空的路由规则将自动失效，可不填，缺省为flase。
runtime=false
- 是否在每次调用时执行路由规则，否则只在提供者地址列表变更时预先执行并缓存结果，调用时直接从缓存中获取路由结果。
- 如果用了参数路由，必须设为true，需要注意设置会影响调用的性能，可不填，缺省为flase。
priority=1
- 路由规则的优先级，用于排序，优先级越大越靠前执行，可不填，缺省为0。
rule=URL.encode("host = 10.20.153.10 => host = 10.20.153.11")
- 表示路由规则的内容，必填。

条件路由规则

(#)

基于条件表达式的路由规则，如：

           host =10.20.153.10=> host =10.20.153.11 
         

规则：

"=>"之前的为消费者匹配条件，所有参数和消费者的URL进行对比，当消费者满足匹配条件时，对该消费者执行后面的过滤规则。
"=>"之后为提供者地址列表的过滤条件，所有参数和提供者的URL进行对比，消费者最终只拿到过滤后的地址列表。
如果匹配条件为空，表示对所有消费方应用，如：=> host != 10.20.153.11
如果过滤条件为空，表示禁止访问，如：host = 10.20.153.10 =>

表达式：

参数支持：
- 服务调用信息，如：method, argument 等 (暂不支持参数路由)
- URL本身的字段，如：protocol, host, port 等
- 以及URL上的所有参数，如：application, organization 等
条件支持：
- 等号"="表示"匹配"，如：host = 10.20.153.10
- 不等号"!="表示"不匹配"，如：host != 10.20.153.10
值支持：
- 以逗号","分隔多个值，如：host != 10.20.153.10,10.20.153.11
- 以星号"*"结尾，表示通配，如：host != 10.20.*
- 以美元符"$"开头，表示引用消费者参数，如：host = $host

示例：

1. 排除预发布机：

           => host !=172.22.3.91 
         

2. 白名单：(注意：一个服务只能有一条白名单规则，否则两条规则交叉，就都被筛选掉了)

           host !=10.20.153.10,10.20.153.11=> 
         

3. 黑名单：

           host =10.20.153.10,10.20.153.11=> 
         

4. 服务寄宿在应用上，只暴露一部分的机器，防止整个集群挂掉：

           => host =172.22.3.1*,172.22.3.2* 
         

5. 为重要应用提供额外的机器：

           application != kylin => host !=172.22.3.95,172.22.3.96 
         

6. 读写分离：

           method = find*,list*,get*,is* => host =172.22.3.94,172.22.3.95,172.22.3.96 
         

           method != find*,list*,get*,is* => host =172.22.3.97,172.22.3.98 
         

7. 前后台分离：

           application = bops => host =172.22.3.91,172.22.3.92,172.22.3.93 
         

           application != bops => host =172.22.3.94,172.22.3.95,172.22.3.96 
         

8. 隔离不同机房网段：

           host !=172.22.3.* => host !=172.22.3.* 
         

9. 提供者与消费者部署在同集群内，本机只访问本机的服务：

           => host = $host 
         

脚本路由规则

(#)

支持JDK脚本引擎的所有脚本，比如：javascript,jruby,groovy等，通过type=javascript参数设置脚本类型，缺省为javascript。

脚本没有沙箱约束，可执行任意代码，存在后门风险

           "script://0.0.0.0/com.foo.BarService?category=routers&dynamic=false&rule="+ URL.encode("function route(invokers) { ... } (invokers)") 
         

基于脚本引擎的路由规则，如：

           functionroute(invokers) { 
         
               varresult =newjava.util.ArrayList(invokers.size()); 
         
               for(i = 0; i < invokers.size(); i ++) { 
         
                   if(" 
          http://10.20.160.198/wiki/display/dubbo/10.20.153.10".equals(invokers.get(i).getUrl().getHost())) { 
         
                       result.add(invokers.get(i)); 
         
                   } 
         
               } 
         
               returnresult; 
         
           } (invokers);// 表示立即执行方法

配置规则

(+) (#)

2.2.0以上版本支持

向注册中心写入动态配置覆盖规则：(通常由监控中心或治理中心的页面完成)

           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&timeout=1000"));

其中：

override://
- 表示数据采用覆盖方式，支持override和absent，可扩展，必填。
0.0.0.0
- 表示对所有IP地址生效，如果只想覆盖某个IP的数据，请填入具体IP，必填。
com.foo.BarService
- 表示只对指定服务生效，必填。
category=configurators
- 表示该数据为动态配置类型，必填。
dynamic=false
- 表示该数据为持久数据，当注册方退出时，数据依然保存在注册中心，必填。
enabled=true
- 覆盖规则是否生效，可不填，缺省生效。
application=foo
- 表示只对指定应用生效，可不填，表示对所有应用生效。
timeout=1000
- 表示将满足以上条件的timeout参数的值覆盖为1000。
- 如果想覆盖其它参数，直接加在override的URL参数上。

示例：

1. 禁用提供者：(通常用于临时踢除某台提供者机器，相似的，禁止消费者访问请使用路由规则)

           override://10.20.153.10/com.foo.BarService?category=configurators&dynamic=false&disbaled=true 
         

2. 调整权重：(通常用于容量评估，缺省权重为100)

           override://10.20.153.10/com.foo.BarService?category=configurators&dynamic=false&weight=200 
         

3. 调整负载均衡策略：(缺省负载均衡策略为random)

           override://10.20.153.10/com.foo.BarService?category=configurators&dynamic=false&loadbalance=leastactive 
         

4. 服务降级：(通常用于临时屏蔽某个出错的非关键服务)

           override://0.0.0.0/com.foo.BarService?category=configurators&dynamic=false&application=foo&mock=force:return+null 
         

服务降级

(+) (#)

2.2.0以上版本支持

参见：配置规则

向注册中心写入动态配置覆盖规则：(通过由监控中心或治理中心的页面完成)

           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是通过JDK的ShutdownHook来完成优雅停机的，所以如果用户使用"kill -9 PID"等强制关闭指令，是不会执行优雅停机的，只有通过"kill PID"时，才会执行。

原理：

服务提供方
- 停止时，先标记为不接收新请求，新请求过来时直接报错，让客户端重试其它机器。
- 然后，检测线程池中的线程是否正在运行，如果有，等待所有线程执行完成，除非超时，则强制关闭。
服务消费方
- 停止时，不再发起新的调用请求，所有新的调用在客户端即报错。
- 然后，检测有没有请求的响应还没有返回，等待响应返回，除非超时，则强制关闭。

设置优雅停机超时时间，缺省超时时间是10秒：(超时则强制关闭)

           <dubbo:application...> 
         
               <dubbo:parameterkey="shutdown.timeout"value="60000"/><!-- 单位毫秒 --> 
         
           </dubbo:application>

如果ShutdownHook不能生效，可以自行调用：

           ProtocolConfig.destroyAll(); 
         

主机绑定

(+) (#)

缺省主机IP查找顺序：

通过LocalHost.getLocalHost()获取本机地址。
如果是127.*等loopback地址，则扫描各网卡，获取网卡IP。

注册的地址如果获取不正确，比如需要注册公网地址，可以：
1. 可以在/etc/hosts中加入：机器名公网IP，比如：

           test1205.182.23.201 
         

2. 在dubbo.xml中加入主机地址的配置：

           <dubbo:protocolhost=" 
          http://10.20.160.198/wiki/display/dubbo/205.182.23.201"> 
         

3. 或在dubbo.properties中加入主机地址的配置：

           dubbo.protocol.host=205.182.23.201 
         

缺省主机端口与协议相关：

dubbo: 20880
rmi: 1099
http: 80
hessian: 80
webservice: 80
memcached: 11211
redis: 6379

主机端口配置：

1. 在dubbo.xml中加入主机地址的配置：

           <dubbo:protocolname="dubbo"port="20880"> 
         

3. 或在dubbo.properties中加入主机地址的配置：

           dubbo.protocol.dubbo.port=20880 
         

日志适配

(+) (#)

2.2.1以上版本支持

扩展点：日志适配扩展

缺省自动查找：

log4j
slf4j
jcl
jdk

可以通过以下方式配置日志输出策略：

           java -Ddubbo.application.logger=log4j 
         

dubbo.properties

           dubbo.application.logger=log4j 
         

dubbo.xml

           <dubbo:application logger="log4j"/> 
         

访问日志

(+) (#)

如果你想记录每一次请求信息，可开启访问日志，类似于apache的访问日志。

此日志量比较大，请注意磁盘容量。

将访问日志输出到当前应用的log4j日志：

           <dubbo:protocolaccesslog="true"/> 
         

将访问日志输出到指定文件：

           <dubbo:protocolaccesslog=" 
          http://10.20.160.198/wiki/display/dubbo/foo/bar.log"/> 
         

服务容器

(+) (#)

服务容器是一个standalone的启动程序，因为后台服务不需要Tomcat或JBoss等Web容器的功能，如果硬要用Web容器去加载服务提供方，增加复杂性，也浪费资源。

服务容器只是一个简单的Main方法，并加载一个简单的Spring容器，用于暴露服务。

服务容器的加载内容可以扩展，内置了spring, jetty, log4j等加载，可通过Container扩展点进行扩展，参见：Container

Spring Container

自动加载META-INF/spring目录下的所有Spring配置。
配置：(配在java命令-D参数或者dubbo.properties中)
- dubbo.spring.config=classpath*:META-INF/spring/*.xml ----配置spring配置加载位置

Jetty Container

启动一个内嵌Jetty，用于汇报状态。
配置：(配在java命令-D参数或者dubbo.properties中)
- dubbo.jetty.port=8080 ----配置jetty启动端口
- dubbo.jetty.directory=/foo/bar ----配置可通过jetty直接访问的目录，用于存放静态文件
- dubbo.jetty.page=log,status,system ----配置显示的页面，缺省加载所有页面

Log4j Container

自动配置log4j的配置，在多进程启动时，自动给日志文件按进程分目录。
配置：(配在java命令-D参数或者dubbo.properties中)
- dubbo.log4j.file=/foo/bar.log ----配置日志文件路径
- dubbo.log4j.level=WARN ----配置日志级别
- dubbo.log4j.subdirectory=20880 ----配置日志子目录，用于多进程启动，避免冲突

容器启动

如：(缺省只加载spring)

           java com.alibaba.dubbo.container.Main 
         

或：(通过main函数参数传入要加载的容器)

           java com.alibaba.dubbo.container.Main spring jetty log4j 
         

或：(通过JVM启动参数传入要加载的容器)

           java com.alibaba.dubbo.container.Main -Ddubbo.container=spring,jetty,log4j 
         

或：(通过classpath下的dubbo.properties配置传入要加载的容器)

dubbo.properties

           dubbo.container=spring,jetty,log4j 
         

Reference Config缓存

(+) (#)

ReferenceConfig实例很重，封装了与注册中心的连接以及与提供者的连接，需要缓存，否则重复生成ReferenceConfig可能造成性能问题并且会有内存和连接泄漏。API方式编程时，容易忽略此问题。

Dubbo 2.4.0+版本，提供了简单的工具类ReferenceConfigCache用于缓存ReferenceConfig实例。

使用方式如下：

           ReferenceConfig<XxxService> reference =newReferenceConfig<XxxService>(); 
         
           reference.setInterface(XxxService.class); 
         
           reference.setVersion("1.0.0"); 
         
           ...... 
         
           ReferenceConfigCache cache = ReferenceConfigCache.getCache(); 
         
           XxxService xxxService = cache.get(reference);// cache.get方法中会Cache Reference对象，并且调用ReferenceConfig.get方法启动ReferenceConfig 
         
           // 注意！ Cache会持有ReferenceConfig，不要在外部再调用ReferenceConfig的destroy方法，导致Cache内的ReferenceConfig失效！ 
         
           // 使用xxxService对象 
         
           xxxService.sayHello();

消除Cache中的ReferenceConfig，销毁ReferenceConfig并释放对应的资源。

           ReferenceConfigCache cache = ReferenceConfigCache.getCache(); 
         
           cache.destroy(reference);

缺省ReferenceConfigCache把相同服务Group、接口、版本的ReferenceConfig认为是相同，缓存一份。即以服务Group、接口、版本为缓存的Key。

可以修改这个策略，在ReferenceConfigCache.getCache时，传一个KeyGenerator。详见ReferenceConfigCache类的方法。

           KeyGenerator keyGenerator =new... 
         
           ReferenceConfigCache cache = ReferenceConfigCache.getCache(keyGenerator );

分布式事务

(+) (#)

基于JTA/XA规范实现。

暂未实现。

两阶段提交：

API参考手册

(+) (#)

Dubbo的常规功能，都保持零侵入，但有些功能不得不用API侵入才能实现。

Dubbo中除这里声明以外的接口或类，都是内部接口或扩展接口，普通用户请不要直接依赖，否则升级版本可能出现不兼容。

API汇总如下：

配置API

com.alibaba.dubbo.config.ServiceConfig
com.alibaba.dubbo.config.ReferenceConfig
com.alibaba.dubbo.config.ProtocolConfig
com.alibaba.dubbo.config.RegistryConfig
com.alibaba.dubbo.config.MonitorConfig
com.alibaba.dubbo.config.ApplicationConfig
com.alibaba.dubbo.config.ModuleConfig
com.alibaba.dubbo.config.ProviderConfig
com.alibaba.dubbo.config.ConsumerConfig
com.alibaba.dubbo.config.MethodConfig
com.alibaba.dubbo.config.ArgumentConfig
- 参见：API配置

注解API

com.alibaba.dubbo.config.annotation.Service
com.alibaba.dubbo.config.annotation.Reference
- 参见：注解配置

模型API

com.alibaba.dubbo.common.URL
com.alibaba.dubbo.rpc.RpcException

上下文API

com.alibaba.dubbo.rpc.RpcContext
- 参见：上下文信息 & 对方地址 & 隐式传参 & 异步调用

服务API

com.alibaba.dubbo.rpc.service.GenericService
com.alibaba.dubbo.rpc.service.GenericException
- 参见：泛化引用 & 泛化实现
com.alibaba.dubbo.rpc.service.EchoService
- 参见：回声测试

配置参考手册

(+) (#)

这里以Xml配置为准，列举所有配置项，其它配置方式，请参见相应转换关系：属性配置，注解配置，API配置

注意：只有group，interface，version是服务的匹配条件，三者决定是不是同一个服务，其它配置项均为调优和治理参数。

所有配置项分为三大类，参见下表中的"作用"一列。

服务发现：表示该配置项用于服务的注册与发现，目的是让消费方找到提供方。
服务治理：表示该配置项用于治理服务间的关系，或为开发测试提供便利条件。
性能调优：表示该配置项用于调优性能，不同的选项对性能会产生影响。

所有配置最终都将转换为URL表示，并由服务提供方生成，经注册中心传递给消费方，各属性对应URL的参数，参见配置项一览表中的"对应URL参数"列。
URL格式：

protocol://username:password@host:port/path?key=value&key=value

Schema: http://code.alibabatech.com/schema/dubbo/dubbo.xsd

<dubbo:service/>

(+) (#)

服务提供者暴露服务配置：
配置类：com.alibaba.dubbo.config.ServiceConfig

标签	属性	对应URL参数	类型	是否必填	缺省值	作用	描述	兼容性
<dubbo:service>	interface		class	必填		服务发现	服务接口名	1.0.0以上版本
<dubbo:service>	ref		object	必填		服务发现	服务对象实现引用	1.0.0以上版本
<dubbo:service>	version	version	string	可选	0.0.0	服务发现	服务版本，建议使用两位数字版本，如：1.0，通常在接口不兼容时版本号才需要升级	1.0.0以上版本
<dubbo:service>	group	group	string	可选		服务发现	服务分组，当一个接口有多个实现，可以用分组区分	1.0.7以上版本
<dubbo:service>	path	<path>	string	可选	缺省为接口名	服务发现	服务路径 (注意：1.0不支持自定义路径，总是使用接口名，如果有1.0调2.0，配置服务路径可能不兼容)	1.0.12以上版本
<dubbo:service>	delay	delay	int	可选	0	性能调优	延迟注册服务时间(毫秒) ，设为-1时，表示延迟到Spring容器初始化完成时暴露服务	1.0.14以上版本
<dubbo:service>	timeout	timeout	int	可选	1000	性能调优	远程服务调用超时时间(毫秒)	2.0.0以上版本
<dubbo:service>	retries	retries	int	可选	2	性能调优	远程服务调用重试次数，不包括第一次调用，不需要重试请设为0	2.0.0以上版本
<dubbo:service>	connections	connections	int	可选	100	性能调优	对每个提供者的最大连接数，rmi、http、hessian等短连接协议表示限制连接数，dubbo等长连接协表示建立的长连接个数	2.0.0以上版本
<dubbo:service>	loadbalance	loadbalance	string	可选	random	性能调优	负载均衡策略，可选值：random,roundrobin,leastactive，分别表示：随机，轮循，最少活跃调用	2.0.0以上版本
<dubbo:service>	async	async	boolean	可选	false	性能调优	是否缺省异步执行，不可靠异步，只是忽略返回值，不阻塞执行线程	2.0.0以上版本
<dubbo:service>	stub	stub	class/boolean	可选	false	服务治理	设为true，表示使用缺省代理类名，即：接口名 + Local后缀，服务接口客户端本地代理类名，用于在客户端执行本地逻辑，如本地缓存等，该本地代理类的构造函数必须允许传入远程代理对象，构造函数如：public XxxServiceLocal(XxxService xxxService)	2.0.0以上版本
<dubbo:service>	mock	mock	class/boolean	可选	false	服务治理	设为true，表示使用缺省Mock类名，即：接口名 + Mock后缀，服务接口调用失败Mock实现类，该Mock类必须有一个无参构造函数，与Local的区别在于，Local总是被执行，而Mock只在出现非业务异常(比如超时，网络异常等)时执行，Local在远程调用之前执行，Mock在远程调用后执行。	2.0.0以上版本
<dubbo:service>	token	token	string/boolean	可选	false	服务治理	令牌验证，为空表示不开启，如果为true，表示随机生成动态令牌，否则使用静态令牌，令牌的作用是防止消费者绕过注册中心直接访问，保证注册中心的授权功能有效，如果使用点对点调用，需关闭令牌功能	2.0.0以上版本
<dubbo:service>	registry		string	可选	缺省向所有registry注册	配置关联	向指定注册中心注册，在多个注册中心时使用，值为<dubbo:registry>的id属性，多个注册中心ID用逗号分隔，如果不想将该服务注册到任何registry，可将值设为N/A	2.0.0以上版本
<dubbo:service>	provider		string	可选	缺使用第一个provider配置	配置关联	指定provider，值为<dubbo:provider>的id属性	2.0.0以上版本
<dubbo:service>	deprecated	deprecated	boolean	可选	false	服务治理	服务是否过时，如果设为true，消费方引用时将打印服务过时警告error日志	2.0.5以上版本
<dubbo:service>	dynamic	dynamic	boolean	可选	true	服务治理	服务是否动态注册，如果设为false，注册后将显示后disable状态，需人工启用，并且服务提供者停止时，也不会自动取消册，需人工禁用。	2.0.5以上版本
<dubbo:service>	accesslog	accesslog	string/boolean	可选	false	服务治理	设为true，将向logger中输出访问日志，也可填写访问日志文件路径，直接把访问日志输出到指定文件	2.0.5以上版本
<dubbo:service>	owner	owner	string	可选		服务治理	服务负责人，用于服务治理，请填写负责人公司邮箱前缀	2.0.5以上版本
<dubbo:service>	document	document	string	可选		服务治理	服务文档URL	2.0.5以上版本
<dubbo:service>	weight	weight	int	可选		性能调优	服务权重	2.0.5以上版本
<dubbo:service>	executes	executes	int	可选	0	性能调优	服务提供者每服务每方法最大可并行执行请求数	2.0.5以上版本
<dubbo:service>	actives	actives	int	可选	0	性能调优	每服务消费者每服务每方法最大并发调用数	2.0.5以上版本
<dubbo:service>	proxy	proxy	string	可选	javassist	性能调优	生成动态代理方式，可选：jdk/javassist	2.0.5以上版本
<dubbo:service>	cluster	cluster	string	可选	failover	性能调优	集群方式，可选：failover/failfast/failsafe/failback/forking	2.0.5以上版本
<dubbo:service>	filter	service.filter	string	可选	default	性能调优	服务提供方远程调用过程拦截器名称，多个名称用逗号分隔	2.0.5以上版本
<dubbo:service>	listener	exporter.listener	string	可选	default	性能调优	服务提供方导出服务监听器名称，多个名称用逗号分隔
<dubbo:service>	protocol		string	可选		配置关联	使用指定的协议暴露服务，在多协议时使用，值为<dubbo:protocol>的id属性，多个协议ID用逗号分隔	2.0.5以上版本
<dubbo:service>	layer	layer	string	可选		服务治理	服务提供者所在的分层。如：biz、dao、intl:web、china:acton。	2.0.7以上版本
<dubbo:service>	register	register	boolean	可选	true	服务治理	该协议的服务是否注册到注册中心	2.0.8以上版本

<dubbo:reference/>

(+) (#)

服务消费者引用服务配置：
配置类：com.alibaba.dubbo.config.ReferenceConfig

标签	属性	对应URL参数	类型	是否必填	缺省值	作用	描述	兼容性
<dubbo:reference>	id		string	必填		配置关联	服务引用BeanId	1.0.0以上版本
<dubbo:reference>	interface		class	必填		服务发现	服务接口名	1.0.0以上版本
<dubbo:reference>	version	version	string	可选		服务发现	服务版本，与服务提供者的版本一致	1.0.0以上版本
<dubbo:reference>	group	group	string	可选		服务发现	服务分组，当一个接口有多个实现，可以用分组区分，必需和服务提供方一致	1.0.7以上版本
<dubbo:reference>	timeout	timeout	long	可选	缺省使用<dubbo:consumer>的timeout	性能调优	服务方法调用超时时间(毫秒)	1.0.5以上版本
<dubbo:reference>	retries	retries	int	可选	缺省使用<dubbo:consumer>的retries	性能调优	远程服务调用重试次数，不包括第一次调用，不需要重试请设为0	2.0.0以上版本
<dubbo:reference>	connections	connections	int	可选	缺省使用<dubbo:consumer>的connections	性能调优	对每个提供者的最大连接数，rmi、http、hessian等短连接协议表示限制连接数，dubbo等长连接协表示建立的长连接个数	2.0.0以上版本
<dubbo:reference>	loadbalance	loadbalance	string	可选	缺省使用<dubbo:consumer>的loadbalance	性能调优	负载均衡策略，可选值：random,roundrobin,leastactive，分别表示：随机，轮循，最少活跃调用	2.0.0以上版本
<dubbo:reference>	async	async	boolean	可选	缺省使用<dubbo:consumer>的async	性能调优	是否异步执行，不可靠异步，只是忽略返回值，不阻塞执行线程	2.0.0以上版本
<dubbo:reference>	generic	generic	boolean	可选	缺省使用<dubbo:consumer>的generic	服务治理	是否缺省泛化接口，如果为泛化接口，将返回GenericService	2.0.0以上版本
<dubbo:reference>	check	check	boolean	可选	缺省使用<dubbo:consumer>的check	服务治理	启动时检查提供者是否存在，true报错，false忽略	2.0.0以上版本
<dubbo:reference>	url	<url>	string	可选		服务治理	点对点直连服务提供者地址，将绕过注册中心	1.0.6以上版本
<dubbo:reference>	stub	stub	class/boolean	可选		服务治理	服务接口客户端本地代理类名，用于在客户端执行本地逻辑，如本地缓存等，该本地代理类的构造函数必须允许传入远程代理对象，构造函数如：public XxxServiceLocal(XxxService xxxService)	2.0.0以上版本
<dubbo:reference>	mock	mock	class/boolean	可选		服务治理	服务接口调用失败Mock实现类名，该Mock类必须有一个无参构造函数，与Local的区别在于，Local总是被执行，而Mock只在出现非业务异常(比如超时，网络异常等)时执行，Local在远程调用之前执行，Mock在远程调用后执行。	Dubbo1.0.13及其以上版本支持
<dubbo:reference>	cache	cache	string/boolean	可选		服务治理	以调用参数为key，缓存返回结果，可选：lru, threadlocal, jcache等	Dubbo2.1.0及其以上版本支持
<dubbo:reference>	validation	validation	boolean	可选		服务治理	是否启用JSR303标准注解验证，如果启用，将对方法参数上的注解进行校验	Dubbo2.1.0及其以上版本支持
<dubbo:reference>	proxy	proxy	boolean	可选	javassist	性能调优	选择动态代理实现策略，可选：javassist, jdk	2.0.2以上版本
<dubbo:reference>	client	client	string	可选		性能调优	客户端传输类型设置，如Dubbo协议的netty或mina。	Dubbo2.0.0以上版本支持
<dubbo:reference>	registry		string	可选	缺省将从所有注册中心获服务列表后合并结果	配置关联	从指定注册中心注册获取服务列表，在多个注册中心时使用，值为<dubbo:registry>的id属性，多个注册中心ID用逗号分隔	2.0.0以上版本
<dubbo:reference>	owner	owner	string	可选		服务治理	调用服务负责人，用于服务治理，请填写负责人公司邮箱前缀	2.0.5以上版本
<dubbo:reference>	actives	actives	int	可选	0	性能调优	每服务消费者每服务每方法最大并发调用数	2.0.5以上版本
<dubbo:reference>	cluster	cluster	string	可选	failover	性能调优	集群方式，可选：failover/failfast/failsafe/failback/forking	2.0.5以上版本
<dubbo:reference>	filter	reference.filter	string	可选	default	性能调优	服务消费方远程调用过程拦截器名称，多个名称用逗号分隔	2.0.5以上版本
<dubbo:reference>	listener	invoker.listener	string	可选	default	性能调优	服务消费方引用服务监听器名称，多个名称用逗号分隔	2.0.5以上版本
<dubbo:reference>	layer	layer	string	可选		服务治理	服务调用者所在的分层。如：biz、dao、intl:web、china:acton。	2.0.7以上版本
<dubbo:reference>	init	init	boolean	可选	false	性能调优	是否在afterPropertiesSet()时饥饿初始化引用，否则等到有人注入或引用该实例时再初始化。	2.0.10以上版本
<dubbo:reference>	protocol	protocol	string	可选		服力治理	只调用指定协议的服务提供方，其它协议忽略。	2.2.0以上版本

<dubbo:protocol/>

(+) (#)

服务提供者协议配置：
配置类：com.alibaba.dubbo.config.ProtocolConfig
说明：如果需要支持多协议，可以声明多个<dubbo:protocol>标签，并在<dubbo:service>中通过protocol属性指定使用的协议。

标签	属性	对应URL参数	类型	是否必填	缺省值	作用	描述	兼容性
<dubbo:protocol>	id		string	可选	dubbo	配置关联	协议BeanId，可以在<dubbo:service protocol="">中引用此ID，如果ID不填，缺省和name属性值一样，重复则在name后加序号。	2.0.5以上版本
<dubbo:protocol>	name	<protocol>	string	必填	dubbo	性能调优	协议名称	2.0.5以上版本
<dubbo:protocol>	port	<port>	int	可选	dubbo协议缺省端口为20880，rmi协议缺省端口为1099，http和hessian协议缺省端口为80 如果配置为-1 或者没有配置port，则会分配一个没有被占用的端口。Dubbo 2.4.0+，分配的端口在协议缺省端口的基础上增长，确保端口段可控。	服务发现	服务端口	2.0.5以上版本
<dubbo:protocol>	host	<host>	string	可选	自动查找本机IP	服务发现	-服务主机名，多网卡选择或指定VIP及域名时使用，为空则自动查找本机IP，-建议不要配置，让Dubbo自动获取本机IP	2.0.5以上版本
<dubbo:protocol>	threadpool	threadpool	string	可选	fixed	性能调优	线程池类型，可选：fixed/cached	2.0.5以上版本
<dubbo:protocol>	threads	threads	int	可选	100	性能调优	服务线程池大小(固定大小)	2.0.5以上版本
<dubbo:protocol>	iothreads	threads	int	可选	cpu个数+1	性能调优	io线程池大小(固定大小)	2.0.5以上版本
<dubbo:protocol>	accepts	accepts	int	可选	0	性能调优	服务提供方最大可接受连接数	2.0.5以上版本
<dubbo:protocol>	payload	payload	int	可选	88388608(=8M)	性能调优	请求及响应数据包大小限制，单位：字节	2.0.5以上版本
<dubbo:protocol>	codec	codec	string	可选	dubbo	性能调优	协议编码方式	2.0.5以上版本
<dubbo:protocol>	serialization	serialization	string	可选	dubbo协议缺省为hessian2，rmi协议缺省为java，http协议缺省为json	性能调优	协议序列化方式，当协议支持多种序列化方式时使用，比如：dubbo协议的dubbo,hessian2,java,compactedjava，以及http协议的json等	2.0.5以上版本
<dubbo:protocol>	accesslog	accesslog	string/boolean	可选		服务治理	设为true，将向logger中输出访问日志，也可填写访问日志文件路径，直接把访问日志输出到指定文件	2.0.5以上版本
<dubbo:protocol>	path	<path>	string	可选		服务发现	提供者上下文路径，为服务path的前缀	2.0.5以上版本
<dubbo:protocol>	transporter	transporter	string	可选	dubbo协议缺省为netty	性能调优	协议的服务端和客户端实现类型，比如：dubbo协议的mina,netty等，可以分拆为server和client配置	2.0.5以上版本
<dubbo:protocol>	server	server	string	可选	dubbo协议缺省为netty，http协议缺省为servlet	性能调优	协议的服务器端实现类型，比如：dubbo协议的mina,netty等，http协议的jetty,servlet等	2.0.5以上版本
<dubbo:protocol>	client	client	string	可选	dubbo协议缺省为netty	性能调优	协议的客户端实现类型，比如：dubbo协议的mina,netty等	2.0.5以上版本
<dubbo:protocol>	dispatcher	dispatcher	string	可选	dubbo协议缺省为all	性能调优	协议的消息派发方式，用于指定线程模型，比如：dubbo协议的all, direct, message, execution, connection等	2.1.0以上版本
<dubbo:protocol>	queues	queues	int	可选	0	性能调优	线程池队列大小，当线程池满时，排队等待执行的队列大小，建议不要设置，当线程程池时应立即失败，重试其它服务提供机器，而不是排队，除非有特殊需求。	2.0.5以上版本
<dubbo:protocol>	charset	charset	string	可选	UTF-8	性能调优	序列化编码	2.0.5以上版本
<dubbo:protocol>	buffer	buffer	int	可选	8192	性能调优	网络读写缓冲区大小	2.0.5以上版本
<dubbo:protocol>	heartbeat	heartbeat	int	可选	0	性能调优	心跳间隔，对于长连接，当物理层断开时，比如拔网线，TCP的FIN消息来不及发送，对方收不到断开事件，此时需要心跳来帮助检查连接是否已断开	2.0.10以上版本
<dubbo:protocol>	telnet	telnet	string	可选		服务治理	所支持的telnet命令，多个命令用逗号分隔	2.0.5以上版本
<dubbo:protocol>	register	register	boolean	可选	true	服务治理	该协议的服务是否注册到注册中心	2.0.8以上版本
<dubbo:protocol>	contextpath	contextpath	String	可选	缺省为空串	服务治理		2.0.6以上版本

<dubbo:registry/>

(+) (#)

注册中心配置：
配置类：com.alibaba.dubbo.config.RegistryConfig
说明：如果有多个不同的注册中心，可以声明多个<dubbo:registry>标签，并在<dubbo:service>或<dubbo:reference>的registry属性指定使用的注册中心。

标签	属性	对应URL参数	类型	是否必填	缺省值	作用	描述	兼容性
<dubbo:registry>	id		string	可选		配置关联	注册中心引用BeanId，可以在<dubbo:service registry="">或<dubbo:reference registry="">中引用此ID	1.0.16以上版本
<dubbo:registry>	address	<host:port>	string	必填		服务发现	注册中心服务器地址，如果地址没有端口缺省为9090，同一集群内的多个地址用逗号分隔，如：ip:port,ip:port，不同集群的注册中心，请配置多个<dubbo:registry>标签	1.0.16以上版本
<dubbo:registry>	protocol	<protocol>	string	可选	dubbo	服务发现	注同中心地址协议，支持dubbo, http, local三种协议，分别表示，dubbo地址，http地址，本地注册中心	2.0.0以上版本
<dubbo:registry>	port	<port>	int	可选	9090	服务发现	注册中心缺省端口，当address没有带端口时使用此端口做为缺省值	2.0.0以上版本
<dubbo:registry>	username	<username>	string	可选		服务治理	登录注册中心用户名，如果注册中心不需要验证可不填	2.0.0以上版本
<dubbo:registry>	password	<password>	string	可选		服务治理	登录注册中心密码，如果注册中心不需要验证可不填	2.0.0以上版本
<dubbo:registry>	transport	registry.transporter	string	可选	netty	性能调优	网络传输方式，可选mina,netty	2.0.0以上版本
<dubbo:registry>	timeout	registry.timeout	int	可选	5000	性能调优	注册中心请求超时时间(毫秒)	2.0.0以上版本
<dubbo:registry>	session	registry.session	int	可选	60000	性能调优	注册中心会话超时时间(毫秒)，用于检测提供者非正常断线后的脏数据，比如用心跳检测的实现，此时间就是心跳间隔，不同注册中心实现不一样。	2.1.0以上版本
<dubbo:registry>	file	registry.file	string	可选		服务治理	使用文件缓存注册中心地址列表及服务提供者列表，应用重启时将基于此文件恢复，注意：两个注册中心不能使用同一文件存储	2.0.0以上版本
<dubbo:registry>	wait	registry.wait	int	可选	0	性能调优	停止时等待通知完成时间(毫秒)	2.0.0以上版本
<dubbo:registry>	check	check	boolean	可选	true	服务治理	注册中心不存在时，是否报错	2.0.0以上版本
<dubbo:registry>	register	register	boolean	可选	true	服务治理	是否向此注册中心注册服务，如果设为false，将只订阅，不注册	2.0.5以上版本
<dubbo:registry>	subscribe	subscribe	boolean	可选	true	服务治理	是否向此注册中心订阅服务，如果设为false，将只注册，不订阅	2.0.5以上版本
<dubbo:registry>	dynamic	dynamic	boolean	可选	true	服务治理	服务是否动态注册，如果设为false，注册后将显示后disable状态，需人工启用，并且服务提供者停止时，也不会自动取消册，需人工禁用。	2.0.5以上版本

<dubbo:monitor/>

(+) (#)

监控中心配置：
配置类：com.alibaba.dubbo.config.MonitorConfig

标签	属性	对应URL参数	类型	是否必填	缺省值	作用	描述	兼容性
<dubbo:monitor>	protocol	protocol	string	可选	dubbo	服务治理	监控中心协议，如果为protocol="registry"，表示从注册中心发现监控中心地址，否则直连监控中心。	2.0.9以上版本
<dubbo:monitor>	address	<url>	string	可选	N/A	服务治理	直连监控中心服务器地址，address="10.20.130.230:12080"	1.0.16以上版本

<dubbo:application/>

(+) (#)

应用信息配置：
配置类：com.alibaba.dubbo.config.ApplicationConfig

标签	属性	对应URL参数	类型	是否必填	缺省值	作用	描述	兼容性
<dubbo:application>	name	application	string	必填		服务治理	当前应用名称，用于注册中心计算应用间依赖关系，注意：消费者和提供者应用名不要一样，此参数不是匹配条件，你当前项目叫什么名字就填什么，和提供者消费者角色无关，比如：kylin应用调用了morgan应用的服务，则kylin项目配成kylin，morgan项目配成morgan，可能kylin也提供其它服务给别人使用，但kylin项目永远配成kylin，这样注册中心将显示kylin依赖于morgan	1.0.16以上版本
<dubbo:application>	version	application.version	string	可选		服务治理	当前应用的版本	2.2.0以上版本
<dubbo:application>	owner	owner	string	可选		服务治理	应用负责人，用于服务治理，请填写负责人公司邮箱前缀	2.0.5以上版本
<dubbo:application>	organization	organization	string	可选		服务治理	组织名称(BU或部门)，用于注册中心区分服务来源，此配置项建议不要使用autoconfig，直接写死在配置中，比如china,intl,itu,crm,asc,dw,aliexpress等	2.0.0以上版本
<dubbo:application>	architecture	architecture	string	可选		服务治理	用于服务分层对应的架构。如，intl、china。不同的架构使用不同的分层。	2.0.7以上版本
<dubbo:application>	environment	environment	string	可选		服务治理	应用环境，如：develop/test/product，不同环境使用不同的缺省值，以及作为只用于开发测试功能的限制条件	2.0.0以上版本
<dubbo:application>	compiler	compiler	string	可选	javassist	性能优化	Java字节码编译器，用于动态类的生成，可选：jdk或javassist	2.1.0以上版本
<dubbo:application>	logger	logger	string	可选	slf4j	性能优化	日志输出方式，可选：slf4j,jcl,log4j,jdk	2.2.0以上版本

<dubbo:module/>

(+) (#)

模块信息配置：
配置类：com.alibaba.dubbo.config.ModuleConfig

标签	属性	对应URL参数	类型	是否必填	作用	描述	兼容性
<dubbo:module>	name	module	string	必填	服务治理	当前模块名称，用于注册中心计算模块间依赖关系	2.2.0以上版本
<dubbo:module>	version	module.version	string	可选	服务治理	当前模块的版本	2.2.0以上版本
<dubbo:module>	owner	owner	string	可选	服务治理	模块负责人，用于服务治理，请填写负责人公司邮箱前缀	2.2.0以上版本
<dubbo:module>	organization	organization	string	可选	服务治理	组织名称(BU或部门)，用于注册中心区分服务来源，此配置项建议不要使用autoconfig，直接写死在配置中，比如china,intl,itu,crm,asc,dw,aliexpress等	2.2.0以上版本

<dubbo:provider/>

(+) (#)

服务提供者缺省值配置：
配置类：com.alibaba.dubbo.config.ProviderConfig
说明：该标签为<dubbo:service>和<dubbo:protocol>标签的缺省值设置。

标签	属性	对应URL参数	类型	是否必填	缺省值	作用	描述	兼容性
<dubbo:provider>	id		string	可选	dubbo	配置关联	协议BeanId，可以在<dubbo:service proivder="">中引用此ID	1.0.16以上版本
<dubbo:provider>	protocol	<protocol>	string	可选	dubbo	性能调优	协议名称	1.0.16以上版本
<dubbo:provider>	host	<host>	string	可选	自动查找本机IP	服务发现	服务主机名，多网卡选择或指定VIP及域名时使用，为空则自动查找本机IP，建议不要配置，让Dubbo自动获取本机IP	1.0.16以上版本
<dubbo:provider>	threads	threads	int	可选	100	性能调优	服务线程池大小(固定大小)	1.0.16以上版本
<dubbo:provider>	payload	payload	int	可选	88388608(=8M)	性能调优	请求及响应数据包大小限制，单位：字节	2.0.0以上版本
<dubbo:provider>	path	<path>	string	可选		服务发现	提供者上下文路径，为服务path的前缀	2.0.0以上版本
<dubbo:provider>	server	server	string	可选	dubbo协议缺省为netty，http协议缺省为servlet	性能调优	协议的服务器端实现类型，比如：dubbo协议的mina,netty等，http协议的jetty,servlet等	2.0.0以上版本
<dubbo:provider>	client	client	string	可选	dubbo协议缺省为netty	性能调优	协议的客户端实现类型，比如：dubbo协议的mina,netty等	2.0.0以上版本
<dubbo:provider>	codec	codec	string	可选	dubbo	性能调优	协议编码方式	2.0.0以上版本
<dubbo:provider>	serialization	serialization	string	可选	dubbo协议缺省为hessian2，rmi协议缺省为java，http协议缺省为json	性能调优	协议序列化方式，当协议支持多种序列化方式时使用，比如：dubbo协议的dubbo,hessian2,java,compactedjava，以及http协议的json,xml等	2.0.5以上版本
<dubbo:provider>	default		boolean	可选	false	配置关联	是否为缺省协议，用于多协议	1.0.16以上版本
<dubbo:provider>	filter	service.filter	string	可选		性能调优	服务提供方远程调用过程拦截器名称，多个名称用逗号分隔	2.0.5以上版本
<dubbo:provider>	listener	exporter.listener	string	可选		性能调优	服务提供方导出服务监听器名称，多个名称用逗号分隔	2.0.5以上版本
<dubbo:provider>	threadpool	threadpool	string	可选	fixed	性能调优	线程池类型，可选：fixed/cached	2.0.5以上版本
<dubbo:provider>	accepts	accepts	int	可选	0	性能调优	服务提供者最大可接受连接数	2.0.5以上版本
<dubbo:provider>	version	version	string	可选	0.0.0	服务发现	服务版本，建议使用两位数字版本，如：1.0，通常在接口不兼容时版本号才需要升级	2.0.5以上版本
<dubbo:provider>	group	group	string	可选		服务发现	服务分组，当一个接口有多个实现，可以用分组区分	2.0.5以上版本
<dubbo:provider>	delay	delay	int	可选	0	性能调优	延迟注册服务时间(毫秒)- ，设为-1时，表示延迟到Spring容器初始化完成时暴露服务	2.0.5以上版本
<dubbo:provider>	timeout	default.timeout	int	可选	1000	性能调优	远程服务调用超时时间(毫秒)	2.0.5以上版本
<dubbo:provider>	retries	default.retries	int	可选	2	性能调优	远程服务调用重试次数，不包括第一次调用，不需要重试请设为0	2.0.5以上版本
<dubbo:provider>	connections	default.connections	int	可选	0	性能调优	对每个提供者的最大连接数，rmi、http、hessian等短连接协议表示限制连接数，dubbo等长连接协表示建立的长连接个数	2.0.5以上版本
<dubbo:provider>	loadbalance	default.loadbalance	string	可选	random	性能调优	负载均衡策略，可选值：random,roundrobin,leastactive，分别表示：随机，轮循，最少活跃调用	2.0.5以上版本
<dubbo:provider>	async	default.async	boolean	可选	false	性能调优	是否缺省异步执行，不可靠异步，只是忽略返回值，不阻塞执行线程	2.0.5以上版本
<dubbo:provider>	stub	stub	boolean	可选	false	服务治理	设为true，表示使用缺省代理类名，即：接口名 + Local后缀。	2.0.5以上版本
<dubbo:provider>	mock	mock	boolean	可选	false	服务治理	设为true，表示使用缺省Mock类名，即：接口名 + Mock后缀。	2.0.5以上版本
<dubbo:provider>	token	token	boolean	可选	false	服务治理	令牌验证，为空表示不开启，如果为true，表示随机生成动态令牌	2.0.5以上版本
<dubbo:provider>	registry	registry	string	可选	缺省向所有registry注册	配置关联	向指定注册中心注册，在多个注册中心时使用，值为<dubbo:registry>的id属性，多个注册中心ID用逗号分隔，如果不想将该服务注册到任何registry，可将值设为N/A	2.0.5以上版本
<dubbo:provider>	dynamic	dynamic	boolean	可选	true	服务治理	服务是否动态注册，如果设为false，注册后将显示后disable状态，需人工启用，并且服务提供者停止时，也不会自动取消册，需人工禁用。	2.0.5以上版本
<dubbo:provider>	accesslog	accesslog	string/boolean	可选	false	服务治理	设为true，将向logger中输出访问日志，也可填写访问日志文件路径，直接把访问日志输出到指定文件	2.0.5以上版本
<dubbo:provider>	owner	owner	string	可选		服务治理	服务负责人，用于服务治理，请填写负责人公司邮箱前缀	2.0.5以上版本
<dubbo:provider>	document	document	string	可选		服务治理	服务文档URL	2.0.5以上版本
<dubbo:provider>	weight	weight	int	可选		性能调优	服务权重	2.0.5以上版本
<dubbo:provider>	executes	executes	int	可选	0	性能调优	服务提供者每服务每方法最大可并行执行请求数	2.0.5以上版本
<dubbo:provider>	actives	default.actives	int	可选	0	性能调优	每服务消费者每服务每方法最大并发调用数	2.0.5以上版本
<dubbo:provider>	proxy	proxy	string	可选	javassist	性能调优	生成动态代理方式，可选：jdk/javassist	2.0.5以上版本
<dubbo:provider>	cluster	default.cluster	string	可选	failover	性能调优	集群方式，可选：failover/failfast/failsafe/failback/forking	2.0.5以上版本
<dubbo:provider>	deprecated	deprecated	boolean	可选	false	服务治理	服务是否过时，如果设为true，消费方引用时将打印服务过时警告error日志	2.0.5以上版本
<dubbo:provider>	queues	queues	int	可选	0	性能调优	线程池队列大小，当线程池满时，排队等待执行的队列大小，建议不要设置，当线程程池时应立即失败，重试其它服务提供机器，而不是排队，除非有特殊需求。	2.0.5以上版本
<dubbo:provider>	charset	charset	string	可选	UTF-8	性能调优	序列化编码	2.0.5以上版本
<dubbo:provider>	buffer	buffer	int	可选	8192	性能调优	网络读写缓冲区大小	2.0.5以上版本
<dubbo:provider>	iothreads	iothreads	int	可选	CPU + 1	性能调优	IO线程池，接收网络读写中断，以及序列化和反序列化，不处理业务，业务线程池参见threads配置，此线程池和CPU相关，不建议配置。	2.0.5以上版本
<dubbo:provider>	telnet	telnet	string	可选		服务治理	所支持的telnet命令，多个命令用逗号分隔	2.0.5以上版本
<dubbo:service>	contextpath	contextpath	String	可选	缺省为空串	服务治理		2.0.6以上版本
<dubbo:provider>	layer	layer	string	可选		服务治理	服务提供者所在的分层。如：biz、dao、intl:web、china:acton。	2.0.7以上版本

<dubbo:consumer/>

(+) (#)

服务消费者缺省值配置：
配置类：com.alibaba.dubbo.config.ConsumerConfig
说明：该标签为<dubbo:reference>标签的缺省值设置。

标签	属性	对应URL参数	类型	是否必填	缺省值	作用	描述	兼容性
<dubbo:consumer>	timeout	default.timeout	int	可选	1000	性能调优	远程服务调用超时时间(毫秒)	1.0.16以上版本
<dubbo:consumer>	retries	default.retries	int	可选	2	性能调优	远程服务调用重试次数，不包括第一次调用，不需要重试请设为0	1.0.16以上版本
<dubbo:consumer>	loadbalance	default.loadbalance	string	可选	random	性能调优	负载均衡策略，可选值：random,roundrobin,leastactive，分别表示：随机，轮循，最少活跃调用	1.0.16以上版本
<dubbo:consumer>	async	default.async	boolean	可选	false	性能调优	是否缺省异步执行，不可靠异步，只是忽略返回值，不阻塞执行线程	2.0.0以上版本
<dubbo:consumer>	connections	default.connections	int	可选	100	性能调优	每个服务对每个提供者的最大连接数，rmi、http、hessian等短连接协议支持此配置，dubbo协议长连接不支持此配置	1.0.16以上版本
<dubbo:consumer>	generic	generic	boolean	可选	false	服务治理	是否缺省泛化接口，如果为泛化接口，将返回GenericService	2.0.0以上版本
<dubbo:consumer>	check	check	boolean	可选	true	服务治理	启动时检查提供者是否存在，true报错，false忽略	1.0.16以上版本
<dubbo:consumer>	proxy	proxy	string	可选	javassist	性能调优	生成动态代理方式，可选：jdk/javassist	2.0.5以上版本
<dubbo:consumer>	owner	owner	string	可选		服务治理	调用服务负责人，用于服务治理，请填写负责人公司邮箱前缀	2.0.5以上版本
<dubbo:consumer>	actives	default.actives	int	可选	0	性能调优	每服务消费者每服务每方法最大并发调用数	2.0.5以上版本
<dubbo:consumer>	cluster	default.cluster	string	可选	failover	性能调优	集群方式，可选：failover/failfast/failsafe/failback/forking	2.0.5以上版本
<dubbo:consumer>	filter	reference.filter	string	可选		性能调优	服务消费方远程调用过程拦截器名称，多个名称用逗号分隔	2.0.5以上版本
<dubbo:consumer>	listener	invoker.listener	string	可选		性能调优	服务消费方引用服务监听器名称，多个名称用逗号分隔	2.0.5以上版本
<dubbo:consumer>	registry		string	可选	缺省向所有registry注册	配置关联	向指定注册中心注册，在多个注册中心时使用，值为<dubbo:registry>的id属性，多个注册中心ID用逗号分隔，如果不想将该服务注册到任何registry，可将值设为N/A	2.0.5以上版本
<dubbo:consumer>	layer	layer	string	可选		服务治理	服务调用者所在的分层。如：biz、dao、intl:web、china:acton。	2.0.7以上版本
<dubbo:consumer>	init	init	boolean	可选	false	性能调优	是否在afterPropertiesSet()时饥饿初始化引用，否则等到有人注入或引用该实例时再初始化。	2.0.10以上版本
<dubbo:consumer>	cache	cache	string/boolean	可选		服务治理	以调用参数为key，缓存返回结果，可选：lru, threadlocal, jcache等	Dubbo2.1.0及其以上版本支持
<dubbo:consumer>	validation	validation	boolean	可选		服务治理	是否启用JSR303标准注解验证，如果启用，将对方法参数上的注解进行校验	Dubbo2.1.0及其以上版本支持

<dubbo:method/>

(+) (#)

方法级配置：
配置类：com.alibaba.dubbo.config.MethodConfig
说明：该标签为<dubbo:service>或<dubbo:reference>的子标签，用于控制到方法级，

标签	属性	对应URL参数	类型	是否必填	缺省值	作用	描述	兼容性
<dubbo:method>	name		string	必填		标识	方法名	1.0.8以上版本
<dubbo:method>	timeout	<metodName>.timeout	int	可选	缺省为的timeout	性能调优	方法调用超时时间(毫秒)	1.0.8以上版本
<dubbo:method>	retries	<metodName>.retries	int	可选	缺省为<dubbo:reference>的retries	性能调优	远程服务调用重试次数，不包括第一次调用，不需要重试请设为0	2.0.0以上版本
<dubbo:method>	loadbalance	<metodName>.loadbalance	string	可选	缺省为的loadbalance	性能调优	负载均衡策略，可选值：random,roundrobin,leastactive，分别表示：随机，轮循，最少活跃调用	2.0.0以上版本
<dubbo:method>	async	<metodName>.async	boolean	可选	缺省为<dubbo:reference>的async	性能调优	是否异步执行，不可靠异步，只是忽略返回值，不阻塞执行线程	1.0.9以上版本
<dubbo:method>	sent	<methodName>.sent	boolean	可选	true	性能调优	异步调用时，标记sent=true时，表示网络已发出数据	2.0.6以上版本
<dubbo:method>	actives	<metodName>.actives	int	可选	0	性能调优	每服务消费者最大并发调用限制	2.0.5以上版本
<dubbo:method>	executes	<metodName>.executes	int	可选	0	性能调优	每服务每方法最大使用线程数限制- -，此属性只在<dubbo:method>作为<dubbo:service>子标签时有效	2.0.5以上版本
<dubbo:method>	deprecated	<methodName>.deprecated	boolean	可选	false	服务治理	服务方法是否过时，此属性只在<dubbo:method>作为<dubbo:service>子标签时有效	2.0.5以上版本
<dubbo:method>	sticky	<methodName>.sticky	boolean	可选	false	服务治理	设置true 该接口上的所有方法使用同一个provider.如果需要更复杂的规则，请使用用路由	2.0.6以上版本
<dubbo:method>	return	<methodName>.return	boolean	可选	true	性能调优	方法调用是否需要返回值,async设置为true时才生效，如果设置为true，则返回future，或回调onreturn等方法，如果设置为false，则请求发送成功后直接返回Null	2.0.6以上版本
<dubbo:method>	oninvoke	attribute属性，不在URL中体现	String	可选		性能调优	方法执行前拦截	2.0.6以上版本
<dubbo:method>	onreturn	attribute属性，不在URL中体现	String	可选		性能调优	方法执行返回后拦截	2.0.6以上版本
<dubbo:method>	onthrow	attribute属性，不在URL中体现	String	可选		性能调优	方法执行有异常拦截	2.0.6以上版本
<dubbo:method>	cache	<methodName>.cache	string/boolean	可选		服务治理	以调用参数为key，缓存返回结果，可选：lru, threadlocal, jcache等	Dubbo2.1.0及其以上版本支持
<dubbo:method>	validation	<methodName>.validation	boolean	可选		服务治理	是否启用JSR303标准注解验证，如果启用，将对方法参数上的注解进行校验	Dubbo2.1.0及其以上版本支持

比如：

           <dubbo:referenceinterface="com.xxx.XxxService"> 
         
               <dubbo:methodname="findXxx"timeout="3000"retries="2"/> 
         
           </dubbo:reference>

<dubbo:argument/>

(+) (#)

方法参数配置：
配置类：com.alibaba.dubbo.config.ArgumentConfig
说明：该标签为<dubbo:method>的子标签，用于方法参数的特征描述，比如：

           <dubbo:methodname="findXxx"timeout="3000"retries="2"> 
         
               <dubbo:argumentindex="0"callback="true"/> 
         
           <dubbo:method>

标签	属性	对应URL参数	类型	是否必填	作用	描述	兼容性
<dubbo:argument>	index		int	必填	标识	方法名	2.0.6以上版本
<dubbo:argument>	type		String	与index二选一	标识	通过参数类型查找参数的index	2.0.6以上版本
<dubbo:argument>	callback	<metodName><index>.retries	boolean	可选	服务治理	参数是否为callback接口，如果为callback，服务提供方将生成反向代理，可以从服务提供方反向调用消费方，通常用于事件推送.	2.0.6以上版本

<dubbo:parameter/>

(+) (#)

选项参数配置：
配置类：java.util.Map
说明：该标签为<dubbo:protocol>或<dubbo:service>或<dubbo:provider>或<dubbo:reference>或<dubbo:consumer>的子标签，用于配置自定义参数，该配置项将作为扩展点设置自定义参数使用。

标签	属性	对应URL参数	类型	是否必填	缺省值	作用	描述	兼容性
<dubbo:parameter>	key	key	string	必填		服务治理	路由参数键	2.0.0以上版本
<dubbo:parameter>	value	value	string	必填		服务治理	路由参数值	2.0.0以上版本

比如：

           <dubbo:protocolname="napoli"> 
         
               <dubbo:parameterkey=" 
          http://10.20.160.198/wiki/display/dubbo/napoli.queue.name"value="xxx"/> 
         
           </dubbo:protocol>

也可以：

           <dubbo:protocolname="jms"p:queue="xxx"/> 
         

详细参见：自定义参数

协议参考手册

(+) (#)

推荐使用Dubbo协议

性能测试报告
各协议的性能情况，请参见：性能测试报告 (+)

dubbo://

(+) (#)

Dubbo缺省协议采用单一长连接和NIO异步通讯，适合于小数据量大并发的服务调用，以及服务消费者机器数远大于服务提供者机器数的情况。

Dubbo缺省协议不适合传送大数据量的服务，比如传文件，传视频等，除非请求量很低。

           <dubbo:protocolname="dubbo"port="20880"/> 
         

Set default protocol:

           <dubbo:providerprotocol="dubbo"/> 
         

Set service protocol:

           <dubbo:serviceprotocol="dubbo"/> 
         

Multi port:

           <dubbo:protocolid="dubbo1"name="dubbo"port="20880"/> 
         
           <dubbo:protocolid="dubbo2"name="dubbo"port="20881"/>

Dubbo protocol options:

           <dubbo:protocolname=“dubbo” port=“9090” server=“netty” client=“netty” codec=“dubbo” serialization=“hessian2” charset=“UTF-8” threadpool=“fixed” threads=“100” queues=“0” iothreads=“9” buffer=“8192” accepts=“1000” payload=“8388608” /> 
         

Transporter
- mina, netty, grizzy
Serialization
- dubbo, hessian2, java, json
Dispatcher
- all, direct, message, execution, connection
ThreadPool
- fixed, cached

Dubbo协议缺省每服务每提供者每消费者使用单一长连接，如果数据量较大，可以使用多个连接。

           <dubbo:protocolname="dubbo"connections="2"/> 
         

<dubbo:service connections=”0”>或<dubbo:reference connections=”0”>表示该服务使用JVM共享长连接。(缺省)
<dubbo:service connections=”1”>或<dubbo:reference connections=”1”>表示该服务使用独立长连接。
<dubbo:service connections=”2”>或<dubbo:reference connections=”2”>表示该服务使用独立两条长连接。

为防止被大量连接撑挂，可在服务提供方限制大接收连接数，以实现服务提供方自我保护。

           <dubbo:protocolname="dubbo"accepts="1000"/> 
         

缺省协议，使用基于mina1.1.7+hessian3.2.1的tbremoting交互。

连接个数：单连接
连接方式：长连接
传输协议：TCP
传输方式：NIO异步传输
序列化：Hessian二进制序列化
适用范围：传入传出参数数据包较小（建议小于100K），消费者比提供者个数多，单一消费者无法压满提供者，尽量不要用dubbo协议传输大文件或超大字符串。
适用场景：常规远程服务方法调用

为什么要消费者比提供者个数多：
因dubbo协议采用单一长连接，
假设网络为千兆网卡(1024Mbit=128MByte)，
根据测试经验数据每条连接最多只能压满7MByte(不同的环境可能不一样，供参考)，
理论上1个服务提供者需要20个服务消费者才能压满网卡。

为什么不能传大包：
因dubbo协议采用单一长连接，
如果每次请求的数据包大小为500KByte，假设网络为千兆网卡(1024Mbit=128MByte)，每条连接最大7MByte(不同的环境可能不一样，供参考)，
单个服务提供者的TPS(每秒处理事务数)最大为：128MByte / 500KByte = 262。
单个消费者调用单个服务提供者的TPS(每秒处理事务数)最大为：7MByte / 500KByte = 14。
如果能接受，可以考虑使用，否则网络将成为瓶颈。

为什么采用异步单一长连接：
因为服务的现状大都是服务提供者少，通常只有几台机器，
而服务的消费者多，可能整个网站都在访问该服务，
比如Morgan的提供者只有6台提供者，却有上百台消费者，每天有1.5亿次调用，
如果采用常规的hessian服务，服务提供者很容易就被压跨，
通过单一连接，保证单一消费者不会压死提供者，
长连接，减少连接握手验证等，
并使用异步IO，复用线程池，防止C10K问题。

(1) 约束：

参数及返回值需实现Serializable接口
参数及返回值不能自定义实现List, Map, Number, Date, Calendar等接口，只能用JDK自带的实现，因为hessian会做特殊处理，自定义实现类中的属性值都会丢失。()

Hessian序列化，只传成员属性值和值的类型，不传方法或静态变量，兼容情况：(由吴亚军提供)

数据通讯	情况	结果
A->B	类A多一种属性（或者说类B少一种属性）	不抛异常，A多的那个属性的值，B没有，其他正常
A->B	枚举A多一种枚举（或者说B少一种枚举），A使用多出来的枚举进行传输	抛异常
A->B	枚举A多一种枚举（或者说B少一种枚举），A不使用多出来的枚举进行传输	不抛异常，B正常接收数据
A->B	A和B的属性名相同，但类型不相同	抛异常
A->B	serialId 不相同	正常传输

总结：会抛异常的情况：枚举值一边多一种，一边少一种，正好使用了差别的那种，或者属性名相同，类型不同

接口增加方法，对客户端无影响，如果该方法不是客户端需要的，客户端不需要重新部署；
输入参数和结果集中增加属性，对客户端无影响，如果客户端并不需要新属性，不用重新
部署；
输入参数和结果集属性名变化，对客户端序列化无影响，但是如果客户端不重新部署，不管输入还是输出，属性名变化的属性值是获取不到的。
总结：服务器端和客户端对领域对象并不需要完全一致，而是按照最大匹配原则。

(2) 配置：
dubbo.properties：

           dubbo.service.protocol=dubbo 
         

rmi://

(+) (#)

RMI协议采用JDK标准的java.rmi.*实现，采用阻塞式短连接和JDK标准序列化方式。

如果服务接口继承了java.rmi.Remote接口，可以和原生RMI互操作，即：
- 提供者用Dubbo的RMI协议暴露服务，消费者直接用标准RMI接口调用，
- 或者提供方用标准RMI暴露服务，消费方用Dubbo的RMI协议调用。
如果服务接口没有继承java.rmi.Remote接口，
- 缺省Dubbo将自动生成一个com.xxx.XxxService$Remote的接口，并继承java.rmi.Remote接口，并以此接口暴露服务，
- 但如果设置了<dubbo:protocol name="rmi" codec="spring" />，将不生成$Remote接口，而使用Spring的RmiInvocationHandler接口暴露服务，和Spring兼容。

Define rmi protocol:

           <dubbo:protocolname="rmi"port="1099"/> 
         

Set default protocol:

           <dubbo:providerprotocol="rmi"/> 
         

Set service protocol:

           <dubbo:serviceprotocol="rmi"/> 
         

Multi port:

           <dubbo:protocolid="rmi1"name="rmi"port="1099"/> 
         
           <dubbo:protocolid="rmi2"name="rmi"port="2099"/> 
         
           <dubbo:serviceprotocol="rmi1"/>

Spring compatible:

           <dubbo:protocolname="rmi"codec="spring"/> 
         

Java标准的远程调用协议。

连接个数：多连接
连接方式：短连接
传输协议：TCP
传输方式：同步传输
序列化：Java标准二进制序列化
适用范围：传入传出参数数据包大小混合，消费者与提供者个数差不多，可传文件。
适用场景：常规远程服务方法调用，与原生RMI服务互操作

(1) 约束：

参数及返回值需实现Serializable接口
dubbo配置中的超时时间对rmi无效，需使用java启动参数设置：-Dsun.rmi.transport.tcp.responseTimeout=3000，参见下面的RMI配置。

(2) 配置：
dubbo.properties：

           dubbo.service.protocol=rmi 
         

(3) RMI配置：

           java -Dsun.rmi.transport.tcp.responseTimeout=3000 
         

hessian://

(+) (#)

Hessian协议用于集成Hessian的服务，Hessian底层采用Http通讯，采用Servlet暴露服务，Dubbo缺省内嵌Jetty作为服务器实现。

Hessian是Caucho开源的一个RPC框架：http://hessian.caucho.com，其通讯效率高于WebService和Java自带的序列化。

依赖：

           <dependency> 
         
               <groupId>com.caucho</groupId> 
         
               <artifactId>hessian</artifactId> 
         
               <version>4.0.7</version> 
         
           </dependency>

可以和原生Hessian服务互操作，即：

提供者用Dubbo的Hessian协议暴露服务，消费者直接用标准Hessian接口调用，
或者提供方用标准Hessian暴露服务，消费方用Dubbo的Hessian协议调用。

基于Hessian的远程调用协议。

连接个数：多连接
连接方式：短连接
传输协议：HTTP
传输方式：同步传输
序列化：Hessian二进制序列化
适用范围：传入传出参数数据包较大，提供者比消费者个数多，提供者压力较大，可传文件。
适用场景：页面传输，文件传输，或与原生hessian服务互操作

(1) 约束：

参数及返回值需实现Serializable接口
参数及返回值不能自定义实现List, Map, Number, Date, Calendar等接口，只能用JDK自带的实现，因为hessian会做特殊处理，自定义实现类中的属性值都会丢失。

(2) 配置：
Define hessian protocol:

           <dubbo:protocolname="hessian"port="8080"server="jetty"/> 
         

Set default protocol:

           <dubbo:providerprotocol="hessian"/> 
         

Set service protocol:

           <dubbo:serviceprotocol="hessian"/> 
         

Multi port:

           <dubbo:protocolid="hessian1"name="hessian"port="8080"/> 
         
           <dubbo:protocolid="hessian2"name="hessian"port="8081"/>

Directly provider:

           <dubbo:referenceid="helloService"interface="HelloWorld"url="hessian://10.20.153.10:8080/helloWorld"/> 
         

h4. Jetty Server: (default)

           <dubbo:protocol...server="jetty"/> 
         

h4. Servlet Bridge Server: (recommend)

           <dubbo:protocol...server="servlet"/> 
         

web.xml：

           <servlet> 
         
                    <servlet-name>dubbo</servlet-name> 
         
                    <servlet-class>com.alibaba.dubbo.remoting.http.servlet.DispatcherServlet</servlet-class> 
         
                    <load-on-startup>1</load-on-startup> 
         
           </servlet> 
         
           <servlet-mapping> 
         
                    <servlet-name>dubbo</servlet-name> 
         
                    <url-pattern>/*</url-pattern> 
         
           </servlet-mapping>

注意，如果使用servlet派发请求：

协议的端口<dubbo:protocol port="8080" />必须与servlet容器的端口相同，
协议的上下文路径<dubbo:protocol contextpath="foo" />必须与servlet应用的上下文路径相同。

http://

(+) (#)

采用Spring的HttpInvoker实现

2.3.0以上版本支持

基于http表单的远程调用协议。参见：[HTTP协议使用说明]

连接个数：多连接
连接方式：短连接
传输协议：HTTP
传输方式：同步传输
序列化：表单序列化
适用范围：传入传出参数数据包大小混合，提供者比消费者个数多，可用浏览器查看，可用表单或URL传入参数，暂不支持传文件。
适用场景：需同时给应用程序和浏览器JS使用的服务。

(1) 约束：

参数及返回值需符合Bean规范

(2) 配置：
dubbo.xml：

           <dubbo:protocol name="http"port="8080"/> 
         

h4. Jetty Server: (default)

           <dubbo:protocol...server="jetty"/> 
         

h4. Servlet Bridge Server: (recommend)

           <dubbo:protocol...server="servlet"/> 
         

web.xml：

           <servlet> 
         
                    <servlet-name>dubbo</servlet-name> 
         
                    <servlet-class>com.alibaba.dubbo.remoting.http.servlet.DispatcherServlet</servlet-class> 
         
                    <load-on-startup>1</load-on-startup> 
         
           </servlet> 
         
           <servlet-mapping> 
         
                    <servlet-name>dubbo</servlet-name> 
         
                    <url-pattern>/*</url-pattern> 
         
           </servlet-mapping>

注意，如果使用servlet派发请求：

协议的端口<dubbo:protocol port="8080" />必须与servlet容器的端口相同，
协议的上下文路径<dubbo:protocol contextpath="foo" />必须与servlet应用的上下文路径相同。

webservice://

(+) (#)

2.3.0以上版本支持。

基于CXF的frontend-simple和transports-http实现。

CXF是Apache开源的一个RPC框架：http://cxf.apache.org，由Xfire和Celtix合并而来。

依赖：

           <dependency> 
         
               <groupId>org.apache.cxf</groupId> 
         
               <artifactId>cxf-rt-frontend-simple</artifactId> 
         
               <version>2.6.1</version> 
         
           </dependency> 
         
           <dependency> 
         
               <groupId>org.apache.cxf</groupId> 
         
               <artifactId>cxf-rt-transports-http</artifactId> 
         
               <version>2.6.1</version> 
         
           </dependency>

可以和原生WebService服务互操作，即：

提供者用Dubbo的WebService协议暴露服务，消费者直接用标准WebService接口调用，
或者提供方用标准WebService暴露服务，消费方用Dubbo的WebService协议调用。

基于WebService的远程调用协议。

连接个数：多连接
连接方式：短连接
传输协议：HTTP
传输方式：同步传输
序列化：SOAP文本序列化
适用场景：系统集成，跨语言调用。

(1) 约束：

参数及返回值需实现Serializable接口
参数尽量使用基本类型和POJO。

(2) 配置：
Define hessian protocol:

           <dubbo:protocolname="webservice"port="8080"server="jetty"/> 
         

Set default protocol:

           <dubbo:providerprotocol="webservice"/> 
         

Set service protocol:

           <dubbo:serviceprotocol="webservice"/> 
         

Multi port:

           <dubbo:protocolid="webservice1"name="webservice"port="8080"/> 
         
           <dubbo:protocolid="webservice2"name="webservice"port="8081"/>

Directly provider:

           <dubbo:referenceid="helloService"interface="HelloWorld"url="webservice://10.20.153.10:8080/com.foo.HelloWorld"/> 
         

WSDL:

 
          http://10.20.153.10:8080/com.foo.HelloWorld?wsdl 
         

h4. Jetty Server: (default)

           <dubbo:protocol...server="jetty"/> 
         

h4. Servlet Bridge Server: (recommend)

           <dubbo:protocol...server="servlet"/> 
         

web.xml：

           <servlet> 
         
                    <servlet-name>dubbo</servlet-name> 
         
                    <servlet-class>com.alibaba.dubbo.remoting.http.servlet.DispatcherServlet</servlet-class> 
         
                    <load-on-startup>1</load-on-startup> 
         
           </servlet> 
         
           <servlet-mapping> 
         
                    <servlet-name>dubbo</servlet-name> 
         
                    <url-pattern>/*</url-pattern> 
         
           </servlet-mapping>

注意，如果使用servlet派发请求：

协议的端口<dubbo:protocol port="8080" />必须与servlet容器的端口相同，
协议的上下文路径<dubbo:protocol contextpath="foo" />必须与servlet应用的上下文路径相同。

thrift://

(+) (#)

2.3.0以上版本支持。

Thrift说明
Thrift是Facebook捐给Apache的一个RPC框架，参见：http://thrift.apache.org

dubbo thrift协议
当前 dubbo 支持的 thrift 协议是对 thrift 原生协议的扩展，在原生协议的基础上添加了一些额外的头信息，比如service name，magic number等。使用dubbo thrift协议同样需要使用thrift的idl compiler编译生成相应的java代码，后续版本中会在这方面做一些增强。

示例：https://github.com/alibaba/dubbo/tree/master/dubbo-rpc/dubbo-rpc-thrift/src/test/java/com/alibaba/dubbo/rpc/protocol/thrift/examples

依赖：

           <dependency> 
         
               <groupId>org.apache.thrift</groupId> 
         
               <artifactId>libthrift</artifactId> 
         
               <version>0.8.0</version> 
         
           </dependency>

所有服务共用一个端口：(与原生Thrift不兼容)

           <dubbo:protocol name="thrift"port="3030"/> 
         

Thrift不支持数据类型：

null值 (不能在协议中传递null值)

memcached://

(+) (#)

2.3.0以上版本支持。

Memcached说明
Memcached是一个高效的KV缓存服务器，参见：http://memcached.org/

可以通过脚本或监控中心手工填写表单注册memcached服务的地址：

           RegistryFactory registryFactory = ExtensionLoader.getExtensionLoader(RegistryFactory.class).getAdaptiveExtension(); 
         
           Registry registry = registryFactory.getRegistry(URL.valueOf("zookeeper://10.20.153.10:2181")); 
         
           registry.register(URL.valueOf("memcached://10.20.153.11/com.foo.BarService?category=providers&dynamic=false&application=foo&group=member&loadbalance=consistenthash"));

然后在客户端使用时，不需要感知Memcached的地址：

           <dubbo:referenceid="cache"interface=" 
          http://10.20.160.198/wiki/display/dubbo/java.util.Map"group="member"/> 
         

或者，点对点直连：

           <dubbo:referenceid="cache"interface=" 
          http://10.20.160.198/wiki/display/dubbo/java.util.Map"url="memcached://10.20.153.10:11211"/> 
         

也可以使用自定义接口：

           <dubbo:referenceid="cache"interface="com.foo.CacheService"url="memcached://10.20.153.10:11211"/> 
         

方法名建议和memcached的标准方法名相同，即：get(key), set(key, value), delete(key)。

如果方法名和memcached的标准方法名不相同，则需要配置映射关系：(其中"p:xxx"为spring的标准p标签)

           <dubbo:referenceid="cache"interface="com.foo.CacheService"url="memcached://10.20.153.10:11211"p:set="putFoo"p:get="getFoo"p:delete="removeFoo"/> 
         

redis://

(+) (#)

2.3.0以上版本支持。

Redis说明
Redis是一个高效的KV存储服务器，参见：http://redis.io

可以通过脚本或监控中心手工填写表单注册redis服务的地址：

           RegistryFactory registryFactory = ExtensionLoader.getExtensionLoader(RegistryFactory.class).getAdaptiveExtension(); 
         
           Registry registry = registryFactory.getRegistry(URL.valueOf("zookeeper://10.20.153.10:2181")); 
         
           registry.register(URL.valueOf("redis://10.20.153.11/com.foo.BarService?category=providers&dynamic=false&application=foo&group=member&loadbalance=consistenthash"));

然后在客户端使用时，不需要感知Redis的地址：

           <dubbo:referenceid="store"interface=" 
          http://10.20.160.198/wiki/display/dubbo/java.util.Map"group="member"/> 
         

或者，点对点直连：

           <dubbo:referenceid="store"interface=" 
          http://10.20.160.198/wiki/display/dubbo/java.util.Map"url="redis://10.20.153.10:6379"/> 
         

也可以使用自定义接口：

           <dubbo:referenceid="store"interface="com.foo.StoreService"url="redis://10.20.153.10:6379"/> 
         

方法名建议和redis的标准方法名相同，即：get(key), set(key, value), delete(key)。

如果方法名和redis的标准方法名不相同，则需要配置映射关系：(其中"p:xxx"为spring的标准p标签)

           <dubbo:referenceid="cache"interface="com.foo.CacheService"url="memcached://10.20.153.10:11211"p:set="putFoo"p:get="getFoo"p:delete="removeFoo"/> 
         

注册中心参考手册

(+) (#)

推荐使用Zookeeper注册中心

Multicast注册中心

(+) (#)

不需要启动任何中心节点，只要广播地址一样，就可以互相发现

组播受网络结构限制，只适合小规模应用或开发阶段使用。

组播地址段: 224.0.0.0 - 239.255.255.255

提供方启动时广播自己的地址。
消费方启动时广播订阅请求。
提供方收到订阅请求时，单播自己的地址给订阅者，如果设置了unicast=false，则广播给订阅者。
消费方收到提供方地址时，连接该地址进行RPC调用。

           <dubbo:registryaddress="multicast://224.5.6.7:1234"/> 
         

Or:

           <dubbo:registryprotocol="multicast"address="224.5.6.7:1234"/> 
         

为了减少广播量，Dubbo缺省使用单播发送提供者地址信息给消费者，
如果一个机器上同时启了多个消费者进程，消费者需声明unicast=false，否则只会有一个消费者能收到消息：

           <dubbo:registryaddress="multicast://224.5.6.7:1234?unicast=false"/> 
         

Or:

           <dubbo:registryprotocol="multicast"address="224.5.6.7:1234"> 
         
               <dubbo:parameterkey="unicast"value="false"/> 
         
           </dubbo:registry>

Zookeeper注册中心

(+) (#)

建议使用dubbo-2.3.3以上版本的zookeeper注册中心客户端

Zookeeper说明
Zookeeper是Apacahe Hadoop的子项目，是一个树型的目录服务，支持变更推送，适合作为Dubbo服务的注册中心，工业强度较高，可用于生产环境，并推荐使用，参见：http://zookeeper.apache.org

Zookeeper安装
安装方式参见: Zookeeper安装手册，只需搭一个原生的Zookeeper服务器，并将Quick Start中Provider和Consumer里的conf/dubbo.properties中的dubbo.registry.addrss的值改为zookeeper://127.0.0.1:2181即可使用

可靠性声明
阿里内部并没有采用Zookeeper做为注册中心，而是使用自己实现的基于数据库的注册中心，即：Zookeeper注册中心并没有在阿里内部长时间运行的可靠性保障，此Zookeeper桥接实现只为开源版本提供，其可靠性依赖于Zookeeper本身的可靠性。

兼容性声明
因2.0.8最初设计的zookeeper存储结构不能扩充不同类型的数据，2.0.9版本做了调整，所以不兼容，需全部改用2.0.9版本才行，以后的版本会保持兼容2.0.9。
2.2.0版本改为基于zkclient实现，需增加zkclient的依赖包，2.3.0版本增加了基于curator的实现，作为可选实现策略。

流程说明：

服务提供者启动时
- 向/dubbo/com.foo.BarService/providers目录下写入自己的URL地址。
服务消费者启动时
- 订阅/dubbo/com.foo.BarService/providers目录下的提供者URL地址。
- 并向/dubbo/com.foo.BarService/consumers目录下写入自己的URL地址。
监控中心启动时
- 订阅/dubbo/com.foo.BarService目录下的所有提供者和消费者URL地址。

支持以下功能：

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

在provider和consumer中增加zookeeper客户端jar包依赖：

           <dependency> 
         
               <groupId>org.apache.zookeeper</groupId> 
         
               <artifactId>zookeeper</artifactId> 
         
               <version>3.3.3</version> 
         
           </dependency>

或直接下载：http://repo1.maven.org/maven2/org/apache/zookeeper/zookeeper

支持zkclient和curator两种Zookeeper客户端实现：

ZKClient Zookeeper Registry

从2.2.0版本开始缺省为zkclient实现，以提升zookeeper客户端的健状性。

ZKClient是Datameer开源的一个Zookeeper客户端实现，开源比较早，参见：https://github.com/sgroschupf/zkclient

缺省配置：

           <dubbo:registry...client="zkclient"/> 
         

或：

           dubbo.registry.client=zkclient 
         

或：

           zookeeper://10.20.153.10:2181?client=zkclient 
         

需依赖：

           <dependency> 
         
               <groupId>com.github.sgroschupf</groupId> 
         
               <artifactId>zkclient</artifactId> 
         
               <version>0.1</version> 
         
           </dependency>

或直接下载：http://repo1.maven.org/maven2/com/github/sgroschupf/zkclient

Curator Zookeeper Registry

从2.3.0版本开始支持可选curator实现。

Curator是Netflix开源的一个Zookeeper客户端实现，比较活跃，参见：https://github.com/Netflix/curator

如果需要改为curator实现，请配置：

           <dubbo:registry...client="curator"/> 
         

或：

           dubbo.registry.client=curator 
         

或：

           zookeeper://10.20.153.10:2181?client=curator 
         

需依赖：

           <dependency> 
         
               <groupId>com.netflix.curator</groupId> 
         
               <artifactId>curator-framework</artifactId> 
         
               <version>1.1.10</version> 
         
           </dependency>

或直接下载：http://repo1.maven.org/maven2/com/netflix/curator/curator-framework

Zookeeper单机配置:

           <dubbo:registryaddress="zookeeper://10.20.153.10:2181"/> 
         

Or:

           <dubbo:registryprotocol="zookeeper"address="10.20.153.10:2181"/> 
         

Zookeeper集群配置:

           <dubbo:registryaddress="zookeeper://10.20.153.10:2181?backup=10.20.153.11:2181,10.20.153.12:2181"/> 
         

Or:

           <dubbo:registryprotocol="zookeeper"address="10.20.153.10:2181,10.20.153.11:2181,10.20.153.12:2181"/> 
         

同一Zookeeper，分成多组注册中心:

           <dubbo:registryid="chinaRegistry"protocol="zookeeper"address="10.20.153.10:2181"group="china"/> 
         
           <dubbo:registryid="intlRegistry"protocol="zookeeper"address="10.20.153.10:2181"group="intl"/>

Redis注册中心

(+) (#)

Redis说明
Redis是一个高效的KV存储服务器，参见：http://redis.io

Redis安装
安装方式参见: Redis安装手册，只需搭一个原生的Redis服务器，并将Quick Start中Provider和Consumer里的conf/dubbo.properties中的dubbo.registry.addrss的值改为redis://127.0.0.1:6379即可使用

Redis过期数据
通过心跳的方式检测脏数据，服务器时间必须相同，并且对服务器有一定压力。

可靠性声明
阿里内部并没有采用Redis做为注册中心，而是使用自己实现的基于数据库的注册中心，即：Redis注册中心并没有在阿里内部长时间运行的可靠性保障，此Redis桥接实现只为开源版本提供，其可靠性依赖于Redis本身的可靠性。

从2.1.0版本开始支持

数据结构：

使用Redis的Key/Map结构存储数据。
- 主Key为服务名和类型。
- Map中的Key为URL地址。
- Map中的Value为过期时间，用于判断脏数据，脏数据由监控中心删除。(注意：服务器时间必需同步，否则过期检测会不准确)
使用Redis的Publish/Subscribe事件通知数据变更。
- 通过事件的值区分事件类型：register, unregister, subscribe, unsubscribe。
- 普通消费者直接订阅指定服务提供者的Key，只会收到指定服务的register, unregister事件。
- 监控中心通过psubscribe功能订阅/dubbo/*，会收到所有服务的所有变更事件。

调用过程：

服务提供方启动时，向Key:/dubbo/com.foo.BarService/providers下，添加当前提供者的地址。
并向Channel:/dubbo/com.foo.BarService/providers发送register事件。
服务消费方启动时，从Channel:/dubbo/com.foo.BarService/providers订阅register和unregister事件。
并向Key:/dubbo/com.foo.BarService/providers下，添加当前消费者的地址。
服务消费方收到register和unregister事件后，从Key:/dubbo/com.foo.BarService/providers下获取提供者地址列表。
服务监控中心启动时，从Channel:/dubbo/*订阅register和unregister，以及subscribe和unsubsribe事件。
服务监控中心收到register和unregister事件后，从Key:/dubbo/com.foo.BarService/providers下获取提供者地址列表。
服务监控中心收到subscribe和unsubsribe事件后，从Key:/dubbo/com.foo.BarService/consumers下获取消费者地址列表。

选项：

可通过<dubbo:registry group="dubbo" />设置redis中key的前缀，缺省为dubbo。
可通过<dubbo:registry cluster="replicate" />设置redis集群策略，缺省为failover。
- failover: 只写入和读取任意一台，失败时重试另一台，需要服务器端自行配置数据同步。
- replicate: 在客户端同时写入所有服务器，只读取单台，服务器端不需要同步，注册中心集群增大，性能压力也会更大。

Config redis registry:

           <dubbo:registryaddress="redis://10.20.153.10:6379"/> 
         

Or:

           <dubbo:registryaddress="redis://10.20.153.10:6379?backup=10.20.153.11:6379,10.20.153.12:6379"/> 
         

Or:

           <dubbo:registryprotocol="redis"address="10.20.153.10:6379"/> 
         

Or:

           <dubbo:registryprotocol="redis"address="10.20.153.10:6379,10.20.153.11:6379,10.20.153.12:6379"/> 
         

Simple注册中心

(+) (#)

Dogfooding
注册中心本身就是一个普通的Dubbo服务，可以减少第三方依赖，使整体通讯方式一致。

适用性说明
此SimpleRegistryService只是简单实现，不支持集群，可作为自定义注册中心的参考，但不适合直接用于生产环境。

Export simple registry service:

           <?xmlversion="1.0"encoding="UTF-8"?> 
         
           <beansxmlns=" 
          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-2.5.xsdhttp://code.alibabatech.com/schema/dubbo 
          http://code.alibabatech.com/schema/dubbo/dubbo.xsd"> 
         
               <!-- 当前应用信息配置 --> 
         
               <dubbo:applicationname="simple-registry"/> 
         
               <!-- 暴露服务协议配置 --> 
         
               <dubbo:protocolport="9090"/> 
         
               <!-- 暴露服务配置 --> 
         
               <dubbo:serviceinterface="com.alibaba.dubbo.registry.RegistryService"ref="registryService"registry="N/A"ondisconnect="disconnect"callbacks="1000"> 
         
                   <dubbo:methodname="subscribe"><dubbo:argumentindex="1"callback="true"/></dubbo:method> 
         
                   <dubbo:methodname="unsubscribe"><dubbo:argumentindex="1"callback="false"/></dubbo:method> 
         
               </dubbo:service> 
         
               <!-- 简单注册中心实现，可自行扩展实现集群和状态同步 --> 
         
               <beanid="registryService"class="com.alibaba.dubbo.registry.simple.SimpleRegistryService"/> 
         
           </beans>

Reference the simple registry service:

           <dubbo:registryaddress="127.0.0.1:9090"/> 
         

Or:

           <dubbo:serviceinterface="com.alibaba.dubbo.registry.RegistryService"group="simple"version="1.0.0"... > 
         

           <dubbo:registryaddress="127.0.0.1:9090"group="simple"version="1.0.0"/> 
         

Simple监控中心

(+) (#)

监控中心也是一个标准的Dubbo服务，可以通过注册中心发现，也可以直连。

简易注册中心安装

1.1 暴露一个简单监控中心服务到注册中心: (如果是用安装包，不需要自己写这个配置，如果是自己实现监控中心，则需要)

           <beansxmlns=" 
          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-2.5.xsdhttp://code.alibabatech.com/schema/dubbo 
          http://code.alibabatech.com/schema/dubbo/dubbo.xsd"> 
         
               <!-- 当前应用信息配置 --> 
         
               <dubbo:applicationname="simple-monitor"/> 
         
               <!-- 连接注册中心配置 --> 
         
               <dubbo:registryaddress="127.0.0.1:9090"/> 
         
               <!-- 暴露服务协议配置 --> 
         
               <dubbo:protocolport="7070"/> 
         
               <!-- 暴露服务配置 --> 
         
               <dubbo:serviceinterface="com.alibaba.dubbo.monitor.MonitorService"ref="monitorService"/> 
         
               <beanid="monitorService"class="com.alibaba.dubbo.monitor.simple.SimpleMonitorService"/> 
         
           </beans>

1.2 通过注册中心发现监控中心服务:

           <dubbo:monitorprotocol="registry"/> 
         

或：

dubbo.properties

           dubbo.monitor.protocol=registry 
         

2.1 暴露一个简单监控中心服务，但不注册到注册中心: (如果是用安装包，不需要自己写这个配置，如果是自己实现监控中心，则需要)

           <beansxmlns=" 
          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-2.5.xsdhttp://code.alibabatech.com/schema/dubbo 
          http://code.alibabatech.com/schema/dubbo/dubbo.xsd"> 
         
               <!-- 当前应用信息配置 --> 
         
               <dubbo:applicationname="simple-monitor"/> 
         
               <!-- 暴露服务协议配置 --> 
         
               <dubbo:protocolport="7070"/> 
         
               <!-- 暴露服务配置 --> 
         
               <dubbo:serviceinterface="com.alibaba.dubbo.monitor.MonitorService"ref="monitorService"registry="N/A"/> 
         
               <beanid="monitorService"class="com.alibaba.dubbo.monitor.simple.SimpleMonitorService"/> 
         
           </beans>

2.2 直连监控中心服务:

           <dubbo:monitoraddress="dubbo://127.0.0.1:7070/com.alibaba.dubbo.monitor.MonitorService"/> 
         

或：

           <dubbo:monitoraddress="127.0.0.1:7070"/> 
         

或：

dubbo.properties

           dubbo.monitor.address=127.0.0.1:7070 
         

Telnet命令参考手册

(+) (#)

Dubbo2.0.5以上版本服务提供端口支持telnet命令，
使用如：

telnet localhost 20880

或者：

echo status | nc -i 1 localhost 20880

telnet命令可以扩展，参见：扩展参考手册第6条。
status命令所检查的资源也可以扩展，参见：扩展参考手册第5条。

ls

(list services and methods)

显示服务列表。

ls -l

显示服务详细信息列表。

ls XxxService

显示服务的方法列表。

ls -l XxxService

显示服务的方法详细信息列表。

ps

(print server ports and connections)

显示服务端口列表。

ps -l

显示服务地址列表。

ps 20880

显示端口上的连接信息。

ps -l 20880

显示端口上的连接详细信息。

cd

(change default service)

cd XxxService

改变缺省服务，当设置了缺省服务，凡是需要输入服务名作为参数的命令，都可以省略服务参数。

cd /

取消缺省服务。

pwd

(print working default service)

pwd

显示当前缺省服务。

trace

trace XxxService

跟踪1次服务任意方法的调用情况。

trace XxxService 10

跟踪10次服务任意方法的调用情况。

trace XxxService xxxMethod

跟踪1次服务方法的调用情况

trace XxxService xxxMethod 10

跟踪10次服务方法的调用情况。

count

count XxxService

统计1次服务任意方法的调用情况。

count XxxService 10

统计10次服务任意方法的调用情况。

count XxxService xxxMethod

统计1次服务方法的调用情况。

count XxxService xxxMethod 10

统计10次服务方法的调用情况。

invoke

invoke XxxService.xxxMethod({"prop": "value"})

调用服务的方法。

invoke xxxMethod({"prop": "value"})

调用服务的方法(自动查找包含此方法的服务)。

status

显示汇总状态，该状态将汇总所有资源的状态，当全部OK时则显示OK，只要有一个ERROR则显示ERROR，只要有一个WARN则显示WARN。

status -l

显示状态列表。

log

2.0.6以上版本支持

log debug
修改dubbo logger的日志级别

log 100
查看file logger的最后100字符的日志

help

显示telnet命帮助信息。

help xxx

显示xxx命令的详细帮助信息。

clear

清除屏幕上的内容。

clear 100

清除屏幕上的指定行数的内容。

exit

退出当前telnet命令行。

Maven插件参考手册

(+) (#)

mvn dubbo:registry

mvn dubbo:registry
以缺省的9090端口启动一个简易注册中心

mvn dubbo:registry -Dport=9099
以指定的9099端口启动一个简易注册中心

mvn dubbo:create

(尚未发布)

mvn dubbo:create
生成demo服务提供者应用

mvn dubbo:create -Dapplication=xxx -Dpackage=com.alibaba.xxx -Dservice=XxxService,YyyService -Dversion=1.0.0
生成指定接口和版本的服务提供者应用

服务化最佳实践

(+) (#)

分包

建议将服务接口，服务模型，服务异常等均放在API包中，因为服务模型及异常也是API的一部分，
同时，这样做也符合分包原则：重用发布等价原则(REP)，共同重用原则(CRP)
如果需要，也可以考虑在API包中放置一份spring的引用配置，这样使用方，只需在Spring加载过程中引用此配置即可，
配置建议放在模块的包目录下，以免冲突，如：com/alibaba/china/xxx/dubbo-reference.xml

粒度

服务接口尽可能大粒度，每个服务方法应代表一个功能，而不是某功能的一个步骤，否则将面临分布式事务问题，Dubbo暂未提供分布式事务支持。
服务接口建议以业务场景为单位划分，并对相近业务做抽象，防止接口数量爆炸
不建议使用过于抽象的通用接口，如：Map query(Map)，这样的接口没有明确语义，会给后期维护带来不便。

版本

每个接口都应定义版本号，为后续不兼容升级提供可能，如：<dubbo:service interface="com.xxx.XxxService" version="1.0" />
建议使用两位版本号，因为第三位版本号通常表示兼容升级，只有不兼容时才需要变更服务版本。
当不兼容时，先升级一半提供者为新版本，再将消费者全部升为新版本，然后将剩下的一半提供者升为新版本。

兼容性

服务接口增加方法，或服务模型增加字段，可向后兼容，删除方法或删除字段，将不兼容，枚举类型新增字段也不兼容，需通过变更版本号升级。
各协议的兼容性不同，参见：服务协议

枚举值

如果是完备集，可以用Enum，比如：ENABLE, DISABLE。
如果是业务种类，以后明显会有类型增加，不建议用Enum，可以用String代替。
如果是在返回值中用了Enum，并新增了Enum值，建议先升级服务消费方，这样服务提供方不会返回新值。
如果是在传入参数中用了Enum，并新增了Enum值，建议先升级服务提供方，这样服务消费方不会传入新值。

序列化

服务参数及返回值建议使用POJO对象，即通过set,get方法表示属性的对象。
服务参数及返回值不建议使用接口，因为数据模型抽象的意义不大，并且序列化需要接口实现类的元信息，并不能起到隐藏实现的意图。
服务参数及返回值都必需是byValue的，而不能是byRef的，消费方和提供方的参数或返回值引用并不是同一个，只是值相同，Dubbo不支持引用远程对象。

异常

建议使用异常汇报错误，而不是返回错误码，异常信息能携带更多信息，以及语义更友好，
如果担心性能问题，在必要时，可以通过override掉异常类的fillInStackTrace()方法为空方法，使其不拷贝栈信息，
查询方法不建议抛出checked异常，否则调用方在查询时将过多的try...catch，并且不能进行有效处理，
服务提供方不应将DAO或SQL等异常抛给消费方，应在服务实现中对消费方不关心的异常进行包装，否则可能出现消费方无法反序列化相应异常。

调用

不要只是因为是Dubbo调用，而把调用Try-Catch起来。Try-Catch应该加上合适的回滚边界上。
对于输入参数的校验逻辑在Provider端要有。如有性能上的考虑，服务实现者可以考虑在API包上加上服务Stub类来完成检验。

容量规划

(+) (#)

以下数据供参考：

使用Dubbo的会员服务项目

每天接收4亿次远程调用
使用12台网站标配机器提供服务(8核CPU,8G内存)
平均负载在1以下(对于8核CPU负载很低)
平均响应时间2.3到2.5毫秒，网络开销约占1.5到1.6毫秒(和数据包大小有关)

使用Dubbo的产品授权服务项目

每天接收3亿次远程调用
使用8台网站标配机器提供服务(8核CPU,8G内存)
平均负载在1以下(对于8核CPU负载很低)
平均响应时间1.4到2.8毫秒，网络开销约占1.0到1.1毫秒(和数据包大小有关)

基准测试工具包

(+) (#)

下载benchmark压缩包，并解压

dubbo.benchmark-2.0.14.tar.gz

阅读ReadMe.txt（内容如下，请以压缩包内的为准）

一、新建一个benchmark工程，如demo.benchmark
二、导入自己服务的接口api包和dubbo.benchmark.jar(解压dubbo.benchmark.tar.gz，在lib目录下)
三、新建一个类，实现AbstractClientRunnable
a、实现父类的构造函数
b、实现invoke方法，通过serviceFactory创建本地接口代理，并实现自己的业务逻辑，如下

           publicObject invoke(ServiceFactory serviceFactory) { 
         
                   DemoService demoService = (DemoService) serviceFactory.get(DemoService.class); 
         
                   returndemoService.sendRequest("hello"); 
         
               }

四、将自己的benchmark工程打成jar包,如demo.benchmark.jar
五、将demo.benchmark.jar 和服务的api包放到dubbo.benchmark/lib目录下
六、配置duubo.properties
七、运行run.bat(windows)或run.sh(linux)

如想测试dubbo的不同版本，直接替换lib下的dubbo的jar包即可。

性能测试报告

(+) (#)

测试说明

a、本次性能测试，测试了dubbo2.0所有支持的协议在不同大小和数据类型下的表现，并与dubbo1.0进行了对比。

b、整体性能相比1.0有了提升，平均提升10%，使用dubbo2.0新增的dubbo序列化还能获得10%~50%的性能提升，详见下面的性能数据。

c、稳定性测试中由于将底层通信框架从mina换成netty，old区对象的增长大大减少，50小时运行，增长不到200m，无fullgc。（可以确认为mina在高并发下的设计缺陷）

d、存在的问题：在50k数据的时候2.0性能不如1.0，怀疑可能是缓冲区设置的问题，下版本会进一步确认。

测试环境

2.1 硬件部署与参数调整

主机/ip
硬件配置
操作系统及参数调整

10.20.153.11		机型	Tecal BH620
CPU	model name : Intel(R) Xeon(R) CPU E5520 @ 2.27GHz cache size : 8192 KB processor_count : 16
内存	Total System Memory: 6G Hardware Memory Info: Size: 4096MB, 1066MHz(0.9ns) Size: NoModule, Unknown Size: 4096MB, 1066MHz(0.9ns) Size: NoModule, Unknown Size: 4096MB, 1066MHz(0.9ns) Size: NoModule, Unknown Size: 4096MB, 1066MHz(0.9ns) Size: NoModule, Unknown Size: 4096MB, 1066MHz(0.9ns) Size: NoModule, Unknown Size: 4096MB, 1066MHz(0.9ns) Size: NoModule, Unknown
网络	Total System Memory: 6G Hardware Memory Info: Size: 4096MB, 1066MHz(0.9ns) Size: NoModule, Unknown Size: 4096MB, 1066MHz(0.9ns) Size: NoModule, Unknown Size: 4096MB, 1066MHz(0.9ns) Size: NoModule, Unknown Size: 4096MB, 1066MHz(0.9ns) Size: NoModule, Unknown Size: 4096MB, 1066MHz(0.9ns) Size: NoModule, Unknown Size: 4096MB, 1066MHz(0.9ns) Size: NoModule, Unknown
磁盘	/dev/sda: 597.9 GB,		2.6.18-128.el5xen x86_64
10.20.153.10		机型	Tecal BH620
CPU	model name : Intel(R) Xeon(R) CPU E5520 @ 2.27GHz cache size : 8192 KB processor_count : 16
内存	Total System Memory: 6G Hardware Memory Info: Size: 4096MB, 1066MHz(0.9ns) Size: NoModule, Unknown Size: 4096MB, 1066MHz(0.9ns) Size: NoModule, Unknown Size: 4096MB, 1066MHz(0.9ns) Size: NoModule, Unknown Size: 4096MB, 1066MHz(0.9ns) Size: NoModule, Unknown Size: 4096MB, 1066MHz(0.9ns) Size: NoModule, Unknown Size: 4096MB, 1066MHz(0.9ns) Size: NoModule, Unknown
网络	eth0: Link is up at 1000 Mbps, full duplex. peth0: Link is up at 1000 Mbps, full duplex.
磁盘	/dev/sda: 597.9 GB,		2.6.18-128.el5xen x86_64

2.2 软件架构

主机/ip
软件名称及版本
关键参数

	java version "1.6.0_18" Java(TM) SE Runtime Environment (build 1.6.0_18-b07) Java HotSpot(TM) 64-Bit Server VM (build 16.0-b13, mixed mode)	-server -Xmx2g -Xms2g -Xmn256m -XX:PermSize=128m -Xss256k -XX:+DisableExplicitGC -XX:+UseConcMarkSweepGC -XX:+CMSParallelRemarkEnabled -XX:+UseCMSCompactAtFullCollection -XX:LargePageSizeInBytes=128m -XX:+UseFastAccessorMethods -XX:+UseCMSInitiatingOccupancyOnly -XX:CMSInitiatingOccupancyFraction=70
	jboss-4.0.5.GA
	httpd-2.0.61	KeepAlive On MaxKeepAliveRequests 100000 KeepAliveTimeout 180 MaxRequestsPerChild 1000000 <IfModule worker.c> StartServers 5 MaxClients 1024 MinSpareThreads 25 MaxSpareThreads 75 ThreadsPerChild 64 ThreadLimit 128 ServerLimit 16 </IfModule>

测试目的

3.1 期望性能指标(量化)

场景名称
对应指标名称
期望值范围
实际值
是否满足期望(是/否)

1k数据	响应时间	0.9ms	0.79ms	是
1k数据	TPS	10000	11994	是

3.2 期望运行状况(非量化，可选)

2.0性能不低于1.0,2.0和1.0互调用的性能无明显下降。除了50k string其余皆通过
JVM内存运行稳定，无OOM，堆内存中无不合理的大对象的占用。通过
CPU、内存、网络、磁盘、文件句柄占用平稳。通过
无频繁线程锁，线程数平稳。通过
业务线程负载均衡。通过

测试脚本

1、性能测试场景（10并发）

a、传入1kString，不做任何处理，原样返回

b、传入50kString，不做任何处理，原样返回

c、传入200kString，不做任何处理，原样返回

d、传入1k pojo（嵌套的复杂person对象），不做任何处理，原样返回

上述场景在dubbo1.0\dubbo2.0(hessian2序列化)\dubbo2.0(dubbo序列化)\rmi\hessian3.2.0\http(json序列化)进行10分钟的性能测试。主要考察序列化和网络IO的性能，因此服务端无任何业务逻辑。取10并发是考虑到http协议在高并发下对CPU的使用率较高可能会先打到瓶颈。

2、并发场景（20并发）

传入1kString，在服务器段循环1w次，每次重新生成一个随机数然后进行拼装。

考察业务线程是否能够分配到每个CPU上。

3、稳定性场景（20并发）

同时调用1个参数为String（5k）方法，1个参数为person对象的方法，1个参数为map（值为3个person）的方法，持续运行50小时。

4、高压力场景（20并发）

在稳定性场景的基础上，将提供者和消费者布置成均为2台（一台机器2个实例），且String的参数从20byte到200k，每隔10分钟随机变换。

测试结果

5.1 场景名称：pojo 场景

	TPS成功平均值	响应时间成功平均值(ms)
dubbo1 （hessian2序列化+mina）	10813.5	0.9
dubbo2 (hessian2序列化+netty)	11994	0.79
dubbo2 (dubbo序列化+netty)	13620	0.67
rmi	2461.79	4
hessian	2417.7	4.1
http（json序列化）	8179.08	1.15
2.0和1.0默认对比百分比	10.92	-12.22
dubbo序列化相比hessian2序列化百分比	13.56	-15.19

5.2 场景名称：1k string 场景 |

	TPS成功平均值	响应时间成功平均值(ms)
dubbo1 （hessian2序列化+mina）	11940	0.8
dubbo2 (hessian2序列化+netty)	14402	0.64
dubbo2 (dubbo序列化+netty)	15096	0.6
rmi	11136.02	0.81
hessian	11426.83	0.79
http（json序列化）	8919.27	1.04
2.0和1.0默认对比百分比	20.62	-20.00
dubbo序列化相比hessian2序列化百分比	4.82	-6.25

5.3 场景名称：50k string场景 |

	TPS成功平均值	响应时间成功平均值(ms)
dubbo1 （hessian2序列化+mina）	1962.7	5.1
dubbo2 (hessian2序列化+netty)	1293	5.03
dubbo2 (dubbo序列化+netty)	1966	7.68
rmi	3349.88	2.9
hessian	1925.33	5.13
http（json序列化）	3247.1	3
2.0和1.0默认对比百分比	-34.12	-1.37
dubbo序列化相比hessian2序列化百分比	52.05	52.68

5.4 场景名称：200k string 场景 |

	TPS成功平均值	响应时间成功平均值(ms)
dubbo1 （hessian2序列化+mina）	324.2	30.8
dubbo2 (hessian2序列化+netty)	362.92	27.49
dubbo2 (dubbo序列化+netty)	569.5	17.51
rmi	1031.28	9.61
hessian	628.06	15.83
http（json序列化）	1011.97	9.79
2.0和1.0默认对比百分比	11.94	-10.75
dubbo序列化相比hessian2序列化百分比	56.92	-36.30

测试分析

6.1 性能分析评估

Dubbo2.0的性能测试结论为通过，从性能、内存占用和稳定性上都有了提高和改进。由其是内存管理由于将mina换成netty，大大减少了1.0版本在高并发大数据下的内存大锯齿。如下图：

6.2 性能对比分析(新旧环境、不同数据量级等)

Dubbo2.0相比较Dubbo1.0（默认使用的都是hessian2序列化）性能均有提升（除了50k String），详见第五章的性能数据。

出于兼容性考虑默认的序列化方式和1.0保持一致使用hessian2，如对性能有更高要求可以使用dubbo序列化，由其是在处理复杂对象时，在大数据量下能获得50%的提升（但此时已不建议使用Dubbo协议）。

Dubbo的设计目的是为了满足高并发小数据量的rpc调用，在大数据量下的性能表现并不好，建议使用rmi或http协议。

6.3 测试局限性分析（可选）

本次性能测试考察的是dubbo本身的性能，实际使用过程中的性能有待应用来验证。

由于dubbo本身的性能占用都在毫秒级，占的基数很小，性能提升可能对应用整体的性能变化不大。

由于邮件篇幅所限没有列出所有的监控图，如需获得可在大力神平台上查询。

测试覆盖率报告

(+) (#)

统计于 2012-02-03 (2.0.12)

Labels:

None

19 Child Pages

Reorder Pages

Page: API Reference-zh Page: Benchmark Test Toolkit-zh Page: Capacity Estimated-zh Page: Code Coverage Report-zh Page: Configs-zh Page: Configuration Reference-zh Page: Dependencies-zh Page: Examples-zh Page: Getting Started-zh Page: Maturity-zh Page: Maven Plugin Reference-zh Page: Performance Test Report-zh Page: Protocol Reference-zh Page: Quick Start-zh Page: Recommended Usage-zh Page: Registry Reference-zh Page: Serialization Issues-zh Page: Service Best Practices-zh Page: Telnet Command Reference-zh

来源：oschina

链接：https://my.oschina.net/u/2624214/blog/632101

标签

Dubbo

spring框架

alibaba

dubbo 阿里巴巴官方文档

用户指南

入门

背景

需求

架构

用法

本地服务：(Spring配置)

远程服务：(Spring配置)

快速启动

服务提供者

服务消费者

依赖

必需依赖

缺省依赖

可选依赖

成熟度

功能成熟度

策略成熟度

配置

Xml配置

属性配置

注解配置

API配置

(1) 服务提供者：

(2) 服务消费者：

(3) 特殊场景

(3.1) 方法级设置：

(3.2) 点对点直连：

示例

启动时检查

集群容错

集群容错模式：

Failover Cluster

Failfast Cluster

Failsafe Cluster

Failback Cluster

Forking Cluster

Broadcast Cluster

负载均衡

Random LoadBalance

RoundRobin LoadBalance

LeastActive LoadBalance

ConsistentHash LoadBalance

线程模型

直连提供者

只订阅

只注册

静态服务

多协议

(1) 不同服务不同协议

(2) 多协议暴露服务

多注册中心

(1) 多注册中心注册

(2) 不同服务使用不同注册中心

(3) 多注册中心引用

服务分组

多版本

分组聚合

参数验证

结果缓存

泛化引用

泛化实现

回声测试

上下文信息

(1) 服务消费方

(2) 服务提供方

隐式传参

(1) 服务消费方

(2) 服务提供方

异步调用

本地调用

参数回调

事件通知

本地存根

本地伪装

延迟暴露

并发控制

连接控制

延迟连接