聊聊Dubbo（二）：简单入门

时间 2019-11-21

标签聊聊 dubbo 简单入门栏目 Dubbo 繁體版

原文原文链接

0 准备

安装注册中心：Zookeeper、Dubbox自带的dubbo-registry-simple；

安装DubboKeeper监控：https://github.com/dubboclub/dubbokeeper；

以上两点准备，不是本文重点，不作详细介绍，安装比较简单，自行查阅相关资料安装学习。php

1 服务端

1.2 接口定义

建立Maven模块：msa-demo-apihtml

msa-demo-api：配置pom.xmljava

<!-- Dubbox依赖 -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>dubbo</artifactId>
    <version>2.8.4</version>
</dependency>
<!-- END -->

<!-- 若是要使用lombok -->
<dependency>
     <groupId>org.projectlombok</groupId>
     <artifactId>lombok</artifactId>
</dependency>
<!-- END -->

<!-- 若是要使用REST风格远程调用 -->
<dependency>
    <groupId>org.jboss.resteasy</groupId>
    <artifactId>resteasy-jaxrs</artifactId>
    <version>3.0.7.Final</version>
</dependency>
<dependency>
    <groupId>org.jboss.resteasy</groupId>
    <artifactId>resteasy-client</artifactId>
    <version>3.0.7.Final</version>
</dependency>
<dependency>
    <groupId>javax.validation</groupId>
    <artifactId>validation-api</artifactId>
    <version>1.0.0.GA</version>
</dependency>
<!-- END -->

<!-- 若是要使用json序列化 -->
<dependency>
    <groupId>org.jboss.resteasy</groupId>
    <artifactId>resteasy-jackson-provider</artifactId>
    <version>3.0.7.Final</version>
</dependency>
<!-- END -->

<!-- 若是要使用xml序列化 -->
<dependency>
    <groupId>org.jboss.resteasy</groupId>
    <artifactId>resteasy-jaxb-provider</artifactId>
    <version>3.0.7.Final</version>
</dependency>
<!-- END -->

<!-- 若是要使用netty server -->
<dependency>
    <groupId>org.jboss.resteasy</groupId>
    <artifactId>resteasy-netty</artifactId>
    <version>3.0.7.Final</version>
</dependency>
<!-- END -->

<!-- 若是要使用Sun HTTP server -->
<dependency>
    <groupId>org.jboss.resteasy</groupId>
    <artifactId>resteasy-jdk-http</artifactId>
    <version>3.0.7.Final</version>
</dependency>
<!-- END -->

<!-- 若是要使用tomcat server -->
<dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embed-core</artifactId>
    <version>8.0.11</version>
</dependency>
<dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embed-logging-juli</artifactId>
    <version>8.0.11</version>
</dependency>
<!-- END -->

<!-- 若是要使用Kyro序列化 -->
<dependency>
    <groupId>com.esotericsoftware.kryo</groupId>
    <artifactId>kryo</artifactId>
    <version>2.24.0</version>
</dependency>
<dependency>
    <groupId>de.javakaffee</groupId>
    <artifactId>kryo-serializers</artifactId>
    <version>0.26</version>
</dependency>
<!-- END -->

<!-- 若是要使用FST序列化 -->
<dependency>
    <groupId>de.ruedigermoeller</groupId>
    <artifactId>fst</artifactId>
    <version>1.55</version>
</dependency>
<!-- END -->

<!-- 若是要使用Jackson序列化 -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-core</artifactId>
    <version>2.3.3</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.3.3</version>
</dependency>
<!-- END -->
复制代码

以上POM配置，从dubbox-2.8.4开始，全部依赖库的使用方式将和dubbo原来的同样：即若是要使用REST、Kyro、FST、Jackson等功能，须要用户自行手工添加相关的依赖。git

定义接口：UserService.javagithub

/** * @author TaoBangren * @version 1.0 * @since 2017/5/17 上午9:26 */
public interface UserService {
    User getUser(Long id);
    Long registerUser(User user);
}
复制代码

定义REST接口：AnotherUserRestService.javaweb

