Dubbo文档

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

需求

(#) git

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

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

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

并经过在消费方获取服务提供方地址列表，实现软负载均衡和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（内容以下，请以压缩包内的为准）

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

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

4、将本身的benchmark工程打成jar包,如demo.benchmark.jar
5、将demo.benchmark.jar 和服务的api包放到dubbo.benchmark/lib目录下
6、配置duubo.properties
7、运行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、内存、网络、磁盘、文件句柄占用平稳。经过
无频繁线程锁，线程数平稳。经过
业务线程负载均衡。经过

测试脚本

一、性能测试场景（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的使用率较高可能会先打到瓶颈。

二、并发场景（20并发）

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

考察业务线程是否可以分配到每一个CPU上。

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

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

四、高压力场景（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