RPC 远程调用

说明

此文档只适用于 jboot v3.1.0 以上，之前的版本请参考 这里 。

目录

  • 添加依赖
  • 配置
  • 开始使用
  • restful 暴露
  • 高级功能

添加依赖

Jboot 支持 dubbo 和 motan，假设我们需要使用 dubbo 作为底层的 RPC 框架，需要添加如下依赖：

  1. <dependency>
  2.     <groupId>org.apache.dubbo</groupId>
  3.     <artifactId>dubbo</artifactId>
  4.     <version>${dubbo.version}</version>
  5.     <exclusions>
  6.         <exclusion>
  7.             <groupId>org.springframework</groupId>
  8.             <artifactId>spring-context</artifactId>
  9.         </exclusion>
  10.         <exclusion>
  11.             <groupId>com.alibaba.spring</groupId>
  12.             <artifactId>spring-context-support</artifactId>
  13.         </exclusion>
  14.     </exclusions>
  15. </dependency>
  17. <dependency>
  18.     <groupId>org.apache.dubbo</groupId>
  19.     <artifactId>dubbo-dependencies-zookeeper</artifactId>
  20.     <version>${dubbo.version}</version>
  21.     <type>pom</type>
  22. </dependency>

如果使用 motan，需要添加如下依赖：

  1. <dependency>
  2.     <groupId>com.weibo</groupId>
  3.     <artifactId>motan-core</artifactId>
  4.     <version>${motan.version}</version>
  5. </dependency>
  7. <dependency>
  8.     <groupId>com.weibo</groupId>
  9.     <artifactId>motan-transport-netty4</artifactId>
  10.     <version>${motan.version}</version>
  11. </dependency>
  13. <!-- 以下的 consul 和 zookeeper 只需要一个即可，使用哪个注册中心就导入哪个依赖  -->
  14. <dependency>
  15.     <groupId>com.weibo</groupId>
  16.     <artifactId>motan-registry-consul</artifactId>
  17.     <version>${motan.version}</version>
  18. </dependency>
  20. <dependency>
  21.     <groupId>com.weibo</groupId>
  22.     <artifactId>motan-registry-zookeeper</artifactId>
  23.     <version>${motan.version}</version>
  24. </dependency>

配置

在 Jboot 中，默认实现了对 Dubbo、motan 的 RPC 调用支持。在使用 RPC 远程调用之前，需要做一些基本的配置。

例如 ：

  1. jboot.rpc.type = dubbo
  2. jboot.rpc.urls = com.yourdomain.AAAService:127.0.0.1:8080,com.yourdomain.XXXService:127.0.0.1:8080
  3. jboot.rpc.providers = com.yourdomain.AAAService:providerName,com.yourdomain.XXXService:providerName
  4. jboot.rpc.consumers = com.yourdomain.AAAService:consumerName,com.yourdomain.XXXService:consumerName
  5. jboot.rpc.defaultVersion = 1.0.0
  6. jboot.rpc.versions = com.yourdomain.AAAService:1.0.0,com.yourdomain.XXXService:1.0.1
  7. jboot.rpc.defaultGroup = 
  8. jboot.rpc.groups = com.yourdomain.AAAService:group1,com.yourdomain.XXXService:group2
  9. jboot.rpc.autoExportEnable = true
  • jboot.rpc.type ： RPC 的类型，目前只支持 dubbo 和 motan
  • jboot.rpc.urls ： 一般不用配置，只有直连模式下才会去配置，此处是配置 Service接口和URL地址的映射关系。
  • jboot.rpc.providers ： 配置 Service 和 Provider 的映射关系（ Motan下配置的是 Service 和 BasicService 的映射关系）。
  • jboot.rpc.consumers ： 配置 Reference 和 consumer 的映射关系（ Motan下配置的是 Referer 和 BaseReferer 的映射关系）。
  • jboot.rpc.defaultVersion ： 当service不配置版本时，默认的版本号，默认值为 1.0.0
  • jboot.rpc.versions ： 每个服务对应的版本号
  • jboot.rpc.defaultGroup ： 当服务不配置 group 时，默认的 gourp
  • jboot.rpc.groups ： 每个服务对应的 group
  • jboot.rpc.autoExportEnable ： 当 Jboot 启动的时候，是否自动暴露 @RPCBean 注解的接口。