package com.alibaba.dubbo.demo.user.facade;
import com.alibaba.dubbo.demo.user.User;
import com.alibaba.dubbo.rpc.protocol.rest.support.ContentType;
import javax.validation.constraints.Min;
import javax.ws.rs.*;
import javax.ws.rs.core.MediaType;
/** * @author TaoBangren * @version 1.0 * @since 2017/5/17 上午9:26 */
// 在Dubbo中开发REST服务主要都是经过JAX-RS的annotation来完成配置的，
// 在上面的示例中，咱们都是将annotation放在服务的实现类中。但其实，我
// 们彻底也能够将annotation放到服务的接口上，这两种方式是彻底等价的.
//
// 在通常应用中，咱们建议将annotation放到服务实现类，这样annotation和
// java实现代码位置更接近，更便于开发和维护。另外更重要的是，咱们通常倾向
// 于避免对接口的污染，保持接口的纯净性和普遍适用性。
// 可是，如后文所述，若是咱们要用dubbo直接开发的消费端来访问此服务，则annotation必须放到接口上。
// 若是接口和实现类都同时添加了annotation，则实现类的annotation配置会生效，接口上的annotation被直接忽略。
@Path("u")
@Consumes({MediaType.APPLICATION_JSON, MediaType.TEXT_XML})
@Produces({ContentType.APPLICATION_JSON_UTF_8, ContentType.TEXT_XML_UTF_8})
public interface AnotherUserRestService {

      @GET
      @Path("{id : \\d+}")
      // 在一个REST服务同时对多种数据格式支持的状况下，根据JAX-RS标准，
      // 通常是经过HTTP中的MIME header（content-type和accept）来指定当前想用的是哪一种格式的数据。
      // @Produces({ContentType.APPLICATION_JSON_UTF_8, ContentType.TEXT_XML_UTF_8})
      // 可是在dubbo中，咱们还自动支持目前业界广泛使用的方式，即用一个URL后缀（.json和.xml）来指定
      // 想用的数据格式。例如，在添加上述annotation后，直接访问http://localhost:8888/users/1001.json
      // 则表示用json格式，直接访问http://localhost:8888/users/1002.xml则表示用xml格式，
      // 比用HTTP Header更简单直观。Twitter、微博等的REST API都是采用这种方式。
      // 若是你既不加HTTP header，也不加后缀，则dubbo的REST会优先启用在以上annotation定义中排位最靠前的那种数据格式。
      // 注意：这里要支持XML格式数据，在annotation中既能够用MediaType.TEXT_XML，也能够用MediaType.APPLICATION_XML，
      // 可是TEXT_XML是更经常使用的，而且若是要利用上述的URL后缀方式来指定数据格式，只能配置为TEXT_XML才能生效。
      User getUser(@PathParam("id") @Min(1L) Long id);

      @POST
      @Path("register")
      RegistrationResult registerUser(User user);
}
复制代码

定义实体：User.javaredis

package com.alibaba.dubbo.demo.user;
import lombok.Data;
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;
/** * @author TaoBangren * @version 1.0 * @since 2017/5/17 上午9:26 */
// 因为JAX-RS的实现通常都用标准的JAXB（Java API for XML Binding）来序列化和反序列化XML格式数据，
// 因此咱们须要为每个要用XML传输的对象添加一个类级别的JAXB annotation(@XmlRootElement) ，不然序列化将报错。
@Data
@XmlRootElement
@XmlAccessorType(XmlAccessType.FIELD)
public class User implements Serializable {

      @NotNull
      @Min(1L)
      private Long id;

      // REST的底层实现会在service的对象和JSON/XML数据格式之间自动作序列化/反序列化。
      // 但有些场景下，若是以为这种自动转换不知足要求，能够对其作定制。
      // Dubbo中的REST实现是用JAXB作XML序列化，用Jackson作JSON序列化，
      // 因此在对象上添加JAXB或Jackson的annotation便可以定制映射。
      @JsonProperty("username")
      @XmlElement(name = "username")
      @NotNull
      @Size(min = 6, max = 50)
      private String name;
}
复制代码

定义REST响应结果实体：RegistrationResult.javaspring

