淘宝SOA框架Dubbo之Hessian(三)

admin

Dubbo基于Hessian实现了自己Hessian协议，可以直接通过配置的Dubbo内置的其他协议，在服务消费方进行远程调用，也就是说，服务调用方需要使用java语言来基于Dubbo调用提供方服务，限制了服务调用方。同时，使用Dubbo的Hessian协议实现提供方服务，而调用方可以使用标准的Hessian接口来调用，原生的Hessian协议已经支持多语言客户端调用，支持语言如下所示：


Java：http://hessian.caucho.com/#Java
Flash/Flex：http://hessian.caucho.com/#FlashFlex
Python：http://hessian.caucho.com/#Python
C++：http://hessian.caucho.com/#C
C#：http://hessian.caucho.com/#NETC
D：http://hessian.caucho.com/#D
Erlang：http://hessian.caucho.com/#Erlang
PHP：http://hessian.caucho.com/#PHP
Ruby：http://hessian.caucho.com/#Ruby
Objective-C：http://hessian.caucho.com/#ObjectiveC
下面，我们的思路是，先基于Dubbo封装的Hessian协议，实现提供方服务和消费方调用服务，双方必须都使用Dubbo来开发；然后，基于Dubbo封装的Hessian协议实现提供方服务，然后服务消费方使用标准的Hessian接口来进行远程调用，分别使用Java和Python语言来实现。而且，我们实现的提供方服务通过Tomcat发布到服务注册中心。
首先，使用Java语言定义一个搜索服务的接口，代码如下所示：

1. package org.shirdrn.platform.dubbo.service.rpc.api;
   
2. 
   
3. public interface SolrSearchService {
   
4.         String search(String collection, String q, String type, int start, int rows);
   
5. }

复制代码

上面接口提供了搜索远程调用功能。


基于Dubbo的Hessian协议实现提供方服务



提供方实现基于Dubbo封装的Hessian协议，实现接口SolrSearchService，实现代码如下所示：

1. package org.shirdrn.platform.dubbo.service.rpc.server;
   
2. 
   
3. import java.io.IOException;
   
4. import java.util.HashMap;
   
5. import java.util.Map;
   
6. 
   
7. import org.apache.commons.logging.Log;
   
8. import org.apache.commons.logging.LogFactory;
   
9. import org.shirdrn.platform.dubbo.service.rpc.api.SolrSearchService;
   
10. import org.shirdrn.platform.dubbo.service.rpc.utils.QueryPostClient;
    
11. import org.springframework.context.support.ClassPathXmlApplicationContext;
    
12. 
    
13. public class SolrSearchServer implements SolrSearchService {
    
14. 
    
15.         private static final Log LOG = LogFactory.getLog(SolrSearchServer.class);
    
16.         private String baseUrl;
    
17.         private final QueryPostClient postClient;
    
18.         private static final Map<String, FormatHandler> handlers = new HashMap<String, FormatHandler>(0);
    
19.         static {
    
20.                 handlers.put("xml", new FormatHandler() {
    
21.                         public String format() {
    
22.                                 return "&wt=xml";
    
23.                         }
    
24.                 });
    
25.                 handlers.put("json", new FormatHandler() {
    
26.                         public String format() {
    
27.                                 return "&wt=json";
    
28.                         }
    
29.                 });
    
30.         }
    
31. 
    
32.         public SolrSearchServer() {
    
33.                 super();
    
34.                 postClient = QueryPostClient.newIndexingClient(null);
    
35.         }
    
36. 
    
37.         public void setBaseUrl(String baseUrl) {
    
38.                 this.baseUrl = baseUrl;
    
39.         }
    
40. 
    
41.         public String search(String collection, String q, String type, int start, int rows) {
    
42.                 StringBuffer url = new StringBuffer();
    
43.                 url.append(baseUrl).append(collection).append("/select?").append(q);
    
44.                 url.append("&start=").append(start).append("&rows=").append(rows);
    
45.                 url.append(handlers.get(type.toLowerCase()).format());
    
46.                 LOG.info("[REQ] " + url.toString());
    
47.                 return postClient.request(url.toString());
    
48.         }
    
49. 
    
50.         interface FormatHandler {
    
51.                 String format();
    
52.         }
    
53. }