开始使用

一般情况下，RPC 调用需要以下几个步骤：

  • 1、定义接口
  • 2、编写实现类
  • 3、启动 Server（Provider） 暴露服务
  • 4、启动客户端、通过 RPC 调用 Server 提供的服务

定义接口

  1. public interface BlogService {
  3.     public String findById();
  4.     public List<String> findAll();
  5. }

编写实现类

  1. @RPCBean
  2. public class BlogServiceProvider implements BlogService {
  4.     @Override
  5.     public String findById() {
  6.         return "id from provider";
  7.     }
  9.     @Override
  10.     public List<String> findAll() {
  11.         return Lists.newArrayList("item1","item2");
  12.     }
  13. }

启动 Server 暴露服务

  1. public class DubboServer {
  3.     public static void main(String[] args)  {
  5.         JbootApplication.setBootArg("undertow.port", "9998");
  7.         JbootApplication.setBootArg("jboot.rpc.type", "dubbo");
  9.         // 开启 @RPCBean 自动暴露功能，默认情况下是开启的，无需配置，
  10.         // 但是此测试代码的 jboot.properties 文件关闭了，这里需要开启下
  11.         JbootApplication.setBootArg("jboot.rpc.autoExportEnable", true);
  13.         //dubbo 的通信协议配置
  14.         JbootApplication.setBootArg("jboot.rpc.dubbo.protocol.name", "dubbo");
  15.         JbootApplication.setBootArg("jboot.rpc.dubbo.protocol.port", "28080");
  18.         // dubbo 注册中心的配置，
  19.         // 当不配置注册中心的时候，默认此服务只提供了直联模式的请求
  20.         // JbootApplication.setBootArg("jboot.rpc.dubbo.registry.protocol", "zookeeper");
  21.         // JbootApplication.setBootArg("jboot.rpc.dubbo.registry.address", "127.0.0.1:2181");
  24.         JbootApplication.run(args);
  25.         System.out.println("DubboServer started...");
  27.     }
  28. }

备注：以上的 JbootApplication.setBootArg() 里设置的内容，都可以配置到 jboot.properties 里。例如： JbootApplication.setBootArg("jboot.rpc.autoExportEnable", true); 在 jboot.properties 里对应的配置是 jboot.rpc.autoExportEnable = true 。

启动客户端、通过 RPC 调用 Server 提供的服务

  2. @RequestMapping("/dubbo")
  3. public class DubboClient extends JbootController{
  5.     public static void main(String[] args)  {
  7.        //Undertow端口号配置
  8.        JbootApplication.setBootArg("undertow.port", "9999");
  10.        //RPC配置
  11.        JbootApplication.setBootArg("jboot.rpc.type", "dubbo");
  13.        //设置直连模式，方便调试，默认为注册中心
  14.        JbootApplication.setBootArg("jboot.rpc.urls", "io.jboot.test.rpc.commons.BlogService:127.0.0.1:28080");
  16.         JbootApplication.run(args);
  17.     }
  20.     @RPCInject
  21.     private  BlogService blogService;
  23.     public void index() {
  24.         System.out.println(blogService);
  25.         renderText("blogId : " + blogService.findById());
  26.     }
  27. }

restful 暴露

在某些情况下，我们希望 rpc service 通过 restful 协议暴露给其他客户端（或者其他编程语言）去使用，我们需要添加如下的依赖。