package com.alibaba.dubbo.demo.user.facade;
import lombok.Data;
import javax.xml.bind.annotation.XmlRootElement;
import java.io.Serializable;
/** * @author TaoBangren * @version 1.0 * @since 2017/5/17 上午9:26 */
// 此外，若是service方法中的返回值是Java的 primitive类型（如int，long，float，double等），
// 最好为它们添加一层wrapper对象，由于JAXB不能直接序列化primitive类型。这样不但可以解决XML序列化的问题，
// 并且使得返回的数据都符合XML和JSON的规范。
// 这种wrapper对象其实利用所谓Data Transfer Object（DTO）模式，采用DTO还能对传输数据作更多有用的定制。
@Data
@XmlRootElement
public class RegistrationResult implements Serializable {
      private Long id;
}
复制代码

1.3 服务实现

建立Maven模块：msa-demo-providerapache

msa-demo-provider：配置pom.xmljson

<!-- Module依赖 START -->
<dependency>
     <groupId>com.alibaba</groupId>
     <artifactId>msa-demo-api</artifactId>
     <version>1.0-SNAPSHOT</version>
</dependency>
<!-- Module依赖 END -->
复制代码

实现UserService接口：UserServiceImpl.java

package com.alibaba.dubbo.demo.user;
import lombok.extern.slf4j.Slf4j;
import java.util.concurrent.atomic.AtomicLong;
/** * @author TaoBangren * @version 1.0 * @since 2017/5/17 上午9:26 */
@Slf4j
public class UserServiceImpl implements UserService {
      private final AtomicLong idGen = new AtomicLong();
      public User getUser(Long id) {
          User user = new User();
          user.setId(id);
          user.setName("username" + id);
          return user;
      }
  
      public Long registerUser(User user) {
          // System.out.println("Username is " + user.getName());
          return idGen.incrementAndGet();
      }
}
复制代码

实现REST接口AnotherUserRestService：AnotherUserRestServiceImpl.java

package com.alibaba.dubbo.demo.user.facade;
import com.alibaba.dubbo.demo.user.User;
import com.alibaba.dubbo.demo.user.UserService;
import com.alibaba.dubbo.rpc.RpcContext;
import lombok.extern.slf4j.Slf4j;
/** * @author TaoBangren * @version 1.0 * @since 2017/5/17 上午9:26 */
@Slf4j
public class AnotherUserRestServiceImpl implements AnotherUserRestService {

      private UserService userService;

      public void setUserService(UserService userService) {
          this.userService = userService;
      }

      public User getUser(Long id) {
          System.out.println("Client name is " + RpcContext.getContext().getAttachment("clientName"));
          System.out.println("Client impl is " + RpcContext.getContext().getAttachment("clientImpl"));
          return userService.getUser(id);
      }

      public RegistrationResult registerUser(User user) {
          Long id = userService.registerUser(user);
          RegistrationResult registrationResult = new RegistrationResult();
          registrationResult.setId(id);
          return registrationResult;
      }
}
复制代码