复制代码

因为考虑到后面要使用标准Hessian接口来调用，这里接口方法参数全部使用内置标准类型。然后，我们使用Dubbo的配置文件进行配置，文件search-provider.xml的内容如下所示：

1. <?xml version="1.0" encoding="UTF-8"?>
   
2. 
   
3. <beans xmlns="http://www.springframework.org/schema/beans"
   
4.         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
   
5.         xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
   
6.      http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
   
7. 
   
8.         <dubbo:application name="search-provider" />
   
9.         <dubbo:registry
   
10.                 address="zookeeper://slave1:2188?backup=slave3:2188,slave4:2188" />
    
11.         <dubbo:protocol name="hessian" port="8080" server="servlet" />
    
12.         <bean id="searchService"
    
13.                 class="org.shirdrn.platform.dubbo.service.rpc.server.SolrSearchServer">
    
14.                 <property name="baseUrl" value="http://nginx-lbserver/solr-cloud/" />
    
15.         </bean>
    
16.         <dubbo:service
    
17.                 interface="org.shirdrn.platform.dubbo.service.rpc.api.SolrSearchService"
    
18.                 ref="searchService" path="http_dubbo/search" />
    
19. 
    
20. </beans>

复制代码

因为使用Tomcat发布提供方服务，所以我们需要实现Spring的org.springframework.web.context.ContextLoader来初始化应用上下文（基于Spring的IoC容器来管理服务对象）。实现类SearchContextLoader代码如下所示：

1. package org.shirdrn.platform.dubbo.context;
   
2. 
   
3. import javax.servlet.ServletContextEvent;
   
4. import javax.servlet.ServletContextListener;
   
5. 
   
6. import org.shirdrn.platform.dubbo.service.rpc.server.SolrSearchServer;
   
7. import org.springframework.context.support.ClassPathXmlApplicationContext;
   
8. import org.springframework.web.context.ContextLoader;
   
9. 
   
10. public class SearchContextLoader extends ContextLoader implements ServletContextListener {
    
11. 
    
12.         @Override
    
13.         public void contextDestroyed(ServletContextEvent arg0) {
    
14.                 // TODO Auto-generated method stub
    
15. 
    
16.         }
    
17. 
    
18.         @Override
    
19.         public void contextInitialized(ServletContextEvent arg0) {
    
20.                 String config = arg0.getServletContext().getInitParameter("contextConfigLocation");
    
21.                 ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(config);
    
22.                 context.start();
    
23.         }
    
24. 
    
25. }

复制代码

最后，配置Web应用部署描述符文件，web.xml内容如下所示：

1. <?xml version="1.0" encoding="UTF-8"?>
   
2. <web-app id="WebApp_ID" version="2.4"
   
3.         xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   
4.         xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
   
5.         <display-name>http_dubbo</display-name>
   
6. 
   
7.         <listener>
   
8.                 <listener-class>org.shirdrn.platform.dubbo.context.SearchContextLoader</listener-class>
   
9.         </listener>
   
10.         <context-param>
    
11.                 <param-name>contextConfigLocation</param-name>
    
12.                 <param-value>classpath:search-provider.xml</param-value>
    
13.         </context-param>
    
14. 
    
15.         <servlet>
    
16.                 <servlet-name>search</servlet-name>
    
17.                 <servlet-class>com.alibaba.dubbo.remoting.http.servlet.DispatcherServlet</servlet-class>
    
18.                 <init-param>
    
19.                         <param-name>home-class</param-name>
    
20.                         <param-value>org.shirdrn.platform.dubbo.service.rpc.server.SolrSearchServer</param-value>
    
21.                 </init-param>
    
22.                 <init-param>
    
23.                         <param-name>home-api</param-name>
    
24.                         <param-value>org.shirdrn.platform.dubbo.service.rpc.api.SolrSearchService</param-value>
    
25.                 </init-param>
    
26.                 <load-on-startup>1</load-on-startup>
    
27.         </servlet>
    
28.         <servlet-mapping>
    
29.                 <servlet-name>search</servlet-name>
    