PS：目前只有 dubbo 支持了 restful 协议，其他 rpc 框架暂时不支持。

  1. <!-- 用于支持 dubbo 的 restful 注解 start -->
  2. <dependency>
  3.     <groupId>io.netty</groupId>
  4.     <artifactId>netty-all</artifactId>
  5.     <version>${io.netty.version}</version>
  6. </dependency>
  8. <dependency>
  9.     <groupId>org.jboss.resteasy</groupId>
  10.     <artifactId>resteasy-jaxrs</artifactId>
  11.     <version>${org.jboss.resteasy.version}</version>
  12. </dependency>
  14. <dependency>
  15.     <groupId>org.jboss.resteasy</groupId>
  16.     <artifactId>resteasy-client</artifactId>
  17.     <version>${org.jboss.resteasy.version}</version>
  18. </dependency>
  20. <dependency>
  21.     <groupId>org.jboss.resteasy</groupId>
  22.     <artifactId>resteasy-netty4</artifactId>
  23.     <version>${org.jboss.resteasy.version}</version>
  24. </dependency>
  26. <dependency>
  27.     <groupId>javax.validation</groupId>
  28.     <artifactId>validation-api</artifactId>
  29.     <version>1.1.0.Final</version>
  30. </dependency>
  32. <dependency>
  33.     <groupId>org.jboss.resteasy</groupId>
  34.     <artifactId>resteasy-jackson-provider</artifactId>
  35.     <version>${org.jboss.resteasy.version}</version>
  36. </dependency>
  38. <dependency>
  39.     <groupId>org.jboss.resteasy</groupId>
  40.     <artifactId>resteasy-jaxb-provider</artifactId>
  41.     <version>${org.jboss.resteasy.version}</version>
  42. </dependency>
  43. <!-- 用于支持 dubbo 的 restful 注解 end -->

其中版本号对应为

  1. <io.netty.version>4.1.9.Final</io.netty.version>
  2. <org.jboss.resteasy.version>3.9.0.Final</org.jboss.resteasy.version>

第二步需要在 接口添加 相关注解

  1. @Path("users") // #1
  2. @Consumes({MediaType.APPLICATION_JSON, MediaType.TEXT_XML}) // #2
  3. @Produces({MediaType.APPLICATION_JSON, MediaType.TEXT_XML})
  4. public interface UserService {
  5.     @GET // #3
  6.     @Path("{id: \\d+}")
  7.     User getUser(@PathParam("id") Long id);
  9.     @POST // #4
  10.     @Path("register")
  11.     Long registerUser(User user);
  12. }

这部分的内容，可以添加在接口里，也可以添加在实现类里，具体参考：http://dubbo.apache.org/zh-cn/blog/dubbo-rest.html

第三步，在 jboot.properties 添加 restful 协议：

  1. jboot.rpc.dubbo.protocol.name = dubbo
  2. jboot.rpc.dubbo.protocol.host = 127.0.0.1
  3. jboot.rpc.dubbo.protocol.port = 28080
  5. jboot.rpc.dubbo.protocol.rest.name = rest
  6. jboot.rpc.dubbo.protocol.rest.host = 127.0.0.1
  7. jboot.rpc.dubbo.protocol.rest.port = 8080
  8. jboot.rpc.dubbo.protocol.rest.server = netty

第四步：给 Service 配置暴露协议

  1. jboot.rpc.dubbo.provider.protocal = default,rest //使用 dubbo 和 rest 两种协议同时暴露
  2. jboot.rpc.dubbo.provider.default = true // 给应用配置默认的 provider

高级功能

更多的 dubbo 配置

目前，jboot 不支持通过 jboot.properties 直接对 service 和 reference 配置，但是可以对 provider 和 consumer 的配置， 在通过 @RPCInject 来再次复制给 service 或者 reference，结果也等同于对 service 和 reference 配置进行配置了。

application

http://dubbo.apache.org/zh-cn/docs/user/references/xml/dubbo-application.html

对应的 jboot 的配置前缀为： jboot.rpc.dubbo.application

例如：

  1. jboot.rpc.dubbo.application.name = xx.xx.xx
  2. jboot.rpc.dubbo.application.version = xx.xx.xx

registry

http://dubbo.apache.org/zh-cn/docs/user/references/xml/dubbo-registry.html

对应的 jboot 的配置前缀为： jboot.rpc.dubbo.registry

例如：

  1. jboot.rpc.dubbo.registry.address = xx.xx.xx

多 registry （多注册中心）

默认的注册中心配置内容如下：

  1. jboot.rpc.dubbo.registry.address = xx.xx.xx
  2. jboot.rpc.dubbo.registry.port = xx.xx.xx
  3. jboot.rpc.dubbo.registry.username = xx.xx.xx
  4. jboot.rpc.dubbo.registry.password = xx.xx.xx