Dubbox与Spring集成配置：msa-demo-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/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">

     <!-- 当前应用信息配置 -->
     <dubbo:application name="msa-demo-provider" owner="tbr" organization="tbr"/>
     <dubbo:monitor address="x.x.x.x:20884"/>

     <!-- 多注册中心配置，竖号分隔表示同时链接多个不一样注册中心，同一注册中心的多个集群地址用逗号分隔 -->
     <dubbo:registry protocol="zookeeper" address="x.x.x.x:2181,x.x.x.x:2181,x.x.x.x:2181"/>
     <dubbo:protocol name="dubbo" port="20880" serialization="kryo"/>

     <!-- 1. 选用了嵌入式的jetty来作rest server，同时，若是不配置server属性，rest协议默认也是选用jetty。 jetty是很是成熟的java servlet容器，并和dubbo已经有较好的集成（目前5种嵌入式server中只有jetty 和后面所述的tomcat、tjws，与dubbo监控系统等完成了无缝的集成），因此，若是你的dubbo系统是单独启动的进程， 你能够直接默认采用jetty便可。dubbo中的rest协议默认将采用80端口. <dubbo:protocol name="rest" server="jetty"/> 2. 配置选用了嵌入式的tomcat来作rest server。在嵌入式tomcat上，REST的性能比jetty上要好得多（参见后面的基准测试）， 建议在须要高性能的场景下采用tomcat。 <dubbo:protocol name="rest" server="tomcat"/> 3. 配置选用嵌入式的netty来作rest server。 <dubbo:protocol name="rest" server="netty"/> 4. 配置选用嵌入式的tjws或Sun HTTP server来作rest server。这两个server实现很是轻量级， 很是方便在集成测试中快速启动使用，固然也能够在负荷不高的生产环境中使用。 注：tjws目前已经 被deprecated掉了，由于它不能很好的和servlet 3.1 API工做。 <dubbo:protocol name="rest" server="tjws"/> <dubbo:protocol name="rest" server="sunhttp"/> 5. 若是你的dubbo系统不是单独启动的进程，而是部署到了Java应用服务器中，则建议你采用如下配置： <dubbo:protocol name="rest" server="servlet"/> 6. 经过将server设置为servlet，dubbo将采用外部应用服务器的servlet容器来作rest server。同时，还要在dubbo系统的web.xml中添加以下配置： <web-app> <context-param> <param-name>contextConfigLocation</param-name> <param-value>/WEB-INF/classes/META-INF/spring/dubbo-demo-provider.xml</param-value> </context-param> <listener> <listener-class>com.alibaba.dubbo.remoting.http.servlet.BootstrapListener</listener-class> </listener> <listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener> <servlet> <servlet-name>dispatcher</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>dispatcher</servlet-name> <url-pattern>/*</url-pattern> </servlet-mapping> </web-app> 即必须将dubbo的BootstrapListener和DispatherServlet添加到web.xml，以完成dubbo的REST功能与外部servlet容器的集成。 其实，这种场景下你依然能够坚持用嵌入式server，但外部应用服务器的servlet容器每每比嵌入式server更增强大 （特别是若是你是部署到更健壮更可伸缩的WebLogic，WebSphere等），另外有时也便于在应用服务器作统一管理、监控等等。 若是将dubbo REST部署到外部Tomcat上，并配置server="servlet"，即启用外部的tomcat来作为rest server的底层实现， 则最好在tomcat上添加以下配置： <Connector port="8080" protocol="org.apache.coyote.http11.Http11NioProtocol" connectionTimeout="20000" redirectPort="8443" minSpareThreads="20" enableLookups="false" maxThreads="100" maxKeepAliveRequests="-1" keepAliveTimeout="60000"/> 特别是maxKeepAliveRequests="-1"，这个配置主要是保证tomcat一直启用http长链接，以提升REST调用性能。 可是请注意，若是REST消费端不是持续的调用REST服务，则一直启用长链接未必是最好的作法。另外，一直启用长连 接的方式通常不适合针对普通webapp，更适合这种相似rpc的场景。因此为了高性能，在tomcat中，dubbo REST应 用和普通web应用最好不要混合部署，而应该用单独的实例。 7. 注意：若是你是用spring的ContextLoaderListener来加载spring， 则必须保证BootstrapListener配置在ContextLoaderListener以前，不然dubbo初始化会出错。 -->
 
     <!-- 1. 设置一个全部rest服务都适用的基础相对路径，即java web应用中常说的context path。只须要添加以下contextpath属性便可. <dubbo:protocol name="rest" port="8888" keepalive="true" server="netty" iothreads="5" threads="100" contextpath="services"/> 2. 能够为rest服务配置线程池大小： <dubbo:protocol name="rest" threads="500"/> 注意：目前线程池的设置只有当server="netty"或者server="jetty"或者server="tomcat"的时候才能生效。另外，若是server="servlet"，因为这时候启用 的是外部应用服务器作rest server，不受dubbo控制，因此这里的线程池设置也无效。 若是是选用netty server，还能够配置Netty的IO worker线程数： <dubbo:protocol name="rest" iothreads="5" threads="100"/> 3. 注意：若是你是选用外部应用服务器作rest server, 即配置: <dubbo:protocol name="rest" port="8888" contextpath="services" server="servlet"/> 则必须保证这里设置的port、contextpath，与外部应用服务器的端口、DispatcherServlet的上下文路径（即webapp path加上servlet url pattern）保持一致。 4. Dubbo中的rest服务默认都是采用http长链接来访问，若是想切换为短链接，直接配置： <dubbo:protocol name="rest" keepalive="false"/> 注意：这个配置目前只对server="netty"和server="tomcat"才能生效。 5. 配置服务器提供端所能同时接收的最大HTTP链接数，防止REST server被过多链接撑爆，以做为一种最基本的自我保护机制： <dubbo:protocol name="rest" accepts="500" server="tomcat/> 注意：这个配置目前只对server="tomcat"才能生效。 6. 若是rest服务的消费端也是dubbo系统，能够像其余dubbo RPC机制同样，配置消费端调用此rest服务的最大超时时间以及每一个消费端所能启动的最大HTTP链接数。 <dubbo:service interface="xxx" ref="xxx" protocol="rest" timeout="2000" connections="10"/> 固然，因为这个配置针对消费端生效的，因此也能够在消费端配置： <dubbo:reference id="xxx" interface="xxx" timeout="2000" connections="10"/> 可是，一般咱们建议配置在服务提供端提供此类配置。按照dubbo官方文档的说法：“Provider上尽可能多配置Consumer端的属性，让Provider实现者一开始就思考Provider服务特色、服务质量的问题。” 注意：若是dubbo的REST服务是发布给非dubbo的客户端使用，则这里<dubbo:service/>上的配置彻底无效，由于这种客户端不受dubbo控制。 7. Dubbo的REST支持用GZIP压缩请求和响应的数据，以减小网络传输时间和带宽占用，但这种方式会也增长CPU开销。 -->

     <!-- 1. use tomcat server 2. 用rest协议在8888端口暴露服务 3. Dubbo的REST也支持JAX-RS标准的Filter和Interceptor，以方便对REST的请求与响应过程作定制化的拦截处理。 其中，Filter主要用于访问和设置HTTP请求和响应的参数、URI等等。如:CacheControlFilter.java Interceptor主要用于访问和修改输入与输出字节流，例如，手动添加GZIP压缩.如:GZIPWriterInterceptor.java 4. 在标准JAX-RS应用中，咱们通常是为Filter和Interceptor添加@Provider annotation，而后JAX-RS runtime会 自动发现并启用它们。而在dubbo中，咱们是经过添加XML配置的方式来注册Filter和Interceptor. 5. 在此，咱们能够将Filter、Interceptor和DynamicFuture这三种类型的对象都添加到extension属性上，多个之间用逗号分隔。（DynamicFuture是另外一个接口，能够方便咱们更动态的启用Filter和Interceptor，感兴趣请自行google。） 6. 固然，dubbo自身也支持Filter的概念，但咱们这里讨论的Filter和Interceptor更加接近协议实现的底层， 相比dubbo的filter，能够作更底层的定制化。 注：这里的XML属性叫extension，而不是叫interceptor或者filter，是由于除了Interceptor和Filter，将来咱们 还会添加更多的扩展类型。 7. 若是REST的消费端也是dubbo系统（参见下文的讨论），则也能够用相似方式为消费端配置Interceptor和Filter。但注 意，JAX-RS中消费端的Filter和提供端的Filter是两种不一样的接口。例如前面例子中服务端是ContainerResponseFilter接口， 而消费端对应的是ClientResponseFilter. 8. Dubbo的REST也支持JAX-RS标准的ExceptionMapper，能够用来定制特定exception发生后应该返回的HTTP响应。 9. Dubbo rest支持输出全部HTTP请求/响应中的header字段和body消息体。LoggingFilter -->
     <dubbo:protocol name="rest" port="8888" threads="500" contextpath="services" server="tomcat" accepts="500" extension="com.alibaba.dubbo.demo.extension.TraceInterceptor, com.alibaba.dubbo.demo.extension.TraceFilter, com.alibaba.dubbo.demo.extension.ClientTraceFilter, com.alibaba.dubbo.demo.extension.DynamicTraceBinding, com.alibaba.dubbo.demo.extension.CustomExceptionMapper, com.alibaba.dubbo.rpc.protocol.rest.support.LoggingFilter"/>

     <!-- use the external tomcat or other server with the servlet approach; the port and contextpath must be exactly the same as those in external server <dubbo:protocol name="rest" port="8888" contextpath="services" server="servlet"/> -->
 
     <dubbo:protocol name="http" port="8889"/>
     <dubbo:protocol name="hessian" port="8890"/>
     <dubbo:protocol name="webservice" port="8892"/>
  
     <!-- 声明须要暴露的服务接口 -->
     <dubbo:service interface="com.alibaba.dubbo.demo.user.UserService" ref="userService" protocol="dubbo" group="xmlConfig"/>
 
     <!-- 1. 为了和其余dubbo远程调用协议保持一致，在rest中做校验的annotation必须放在服务的接口上, 把annotation放在接口上至少有一个好处是，dubbo的客户端能够共享这个接口的信息，dubbo甚 至不须要作远程调用，在本地就能够完成输入校验。 而后按照dubbo的标准方式在XML配置中打开验证： <dubbo:service interface=xxx.UserService" ref="userService" protocol="rest" validation="true"/> 2. 在dubbo的其余不少远程调用协议中，若是输入验证出错，是直接将RpcException抛向客户端，而在rest中因为客户端常常是非dubbo，甚至非java的系统，因此不便直接抛出Java异常。所以，目前咱们将校验错误以XML的格式返回： <violationReport> <constraintViolations> <path>getUserArgument0</path> <message>User ID must be greater than 1</message> <value>0</value> </constraintViolations> </violationReport> 若是你认为默认的校验错误返回格式不符合你的要求，能够如上面章节所述，添加自定义的ExceptionMapper来自由的定制错误返回格式。 须要注意的是，这个ExceptionMapper必须用泛型声明来捕获dubbo的RpcException，才能成功覆盖dubbo rest默认的异常处理策略。 为了简化操做，其实这里最简单的方式是直接继承dubbo rest的RpcExceptionMapper，并覆盖其中处理校验异常的方法便可. -->
     <dubbo:service interface="com.alibaba.dubbo.demo.user.facade.AnotherUserRestService" ref="anotherUserRestService" protocol="rest" timeout="2000" connections="100" validation="true"/>
  
     <bean id="userService" class="com.alibaba.dubbo.demo.user.UserServiceImpl"/>
 
     <bean id="anotherUserRestService" class="com.alibaba.dubbo.demo.user.facade.AnotherUserRestServiceImpl">
         <property name="userService" ref="userService"/>
     </bean>
 
     <!-- 对于jax-rs和spring mvc，其实我对spring mvc的rest支持尚未太深刻的看过，说点初步想法，请你们指正： spring mvc也支持annotation的配置，其实和jax-rs看起来是很是很是相似的。 我我的认为spring mvc相对更适合于面向web应用的restful服务，好比被AJAX调用，也可能输出HTML之类的，应用中还 有页面跳转流程之类，spring mvc既能够作好正常的web页面请求也能够同时处理rest请求。但总的来讲这个restful服务 是在展示层或者叫web层之类实现的 而jax-rs相对更适合纯粹的服务化应用，也就是传统Java EE中所说的中间层服务，好比它能够把传统的EJB发布成restful 服务。在spring应用中，也就把spring中充当service之类的bean直接发布成restful服务。总的来讲这个restful服务是 在业务、应用层或者facade层。而MVC层次和概念在这种作好比（后台）服务化的应用中一般是没有多大价值的。 固然jax-rs的有些实现好比jersey，也试图提供mvc支持，以更好的适应上面所说的web应用，但应该是不如spring mvc。 在dubbo应用中，我想不少人都比较喜欢直接将一个本地的spring service bean（或者叫manager之类的）彻底透明的发布 成远程服务，则这里用JAX-RS是更天然更直接的，没必要额外的引入MVC概念。固然，先不讨论透明发布远程服务是否是最佳实践， 要不要添加facade之类。 固然，我知道在dubbo不支持rest的状况下，不少朋友采用的架构是spring mvc restful调用dubbo (spring) service 来发布restful服务的。这种方式我以为也很是好，只是若是不修改spring mvc并将其与dubbo深度集成，restful服务不能 像dubbo中的其余远程调用协议好比webservices、dubbo rpc、hessian等等那样，享受诸多高级的服务治理的功能，好比： 注册到dubbo的服务注册中心，经过dubbo监控中心监控其调用次数、TPS、响应时间之类，经过dubbo的统一的配置方式控制其 好比线程池大小、最大链接数等等，经过dubbo统一方式作服务流量控制、权限控制、频次控制。另外spring mvc仅仅负责服务 端，而在消费端，一般是用spring restTemplate，若是restTemplate不和dubbo集成，有可能像dubbo服务客户端那样自动 或者人工干预作服务降级。若是服务端消费端都是dubbo系统，经过spring的rest交互，若是spring rest不深度整合dubbo， 则不能用dubbo统一的路由分流等功能。 固然，其实我我的认为这些东西没必要要非此即彼的。我据说spring创始人rod johnson老是爱说一句话， the customer is always right，其实与其非要探讨哪一种方式更好，不如同时支持两种方式就是了， 因此原来在文档中也写过计划支持spring rest annoation，只是不知道具体可行性有多高。 1. JAX-RS中重载的方法可以映射到同一URL地址吗？ http://stackoverflow.com/questions/17196766/can-resteasy-choose-method-based-on-query-params 2. JAX-RS中做POST的方法可以接收多个参数吗？ http://stackoverflow.com/questions/5553218/jax-rs-post-multiple-objects 注:以上备注,均来自:https://dangdangdotcom.github.io/dubbox/rest.html -->
</beans>
复制代码

配置dubbo.properties

#dubbo.container=log4j,spring
#dubbo.application.name=demo-provider
#dubbo.application.owner=
#dubbo.registry.address=multicast://224.5.6.7:1234
#dubbo.registry.address=zookeeper://127.0.0.1:2181
#dubbo.registry.address=redis://127.0.0.1:6379
#dubbo.registry.address=dubbo://127.0.0.1:9090
#dubbo.monitor.protocol=registry
#dubbo.protocol.name=dubbo
#dubbo.protocol.port=20880
#dubbo.service.loadbalance=roundrobin
#dubbo.log4j.file=logs/msa-demo-provider.log
#dubbo.log4j.level=INFO
#dubbo.log4j.subdirectory=20880
dubbo.application.logger=slf4j
dubbo.spring.config=classpath*:msa-*.xml
复制代码

1.4 服务启动

定义服务启动类

package com.alibaba.dubbo.demo.provider;
/** * @author TaoBangren * @version 1.0 * @since 2017/5/17 上午9:26 */
public class DemoProvider {
      public static void main(String[] args) {
          com.alibaba.dubbo.container.Main.main(args);
      }
}
复制代码