30.                 <url-pattern>/search</url-pattern>
    
31.         </servlet-mapping>
    
32. 
    
33.         <welcome-file-list>
    
34.                 <welcome-file>index.html</welcome-file>
    
35.                 <welcome-file>index.htm</welcome-file>
    
36.                 <welcome-file>index.jsp</welcome-file>
    
37.                 <welcome-file>default.html</welcome-file>
    
38.                 <welcome-file>default.htm</welcome-file>
    
39.                 <welcome-file>default.jsp</welcome-file>
    
40.         </welcome-file-list>
    
41. </web-app>

复制代码

启动Tomcat以后，就可以将提供方服务发布到服务注册中心，这里服务注册中心我们使用的是ZooKeeper集群，可以参考上面Dubbo配置文件search-provider.xml的配置内容。
下面，我们通过两种方式来调用已经注册到服务注册中心的服务。


基于Dubbo的Hessian协议远程调用

服务消费方，通过Dubbo配置文件来指定注册到注册中心的服务，配置文件search-consumer.xml的内容，如下所示：

1. <?xml version="1.0" encoding="UTF-8"?>
   
2. 
   
3. <beans xmlns="http://www.springframework.org/schema/beans"
   
4.         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
   
5.         xsi:schemaLocation="http://www.springframework.org/schema/beans [url]http://www.springframework.org/schema/beans/spring-beans-2.5.xsd[/url]
   
6.      [url]http://code.alibabatech.com/schema/dubbo[/url] [url]http://code.alibabatech.com/schema/dubbo/dubbo.xsd[/url]">
   
7. 
   
8.         <dubbo:application name="search-consumer" />
   
9.         <dubbo:registry
   
10.                 address="zookeeper://slave1:2188?backup=slave3:2188,slave4:2188" />
    
11.         <dubbo:reference id="searchService"
    
12.                 interface="org.shirdrn.platform.dubbo.service.rpc.api.SolrSearchService" />
    
13. 
    
14. </beans>

复制代码

然后，使用Java实现远程调用，实现代码如下所示：

1. package org.shirdrn.platform.dubbo.service.rpc.client;
   
2. 
   
3. import java.util.concurrent.Callable;
   
4. import java.util.concurrent.Future;
   
5. 
   
6. import org.shirdrn.platform.dubbo.service.rpc.api.SolrSearchService;
   
7. import org.springframework.beans.BeansException;
   
8. import org.springframework.context.support.AbstractXmlApplicationContext;
   
9. import org.springframework.context.support.ClassPathXmlApplicationContext;
   
10. 
    
11. import com.alibaba.dubbo.rpc.RpcContext;
    
12. 
    
13. public class SearchConsumer {
    
14. 
    
15.         private final String collection;
    
16.         private AbstractXmlApplicationContext context;
    
17.         private SolrSearchService searchService;
    
18. 
    
19.         public SearchConsumer(String collection, Callable<AbstractXmlApplicationContext> call) {
    
20.                 super();
    
21.                 this.collection = collection;
    
22.                 try {
    
23.                         context = call.call();
    
24.                         context.start();
    
25.                         searchService = (SolrSearchService) context.getBean("searchService");
    
26.                 } catch (BeansException e) {
    
27.                         e.printStackTrace();
    
28.                 } catch (Exception e) {
    
29.                         e.printStackTrace();
    
30.                 }
    
31.         }
    
32. 
    
33.         public Future<String> asyncCall(final String q, final String type, final int start, final int rows) {
    
34.                 Future<String> future = RpcContext.getContext().asyncCall(new Callable<String>() {
    
35.                         public String call() throws Exception {
    
36.                                 return search(q, type, start, rows);
    
37.                         }
    
38.                 });
    
39.                 return future;
    
40.         }
    
41. 
    
42.         public String syncCall(final String q, final String type, final int start, final int rows) {
    
43.                 return search(q, type, start, rows);
    
44.         }
    
45. 
    
46.         private String search(final String q, final String type, final int start, final int rows) {
    
47.                 return searchService.search(collection, q, type, start, rows);
    
48.         }
    
49. 
    
50.         public static void main(String[] args) throws Exception {
    
51.                 final String collection = "tinycollection";
    
52.                 final String beanXML = "search-consumer.xml";
    
53.                 final String config = SearchConsumer.class.getPackage().getName().replace('.', '/') + "/" + beanXML;
    
54.                 SearchConsumer consumer = new SearchConsumer(collection, new Callable<AbstractXmlApplicationContext>() {
    
55.                         public AbstractXmlApplicationContext call() throws Exception {
    
56.                                 final AbstractXmlApplicationContext context = new ClassPathXmlApplicationContext(config);
    
57.                                 return context;
    
58.                         }
    
59.                 });
    
60. 
    
61.                 String q = "q=上海&fl=*&fq=building_type:1";
    
62.                 int start = 0;
    
63.                 int rows = 10;
    
64.                 String type = "xml";
    
65.                 for (int k = 0; k < 10; k++) {
    
66.                         for (int i = 0; i < 10; i++) {
    
67.                                 start = 1 * 10 * i;
    
68.                                 if (i % 2 == 0) {
    
69.                                         type = "xml";
    
70.                                 } else {
    
71.                                         type = "json";
    
72.                                 }
    
73.                                 String result = consumer.syncCall(q, type, start, rows);
    
74.                                 System.out.println(result);
    
75.                                 // Future<String> future = consumer.asyncCall(q, type, start,
    
76.                                 // rows);
    
77.                                 // System.out.println(future.get());
    
78.                         }
    
79.                 }
    
80.         }
    
81. 
    
82. }

