Dubbo从入门到实战
1、为什么需要dubbo
很多时候,其实我们使用这个技术的时候,可能都是因为项目需要,所以,我们就用了,但是,至于为什么我们需
要用到这个技术,可能自身并不是很了解的,但是,其实了解技术的来由及背景知识,对于理解一项技术还是有帮
助的,那么,dubbo是怎么被提上日程的呢?
在互联网的发展过程中,在以前,我们只需要一个服务器,将程序全部打包好就可以,但是,随着流量的增大,常
规的垂直应用架构已无法应对,所以,架构就发生了演变。
-
单一应用架构
-
应用和数据库单独部署
-
应用和数据库集群部署
-
数据库压力变大,读写分离
-
使用缓存技术加快速度
-
数据库分库分表
-
应用分为不同的类型拆分
发展到这个阶段的时候,我们发现,应用与应用之间的关系已经十分的复杂了,就会出现以下几个问题(以下摘录
于官网):
1、当服务越来越多时,服务 URL 配置管理变得非常困难,F5 硬件负载均衡器的单点压力也越来越大。
2、当进一步发展,服务间依赖关系变得错踪复杂,甚至分不清哪个应用要在哪个应用之前启动,架构师都不能完
整的描述应用的架构关系。
3、接着,服务的调用量越来越大,服务的容量问题就暴露出来,这个服务需要多少机器支撑?什么时候该加机器?
为了解决这由于架构的演变所产生的问题几个问题,于是,dubbo 产生了。当然,解决这个问题的技术不止
dubbo。
从上面 Dubbo 的服务治理图我们就可以看到,Dubbo 很好了解决了上面所出现的一些问题。
所以,当你的系统架构发展到了这种阶段的时候,就需要考虑使用 Dubbo 了。
2、Dubbo技术架构
我们已经非常清楚的知道为什么在我们的系统中需要 Dubbo 这项技术了,下面,我们接着唠叨唠叨 Dubbo 的架
构。首先,上一张图(摘自官网)。
看到图之后,可能你对上面的几个概念还是一脸懵逼,无从下手,下面,带你看看这几个角色到底是什么意思?
节点角色说明:
节点 | 角色说明 |
---|---|
Provider | 暴露服务的服务提供方 |
Consumer | 调用远程服务的服务消费方 |
Registry | 服务注册与发现的注册中心 |
Monitor | 统计服务的调用次数和调用时间的监控中心 |
Container | 服务运行容器 |
看了这几个概念后似乎发现,其实 Dubbo 的架构也是很简单的(其实现细节是复杂的),为什么这么说呢,有没有
发现,其实很像生产者-消费者模型。只是在这种模型上,加上了注册中心和监控中心,用于管理提供方提供的
url,以及管理整个过程。
那么,整个发布-订阅的过程就非常的简单了。
-
启动容器,加载,运行服务提供者。
-
服务提供者在启动时,在注册中心发布注册自己提供的服务。
-
服务消费者在启动时,在注册中心订阅自己所需的服务。
如果考虑失败或变更的情况,就需要考虑下面的过程。
-
注册中心返回服务提供者地址列表给消费者,如果有变更,注册中心将基于长连接推送变更数据给消费者。
-
服务消费者,从提供者地址列表中,基于软负载均衡算法,选一台提供者进行调用,如果调用失败,再选另一
台调用。
-
服务消费者和提供者,在内存中累计调用次数和调用时间,定时每分钟发送一次统计数据到监控中心。
通过这番讲解,我相信 Dubbo 的架构我们也轻车熟路了,那就直接入手。
3、Dubbo开始入门
3.1 服务端(dubbo-provider)
首先,我们先把服务端的接口写好,因为其实 dubbo 的作用简单来说就是给消费端提供接口。
3.1.1 接口定义
/*** xml方式服务提供者接口*/
package com.dubbo.provider.service;public interface ProviderService {public String SayHello(String word);
}
这个接口非常简单,只是包含一个 SayHello 的方法。
接着,定义它的实现类。
/*** xml方式服务提供者实现类*/
package com.dubbo.provider.service.impl;import com.dubbo.provider.service.ProviderService;public class ProviderServiceImpl implements ProviderService {@Overridepublic String SayHello(String word) {return word;}
}
这样我们就把我们的接口写好了,那么我们应该怎么将我们的服务暴露出去呢?
3.1.2 导入 maven 依赖
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com.dubbo.provider</groupId><artifactId>dubbo-provider</artifactId><version>0.0.1-SNAPSHOT</version><name>dubbo-provider</name><description>dubbo-provider</description><properties><java.version>1.8</java.version></properties><dependencies><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>3.8.1</version><scope>test</scope></dependency><dependency><groupId>com.alibaba</groupId><artifactId>dubbo</artifactId><version>2.6.6</version></dependency><dependency><groupId>org.apache.zookeeper</groupId><artifactId>zookeeper</artifactId><version>3.4.10</version></dependency><dependency><groupId>com.101tec</groupId><artifactId>zkclient</artifactId><version>0.5</version></dependency><dependency><groupId>io.netty</groupId><artifactId>netty-all</artifactId><version>4.1.32.Final</version></dependency><dependency><groupId>org.apache.curator</groupId><artifactId>curator-framework</artifactId><version>2.8.0</version></dependency><dependency><groupId>org.apache.curator</groupId><artifactId>curator-recipes</artifactId><version>2.8.0</version></dependency></dependencies><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins></build></project>
这里使用的 dubbo 的版本是 2.6.6
,需要注意的是,如果你只导入 dubbo 的包的时候是会报错的,找不到
netty 和 curator 的依赖,所以,在这里我们需要把这两个的依赖加上,就不会报错了。
另外,这里我们使用 zookeeper 作为注册中心。
到目前为止,dubbo 需要的环境就已经可以了,下面,我们就把上面刚刚定义的接口暴露出去。
3.1.3 暴露接口(xml配置方法)
首先,我们在我们项目的 resource 目录下创建 META-INF/spring
包,然后再创建 provider.xml
文件,名字
可以任取哦。
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://code.alibabatech.com/schema/dubbohttp://code.alibabatech.com/schema/dubbo/dubbo.xsd"><!--当前项目在整个分布式架构里面的唯一名称,计算依赖关系的标签--><dubbo:application name="provider" owner="sihai"><dubbo:parameter key="qos.enable" value="true"/><dubbo:parameter key="qos.accept.foreign.ip" value="false"/><dubbo:parameter key="qos.port" value="55555"/></dubbo:application><dubbo:monitor protocol="registry"/><!--dubbo这个服务所要暴露的服务地址所对应的注册中心--><dubbo:registry address="N/A"/><!--当前服务发布所依赖的协议:webserovice、Thrift、Hessain、http--><dubbo:protocol name="dubbo" port="20880"/><!--服务发布的配置,需要暴露的服务接口--><dubbo:serviceinterface="com.dubbo.provider.service.ProviderService"ref="providerService"/><!--Bean bean定义--><bean id="providerService" class="com.dubbo.provider.service.impl.ProviderServiceImpl"/></beans>
①、上面的文件其实就是类似 spring 的配置文件,而且,dubbo 底层就是 spring。
②、节点:dubbo:application
就是整个项目在分布式架构中的唯一名称,可以在 name
属性中配置,另外还可以配置 owner
字段,表示属于
谁。下面的参数是可以不配置的,这里配置是因为出现了端口的冲突,所以配置。
③、节点:dubbo:monitor
监控中心配置, 用于配置连接监控中心相关信息,可以不配置,不是必须的参数。
④、节点:dubbo:registry
配置注册中心的信息,比如,这里我们可以配置 zookeeper 作为我们的注册中心。address
是注册中心的地址,
这里我们配置的是 N/A
表示由 dubbo 自动分配地址。或者说是一种直连的方式,不通过注册中心。
⑤、节点:dubbo:protocol
服务发布的时候 dubbo 依赖什么协议,可以配置 dubbo、webserovice、Thrift、Hessain、http等协议。
⑥、节点:dubbo:service
这个节点就是我们的重点了,当我们服务发布的时候,我们就是通过这个配置将我们的服务发布出去的。
interface
是接口的包路径,ref
是第⑦点配置的接口的 bean。
⑦、最后,我们需要像配置 spring 的接口一样,配置接口的 bean。
到这一步,关于服务端的配置就完成了,下面我们通过 main
方法将接口发布出去。
3.1.4 发布接口
package com.dubbo.provider;import org.springframework.context.support.ClassPathXmlApplicationContext;import java.io.IOException;/*** xml方式启动*/
public class App {public static void main(String[] args) throws IOException {//加载xml配置文件启动ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("META-INF/spring/provider.xml");context.start();// 按任意键退出System.in.read();}
}
发布接口非常简单,因为 dubbo 底层就是依赖 spring 的,所以,我们只需要通过
ClassPathXmlApplicationContext
拿到我们刚刚配置好的 xml ,然后调用 context.start()
方法就启动
了。启动成功了,接口也就发布出去了。
你以为到这里就结束了了,并不是的,我们拿到 dubbo 暴露出去的 url分析分析。
3.1.5 dubbo 暴露的 url
dubbo://192.168.136.185:20880/com.dubbo.provider.service.ProviderService
①、首先,在形式上我们发现,其实这么牛逼的 dubbo 也是用类似于 http 的协议发布自己的服务的,只是这里
我们用的是 dubbo 协议。
②、dubbo://192.168.136.185:20880/com.dubbo.provider.service.ProviderService
上面这段链接就是?
之前的链接,构成:协议://ip:端口/接口
。
3.2 消费端(dubbo-consumer)
上面提到,我们在服务端提供的只是点对点的方式提供服务,并没有使用注册中心,所以,下面的配置也是会有一
些不一样的。
3.2.1 消费端环境配置
首先,我们在消费端的 resource 下建立配置文件 consumer.xml
。
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:dubbo="http://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:application name="consumer" owner="sihai"/><!--dubbo这个服务所要暴露的服务地址所对应的注册中心--><!--点对点的方式--><dubbo:registry address="N/A"/><!--<dubbo:registry address="zookeeper://localhost:2181" check="false"/>--><!--生成一个远程服务的调用代理--><!--点对点方式--><dubbo:reference id="providerService"interface="com.dubbo.provider.service.ProviderService"url="dubbo://192.168.136.185:20880/com.dubbo.provider.service.ProviderService"/></beans>
①、发现这里的 dubbo:application
和 dubbo:registry
是一致的。
②、dubbo:reference
:我们这里采用点对点的方式,所以需要配置在服务端暴露的 url 。
3.2.2 maven 依赖
和服务端一样:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com.dubbo.consumer</groupId><artifactId>dubbo-consumer</artifactId><version>0.0.1-SNAPSHOT</version><name>dubbo-consumer</name><description>dubbo-consumer</description><properties><java.version>1.8</java.version></properties><dependencies><dependency><groupId>com.dubbo.provider</groupId><artifactId>dubbo-provider</artifactId><version>0.0.1-SNAPSHOT</version></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>3.8.1</version><scope>test</scope></dependency><!-- https://mvnrepository.com/artifact/com.alibaba/dubbo --><dependency><groupId>com.alibaba</groupId><artifactId>dubbo</artifactId><version>2.6.6</version></dependency><dependency><groupId>org.apache.zookeeper</groupId><artifactId>zookeeper</artifactId><version>3.4.10</version></dependency><dependency><groupId>com.101tec</groupId><artifactId>zkclient</artifactId><version>0.5</version></dependency><dependency><groupId>io.netty</groupId><artifactId>netty-all</artifactId><version>4.1.32.Final</version></dependency><dependency><groupId>org.apache.curator</groupId><artifactId>curator-framework</artifactId><version>2.8.0</version></dependency><dependency><groupId>org.apache.curator</groupId><artifactId>curator-recipes</artifactId><version>2.8.0</version></dependency></dependencies><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins></build></project>
3.2.3 调用服务
package com.dubbo.consumer;import com.dubbo.provider.service.ProviderService;
import org.springframework.context.support.ClassPathXmlApplicationContext;import java.io.IOException;/*** xml的方式调用**/
public class App
{public static void main( String[] args ) throws IOException {ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("consumer.xml");context.start();ProviderService providerService = (ProviderService) context.getBean("providerService");String str = providerService.SayHello("hello");System.out.println(str);System.in.read();}
}
这里和服务端的发布如出一辙。
# 输出
hello
如此,我们就成功调用接口了。
4、加入zookeeper作为注册中心
在前面的案例中,我们没有使用任何的注册中心,而是用一种直连的方式进行的。但是,实际上很多时候,我们都
是使用 dubbo + zookeeper 的方式,使用 zookeeper 作为注册中心,这里,我们就介绍一下 zookeeper 作为注
册中心的使用方法。
这里,我们在前面的入门实例中进行改造。
4.1 服务端(dubbo-provider1)
在服务端中,我们只需要修改 provider.xml
即可。
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://code.alibabatech.com/schema/dubbohttp://code.alibabatech.com/schema/dubbo/dubbo.xsd"><!--当前项目在整个分布式架构里面的唯一名称,计算依赖关系的标签--><dubbo:application name="provider" owner="sihai"><dubbo:parameter key="qos.enable" value="true"/><dubbo:parameter key="qos.accept.foreign.ip" value="false"/><dubbo:parameter key="qos.port" value="55555"/></dubbo:application><dubbo:monitor protocol="registry"/><!--dubbo这个服务所要暴露的服务地址所对应的注册中心--><!-- <dubbo:registry address="N/A"/> --><dubbo:registry address="zookeeper://localhost:2181" check="false"/><!--当前服务发布所依赖的协议:webserovice、Thrift、Hessain、http--><dubbo:protocol name="dubbo" port="20880"/><!--服务发布的配置,需要暴露的服务接口--><dubbo:serviceinterface="com.dubbo.provider1.service.ProviderService"ref="providerService"/><!--Bean bean定义--><bean id="providerService" class="com.dubbo.provider1.service.impl.ProviderServiceImpl"/></beans>
重点关注这句话:
<dubbo:registry address="zookeeper://localhost:2181" />
在 address 中,使用我们的 zookeeper 的地址。
如果是 zookeeper 集群 的话,使用下面的方式。
<dubbo:registry protocol="zookeeper" address="192.168.11.129:2181,192.168.11.137:2181,192.168.11.138:2181"/>
服务端的配置就好了,其他的跟入门案例 一样。
4.2 消费端(dubbo-consumer1)
跟服务端一样,在消费端,我们也只需要修改 consumer.xml
即可。
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:dubbo="http://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:application name="consumer" owner="sihai"/><!--dubbo这个服务所要暴露的服务地址所对应的注册中心--><!--点对点的方式--><!-- <dubbo:registry address="N/A" /> --><dubbo:registry address="zookeeper://localhost:2181" check="false"/><!--生成一个远程服务的调用代理--><!--点对点方式--><dubbo:reference id="providerService"interface="com.dubbo.provider1.service.ProviderService"/></beans>
①、注册中心配置跟服务端一样。
<dubbo:registry address="zookeeper://localhost:2181"/>
②、dubbo:reference
由于我们这里使用 zookeeper 作为注册中心,所以,跟点对点的方式是不一样的,这里不再需要 dubbo 服务端提
供的 url 了,只需要直接引用服务端提供的接口即可。
<dubbo:reference id="providerService"interface="com.dubbo.provider1.service.ProviderService"/>
好了,消费端也配置好了,这样就可以使用修改的入门案例,重新启动运行了。
# 输出
hello
同样成功了。
这时候的区别在于,将 dubbo 发布的 url 注册到了 zookeeper,消费端从 zookeeper 消费,zookeeper 相当于
一个中介,给消费者提供服务。
你以为这就完了?不,好戏才刚刚开始呢。
5、多种配置方式
在入门实例的时候,我们使用的是 xml 配置的方式,对 dubbo 的环境进行了配置,但是,官方还提供了其他的配
置方式,这里我们也一一分解。
5.1 API配置方式
这种方式其实官方是不太推荐的,官方推荐使用 xml 配置的方式,但是,在有的时候测试的时候,还是可以用的
到的,另外,为了保证完整性,这些内容还是有必要讲讲的。
首先还是回到服务端工程。
5.1.1 服务端(dubbo-provider2)
这里我们使用 api 的方式配置,所以,provider.xml
这个配置文件就暂时不需要了,我们只需要在上面的
AppApi
这个类中的 main
方法中用 api配置及启动即可。
package com.dubbo.provider2;import com.alibaba.dubbo.config.ApplicationConfig;
import com.alibaba.dubbo.config.ProtocolConfig;
import com.alibaba.dubbo.config.RegistryConfig;
import com.alibaba.dubbo.config.ServiceConfig;
import com.dubbo.provider2.service.ProviderService;
import com.dubbo.provider2.service.impl.ProviderServiceImpl;import java.io.IOException;/*** Api方式启动* api的方式调用不需要其他的配置,只需要下面的代码即可。* 但是需要注意,官方建议:* Api方式用于测试用例使用,推荐xml的方式*/
public class App {public static void main(String[] args) throws IOException {// 服务实现ProviderService providerService = new ProviderServiceImpl();// 当前应用配置ApplicationConfig application = new ApplicationConfig();application.setName("provider");application.setOwner("sihai");// 连接注册中心配置RegistryConfig registry = new RegistryConfig();// registry.setAddress("zookeeper://localhost:2181");registry.setAddress("localhost:2181");registry.setProtocol("zookeeper");registry.setCheck(false);// registry.setUsername("root");// registry.setPassword("root");// 服务提供者协议配置ProtocolConfig protocol = new ProtocolConfig();protocol.setName("dubbo");protocol.setPort(20880);// protocol.setThreads(200);// 注意:ServiceConfig为重对象,内部封装了与注册中心的连接,以及开启服务端口// 服务提供者暴露服务配置// 此实例很重,封装了与注册中心的连接,请自行缓存,否则可能造成内存和连接泄漏ServiceConfig<ProviderService> service = new ServiceConfig<ProviderService>();service.setApplication(application);// 多个注册中心可以用setRegistries()service.setRegistry(registry);// 多个协议可以用setProtocols()service.setProtocol(protocol);service.setInterface(ProviderService.class);service.setRef(providerService);// 暴露及注册服务service.export();System.in.read();}
}
看到上面的代码是不是云里雾里,不要慌,我们通过对照 xml 的方式分析一下。
registry 的 xml 方式
<dubbo:registry protocol="zookeeper" address="localhost:2181"/>
API 的方式
RegistryConfig registry = new RegistryConfig();
registry.setAddress("zookeeper://localhost:2181");
dubbo:registry
节点对应RegistryConfig
,xml 的属性对应 API 方式用 set
方法就可以了。对比之下,你就
会发现,如果 API 的方式不熟悉,可以对照 xml 配置方式就可以。
其他 API
org.apache.dubbo.config.ServiceConfig
org.apache.dubbo.config.ReferenceConfig
org.apache.dubbo.config.ProtocolConfig
org.apache.dubbo.config.RegistryConfig
org.apache.dubbo.config.MonitorConfig
org.apache.dubbo.config.ApplicationConfig
org.apache.dubbo.config.ModuleConfig
org.apache.dubbo.config.ProviderConfig
org.apache.dubbo.config.ConsumerConfig
org.apache.dubbo.config.MethodConfig
org.apache.dubbo.config.ArgumentConfig
更详细的可以查看官方文档:
https://cn.dubbo.apache.org/zh-cn/overview/mannual/java-sdk/
我们再看看我配置的消费端的 Api 方式。
5.1.2 消费端
同样,我们不需要 consumer.xml 配置文件了,只需要在 main
方法中启动即可。
package com.dubbo.consumer;import com.alibaba.dubbo.config.ApplicationConfig;
import com.alibaba.dubbo.config.ReferenceConfig;
import com.alibaba.dubbo.config.RegistryConfig;
import com.dubbo.provider2.service.ProviderService;/*** api的方式调用* api的方式调用不需要其他的配置,只需要下面的代码即可。* 但是需要注意,官方建议:* Api方式用于测试用例使用,推荐xml的方式*/
public class App {public static void main(String[] args) {// 当前应用配置ApplicationConfig application = new ApplicationConfig();application.setName("consumer");application.setOwner("sihai");// 连接注册中心配置RegistryConfig registry = new RegistryConfig();// registry.setAddress("zookeeper://localhost:2181");registry.setAddress("localhost:2181");registry.setProtocol("zookeeper");registry.setCheck(false);// 注意:ReferenceConfig为重对象,内部封装了与注册中心的连接,以及与服务提供方的连接// 引用远程服务// 此实例很重,封装了与注册中心的连接以及与提供者的连接,请自行缓存,否则可能造成内存和连接泄漏ReferenceConfig<ProviderService> reference = new ReferenceConfig<ProviderService>();reference.setApplication(application);// 多个注册中心可以用setRegistries()reference.setRegistry(registry);reference.setInterface(ProviderService.class);// 和本地bean一样使用xxxService// 注意:此代理对象内部封装了所有通讯细节,对象较重,请缓存复用ProviderService providerService = reference.get();String result = providerService.SayHello("hello");System.out.println(result);}
}
# 输出
hello
这部分的 API 配置的方式就到这了,注意:官方推荐 xml 的配置方法。
5.2 注解配置方式
注解配置方式还是需要了解一下的,现在微服务都倾向于这种方式,这也是以后发展的趋势,0 配置应该是这几年
的趋势。
那么如何对 dubbo 使用注解的方式呢?我们先看服务端。
5.2.1 服务端(dubbo-provider3)
第一步:定义接口及实现类
package com.dubbo.provider.service;/*** 注解方式接口*/
public interface ProviderServiceAnnotation {String SayHelloAnnotation(String word);
}
package com.dubbo.provider.service;import com.alibaba.dubbo.config.annotation.Service;/*** 注解方式实现类*/
@Service(timeout = 5000)
public class ProviderServiceImplAnnotation implements ProviderServiceAnnotation {@Overridepublic String SayHelloAnnotation(String word) {return word;}
}
@Service
用来配置 Dubbo 的服务提供方。
第二步:组装服务提供方。通过 Spring 中 Java Config
的技术(@Configuration
)和 annotation 扫描
(@EnableDubbo
)来发现、组装、并向外提供 Dubbo 的服务。
package com.dubbo.provider.config;import com.alibaba.dubbo.config.ApplicationConfig;
import com.alibaba.dubbo.config.ProtocolConfig;
import com.alibaba.dubbo.config.ProviderConfig;
import com.alibaba.dubbo.config.RegistryConfig;
import com.alibaba.dubbo.config.spring.context.annotation.EnableDubbo;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;/*** 注解方式配置*/
@Configuration
@EnableDubbo(scanBasePackages = "com.dubbo.provider.service")
public class DubboConfiguration {// #1 服务提供者信息配置@Beanpublic ProviderConfig providerConfig() {ProviderConfig providerConfig = new ProviderConfig();providerConfig.setTimeout(1000);return providerConfig;}// #2 分布式应用信息配置@Beanpublic ApplicationConfig applicationConfig() {ApplicationConfig applicationConfig = new ApplicationConfig();applicationConfig.setName("dubbo-annotation-provider");return applicationConfig;}// #3 注册中心信息配置@Beanpublic RegistryConfig registryConfig() {RegistryConfig registryConfig = new RegistryConfig();registryConfig.setProtocol("zookeeper");registryConfig.setAddress("localhost");registryConfig.setPort(2181);return registryConfig;}// #4 使用协议配置,这里使用 dubbo@Beanpublic ProtocolConfig protocolConfig() {ProtocolConfig protocolConfig = new ProtocolConfig();protocolConfig.setName("dubbo");protocolConfig.setPort(20880);return protocolConfig;}
}
-
通过 @EnableDubbo 指定在
com.sihai.dubbo.provider.service.annotation
下扫描所有标注有@Service
的类 -
通过
@Configuration
将DubboConfiguration
中所有的@Bean
通过Java Config
的方式组装出来并注入给 Dubbo 服务,也就是标注有
@Service
的类。这其中就包括了: -
ProviderConfig:服务提供方配置
-
ApplicationConfig:应用配置
-
RegistryConfig:注册中心配置
-
ProtocolConfig:协议配置
第三步:启动服务
package com.dubbo.provider;import com.dubbo.provider.config.DubboConfiguration;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;import java.io.IOException;/*** 注解启动方式*/
public class App {public static void main(String[] args) throws IOException {AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(DubboConfiguration.class);context.start();System.in.read();}
}
5.2.2 消费端(dubbo-provider3)
同样我们下看看消费端的工程,有一个感性认识。
第一步:引用服务
package com.dubbo.consumer.service;import com.alibaba.dubbo.config.annotation.Reference;
import com.dubbo.provider.service.ProviderServiceAnnotation;
import org.springframework.stereotype.Component;/*** 注解方式的service*/
@Component("annotatedConsumer")
public class ConsumerAnnotationService {@Referenceprivate ProviderServiceAnnotation providerServiceAnnotation;public String doSayHello(String name) {return providerServiceAnnotation.SayHelloAnnotation(name);}
}
在 ConsumerAnnotationService
类中,通过 @Reference
引用服务端提供的类,然后通过方法调用这个类的方
式,给消费端提供接口。
注意:如果这里找不到 ProviderServiceAnnotation
类,请在服务端先把服务端工程用 Maven intall
一下,
然后将服务端的依赖放到消费端的 pom
中。如下:
<dependency><groupId>com.dubbo.provider3</groupId><artifactId>dubbo-provider3</artifactId><version>0.0.1-SNAPSHOT</version>
</dependency>
第二步:组装服务消费者
这一步和服务端是类似的,这里就不在重复了。
package com.dubbo.consumer.config;import com.alibaba.dubbo.config.ApplicationConfig;
import com.alibaba.dubbo.config.ConsumerConfig;
import com.alibaba.dubbo.config.RegistryConfig;
import com.alibaba.dubbo.config.spring.context.annotation.EnableDubbo;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;import java.util.HashMap;
import java.util.Map;/*** 注解配置类*/
@Configuration
@EnableDubbo(scanBasePackages = "com.dubbo.consumer.service")
@ComponentScan(value = {"com.dubbo.consumer.service"})
public class ConsumerConfiguration {// 应用配置@Beanpublic ApplicationConfig applicationConfig() {ApplicationConfig applicationConfig = new ApplicationConfig();applicationConfig.setName("dubbo-annotation-consumer");Map<String, String> stringStringMap = new HashMap<String, String>();stringStringMap.put("qos.enable", "true");stringStringMap.put("qos.accept.foreign.ip", "false");stringStringMap.put("qos.port", "33333");applicationConfig.setParameters(stringStringMap);return applicationConfig;}// 服务消费者配置@Beanpublic ConsumerConfig consumerConfig() {ConsumerConfig consumerConfig = new ConsumerConfig();consumerConfig.setTimeout(3000);return consumerConfig;}// 配置注册中心@Beanpublic RegistryConfig registryConfig() {RegistryConfig registryConfig = new RegistryConfig();registryConfig.setProtocol("zookeeper");registryConfig.setAddress("localhost");registryConfig.setPort(2181);return registryConfig;}
}
第三步:发起远程调用
在 main
方法中通过启动一个 Spring Context
,从其中查找到组装好的 Dubbo 的服务消费者,并发起一次远程
调用。
package com.dubbo.consumer;import com.dubbo.consumer.config.ConsumerConfiguration;
import com.dubbo.consumer.service.ConsumerAnnotationService;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;import java.io.IOException;/*** 注解方式启动*/
public class App {public static void main(String[] args) throws IOException {AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ConsumerConfiguration.class);context.start(); // 启动ConsumerAnnotationService consumerAnnotationService = context.getBean(ConsumerAnnotationService.class);String hello = consumerAnnotationService.doSayHello("annotation"); // 调用方法System.out.println("result: " + hello); // 输出结果}
}
# 输出
result: annotation
6、常用场景
在下面的讲解中,都会是以 xml
配置的方式来讲解的,这也是 dubbo 官方比较推荐的方式。以下的操作都是在
服务端的 xml
配置文件和消费端的配置文件来讲解的。
6.1 启动时检查
Dubbo 缺省会在启动时检查依赖的服务是否可用,不可用时会抛出异常,阻止 Spring 初始化完成,以便上线时,
能及早发现问题,默认 check="true"
。
但是,有的时候,我们并不是都需要启动时就检查的,比如测试的时候,我们是需要更快速的启动,所以,这种场
景的时候,我们是需要关闭这个功能的。
下面,我们看看如何使用这个功能。
在服务端注册的时候(客户端注册时同样适用);
<dubbo:registry protocol="zookeeper" address="localhost:2181,localhost:2182,localhost:2183" check="false"/>
在客户端引用服务端服务的时候;
<dubbo:reference check="false" id="providerService"interface="com.sihai.dubbo.provider.service.ProviderService"/>
就是这么简单,就是这么强!
6.2 集群容错
dubbo 也是支持集群容错的,同时也有很多可选的方案,其中,默认的方案是 failover
,也就是重试机制。
首先,我们先把所有的容错机制都整理一遍,然后再看看使用。
集群模式 | 说明 | 使用方法 |
---|---|---|
Failover Cluster | 失败自动切换,当出现失败,重试其它服务器。通常用于读操作,但重试会带来更长延迟。可通过 retries=“2” 来设置重试次数(不含第一次)。 | cluster=“xxx” xxx:集群模式名称 ,例如cluster=“failover” |
Failfast Cluster | 快速失败,只发起一次调用,失败立即报错。通常用于非幂等性的写操作,比如新增记录。 | |
Failsafe Cluster | 失败安全,出现异常时,直接忽略。 | |
Failback Cluster | 失败自动恢复,后台记录失败请求,定时重发。通常用于消息通知操作。 | |
Forking Cluster | 并行调用多个服务器,只要一个成功即返回。通常用于实时性要求较高的读操作,但需要浪费更多服务资源。可通过 forks=“2” 来设置最大并行数。 | |
Broadcast Cluster | 广播调用所有提供者,逐个调用,任意一台报错则报错。通常用于通知所有提供者更新缓存或日志等本地资源信息。 |
使用实例
在发布服务或者引用服务的时候设置
<!--服务发布的配置,需要暴露的服务接口-->
<dubbo:service cluster="failover" retries="2"interface="com.sihai.dubbo.provider.service.ProviderService"ref="providerService"/>
<dubbo:reference cluster="failover" retries="2" check="false" id="providerService"interface="com.sihai.dubbo.provider.service.ProviderService"/>
6.3 负载均衡
负载均衡想必是一个再熟悉不过的概念了,所以,dubbo 支持也是再正常不过了,这里也总结一下 dubbo 支持的
负载均衡的一些方案及使用方法。
负载均衡模式 | 说明 | 使用方法 |
---|---|---|
Random LoadBalance | 随机 按权重设置随机概率 | <dubbo:service loadbalance=“xxx”/> xxx:负载均衡方法 |
RoundRobin LoadBalance | 轮询 按公约后的权重设置轮询比率。 | |
LeastActive LoadBalance | 最少活跃调用数 相同活跃数的随机,活跃数指调用前后计数差。 | |
ConsistentHash LoadBalance | 一致性 Hash 相同参数的请求总是发到同一提供者。 当某一台提供者挂时,原本发往该提供者的请求,基于虚拟节点,平摊到其它提供者,不会引起剧烈变动。 |
6.4 直连提供者
在开发及测试环境下,经常需要绕过注册中心,只测试指定服务提供者,所以,这种情况下,我们只需要直接连接
服务端的地即可,其实,这种方法在前面的讲解已经使用到了,第一种讲解的方式就是这种方式,因为这种方式简
单。
<dubbo:reference id="providerService"interface="com.sihai.dubbo.provider.service.ProviderService"url="dubbo://192.168.234.1:20880/com.sihai.dubbo.provider.service.ProviderService"/>
说明:可以看到,只要在消费端在 dubbo:reference
节点使用 url
给出服务端的方法即可。
6.5 只订阅
只订阅就是只能够订阅服务端的服务,而不能够注册。
引用官方的使用场景如下:
为方便开发测试,经常会在线下共用一个所有服务可用的注册中心,这时,如果一个正在开发中的服务提供
者注册,可能会影响消费者不能正常运行。
可以让服务提供者开发方,只订阅服务(开发的服务可能依赖其它服务),而不注册正在开发的服务,通过直连
测试正在开发的服务。
<dubbo:registry register="false" protocol="zookeeper" address="localhost:2181,localhost:2182,localhost:2183" check="false"/>
①、使用只订阅方式
当在服务提供端使用 register="false"
的时候,我们使用下面的方式获取服务端的服务;
<dubbo:reference cluster="failover" retries="2" check="false" id="providerService"interface="com.sihai.dubbo.provider.service.ProviderService"/>
发现,这时候并不是向注册中心 zookeeper
注册,而只是做了发布服务和启动netty
。
②、不使用只订阅方式
<dubbo:registry protocol="zookeeper" address="localhost:2181,localhost:2182,localhost:2183" check="false"/>
可以发现,这里就向注册中心 zookeeper 注册了。
6.6 只注册
只注册正好跟前面的只订阅相反,这个时候可以向注册中心注册,但是,消费端却不能够读到服务。
应用场景:
如果有两个镜像环境,两个注册中心,有一个服务只在其中一个注册中心有部署,另一个注册中心还没来得
及部署,而两个注册中心的其它应用都需要依赖此服务。这个时候,可以让服务提供者方只注册服务到另一
注册中心,而不从另一注册中心订阅服务。
使用说明:
<dubbo:registry subscribe="false" address="localhost:2181"></dubbo:registry>
在服务端的 dubbo:registry
节点下使用 subscribe="false"
来声明这个服务是只注册的服务。
这个时候消费端调用的时候是不能调用的。
6.7 多协议机制
在前面我们使用的协议都是 dubbo 协议,但是 dubbo 除了支持这种协议外还支持其他的协议,比如,rmi、
hessian等,另外,而且还可以用多种协议同时暴露一种服务。
使用方法:
①、一种接口使用一种协议
先声明多种协议
<!--当前服务发布所依赖的协议;webserovice、Thrift、Hessain、http-->
<dubbo:protocol name="dubbo" port="20880"/>
<dubbo:protocol name="rmi" port="1099" />
然后在发布接口的时候使用具体协议
<!--服务发布的配置,需要暴露的服务接口-->
<dubbo:service cluster="failover" retries="2"interface="com.sihai.dubbo.provider.service.ProviderService"ref="providerService"/>
<dubbo:service cluster="failover" retries="2"interface="com.sihai.dubbo.provider.service.ProviderService"ref="providerService" protocol="rmi"/>
在输出日志中,就可以找到rmi发布的接口。
rmi://192.168.234.1:1099/com.sihai.dubbo.provider.service.ProviderService?anyhost=true&application=provider&bean.name=com.sihai.dubbo.provider.service.ProviderService&cluster=failover&dubbo=2.0.2&generic=false&interface=com.sihai.dubbo.provider.service.ProviderService&methods=SayHello&owner=sihai&pid=796&retries=2&side=provider×tamp=1564281053185, dubbo version: 2.6.6, current host: 192.168.234.1
②、一种接口使用多种协议
声明协议和上面的方式一样,在发布接口的时候有一点不一样。
<dubbo:service cluster="failover" retries="2"interface="com.sihai.dubbo.provider.service.ProviderService"ref="providerService" protocol="rmi,dubbo"/>
说明:protocol属性,可以用,
隔开,使用多种协议。
6.8 多注册中心
Dubbo 支持同一服务向多注册中心同时注册,或者不同服务分别注册到不同的注册中心上去,甚至可以同时引用
注册在不同注册中心上的同名服务。
服务端多注册中心发布服务:
一个服务可以在不同的注册中心注册,当一个注册中心出现问题时,可以用其他的注册中心。
注册:
<!--多注册中心-->
<dubbo:registry protocol="zookeeper" id="reg1" timeout="10000" address="localhost:2181"/>
<dubbo:registry protocol="zookeeper" id="reg2" timeout="10000" address="localhost:2182"/>
<dubbo:registry protocol="zookeeper" id="reg3" timeout="10000" address="localhost:2183"/>
发布服务:
<!--服务发布的配置,需要暴露的服务接口-->
<dubbo:service cluster="failover" retries="2"interface="com.sihai.dubbo.provider.service.ProviderService"ref="providerService" registry="reg1"/>
<dubbo:service cluster="failover" retries="2"interface="com.sihai.dubbo.provider.service.ProviderService"ref="providerService" protocol="rmi" registry="reg2"/>
说明:使用registry="reg2"
指定该接口使用的注册中心,同时也可以使用多个,用,
隔开,例如,
registry="reg1,,reg2"
。
消费端多注册中心引用服务:
首先,先向不同注册中心注册;
<!--多注册中心-->
<dubbo:registry protocol="zookeeper" id="reg1" timeout="10000" address="localhost:2181"/>
<dubbo:registry protocol="zookeeper" id="reg2" timeout="10000" address="localhost:2182"/>
<dubbo:registry protocol="zookeeper" id="reg3" timeout="10000" address="localhost:2183"/>
其次,不同的消费端服务引用使用不同的注册中心;
<!--不同的服务使用不同的注册中心-->
<dubbo:reference cluster="failover" retries="2" check="false" id="providerService"interface="com.sihai.dubbo.provider.service.ProviderService" registry="reg1"/>
<dubbo:reference cluster="failover" retries="2" check="false" id="providerService2"interface="com.sihai.dubbo.provider.service.ProviderService" registry="reg2"/>
说明:上面分别使用注册中心1和注册中心2。
6.9 多版本
不同的服务是有版本不同的,版本可以更新并且升级,同时,不同的版本之间是不可以调用的。
<!--服务发布的配置,需要暴露的服务接口-->
<dubbo:service cluster="failover" retries="2"interface="com.sihai.dubbo.provider.service.ProviderService"ref="providerService" registry="reg1" version="1.0.0"/>
<dubbo:service cluster="failover" retries="2"interface="com.sihai.dubbo.provider.service.ProviderService"ref="providerService" protocol="rmi" registry="reg2" version="1.0.0"/>
加入了版本控制。
6.10 日志管理
dubbo 也可以将日志信息记录或者保存到文件中的。
①、使用accesslog输出到log4j
<dubbo:protocol accesslog="true" name="dubbo" port="20880"/>
<dubbo:protocol accesslog="true" name="rmi" port="1099" />
②、输出到文件
<dubbo:protocol accesslog="http://localhost/log.txt" name="dubbo" port="20880"/>
<dubbo:protocol accesslog="http://localhost/log2.txt" name="rmi" port="1099" />
7、总结
这篇文章就到这里了,主要讲了一下几个内容:
1、为什么需要dubbo
2、dubbo架构简析
3、dubbo入门
4、zookeeper注册中心加入dubbo
5、dubbo多种配置方式(xml、api、注解)
6、常用场景介绍