执行main方法启动，看到如下日志输出时，msa-demo-provider启动成功：

查看DubboKeeper监控大盘，msa-demo-provider发布服务成功，能够看到咱们发布的两个接口：

2. 客户端

建立Maven模块：msa-demo-client

msa-demo-client：配置pom.xml

<!-- Module依赖 START -->
<dependency>
     <groupId>com.alibaba</groupId>
     <artifactId>msa-demo-api</artifactId>
     <version>1.0-SNAPSHOT</version>
</dependency>
<!-- Module依赖 END -->
复制代码

Dubbox与Spring集成配置：msa-demo-client.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/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">

   <!-- 当前应用信息配置 -->
   <!--<dubbo:application name="msa-demo-client" owner="shark" organization="shark"/>-->

   <!-- 多注册中心配置，竖号分隔表示同时链接多个不一样注册中心，同一注册中心的多个集群地址用逗号分隔 -->
   <!--<dubbo:registry protocol="zookeeper" address="x.x.x.x:2181,x.x.x.x:2181,x.x.x.x:2181"/>-->
   <!--<dubbo:monitor address="x.x.x.x:20884"/>-->
 
   <dubbo:reference id="userService" interface="com.alibaba.dubbo.demo.user.UserService" group="xmlConfig"/>
   <dubbo:reference id="anotherUserRestService" interface="com.alibaba.dubbo.demo.user.facade.AnotherUserRestService"/>

   <!-- directly connect to provider to simulate the access to non-dubbo rest services <dubbo:reference id="anotherUserRestService" interface="com.alibaba.dubbo.demo.user.facade.AnotherUserRestService" url="rest://localhost:8888/services/"/> -->