多注册中心可以配置如下（多 protocol 、多 consumer、多provider 都是同理）：

  1. jboot.rpc.dubbo.registry.address = xx.xx.xx
  2. jboot.rpc.dubbo.registry.port = xx.xx.xx
  3. jboot.rpc.dubbo.registry.username = xx.xx.xx
  4. jboot.rpc.dubbo.registry.password = xx.xx.xx
  7. jboot.rpc.dubbo.registry.other1.address = xx.xx.xx
  8. jboot.rpc.dubbo.registry.other1.port = xx.xx.xx
  9. jboot.rpc.dubbo.registry.other1.username = xx.xx.xx
  10. jboot.rpc.dubbo.registry.other1.password = xx.xx.xx
  13. jboot.rpc.dubbo.registry.other2.address = xx.xx.xx
  14. jboot.rpc.dubbo.registry.other2.port = xx.xx.xx
  15. jboot.rpc.dubbo.registry.other2.username = xx.xx.xx
  16. jboot.rpc.dubbo.registry.other2.password = xx.xx.xx

这样，在系统中就存在了多个注册中心，名称（name 或者 id）分别为 default（没有name的时候，默认为default）、other1、other2，这样，当一个服务（或者接口）需要在 多个注册中心暴露的时候，只需要在其 registry 配置相应的 id 即可。

例如：

  1. jboot.rpc.dubbo.provider.address = default,other1

若当服务没有指定注册中心，那么该服务会在这三个注册中心同时暴露。

protocol

http://dubbo.apache.org/zh-cn/docs/user/references/xml/dubbo-protocol.html

对应的 jboot 的配置前缀为： jboot.rpc.dubbo.protocol

例如：

  1. jboot.rpc.dubbo.protocol.host = 127.0.0.1
  2. jboot.rpc.dubbo.protocol.port = 28080

provider

http://dubbo.apache.org/zh-cn/docs/user/references/xml/dubbo-provider.html

对应的 jboot 的配置前缀为： jboot.rpc.dubbo.provider

例如：

  1. jboot.rpc.dubbo.provider.host = 127.0.0.1

consumer

http://dubbo.apache.org/zh-cn/docs/user/references/xml/dubbo-consumer.html

对应的 jboot 的配置前缀为： jboot.rpc.dubbo.consumer

例如：

  1. jboot.rpc.dubbo.consumer.timeout = 127.0.0.1

SSL

对应的配置类： org.apache.dubbo.config.SslConfig

对应的 jboot 的配置前缀为： jboot.rpc.dubbo.ssl

例如：

  1. jboot.rpc.dubbo.ssl.serverKeyCertChainPath = xxx

monitor

http://dubbo.apache.org/zh-cn/docs/user/references/xml/dubbo-monitor.html

对应的 jboot 的配置前缀为： jboot.rpc.dubbo.monitor

例如：

  1. jboot.rpc.dubbo.monitor.protocol = xxx

metrics

对应的配置类： org.apache.dubbo.config.MetricsConfig

对应的 jboot 的配置前缀为： jboot.rpc.dubbo.metrics

例如：

  1. jboot.rpc.dubbo.metrics.protocol = xxx

module

http://dubbo.apache.org/zh-cn/docs/user/references/xml/dubbo-module.html

对应的 jboot 的配置前缀为： jboot.rpc.dubbo.module

例如：

  1. jboot.rpc.dubbo.module.name = xxx

MetadataReport

对应的配置类： org.apache.dubbo.config.MetadataReportConfig

对应的 jboot 的配置前缀为： jboot.rpc.dubbo.metadata-report

例如：

  1. jboot.rpc.dubbo.metadata-report.group = xxx

ConfigCenter

http://dubbo.apache.org/zh-cn/docs/user/references/xml/dubbo-config-center.html

对应的 jboot 的配置前缀为： jboot.rpc.dubbo.config-center

例如：

  1. jboot.rpc.dubbo.config-center.group = xxx

method

http://dubbo.apache.org/zh-cn/docs/user/references/xml/dubbo-method.html

对应的 jboot 的配置前缀为： jboot.rpc.dubbo.method

例如：

  1. jboot.rpc.dubbo.method.name = xxx

argument

http://dubbo.apache.org/zh-cn/docs/user/references/xml/dubbo-argument.html

对应的 jboot 的配置前缀为： jboot.rpc.dubbo.argument

例如：

  1. jboot.rpc.dubbo.argument.name = xxx