复制代码

执行该调用实现，可以远程调用提供方发布的服务。
这种方式限制了服务调用方也必须使用Dubbo来开发调用的代码，也就是限制了编程的语言，而无论是对于内部还是外部，各个团队之间必然存在语言的多样性，如果限制了编程语言，那么开发的服务也只能在内部使用。


基于标准Hessian协议接口的远程调用
下面，使用标准Hessian接口来实现远程调用，这时就不需要关心服务提供方的所使用的开发语言，因为最终是通过HTTP的方式来访问。我们需要下载Hessian对应语言的调用实现库，才能更方便地编程。


使用Java语言实现远程调用

使用Java语言实现，代码如下所示：

1. package org.shirdrn.rpc.hessian;
   
2. 
   
3. import org.shirdrn.platform.dubbo.service.rpc.api.SolrSearchService;
   
4. 
   
5. import com.caucho.hessian.client.HessianProxyFactory;
   
6. 
   
7. public class HessianConsumer {
   
8. 
   
9.         public static void main(String[] args) throws Throwable {
   
10. 
    
11.                 String serviceUrl = "http://10.95.3.74:8080/http_dubbo/search";
    
12.                 HessianProxyFactory factory = new HessianProxyFactory();
    
13. 
    
14.                 SolrSearchService searchService = (SolrSearchService) factory.create(SolrSearchService.class, serviceUrl);
    
15. 
    
16.                 String q = "q=上海&fl=*&fq=building_type:1";
    
17.                 String collection = "tinycollection";
    
18.                 int start = 0;
    
19.                 int rows = 10;
    
20.                 String type = "xml";
    
21.                 String result = searchService.search(collection, q, type, start, rows);
    
22.                 System.out.println(result);
    
23.         }
    
24. }

复制代码

我们只需要知道提供服务暴露的URL和服务接口即可，这里URL为http://10.95.3.74:8080/http_dubbo/search，接口为org.shirdrn.platform.dubbo.service.rpc.api.SolrSearchService。运行上面程序，可以调用提供方发布的服务。
参考链接


https://github.com/alibaba/dubbo
http://alibaba.github.io/dubbo-doc-static/Home-zh.htm
http://alibaba.github.io/dubbo-doc-static/User+Guide-zh.htm
http://alibaba.github.io/dubbo-doc-static/Developer+Guide-zh.htm
http://alibaba.github.io/dubbo-doc-static/Administrator+Guide-zh.htm
http://alibaba.github.io/dubbo-doc-static/FAQ-zh.htm
http://hessian.caucho.com/#HessianImplementationsDownload

https://github.com/bgilmore/mustaine
http://shiyanjun.cn/archives/349.html