</beans>
复制代码

3. 消费端

3.1 消费端实现

建立Maven模块：msa-demo-consumer

msa-demo-consumer：配置pom.xml

<!-- Module依赖 START -->
<dependency>
      <groupId>com.jeasy</groupId>
      <artifactId>msa-demo-client</artifactId>
      <version>1.0-SNAPSHOT</version>
</dependency>
<!-- Module依赖 END -->
复制代码

建立消费端测试类：DemoAction.java

package com.alibaba.dubbo.demo;
import com.alibaba.dubbo.rpc.RpcContext;
import com.alibaba.dubbo.demo.user.User;
import com.alibaba.dubbo.demo.user.UserService;
import com.alibaba.dubbo.demo.user.facade.AnotherUserRestService;
/** * @author TaoBangren * @version 1.0 * @since 2017/5/17 上午9:26 */
public class DemoAction {

      private UserService userService;

      private AnotherUserRestService anotherUserRestService;

      public void setUserService(final UserService userService) {
          this.userService = userService;
      }

      public void setAnotherUserRestService(final AnotherUserRestService anotherUserRestService) {
          this.anotherUserRestService = anotherUserRestService;
      }

      public void start() throws Exception {
          User user = new User();
          user.setId(1L);
          user.setName("larrypage");

          System.out.println("SUCCESS: registered user with id by rest" + anotherUserRestService.registerUser(user).getId());
          System.out.println("SUCCESS: registered user with id " + userService.registerUser(user));
 
          RpcContext.getContext().setAttachment("clientName", "demo");
          RpcContext.getContext().setAttachment("clientImpl", "dubbox rest");
          System.out.println("SUCCESS: got user by rest" + anotherUserRestService.getUser(1L));
          System.out.println("SUCCESS: got user " + userService.getUser(1L));
      }
}
复制代码

