dubbo服务框架(基础篇)
Dubbo架构分析文档
SOA服务化架构1.1.传统架构传统架构图存在的问题：1、功能耦合度高2、系统维护成本高3、如果并发量大，无法解决高并发的问题体统架构负载均衡传统架构负载均衡图存在的问题：1、系统无法有效进行水平扩展（集群不能针对功能模块）2、用户存在重复登录的问题,需要session共享来解决,是以session广播的形式，比较消耗资源，宽带如果要达到10000并发需要20台服务器做tomcat集群。
当tomcat集群中节点数量增加，服务能力先增加后下降。
3、所以集群中节点数量不能太多，一般也就5个左右。
1.2.分布式架构分布式架构图集群：相当于同一个工程代码拷贝多份部署到多台服务器，每台服务器单独独立部署运行。
分布式架构：把系统按照模块拆分成多个子系统；多个子系统相互协作才能完成业务流程系统之间需要进行通信。
优点：1、把模块拆分，使用接口通信，降低模块之间的耦合度。
2、把项目拆分成若干个子项目，不同的团队负责不同的子项目。
3、增加功能时只需要再增加一个子项目，调用其他系统的接口就可以。
4、可以灵活的进行分布式部署。
缺点：1、系统之间交互需要使用远程通信，需要开发接口，增加工作量。
2、各个模块有一些通用的业务逻辑无法公用。
1.3.基于SOA架构SOA：Service Oriented Architecture面向服务的架构。
也就是把工程都拆分成服务层工程、表现层工程。
服务层中包含业务逻辑，只需要对外提供服务即可。
表现层只需要处理和页面的交互，业务逻辑都是调用服务层的服务来实现。
工程都可以独立部署。
SOA机构图1.4.L ESSO基于SOA架构架构说明:整个架构基于Spring、SpringMVC、MyBatis、RESful分布式敏捷开发系统架构，提供整套公共的微服务模块:日志分析、配置中心、文件服务、内容服务、消息服务等。
业务系统根据自身的业务需要进行开发服务API并结合公共服务进行拓展。
建立统一的权限管理服务(UPMS)确保入口统一。
开源微服务架构DubboX
Dubbo架构介绍
• 节点角色说明
• • • • •
Provider: 暴露服务的服务提供方。 Consumer: 调用远程服务的服务消费方。 Registry: 服务注册与发现的注册中心。 Container: 服务运行容器。（e.g.）Spring Monitor: 统计服务的调用次调和 调用时间的监控中心。
•
<dubbo:module/> 模块配置，用于配置当前模块信息，可选。 <dubbo:monitor/> 监控中心配置，用于配置连接监控中心相关信息，可选。 <dubbo:provider/> 提供方的缺省值，当ProtocolConfig和ServiceConfig某属性没有配置时，采用此 缺省值，可选。 <dubbo:consumer/> 消费方缺省配置，当ReferenceConfig某属性没有配置时，采用此缺省值，可选。
•
数据传输中两个点不是对等的，一个是Server，一个是Client；数据有一个点 到另外一个点需要Transporter来传输 有接口大多提供抽象类； AbstractEndpoint， AbstractClient， AbstractServer，AbstractChannel，TransportCodec 业务抽象后，就是具体实现netty，mina，xSocket – MinaServer ， MinaClient ， MinaChannel ， MinaCodecAdapter
Dubbo是怎么实现交换的
• • • •
RPC数据不仅仅是传输，还要交换（Exchange） 继承传输接口：ExchangeServer、ExchangeClient、ExchangeChannel、
dubbo官方配置指南
Configuration ReferenceConfiguration Relation:SLA配置在此完成！Service Layer Agreement∙ApplicationConfig 应用配置，用于配置当前应用信息，不管该应用是提供者还是消费者。
∙RegistryConfig 注册中心配置，用于配置连接注册中心相关信息。
∙ProtocolConfig 协议配置，用于配置提供服务的协议信息，协议由提供方指定，消费方被动接受。
∙ServiceConfig 服务配置，用于暴露一个服务，定义服务的元信息，一个服务可以用多个协议暴露，一个服务也可以注册到多个注册中心。
∙ProviderConfig 提供方的缺省值，当ProtocolConfig和ServiceConfig某属性没有配置时，采用此缺省值。
∙ReferenceConfig 引用配置，用于创建一个远程服务代理，一个引用可以指向多个注册中心。
∙ConsumerConfig 消费方缺省配置，当ReferenceConfig某属性没有配置时，采用此缺省值。
∙MethodConfig 方法配置，用于ServiceConfig和ReferenceConfig指定方法级的配置信息。
∙ArgumentConfig 用于指定方法参数配置。
Configuration Override:∙上图中以timeout为例，显示了配置的查找顺序，其它retries, loadbalance, actives等类似。
∙方法级优先，接口级次之，全局配置再次之。
∙如果级别一样，则消费方优先，提供方次之。
∙其中，服务提供方配置，通过URL经由注册中心传递给消费方。
∙建议由服务提供方设置超时，因为一个方法需要执行多长时间，服务提供方更清楚，如果一个消费方同时引用多个服务，就不需要关心每个服务的超时设置。
∙理论上ReferenceConfig的非服务标识配置，在ConsumerConfig，ServiceConfig, ProviderConfig均可以缺省配置。
Dubbo框架的使用操作文档
Dubbo框架的使用操作文档目录1ZooKeeper的配置安装.......................................... 错误！未定义书签。
1.1 Z OO K EEPER简介 ................................................................ 错误！未定义书签。
1.2 详细安装文档说明参考.................................................... 错误！未定义书签。
2Dubbo-admin配置安装 ........................................ 错误！未定义书签。
2.1 管理平台的简介................................................................. 错误！未定义书签。
2.2 详细安装文档的参考 ........................................................ 错误！未定义书签。
3创建使用Dubbo框架的Maven项目 ..................... 错误！未定义书签。
3.1 创建Maven项目SINOEP-INTERFACE-USER................... 错误！未定义书签。
3.1.1 创建实体类 ................................................................. 错误！未定义书签。
3.1.2 创建接口...................................................................... 错误！未定义书签。
3.1.3 在Pom.xml文件中引入依赖的包 ......................... 错误！未定义书签。
Dubbo框架面试题
Dubbo框架面试题Dubbo框架是当前Java开发中广泛使用的一种分布式服务框架。
在面试中，经常会涉及到与Dubbo相关的技术问题。
本文将就一些常见的Dubbo框架面试题进行解答，帮助读者更好地理解Dubbo框架的原理和使用。
一、Dubbo框架概述Dubbo是一个分布式服务框架，提供了高性能的远程调用和负载均衡功能。
它采用了基于接口的远程调用方式，将服务拆分为多个小的服务单元，通过网络进行通信。
Dubbo具有一定的可扩展性和高可用性，并且提供了完善的监控和治理功能。
二、Dubbo框架的原理1. 服务注册与发现在Dubbo框架中，服务提供者将自身提供的服务注册到注册中心，而服务消费者从注册中心获取到服务提供者的地址，实现服务的发现。
Dubbo支持多种注册中心，如ZooKeeper、Consul等。
2. 远程调用Dubbo框架通过RPC（远程过程调用）实现服务之间的远程调用。
在服务消费者和服务提供者之间建立连接后，通过通信协议进行数据的传输。
Dubbo支持多种通信协议，如Dubbo协议、HTTP等。
3. 负载均衡Dubbo框架提供了多种负载均衡策略，如轮询、随机、一致性哈希等。
通过负载均衡策略，Dubbo可以将请求均匀地分摊到各个服务提供者上，提高系统的并发处理能力。
三、Dubbo框架的核心组件1. 服务提供者（Provider）服务提供者是提供具体服务的一方，将自己提供的服务注册到注册中心，并响应服务消费者的请求。
服务提供者需要实现服务接口，并配置好相应的Dubbo配置文件。
2. 服务消费者（Consumer）服务消费者是使用服务的一方，通过注册中心获取到服务提供者的地址，并发起远程调用请求。
服务消费者需要引入服务接口的定义，并配置好Dubbo相关的配置文件。
3. 注册中心（Registry）注册中心负责服务的注册与发现。
Dubbo框架支持多种注册中心，如ZooKeeper、Consul等。
注册中心需要保证高可用性，并提供相应的监控和治理功能。
dubbo服务的开发流程
Dubbo服务的开发流程Dubbo是一个分布式服务框架，可以帮助我们快速构建高性能、可扩展的分布式应用。
在开发Dubbo服务时，需要按照以下步骤和流程进行。
1. 环境准备在开始开发Dubbo服务之前，需要进行一些环境准备工作。
1.1 安装JDK首先需要安装Java Development Kit (JDK)，确保你的电脑上已经安装了合适的JDK版本，并配置好了环境变量。
1.2 下载Dubbo从Dubbo官网（）下载最新版本的Dubbo，并解压到本地目录中。
1.3 创建Maven项目使用Maven创建一个新的Java项目，作为你的Dubbo服务的开发工程。
可以使用命令行或者IDE来完成这个步骤。
2. 定义接口在Dubbo中，服务提供者和消费者之间通过接口进行通信。
所以第一步是定义接口。
2.1 创建API模块在Maven项目中创建一个新的Module（如：my-api），用于存放接口定义和实体类等公共代码。
这个模块将被提供者和消费者共同引用。
2.2 定义接口在API模块中创建一个Java接口，用于定义服务的方法。
例如，我们可以创建一个UserService接口，其中包含一些用户相关的方法。
package com.example.api;public interface UserService {User getUserById(int id);List<User> getAllUsers();void addUser(User user);}3. 编写服务提供者在Dubbo中，服务提供者是实际提供服务的一方。
3.1 创建Provider模块在Maven项目中创建一个新的Module（如：my-provider），用于实现服务提供者相关代码。
3.2 引入依赖在Provider模块的pom.xml文件中，引入Dubbo和API模块的依赖。
<dependency><groupId>org.apache.dubbo</groupId><artifactId>dubbo-spring-boot-starter</artifactId><version>${dubbo.version}</version></dependency><dependency><groupId>com.example</groupId><artifactId>my-api</artifactId><version>${project.version}</version></dependency>3.3 配置Dubbo在Provider模块中创建一个名为dubbo.properties（或dubbo.yml）的配置文件，并配置Dubbo相关属性。
分布式服务框架dubbodubbox入门示例
分布式服务框架dubbodubbox⼊门⽰例dubbo是⼀个分布式的服务架构，可直接⽤于⽣产环境作为SOA服务框架。
淘宝将这个项⽬开源出来以后，得到了不少同⾏的⽀持，包括：不管如何，能在阿⾥、当当、京东这些⼤型⽹站正式使⽤的框架，总不⾄于差到哪⾥去。
本⽂下⾯的⽰例均基于当当的dubbox版本，由于dubbox并没向maven提交编译后的jar包，所以只能从github clone代码到本地编译得到jar 包。
编译及测试步骤：(以下步骤全在windows环境中完成)1.本机先安装github on Windows的客户端，将在path路径中，把git.exe加进去3. mvn install -Dmaven.test.skip=true 跳过测试编译4.在本机，参考zoo.cfg如下：tickTime=2000initLimit=10syncLimit=5dataDir=D:/java/zookeeper-3.4.6/datadataLogDir=D:/java/zookeeper-3.4.6/logclientPort=2181server.1=localhost:2287:3387然后输⼊ bin/zkServer.cmd 启⽤zookeeper5. intellij Idea中导⼊源码6.运⾏ \dubbox\dubbo-demo\dubbo-demo-provider\src\test\java\com\alibaba\dubbo\demo\provider\DemoProvider.java把服务提供⽅跑起来，成功后，可以在ZK⾥，⽤ ls / 看下，会发现zk⾥多出了⼀个dubbo的节点，所有服务全注册在这⾥了7.运⾏\dubbox\dubbo-demo\dubbo-demo-consumer\src\test\java\com\alibaba\dubbo\demo\consumer\DemoConsumer.java服务消费⽅调⽤测试，可以看console⾥的输出8.运⾏\dubbox\dubbo-demo\dubbo-demo-consumer\src\test\java\com\alibaba\dubbo\demo\consumer\RestClient.java跑⼀下rest调⽤dubbox官⽅的⽰例，虽然已经很简单了，但是对于初次接触的⼈来讲，仍然略显复杂，下⾯的代码在其基础上简化了⼀下：⼀、先定义服务接⼝及传输对象DTO项⽬结构如下代码：User.javapackage yjmyzz.dubbo.demo.api;import org.codehaus.jackson.annotate.JsonProperty;import javax.validation.constraints.Min;import javax.validation.constraints.NotNull;import javax.validation.constraints.Size;import javax.xml.bind.annotation.XmlAccessType;import javax.xml.bind.annotation.XmlAccessorType;import javax.xml.bind.annotation.XmlElement;import javax.xml.bind.annotation.XmlRootElement;import java.io.Serializable;@XmlRootElement@XmlAccessorType(XmlAccessType.FIELD)public class User implements Serializable {@NotNull@Min(1L)private Long id;@JsonProperty("username")@XmlElement(name = "username")@NotNull@Size(min = 6, max = 50)private String name;public User() {}public User(Long id, String name) {this.id = id; = name;}public Long getId() {return id;}public void setId(Long id) {this.id = id;}public String getName() {return name;}public void setName(String name) { = name;}@Overridepublic String toString() {return "User (" +"id=" + id +", name='" + name + '\'' +')';}}UserService.javapackage yjmyzz.dubbo.demo.api;public interface UserService {User getUser(Long id);}UserRestService.javapackage yjmyzz.dubbo.demo.api;import javax.validation.constraints.Min;public interface UserRestService {User getUser(@Min(value = 1L, message = "User ID must be greater than 1") Long id);}pom.xml1<?xml version="1.0" encoding="UTF-8"?>2<project xmlns="/POM/4.0.0"3 xmlns:xsi="/2001/XMLSchema-instance"4 xsi:schemaLocation="/POM/4.0.0 /xsd/maven-4.0.0.xsd"> 56<modelVersion>4.0.0</modelVersion>78<groupId>blogs.yjmyzz</groupId>9<artifactId>dubbo-hello-api</artifactId>10<version>0.1</version>1112<dependencies>1314<dependency>15<groupId>com.alibaba</groupId>16<artifactId>dubbo</artifactId>17<version>2.8.4</version>18</dependency>1920<dependency>21<groupId>javax.validation</groupId>22<artifactId>validation-api</artifactId>23<version>1.0.0.GA</version>24</dependency>2526<dependency>27<groupId>javax.annotation</groupId>28<artifactId>javax.annotation-api</artifactId>29<version>1.2</version>30</dependency>3132<dependency>33<groupId>org.codehaus.jackson</groupId>34<artifactId>jackson-mapper-asl</artifactId>35<version>1.9.12</version>36</dependency>3738</dependencies>39</project>View Code⼆、定义服务⽣产者（即：服务接⼝的实现⽅）UserServiceImpl.javapackage yjmyzz.dubbo.demo.provider;import er;import erService;public class UserServiceImpl implements UserService {public User getUser(Long id) {return new User(id, "username" + id);}}UserRestServiceImpl.javapackage yjmyzz.dubbo.demo.provider;import com.alibaba.dubbo.rpc.RpcContext;import com.alibaba.dubbo.rpc.protocol.rest.support.ContentType;import er;import erRestService;import erService;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import javax.ws.rs.*;import javax.ws.rs.core.MediaType;@Path("users")@Consumes({MediaType.APPLICATION_JSON, MediaType.TEXT_XML})@Produces({ContentType.APPLICATION_JSON_UTF_8, ContentType.TEXT_XML_UTF_8})public class UserRestServiceImpl implements UserRestService {private UserService userService;public void setUserService(UserService userService) {erService = userService;}@GET@Path("{id : \\d+}")public User getUser(@PathParam("id") Long id) {if (RpcContext.getContext().getRequest(HttpServletRequest.class) != null) {System.out.println("Client IP address from RpcContext: " + RpcContext.getContext().getRequest(HttpServletRequest.class).getRemoteAddr()); }if (RpcContext.getContext().getResponse(HttpServletResponse.class) != null) {System.out.println("Response object from RpcContext: " + RpcContext.getContext().getResponse(HttpServletResponse.class));}return userService.getUser(id);}}DemoProvider.javapackage yjmyzz.dubbo.demo.provider;import org.springframework.context.support.ClassPathXmlApplicationContext;import java.io.IOException;public class DemoProvider {public static void main(String[] args) throws IOException {ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath*:META-INF/spring/*.xml");context.start();System.out.println("服务已经启动...");System.in.read();}}配置⽂件：resources\META-INF\spring\dubbo-demo-provider.xml1<?xml version="1.0" encoding="UTF-8"?>23<beans xmlns="/schema/beans"4 xmlns:xsi="/2001/XMLSchema-instance"5 xmlns:dubbo="/schema/dubbo"6 xsi:schemaLocation="/schema/beans /schema/beans/spring-beans-2.5.xsd7 /schema/dubbo /schema/dubbo/dubbo.xsd">89<dubbo:application name="demo-provider" owner="programmer" organization="dubbox"/>1011<dubbo:registry address="zookeeper://127.0.0.1:2181"/>1213<dubbo:protocol name="dubbo" serialization="kryo" optimizer="yjmyzz.dubbo.demo.api.SerializationOptimizerImpl"/>1415<!-- use tomcat server -->16<dubbo:protocol name="rest" port="8888" threads="500" contextpath="services" server="tomcat" accepts="500"17 extension="com.alibaba.dubbo.rpc.protocol.rest.support.LoggingFilter"/>181920<dubbo:service interface="erService" ref="userService" protocol="dubbo"/>2122<dubbo:service interface="erRestService" ref="userRestService" protocol="rest" validation="true"/>2324<bean id="userService" class="erServiceImpl"/>2526<bean id="userRestService" class="erRestServiceImpl">27<property name="userService" ref="userService"/>28</bean>293031</beans>View Codepom.xml1<?xml version="1.0" encoding="UTF-8"?>2<project xmlns="/POM/4.0.0"3 xmlns:xsi="/2001/XMLSchema-instance"4 xsi:schemaLocation="/POM/4.0.0 /xsd/maven-4.0.0.xsd">56<modelVersion>4.0.0</modelVersion>78<groupId>blogs.yjmyzz</groupId>9<artifactId>dubbo-hello-provider</artifactId>10<version>0.1</version>1112<dependencies>1314<!--公⽤的服务接⼝-->15<dependency>16<groupId>blogs.yjmyzz</groupId>17<artifactId>dubbo-hello-api</artifactId>18<version>0.1</version>19</dependency>2021<dependency>22<groupId>com.alibaba</groupId>23<artifactId>dubbo</artifactId>24<version>2.8.4</version>25</dependency>2627<dependency>28<groupId>org.javassist</groupId>29<artifactId>javassist</artifactId>30<version>3.15.0-GA</version>31</dependency>3233<dependency>34<groupId>org.apache.mina</groupId>35<artifactId>mina-core</artifactId>36<version>1.1.7</version>41<artifactId>grizzly-core</artifactId>42<version>2.1.4</version>43</dependency>4445<dependency>46<groupId>org.apache.httpcomponents</groupId> 47<artifactId>httpclient</artifactId>48<version>4.2.1</version>49</dependency>5051<dependency>52<groupId>com.alibaba</groupId>53<artifactId>fastjson</artifactId>54<version>1.1.39</version>55</dependency>5657<dependency>58<groupId>com.thoughtworks.xstream</groupId>59<artifactId>xstream</artifactId>60<version>1.4.1</version>61</dependency>6263<dependency>64<groupId>org.apache.bsf</groupId>65<artifactId>bsf-api</artifactId>66<version>3.1</version>67</dependency>6869<dependency>70<groupId>org.apache.zookeeper</groupId>71<artifactId>zookeeper</artifactId>72<version>3.4.6</version>73</dependency>7475<dependency>76<groupId>com.github.sgroschupf</groupId>77<artifactId>zkclient</artifactId>78<version>0.1</version>79</dependency>8081<dependency>82<groupId>org.apache.curator</groupId>83<artifactId>curator-framework</artifactId>84<version>2.5.0</version>85</dependency>8687<dependency>88<groupId>com.googlecode.xmemcached</groupId> 89<artifactId>xmemcached</artifactId>90<version>1.3.6</version>91</dependency>9293<dependency>94<groupId>org.apache.cxf</groupId>95<artifactId>cxf-rt-frontend-simple</artifactId>96<version>2.6.1</version>97</dependency>9899<dependency>100<groupId>org.apache.cxf</groupId>101<artifactId>cxf-rt-transports-http</artifactId>102<version>2.6.1</version>103</dependency>104105<dependency>106<groupId>org.apache.thrift</groupId>107<artifactId>libthrift</artifactId>108<version>0.8.0</version>109</dependency>110111<dependency>112<groupId>com.caucho</groupId>113<artifactId>hessian</artifactId>114<version>4.0.7</version>115</dependency>116117<dependency>118<groupId>javax.servlet</groupId>119<artifactId>javax.servlet-api</artifactId>120<version>3.1.0</version>125<artifactId>jetty</artifactId>126<version>6.1.26</version>127<exclusions>128<exclusion>129<groupId>org.mortbay.jetty</groupId>130<artifactId>servlet-api</artifactId>131</exclusion>132</exclusions>133</dependency>134135<dependency>136<groupId>log4j</groupId>137<artifactId>log4j</artifactId>138<version>1.2.16</version>139</dependency>140141<dependency>142<groupId>org.slf4j</groupId>143<artifactId>slf4j-api</artifactId>144<version>1.6.2</version>145</dependency>146147<dependency>148<groupId>redis.clients</groupId>149<artifactId>jedis</artifactId>150<version>2.1.0</version>151</dependency>152153<dependency>154<groupId>javax.validation</groupId>155<artifactId>validation-api</artifactId>156<version>1.0.0.GA</version>157</dependency>158159<dependency>160<groupId>org.hibernate</groupId>161<artifactId>hibernate-validator</artifactId>162<version>4.2.0.Final</version>163</dependency>164165<dependency>166<groupId>javax.cache</groupId>167<artifactId>cache-api</artifactId>168<version>0.4</version>169</dependency>170171<dependency>172<groupId>org.jboss.resteasy</groupId>173<artifactId>resteasy-jaxrs</artifactId>174<version>3.0.7.Final</version>175</dependency>176177<dependency>178<groupId>org.jboss.resteasy</groupId>179<artifactId>resteasy-client</artifactId>180<version>3.0.7.Final</version>181</dependency>182183<dependency>184<groupId>org.jboss.resteasy</groupId>185<artifactId>resteasy-netty</artifactId>186<version>3.0.7.Final</version>187</dependency>188189<dependency>190<groupId>org.jboss.resteasy</groupId>191<artifactId>resteasy-jdk-http</artifactId>192<version>3.0.7.Final</version>193</dependency>194195<dependency>196<groupId>org.jboss.resteasy</groupId>197<artifactId>resteasy-jackson-provider</artifactId> 198<version>3.0.7.Final</version>199</dependency>200201<dependency>202<groupId>org.jboss.resteasy</groupId>203<artifactId>resteasy-jaxb-provider</artifactId> 204<version>3.0.7.Final</version>208<groupId>org.apache.tomcat.embed</groupId>209<artifactId>tomcat-embed-core</artifactId>210<version>8.0.11</version>211</dependency>212213<dependency>214<groupId>org.apache.tomcat.embed</groupId>215<artifactId>tomcat-embed-logging-juli</artifactId>216<version>8.0.11</version>217</dependency>218219<dependency>220<groupId>com.esotericsoftware.kryo</groupId>221<artifactId>kryo</artifactId>222<version>2.24.0</version>223</dependency>224225<dependency>226<groupId>de.javakaffee</groupId>227<artifactId>kryo-serializers</artifactId>228<version>0.26</version>229</dependency>230231<dependency>232<groupId>de.ruedigermoeller</groupId>233<artifactId>fst</artifactId>234<version>1.55</version>235</dependency>236237</dependencies>238239240</project>View Code测试时，运⾏DemoProvider中的main⽅法即可启动服务，所有服务注册在ZooKeeper，层次结构类似下⾯这样：/dubbo/dubbo/erRestService/dubbo/erRestService/providers/dubbo/erRestService/configurators/dubbo/erService/dubbo/erService/providers/dubbo/erService/configurators三、服务消费⽅DemoConsumer.javapackage yjmyzz.dubbo.demo.consumer;import org.springframework.context.support.ClassPathXmlApplicationContext;import erService;import javax.ws.rs.client.Client;import javax.ws.rs.client.ClientBuilder;import javax.ws.rs.client.WebTarget;import javax.ws.rs.core.Response;public class DemoConsumer {public static void main(String[] args) {final String port = "8888";//测试Rest服务getUser("http://localhost:" + port + "/services/users/1.json");getUser("http://localhost:" + port + "/services/users/1.xml");//测试常规服务ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath*:META-INF/spring/*.xml");context.start();UserService userService = context.getBean(UserService.class);System.out.println(userService.getUser(1L));}private static void getUser(String url) {System.out.println("Getting user via " + url);Client client = ClientBuilder.newClient();WebTarget target = client.target(url);Response response = target.request().get();try {if (response.getStatus() != 200) {throw new RuntimeException("Failed with HTTP error code : " + response.getStatus());}System.out.println("Successfully got result: " + response.readEntity(String.class));} finally {response.close();client.close();}}}配置⽂件：resources\META-INF\spring\dubbo-hello-consumer.xml1<?xml version="1.0" encoding="UTF-8"?>2<beans xmlns="/schema/beans"3 xmlns:xsi="/2001/XMLSchema-instance"4 xmlns:dubbo="/schema/dubbo"5 xsi:schemaLocation="/schema/beans /schema/beans/spring-beans-2.5.xsd6 /schema/dubbo /schema/dubbo/dubbo.xsd">78<dubbo:application name="demo-consumer" owner="programmer" organization="dubbox"/>910<dubbo:registry address="zookeeper://127.0.0.1:2181"/>1112<dubbo:reference id="userRestService" interface="erRestService"/>1314<dubbo:reference id="userService" interface="erService"/>1516</beans>View Codepom.xml1<?xml version="1.0" encoding="UTF-8"?>2<project xmlns="/POM/4.0.0"3 xmlns:xsi="/2001/XMLSchema-instance"4 xsi:schemaLocation="/POM/4.0.0 /xsd/maven-4.0.0.xsd">56<modelVersion>4.0.0</modelVersion>78<groupId>blogs.yjmyzz</groupId>9<artifactId>dubbo-hello-consumer</artifactId>10<version>0.1</version>111213<dependencies>14<!--公⽤的服务接⼝-->15<dependency>16<groupId>blogs.yjmyzz</groupId>17<artifactId>dubbo-hello-api</artifactId>18<version>0.1</version>19</dependency>202122<dependency>23<groupId>com.alibaba</groupId>24<artifactId>dubbo</artifactId>25<version>2.8.4</version>26</dependency>2728<dependency>29<groupId>org.javassist</groupId>30<artifactId>javassist</artifactId>31<version>3.15.0-GA</version>32</dependency>3334<dependency>35<groupId>org.apache.mina</groupId>36<artifactId>mina-core</artifactId>37<version>1.1.7</version>38</dependency>3940<dependency>41<groupId>org.glassfish.grizzly</groupId>42<artifactId>grizzly-core</artifactId>4546<dependency>47<groupId>org.apache.httpcomponents</groupId> 48<artifactId>httpclient</artifactId>49<version>4.2.1</version>50</dependency>5152<dependency>53<groupId>com.alibaba</groupId>54<artifactId>fastjson</artifactId>55<version>1.1.39</version>56</dependency>5758<dependency>59<groupId>com.thoughtworks.xstream</groupId>60<artifactId>xstream</artifactId>61<version>1.4.1</version>62</dependency>6364<dependency>65<groupId>org.apache.bsf</groupId>66<artifactId>bsf-api</artifactId>67<version>3.1</version>68</dependency>6970<dependency>71<groupId>org.apache.zookeeper</groupId>72<artifactId>zookeeper</artifactId>73<version>3.4.6</version>74</dependency>7576<dependency>77<groupId>com.github.sgroschupf</groupId>78<artifactId>zkclient</artifactId>79<version>0.1</version>80</dependency>8182<dependency>83<groupId>org.apache.curator</groupId>84<artifactId>curator-framework</artifactId>85<version>2.5.0</version>86</dependency>8788<dependency>89<groupId>com.googlecode.xmemcached</groupId> 90<artifactId>xmemcached</artifactId>91<version>1.3.6</version>92</dependency>9394<dependency>95<groupId>org.apache.cxf</groupId>96<artifactId>cxf-rt-frontend-simple</artifactId>97<version>2.6.1</version>98</dependency>99100<dependency>101<groupId>org.apache.cxf</groupId>102<artifactId>cxf-rt-transports-http</artifactId>103<version>2.6.1</version>104</dependency>105106<dependency>107<groupId>org.apache.thrift</groupId>108<artifactId>libthrift</artifactId>109<version>0.8.0</version>110</dependency>111112<dependency>113<groupId>com.caucho</groupId>114<artifactId>hessian</artifactId>115<version>4.0.7</version>116</dependency>117118<dependency>119<groupId>javax.servlet</groupId>120<artifactId>javax.servlet-api</artifactId>121<version>3.1.0</version>122</dependency>123124<dependency>125<groupId>org.mortbay.jetty</groupId>126<artifactId>jetty</artifactId>129<exclusion>130<groupId>org.mortbay.jetty</groupId>131<artifactId>servlet-api</artifactId>132</exclusion>133</exclusions>134</dependency>135136<dependency>137<groupId>log4j</groupId>138<artifactId>log4j</artifactId>139<version>1.2.16</version>140</dependency>141142<dependency>143<groupId>org.slf4j</groupId>144<artifactId>slf4j-api</artifactId>145<version>1.6.2</version>146</dependency>147148<dependency>149<groupId>redis.clients</groupId>150<artifactId>jedis</artifactId>151<version>2.1.0</version>152</dependency>153154<dependency>155<groupId>javax.validation</groupId>156<artifactId>validation-api</artifactId>157<version>1.0.0.GA</version>158</dependency>159160<dependency>161<groupId>org.hibernate</groupId>162<artifactId>hibernate-validator</artifactId>163<version>4.2.0.Final</version>164</dependency>165166<dependency>167<groupId>javax.cache</groupId>168<artifactId>cache-api</artifactId>169<version>0.4</version>170</dependency>171172<dependency>173<groupId>org.jboss.resteasy</groupId>174<artifactId>resteasy-jaxrs</artifactId>175<version>3.0.7.Final</version>176</dependency>177178<dependency>179<groupId>org.jboss.resteasy</groupId>180<artifactId>resteasy-client</artifactId>181<version>3.0.7.Final</version>182</dependency>183184<dependency>185<groupId>org.jboss.resteasy</groupId>186<artifactId>resteasy-netty</artifactId>187<version>3.0.7.Final</version>188</dependency>189190<dependency>191<groupId>org.jboss.resteasy</groupId>192<artifactId>resteasy-jdk-http</artifactId>193<version>3.0.7.Final</version>194</dependency>195196<dependency>197<groupId>org.jboss.resteasy</groupId>198<artifactId>resteasy-jackson-provider</artifactId> 199<version>3.0.7.Final</version>200</dependency>201202<dependency>203<groupId>org.jboss.resteasy</groupId>204<artifactId>resteasy-jaxb-provider</artifactId> 205<version>3.0.7.Final</version>206</dependency>207208<dependency>209<groupId>org.apache.tomcat.embed</groupId> 210<artifactId>tomcat-embed-core</artifactId>211<version>8.0.11</version>212</dependency>213214<dependency>215<groupId>org.apache.tomcat.embed</groupId>216<artifactId>tomcat-embed-logging-juli</artifactId>217<version>8.0.11</version>218</dependency>219220<dependency>221<groupId>com.esotericsoftware.kryo</groupId>222<artifactId>kryo</artifactId>223<version>2.24.0</version>224</dependency>225226<dependency>227<groupId>de.javakaffee</groupId>228<artifactId>kryo-serializers</artifactId>229<version>0.26</version>230</dependency>231232<dependency>233<groupId>de.ruedigermoeller</groupId>234<artifactId>fst</artifactId>235<version>1.55</version>236</dependency>237</dependencies>238239240</project>View Code其它注意事项：dubbo构架中，zk充着“服务注册中⼼”的⾓⾊，所以⽣产者与消费者的xml配置⽂件中，都要配置zk地址，如果zk采⽤集群部署时，配置写法参考下⾯这样：<dubbo:registry address="zookeeper://172.28.*.102:2181?backup=172.28.*.102:2182,172.28.*.102:2183"/>dubbo还有⼀个管理界⾯，⽤于服务治理，包括启⽤/禁⽤服务，设置服务的路由规则（即：A地址的Consumer直接调⽤B机器的Provider，⽽不是由负载均衡算法分配）等等。
dubbo工作原理和机制
dubbo工作原理和机制
Dubbo是一款高性能、轻量级的分布式服务框架，它基于Java语言开发，致力于提供服务治理、服务调用和服务容错等一系列的分布式服务治理方案。
Dubbo 框架采用了一些关键的技术，如Netty网络通信框架、高效的序列化协议和注册中心等，使得Dubbo能够快速、可靠地运行大规模高并发的分布式应用系统。
Dubbo的工作原理主要是通过服务消费者、服务提供者和注册中心三个角色之间的协作来实现分布式服务的调用。
服务提供者将自己提供的服务发布到注册中心，服务消费者从注册中心中获取到服务提供者的地址列表，然后通过负载均衡算法选择其中一台服务提供者进行调用。
在调用服务提供者的过程中，Dubbo 框架会自动进行服务容错处理，例如超时重试、熔断降级等，确保服务的高可用性和可靠性。
Dubbo框架的工作机制主要分为两个部分：远程通信和服务治理。
远程通信部分主要是指Dubbo框架通过Netty网络通信框架实现了高效、可靠的RPC远程调用，同时支持多种序列化协议，如Hessian、Protobuf、JSON等，保证了服务之间的数据传输的高效和可扩展性。
服务治理部分主要是指Dubbo框架提供了完善的服务治理功能，包括动态配置、服务路由、负载均衡、集群容错等，保证了分布式应用系统的高可用性和可扩展性。
总体来说，Dubbo框架的工作原理和机制非常灵活和可扩展，可以根据项目的
实际需求进行灵活配置和使用。
通过Dubbo框架可以快速搭建分布式应用系统，提高系统的性能和可靠性。
dubbo案例
dubbo案例Dubbo是阿里巴巴开源的分布式服务框架，可以提供高性能、透明化的RPC远程服务调用功能，使得应用的开发更加简单和高效。
下面我们以一个在线购物网站为例，来介绍Dubbo的使用案例。
假设这个购物网站由前端、后端和数据库组成。
前端负责展示商品信息、购物车管理和下单操作，后端负责处理前端的请求并调用相应的服务，数据库则用来存储商品和用户信息。
首先，前端需要调用后端的服务来获取商品信息并展示在网页上。
在Dubbo中，我们可以定义一个服务接口ProductService，包含获取商品信息的方法getProductInfo()。
后端实现该接口，提供相应的服务，同时在Dubbo配置文件中指定该服务的端口号和版本号。
前端可以通过Dubbo提供的服务暴露和引用功能，从而实现远程调用后端的服务。
在前端的代码中，通过Dubbo的@Service注解将ProductService暴露为一个Dubbo服务，并在Dubbo配置文件中指定该服务的地址和端口号。
接下来，在前端的页面加载时，调用getProductInfo()方法来获取商品信息。
Dubbo会负责将该请求发送给后端，并将结果返回给前端。
前端可以根据返回的结果来展示商品信息。
此外，前端还可以调用后端的服务来进行购物车管理和下单操作。
在Dubbo中，我们可以定义一个服务接口CartService，包含添加商品到购物车和生成订单的方法。
后端实现该接口，提供相应的服务。
在前端的代码中，通过Dubbo的@Reference注解引用CartService，并调用相应的方法来实现购物车管理和下单操作。
Dubbo会负责将这些请求发送给后端，并将结果返回给前端。
总结一下，以上就是一个使用Dubbo的在线购物网站的案例。
通过Dubbo的高性能、透明化的RPC远程服务调用能力，前端可以方便地调用后端的服务来获取商品信息、进行购物车管理和下单操作。
这样不仅提升了整个网站系统的性能和效率，还简化了应用的开发。
dubbo基础功能介绍与使用
第4页/共37页
Dubbo如何使用
• 本地服务
<bean id=“xxxService” class=“com.xxx.XxxServiceImpl” /> <bean id=“xxxAction” class=“com.xxx.XxxAction”> <property name=“xxxService” ref=“xxxService” /> </bean>
建议由服务提供方设置超时，因 为一个方法需要执行多长时间， 服务提供方更清楚，如果一个消 费方同时引用多个服务，就不需 要关心每个服务的超时设置。
第11页/共37页
基本功能-可编程可配置-暴露服务
Байду номын сангаас
第12页/共37页
基本功能-可编程可配置-引用服务
第13页/共37页
基本功能-服务分组
当一个接口有多种实现时，可以用group区分
服务提供方：
<dubbo:service interface="com.foo.BarService" version="1.0.0" /> <dubbo:service interface="com.foo.BarService" version="2.0.0" />
服务消费方：
<dubbo:reference id="barService" interface="com.foo.BarService" version="1.0.0" /> <dubbo:reference id="barService" interface="com.foo.BarService" version="2.0.0" />
dubbo 工作原理
dubbo 工作原理Dubbo工作原理Dubbo是一款基于Java的高性能开源RPC框架，被广泛应用于分布式系统中。
它采用了面向接口的设计思想，提供了一种简单、轻量级的远程通信解决方案。
一、概述Dubbo的工作原理可以简单概括为：服务提供者将服务注册到注册中心，服务消费者从注册中心订阅服务，通过网络进行远程通信。
下面将详细介绍Dubbo的工作原理。
二、服务注册与发现Dubbo的核心是注册中心，它用于服务的注册与发现。
在Dubbo 中，服务提供者将自己提供的服务注册到注册中心，而服务消费者则从注册中心订阅所需的服务。
注册中心负责管理服务提供者和服务消费者之间的关系，并在需要时通知相应的服务提供者和服务消费者。
三、远程通信Dubbo使用了基于TCP的长连接进行远程通信。
在服务提供者启动后，它会向注册中心发送心跳包以保持连接，并定期上报自己提供的服务。
服务消费者则从注册中心获取服务提供者的地址，并建立与之的连接。
四、负载均衡Dubbo支持多种负载均衡算法，包括随机、轮询、最少活跃数等。
在服务消费者需要调用某个服务时，Dubbo会根据选择的负载均衡算法从多个服务提供者中选择一个合适的提供者。
五、服务调用与响应当服务消费者调用某个服务时，Dubbo会通过网络将请求发送给服务提供者。
服务提供者接收到请求后，会执行相应的逻辑，并将执行结果返回给服务消费者。
六、容错机制Dubbo提供了多种容错机制，包括失败重试、失败自动切换、失败快速失败等。
在服务调用过程中，如果发生了异常或超时，Dubbo 会根据配置进行相应的容错处理，以保证系统的稳定性和可靠性。
七、服务治理Dubbo提供了丰富的服务治理功能，包括监控、限流、熔断等。
通过这些功能，可以实现对服务的监控与管理，以及对服务的限制和保护。
总结：Dubbo作为一款高性能的RPC框架，采用了注册中心、远程通信、负载均衡、服务调用与响应、容错机制和服务治理等核心技术，实现了分布式系统中的服务提供与消费。
dubbo原理和机制
dubbo原理和机制Dubbo原理和机制。
Dubbo是阿里巴巴开源的一款高性能、轻量级的开源RPC框架。
它提供了完整的服务治理，包括服务发布、发现、调用、容错、负载均衡等一系列功能。
Dubbo的原理和机制是如何实现这些功能的呢？接下来我们将一一介绍。
首先，Dubbo的原理是基于分布式服务框架的。
它采用了面向接口的远程调用方式，通过代理对象来实现远程服务的调用。
Dubbo通过服务注册中心来管理服务的发布和发现，服务提供者将自己的服务注册到注册中心，而服务消费者则可以从注册中心获取服务提供者的地址信息，从而进行远程调用。
其次，Dubbo的机制是基于异步通信的。
Dubbo采用了NIO的方式来实现网络通信，通过线程池来处理并发请求。
这样可以大大提高系统的吞吐量和并发能力。
此外，Dubbo还实现了基于Filter的拦截机制，可以对服务的调用进行统一的拦截和处理，比如权限验证、日志记录等。
另外，Dubbo还实现了负载均衡和容错机制。
在服务调用时，Dubbo可以根据不同的负载均衡策略来选择合适的服务提供者，比如随机、轮询、一致性哈希等。
同时，Dubbo还可以实现服务的容错处理，比如服务提供者出现故障时，Dubbo可以自动切换到其他可用的服务提供者，从而保证系统的稳定性和可靠性。
总的来说，Dubbo的原理和机制是非常复杂和丰富的，它涵盖了分布式系统中的各个方面，包括服务治理、网络通信、负载均衡、容错处理等。
通过深入了解Dubbo的原理和机制，我们可以更好地理解Dubbo框架的设计思想和实现方式，从而更好地应用Dubbo来构建高性能、可靠的分布式系统。
希望本文对大家有所帮助，谢谢阅读！。
dubbo和dubboX与微服务架构（dubbo一）
dubbo和dubboX与微服务架构（dubbo⼀）⼀、传统三层架构模式的缺陷(3-tier architecture) 通常意义上的三层架构就是将整个业务应⽤划分为：界⾯层（User Interface layer）web、业务逻辑层（Business Logic Layer）service、数据访问层（Data access layer）dao。
区别于MVC1）MVC中的模型（Model）指的是数据模型，⽤于封装与应⽤程序的业务逻辑相关的数据，除此之外还可以封装数据的处理⽅法（相当于业务逻辑）。
这是完全区别于三层架构的模型层（Model）的。
MVC中模型（Model）的特点：①有对数据直接访问的权利，如：对数据库的访问；②模型（Model）“不依赖”视图（View）和控制器（Controller），即模型（Model）不关⼼它会被如何显⽰或者如何被操作；③模型（Model）中数据的变化⼀般会通过⼀种刷新机制被“公布”；④为了实现③中的“机制”⽤于监视此模型的视图必须事先在此模型上注册。
从⽽，视图可以了解在数据模型上发⽣的改变。
2）视图（View），这⾥的视图基本跟三层中的视图⼀样，都是为了显⽰数据，没有程序上的逻辑。
为了实现视图上数据的刷新，视图（View）需要访问它监视的模型（Model），所以应该事先在被它监视的数据那⾥进⾏注册。
3）控制器（Controller），这个概念是在三层中不存在的概念。
它主要起到不同层⾯的组织作⽤，⽤于控制应⽤程序的流程。
主要处理事件并作出相应。
“事件”主要包括：⽤户的⾏为和数据的改变。
那么具体的传统的三层架构模式缺点有什么呢？1、所有的代码都在同⼀个项⽬中维护，部署在同⼀个系统中2、所有的代码都在⼀个代码库，代码量⼤，访问⼈数多，导致访问效率低下3、分模块开发，各模块耦合度⼤，改⼀发动全⾝4、多层间有交叉，导致同步改变，失去分层独⽴性5、代码可读性差（模块耦合），运维团队看不懂代码6、拆分多个⼦系统时，做公共代码的服务化（解决重复性问题）量⼤⼆、什么是微服务架构？从上图可以看出，微服务架构是：按功能拆分模块，每个模块有服务消费者和服务提供者两个项⽬。
从零开始手写 dubbo rpc 框架-03-服务对象调用
rpcrpc是基于 netty 实现的 java rpc 框架，类似于 dubbo。
主要用于个人学习，由渐入深，理解 rpc 的底层实现原理。
服务对象调用功能实现 Client 端到服务端之间的固定服务 pojo 调用。
接口服务我们希望实现一个计算功能。
public interface Calculator {/***计算加法* @param request 请求入参*@return 返回结果*/CalculateResponse sum(final CalculateRequest request); }•服务端实现public class CalculatorService implements Calculator { @Overridepublic CalculateResponse sum(CalculateRequest request) { int sum = request.getOne()+request.getTwo();return new CalculateResponse(true, sum);}}pojo 信息入参和出参如下：•CalculateRequest.javapublic class CalculateRequest implements Serializable {private static final long serialVersionUID = 6420751004355300996L;/***参数一*/private int one;/***参数二*/private int two;//Getter & Setter}•CalculateResponse.javapublic class CalculateResponse implements Serializable {private static final long serialVersionUID = -1972014736222511341L;/***是否成功*/private boolean success;/***二者的和*/private int sum;//Getter & Setter}服务端核心代码RpcServerHandler主要处理客户端的调用请求。
dubbo官方配置指南
Configuration ReferenceConfiguration Relation:SLA配置在此完成！Service Layer Agreement∙ApplicationConfig 应用配置，用于配置当前应用信息，不管该应用是提供者还是消费者。
∙RegistryConfig 注册中心配置，用于配置连接注册中心相关信息。
∙ProtocolConfig 协议配置，用于配置提供服务的协议信息，协议由提供方指定，消费方被动接受。
∙ServiceConfig 服务配置，用于暴露一个服务，定义服务的元信息，一个服务可以用多个协议暴露，一个服务也可以注册到多个注册中心。
∙ProviderConfig 提供方的缺省值，当ProtocolConfig和ServiceConfig某属性没有配置时，采用此缺省值。
∙ReferenceConfig 引用配置，用于创建一个远程服务代理，一个引用可以指向多个注册中心。
∙ConsumerConfig 消费方缺省配置，当ReferenceConfig某属性没有配置时，采用此缺省值。
∙MethodConfig 方法配置，用于ServiceConfig和ReferenceConfig指定方法级的配置信息。
∙ArgumentConfig 用于指定方法参数配置。
Configuration Override:∙上图中以timeout为例，显示了配置的查找顺序，其它retries, loadbalance, actives等类似。
∙方法级优先，接口级次之，全局配置再次之。
∙如果级别一样，则消费方优先，提供方次之。
∙其中，服务提供方配置，通过URL经由注册中心传递给消费方。
∙建议由服务提供方设置超时，因为一个方法需要执行多长时间，服务提供方更清楚，如果一个消费方同时引用多个服务，就不需要关心每个服务的超时设置。
∙理论上ReferenceConfig的非服务标识配置，在ConsumerConfig，ServiceConfig, ProviderConfig均可以缺省配置。
从零开始手写 dubbo rpc 框架-12-generic泛化调用
rpcrpc是基于 netty 实现的 java rpc 框架，类似于 dubbo。
主要用于个人学习，由渐入深，理解 rpc 的底层实现原理。
generic 泛化调用说明泛化接口调用方式主要用于客户端没有 API 接口及模型类元的情况，参数及返回值中的所有 POJO 均用 Map 表示，通常用于框架集成，比如：实现一个通用的服务测试框架，可通过 GenericService 调用所有服务实现。
GenericService barService = (GenericService) applicationContext.getBean ("barService");Object result = barService.$invoke("sayHello", new String[] { "n g.String" }, new Object[] { "World" });实现思路客户端泛化调用个人感受不是很深，但是有一点，当没有服务端接口的时候，也就无法通过反射获取对应的方法等原始信息。
所以需要额外提供一个接口，并且可以获取方法的相关属性。
服务端本次基本没做处理。
个人理解是客户使用的时候自行定义实现类。
客户端实现接口/***泛化调用接口*（1）接口直接使用 dubbo 的接口***【应用场景】*泛接口实现方式主要用于服务器端没有API接口及模型类元的情况，参数及返回值中的所有POJO均用Map表示，通常用于框架集成，比如：实现一个通用的远程服务Mock框架，可通过实现GenericService接口处理所有服务请求。
**【服务端】*服务端代码不需要做任何调整。
*客户端泛化调用进行相关调整即可。
**【客户端】** @author binbin.hou*@since 0.1.2*/public interface GenericService {/*** Generic invocation** @param method Method name, e.g. findPerson. If there are overridden methods, parameter info is* required, e.g. findPerson(ng.String) *@param parameterTypes Parameter types*@param args Arguments*@return invocation return value*@throws GenericException potential exception thrown from the inv ocation*/Object $invoke(String method, String[] parameterTypes, Object[] arg s) throws GenericException;}默认实现默认的实现，其实和基于接口的动态代理非常的类似。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
• dubbo:protocol 配置发布服布协议相关信息
• name：协议名称，必填 • host：服务主机名，多网卡选择或指定VIP及域名时使用，为空则自动查找本机IP，建议不要配置 • port：服务端口，默认为20880，建议配置 • • • • interface：服务接口名（包名+类名），必填 ref：服务对象实现引用（spring注册BeanID），必填 group：服务分组，当一个接口有多个实现，可以用分组区分，建议必填 version：服务版本，建议使用两位数字版本，通常在接口不兼容时版本号才需要升级，建议配置
• dubbo:reference 配置服务消费者相关信息
• • • • • • •
id：服务引用spring的BeanID，必填 interface：服务接口名（包名+类名），必填 group：服务分组，必需和服务提供方一致，建议配置 check：启动时检查提供者是否存在，true报错，false忽略，默认true，建议配置 timeout：服务方法调用超时时间（毫秒），默认1000 retries：远程服务调用重试次数，不包括第一次调用，不需要重试设为0 version：服务版本，建议使用两位数字版本，通常在接口不兼容时版本号才需要升级，建议配置信息
• protocol：目前统一使用zookeeper为注册中心，必填 • address：注册中心服务器地址，同一集群内多个地址用逗号分隔，必填
dubbo服务提供者配置
• dubbo-publish.xml
<beans xmlns="/schema/beans" xmlns:xsi="/2001/XMLSchema-instance" xmlns:dubbo="/schema/dubbo" xsi:schemaLocation="/schema/beans /schema/beans/spring-beans-4.0.xsd /schema/dubbo /schema/dubbo/dubbo.xsd"> <dubbo:protocol name="dubbo" host=“192.168.1.180" port="20880"/> <dubbo:service interface="com.fun1.service.OrderService" ref="orderServiceImpl" group="orderService" version=“1.0"/> </beans>
• 高性能和透明化的RPC远程服务调用方案
• SOA服务治理方案 • 基于TCP长连接Reactor模型通信框架
dubbo概述
• 架构演进
• 单一应用架构（ORM） • 垂直应用架构（MVC） • 分布式服务架构（SOA）
• 现实需求
• 管理繁重的服务URL配置及负载均衡需求（注册中心） • 梳理服务间的依赖关系 • 服务器的规划参考（服务调用量、响应时间）
• 服务调用不到
• • • •
• 确定service和reference的group、interface、version配置是否一致 原因1：远程service没有注册到zookeeper上，no provider 原因2：远程service注册到zookeeper上，但是地址和被调用方不在一个网段 原因3：zookeeper配置有问题 原因4：reference声明的group和服务发布者不一致
dubbo全局配置
• spring-dubbo.xml
<beans xmlns="/schema/beans" xmlns:xsi="/2001/XMLSchema-instance" xmlns:dubbo="/schema/dubbo" xsi:schemaLocation="/schema/beans /schema/beans/spring-beans-4.0.xsd /schema/dubbo /schema/dubbo/dubbo.xsd “> <dubbo:application name="bone-demo" owner="programmer" organization="dubbo" environment="dev"/> <dubbo:registry protocol="zookeeper" address="127.0.0.1:2181"/> </beans>
• dubbo的reference不起作用
• dubbo服务无法启动
• 端口被占用（20880） • zookeeper配置有问题
FAQ
• dubbo调用参数的一些注意事项
• 不要用除了Map及其子类/Collection及其子类、提供了get/set方法的JavaBean以外的Java类 当参数 • 当使用网关时参数的类必须实现无参的构造函数 • 当使用网关时对象属性的每个单词不要使用单个字母，如int a
• dubbo:service
dubbo服务消费者配置
• dubbo-ref.xml
<beans xmlns="/schema/beans" xmlns:xsi="/2001/XMLSchema-instance" xmlns:dubbo="/schema/dubbo" xsi:schemaLocation="/schema/beans /schema/beans/spring-beans-4.0.xsd /schema/dubbo /schema/dubbo/dubbo.xsd"> <dubbo:reference id="orderService" version="1.0" interface="com.fun1.service.OrderService" group=“orderService" check="false" timeout="1000" retries="0"/> </beans>
• 注意org.springframework.stereotype.Service和 com.alibaba.dubbo.config.annotation.Service，如果由spring创建对象并管理，应选择前者
THANKS
• • • • • Provider：暴露服务的服务提供方 Consumer：调用远程服务的服务消费方 Registry：服务注册与发现中心 Monitor：服务的调用次数和调用时间的监控中心 Container：服务运行容器
• 调用关系说明
• • • •
服务容器负责启动、加载，运行服务提供者 服务提供者启动时，向注册中心注册自己提供的服务 服务消费者在启动时，向注册中心订阅自己所需的服务 注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据 给消费者 • 服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者调用，如果调用失败， 再选另一台调用 • 服务消费者和提供者，在内存中累计调用次数和调用时间，定时发送一次统计数据到监控中心
dubbo服务框架
基础篇
目录
• dubbo概述 • dubbo全局配置
• dubbo服务提供者配置
• dubbo服务消费者配置 • dubbo管理端
dubbo概述
• dubbo 是阿里巴巴公司开源的一个高性能优秀的服务框架，使得应用可通过高性能的 RPC 实现服务的输出和输入功能，可以和 Spring框架无缝集成。
dubbo管理端
• 提供dubbo服务统一管理控制台
dubbo规划
• 重写dubbo统一管理控制台
• 服务治理 • 性能监控
FAQ
• dubbo配置文件xml报错
<beans xmlns="/schema/beans" xmlns:xsi="/2001/XMLSchema-instance" xmlns:dubbo="/schema/dubbo" xsi:schemaLocation="/schema/beans /schema/beans/spring-beans-4.0.xsd /schema/dubbo /schema/dubbo/dubbo.xsd"> </beans>
• dubbo服务开发时没问题，在测试上发布不能访问
• 多网卡情况下要配置host地址
• dubbo的超时重试配置
• <dubbo:referenes ... timeout="1000"/> • <dubbo:service ... timeout="1000"/>
• spring的注解服务不能被component-scan识别
• dubbo:application 配置应用相关信息
• • • •
name：应用名称，用于注册中心计算应用间依赖关系，消费者和提供者应用名不要一样，必填 owner：应用负责人，用于服务治理，可选 organization：组织名称，用于注册中心区分服务来源，可选 environment：应用环境，可选值develop/test/production，必填
dubbo概述
• 透明化的远程方法调用，就像调用本地方法一样调用远程方法，只需简单配置，没有任何 API侵入。