Dubbox与Spring集成配置：msa-demo-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/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">

   <!-- 当前应用信息配置 -->
   <dubbo:application name="msa-demo-consumer" owner="tbr" organization="tbr"/>

   <!-- 多注册中心配置，竖号分隔表示同时链接多个不一样注册中心，同一注册中心的多个集群地址用逗号分隔 -->
   <dubbo:registry protocol="zookeeper" address="x.x.x.x:2181,x.x.x.x:2181,x.x.x.x:2181"/>
   <dubbo:monitor address="x.x.x.x:20884"/>

   <bean class="com.alibaba.dubbo.demo.DemoAction" init-method="start">
       <property name="userService" ref="userService"/>
       <property name="anotherUserRestService" ref="anotherUserRestService"/>
   </bean>
</beans>
复制代码

配置dubbo.properties

#dubbo.container=log4j,spring
#dubbo.application.name=demo-consumer
#dubbo.application.owner=
#dubbo.registry.address=multicast://224.5.6.7:1234
#dubbo.registry.address=zookeeper://127.0.0.1:2181
#dubbo.registry.address=redis://127.0.0.1:6379
#dubbo.registry.address=dubbo://127.0.0.1:9090
#dubbo.monitor.protocol=registry
#dubbo.log4j.file=logs/msa-demo-consumer.log
#dubbo.log4j.level=INFO
dubbo.application.logger=slf4j
dubbo.spring.config=classpath*:msa-*.xml
复制代码

3.2 消费端测试

定义消费启动类：

package com.jeasy;
/** * @author TaoBangren * @version 1.0 * @since 2017/5/17 上午9:26 */
public class DemoConsumer {
      public static void main(String[] args) {
          com.alibaba.dubbo.container.Main.main(args);
      }
}
复制代码

执行main方法启动，看到如下日志输出时，msa-demo-consumer启动成功：

同时服务端会输出服务调用日志信息，并调用成功，以下：

4. 规范使用

模块	描述	是否必须
msa-xxx-api	定义接口&实体	必须
msa-xxx-provider	依赖api模块，实现服务接口，提供服务	必须
msa-xxx-client	依赖api模块，Spring配置文件&测试用例，提供给第三方调用服务使用	必须
msa-xxx-consumer	依赖client模块，建议保留该模块，避免client模块直接与应用方紧耦合	可选

5. 推荐阅读

5.1 Dubbox相关资源

源码地址 : github.com/dangdangdot…
在Dubbo中开发REST风格的远程调用 : dangdangdotcom.github.io/dubbox/rest…
在Dubbo中使用高效的Java序列化 : dangdangdotcom.github.io/dubbox/seri…
使用JavaConfig方式配置dubbox : dangdangdotcom.github.io/dubbox/java…
Dubbo Jackson序列化使用说明 : dangdangdotcom.github.io/dubbox/jack…
Demo : dangdangdotcom.github.io/dubbox/demo…
当当网开源Dubbox，扩展Dubbo服务框架支持REST风格远程调用 : www.infoq.com/cn/news/201…
Dubbox Wiki : github.com/dangdangdot…

5.2 Dubbo相关资源

源码地址 : github.com/alibaba/dub…
Dubbo Wiki : github.com/alibaba/dub…
http://dubbo.io/