`

hessian研究

hessian研究 
阅读更多
hessian官网
最近一期的《programmer》里几乎从头至尾在讲关于“J2EE without EJB”的事情，可怜的ejb啊，居然被描述成了遗产系统的重要组成部分。。。 

其实有上面的结论，无外乎现在java里面的新技术已经几乎能完全取代ejb的优点，而克服ejb的缺点，entity bean和有状态的session bean已经机乎被视为垃圾，hibernate和spring大行其到，看看最进n期《programmer》中篇幅的比重就知道了。本来我个人的感觉是hibernate取代了entity bean，spring取代了session bean，但是ejb的远程调用用hibernate和spring的架构还取代不了，可是在最近的一期《programmer》中我发现了Hessian！更爽的是，发现了spring原来可以和Hessian结合使用！看来真的可以say byebye to ejb了。 

看到这么振奋人心的消息，怎么能不亲自试验一下呢，于是上http://www.caucho.com/以迅雷不及掩耳盗铃之势下载了Hessian的src jar和bin jar。create一个工程，把这些相关的jar统统扔进去，配置和coding就可以开始了。首先，开了如下几个包： 



whao.test.hessian.server 
放远程服务的接口 

whao.test.hessian.server.impl 
放远程服务的实现类 

whao.test.hessian.client 
放客户端应用 



1． whao.test.hessian.server中写一个MyService接口： 
Java代码  收藏代码
  1. /* 
  2.  
  3.  * Created on 2005-7-25 
  4.  
  5.  * 
  6.  
  7.  */  
  8.   
  9. package whao.test.hessian.server;  
  10.   
  11.    
  12.   
  13. /** 
  14.  
  15.  * @author Hao Wei 
  16.  
  17.  * 
  18.  
  19.  */  
  20.   
  21. public interface MyService {  
  22.   
  23.     public String doSomething(String s);;  
  24.   
  25. }  



2． whao.test.hessian.server.impl中写一个实现类 

Java代码  收藏代码
  1. /* 
  2.  
  3.  * Created on 2005-7-25 
  4.  
  5.  * 
  6.  
  7.  */  
  8.   
  9. package whao.test.hessian.server.impl;  
  10.   
  11.    
  12.   
  13. import whao.test.hessian.server.MyService;  
  14.   
  15.    
  16.   
  17. /** 
  18.  
  19.  * @author Hao Wei 
  20.  
  21.  * 
  22.  
  23.  */  
  24.   
  25. public class MyServiceImpl implements MyService {  
  26.   
  27.    
  28.   
  29.     /* (non-Javadoc); 
  30.  
  31.      * @see whao.test.hessian.server.MyService#doSomething(java.lang.String); 
  32.  
  33.      */  
  34.   
  35.     public String doSomething(String s); {  
  36.   
  37.         return "HAHAHA: " + s;  
  38.   
  39.     }  
  40.   
  41. }  
  42.   
  43.    


3. 配置远程服务 

         Hessian的远程服务要配置成servlet，配置如下： 
Java代码  收藏代码
  1. <servlet>  
  2.   
  3.    <servlet-name>myservice</servlet-name>  
  4.   
  5.    <servlet-class>com.caucho.hessian.server.HessianServlet</servlet-class>  
  6.   
  7.    <load-on-startup>1</load-on-startup>  
  8.   
  9.    <init-param>  
  10.   
  11.        <param-name>service-class</param-name>  
  12.   
  13.        <param-value>whao.test.hessian.server.impl.MyServiceImpl</param-value>  
  14.   
  15.    </init-param>  
  16.   
  17. </servlet>  
  18.   
  19. <servlet-mapping>  
  20.   
  21.    <servlet-name>myservice</servlet-name>  
  22.   
  23.    <url-pattern>/myservice</url-pattern>  
  24.   
  25. </servlet-mapping>  


这样，当启动了这个web应用，这个远程服务就以url http://localhost:8080/test_web/myservice 的形式发布了。然后就是开发客户端来调用这个远程服务。 

Java代码  收藏代码
  1. /* 
  2.  
  3.  * Created on 2005-7-25 
  4.  
  5.  * 
  6.  
  7.  */  
  8.   
  9. package whao.test.hessian.client;  
  10.   
  11.    
  12.   
  13. import whao.test.hessian.server.MyService;  
  14.   
  15.    
  16.   
  17. import com.caucho.hessian.client.HessianProxyFactory;  
  18.   
  19.    
  20.   
  21. /** 
  22.  
  23.  * @author Hao Wei 
  24.  
  25.  *   
  26.  
  27.  */  
  28.   
  29. public class TestMain {  
  30.   
  31.     public static void main(String[] args); throws Exception {  
  32.   
  33.         HessianProxyFactory proxyFactory = new HessianProxyFactory();;  
  34.   
  35.         MyService service = (MyService); proxyFactory.create(MyService.class,  
  36.   
  37.                 "http://localhost:8080/test_web/myservice");;  
  38.   
  39.         System.out.println(service.doSomething("xixixixi"););;  
  40.   
  41.         System.out.println("ok!");;  
  42.   
  43.     }  
  44.   
  45. }  
  46.   
  47.    


运行一把，显示 

HAHAHA:xixixi 

ok! 

不错不错，纯Hessian的远程调用就这样搞定了。继续研究《programmer》看到上面介绍用spring的远程访问解决方案来访问ejb的远程服务。什么？spring还有远程解决方案？没听说过嘛，看了《programmer》上的介绍，发现是真的。那么既然spring能访问ejb的远程服务，那么能访问Hessian的远程服务么？打开spring.jar看看，居然发现了名曰org.springframework.remoting.caucho.HessianProxyFactoryBean的类！夏昕真不厚道啊，再他的spring中文教程中居然匿掉了spring里这么好的东西！于是打开sping英文版reference，终于找到了用spring配置Hessian客户端的方法： 
Java代码  收藏代码
  1. <bean id="myService" class="org.springframework.remoting.caucho.HessianProxyFactoryBean">  
  2.   
  3.    <property name="serviceUrl">  
  4.   
  5.        <value>  
  6.   
  7.        http://localhost:8080/test_web/myservice  
  8.   
  9.        </value>  
  10.   
  11.    </property>  
  12.   
  13.    <property name="serviceInterface">  
  14.   
  15.        <value>whao.test.hessian.server.MyService</value>  
  16.   
  17.    </property>  
  18.   
  19. </bean>  

然后客户端就可以这么玩啦： 

Java代码  收藏代码
  1. /* 
  2.  
  3.  * Created on 2005-7-25 
  4.  
  5.  * 
  6.  
  7.  */  
  8.   
  9. package whao.test.hessian.client;  
  10.   
  11.    
  12.   
  13. import whao.test.hessian.server.MyService;  
  14.   
  15. import whao.util.spirng.SpringBeanFactory;  
  16.   
  17.    
  18.   
  19. import com.caucho.hessian.client.HessianProxyFactory;  
  20.   
  21.    
  22.   
  23. /** 
  24.  
  25.  * @author Hao Wei 
  26.  
  27.  *   
  28.  
  29.  */  
  30.   
  31. public class TestMain {  
  32.   
  33.    
  34.   
  35.     public static void main(String[] args); throws Exception {  
  36.   
  37.         testWithSpring();;  
  38.   
  39.     }  
  40.   
  41.     public static void testWithSpring();{  
  42.   
  43.         MyService service = (MyService);SpringBeanFactory.getBean("myService");;  
  44.   
  45.         System.out.println(service.doSomething("lllllllll"););;  
  46.   
  47.         System.out.println("ok!");;  
  48.   
  49.     }  
  50.   
  51.     public static void testWithoutSpring(); throws Exception {  
  52.   
  53.         HessianProxyFactory proxyFactory = new HessianProxyFactory();;  
  54.   
  55.         MyService service = (MyService); proxyFactory.create(MyService.class,  
  56.   
  57.                 "http://localhost:8080/test_web/myservice");;  
  58.   
  59.         System.out.println(service.doSomething("xixixixi"););;  
  60.   
  61.         System.out.println("ok!");;  
  62.   
  63.     }  
  64.   
  65. }  
  66.   
  67.    


执行一下，输出是： 

HAHAHA:lllllllll 

ok! 

spring真是个好东东，呵呵，其中的SpringBeanFactory是这样实现的： 
Java代码  收藏代码
  1. /* 
  2.  
  3.  * Created on 2005-7-25 
  4.  
  5.  * 
  6.  
  7.  */  
  8.   
  9. package whao.util.spirng;  
  10.   
  11.    
  12.   
  13. import javax.servlet.ServletContext;  
  14.   
  15.    
  16.   
  17. import org.apache.commons.logging.Log;  
  18.   
  19. import org.apache.commons.logging.LogFactory;  
  20.   
  21. import org.springframework.context.ApplicationContext;  
  22.   
  23. import org.springframework.context.support.FileSystemXmlApplicationContext;  
  24.   
  25. import org.springframework.web.context.support.WebApplicationContextUtils;  
  26.   
  27.    
  28.   
  29. /** 
  30.  
  31.  * @author Hao Wei 
  32.  
  33.  * 
  34.  
  35.  */  
  36.   
  37. public class SpringBeanFactory {  
  38.   
  39.     private static final Log log = LogFactory.getLog(SpringBeanFactory.class);;  
  40.   
  41.          private static ApplicationContext ctx = null;  
  42.   
  43.    
  44.   
  45.     public static Object getBean(ServletContext context, String beanID); {  
  46.   
  47.         log.info("beanID=" + beanID);;  
  48.   
  49.         ApplicationContext ac = WebApplicationContextUtils  
  50.   
  51.                 .getWebApplicationContext(context);;  
  52.   
  53.         return ac.getBean(beanID);;  
  54.   
  55.     }  
  56.   
  57.       
  58.   
  59.     public static Object getBean(String beanID);{  
  60.   
  61.                    if(ctx == null);{  
  62.   
  63.                             ctx = new FileSystemXmlApplicationContext(  
  64.   
  65.                             "D:\\whao-work\\src\\test_web\\test_web\\WEB-INF\\applicationContext.xml");;  
  66.   
  67.                    }  
  68.   
  69.                    return ctx.getBean(beanID);;  
  70.   
  71.     }  
  72.   
  73. }  
  74.   
  75.    


看到sping.jar的包org.springframework.remoting.caucho中还有另外两个类叫HessianClientInterceptor和HessianServiceExporter，看来貌似hessian服务端也可以和spring结合，还有客户端的Interceptor估计可以实现对远程服务的AOP，要继续研究一下了，待续吧
声明：ITeye文章版权属于作者，受法律保护。没有作者书面许可不得转载。
推荐链接
  • <iframe id="aswift_0" style="left: 0px; position: absolute; top: 0px;" name="aswift_0" frameborder="0" marginwidth="0" marginheight="0" scrolling="no" width="728" height="90"></iframe>
<iframe src="http://www.iteye.com/iframe_ggbd/155" frameborder="0" scrolling="no" width="728" height="90"></iframe>
返回顶楼
     
 
  • benber
  • 等级: 二星会员
  • 性别: 
  • 文章: 23
  • 积分: 185
  • 来自: 上海
   发表时间：2005-07-31  
 
在成功的将hessian server端也和spring结合后，从整个分布式应用的架构可以看出，无论是服务端与客户端共有的业务接口，还是服务端业务实现类，以及客户端访问远程服务的应用代码里，已经没有一行关于远程操作的代码了。也就是spring让我们的分布式业务开发完全无关于远程访问协议了，这样我们就可以埋头开发服务端和客户端的业务接口、实现、应用等等，二不必关心远程调用究竟要怎么实现。很明显，这也是AOP（面向方面的编程）的一个比较完美的应用，它使远程访问接口和业务逻辑完全无耦合的分开了。设想一下，如果某天我们有需要，远程访问的接口要从rmi、jax-rpc、hessian、httpinvoker之间做切换，也只要改下配置文件就ok了，一行代码都不用改，真的非常exciting。 

接着前面那篇日志，先把spring和hessian在服务端的结合帖上来： 

接口，还是那个接口~；实现，还是那个实现~~；配置却不是了那个配置呀~~~ 

首先，servlet变成了： 
Java代码  收藏代码
  1. <servlet>  
  2.   
  3.    <servlet-name>remote</servlet-name>  
  4.   
  5.    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  
  6.   
  7.    <load-on-startup>1</load-on-startup>  
  8.   
  9. </servlet>  
  10.   
  11. <servlet-mapping>  
  12.   
  13.    <servlet-name>remote</servlet-name>  
  14.   
  15.    <url-pattern>/remote/*</url-pattern>  
  16.   
  17. </servlet-mapping>  

其次，applicationContext.xml没有必要了，但是要有个remote-servlet.xml，内容如下： 

Java代码  收藏代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2.   
  3. <!-- edited with XMLSPY v5 rel. 4 U (http://www.xmlspy.com); by whao (mdc); -->  
  4.   
  5. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">  
  6.   
  7. <beans>  
  8.   
  9.     <description>server properties</description>  
  10.   
  11.     <bean id="_myService_server" class="whao.test.hessian.server.impl.MyServiceImpl">  
  12.   
  13.     </bean>  
  14.   
  15.     <bean name="/myService_server" class="org.springframework.remoting.caucho.HessianServiceExporter">  
  16.   
  17.        <property name="service">  
  18.   
  19.            <ref bean="_myService_server"/>  
  20.   
  21.        </property>  
  22.   
  23.        <property name="serviceInterface">  
  24.   
  25.            <value>whao.test.hessian.server.MyService</value>  
  26.   
  27.        </property>  
  28.   
  29.     </bean>      
  30.   
  31. </beans>  
  32.   
  33.    


这样一来这个hessian服务的发布地址就变成了 http://localhost:8080/test_web/remote/myService_server 

客户端的配置改成： 
Java代码  收藏代码
  1. <bean id="myServiceClient" class="org.springframework.remoting.caucho.HessianProxyFactoryBean">  
  2.   
  3.    <property name="serviceUrl">  
  4.   
  5.        <value>http://localhost:8080/test_web/remote/myService_server</value>  
  6.   
  7.    </property>  
  8.   
  9.    <property name="serviceInterface">  
  10.   
  11.        <value>whao.test.hessian.server.MyService</value>  
  12.   
  13.    </property>  
  14.   
  15. </bean>  



客户端的代码依然是： 
Java代码  收藏代码
  1. MyService service = (MyService);SpringBeanFactory.getBean("myServiceClient");;  
  2.   
  3. System.out.println(service.doSomething("mmmmmmmmm"););;  


运行一下，输出： 

HAHAHA: mmmmmmmmm 

ok! 



嗯，真是不错，下面尝试着不改一行代码，我们把远程协议由hessian改成rmi。 

由于rmi server不用servlet，也就不用web server，所以可以由自己的进程之接启动，我们就把remote-servlet.xml改成beans.xml内容如下： 

Java代码  收藏代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2.   
  3. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">  
  4.   
  5. <beans>  
  6.   
  7.     <bean id="_myService_server" class="whao.test.hessian.server.impl.MyServiceImpl">  
  8.   
  9.     </bean>  
  10.   
  11.     <bean id="myService_server" class="org.springframework.remoting.rmi.RmiServiceExporter">  
  12.   
  13.        <property name="serviceName"><value>myService_server</value></property>  
  14.   
  15.        <property name="service"><ref bean="_myService_server"/></property>  
  16.   
  17.        <property name="serviceInterface"><value>whao.test.hessian.server.MyService</value></property>  
  18.   
  19.     </bean>  
  20.   
  21. </beans>  
  22.   
  23.    


然后随便写个main程序启动服务，就不用启动web server了： 

Java代码  收藏代码
  1. /* 
  2.  
  3.  * Created on 2005-7-31 
  4.  
  5.  * 
  6.  
  7.  */  
  8.   
  9. package whao.test.rmi;  
  10.   
  11.    
  12.   
  13. import org.springframework.context.ApplicationContext;  
  14.   
  15. import org.springframework.context.support.FileSystemXmlApplicationContext;  
  16.   
  17.    
  18.   
  19. /** 
  20.  
  21.  * @author Hao Wei 
  22.  
  23.  * 
  24.  
  25.  */  
  26.   
  27. public class Server {  
  28.   
  29.          public static void main(String[] args); throws Exception{  
  30.   
  31.              ApplicationContext ctx = new FileSystemXmlApplicationContext("D:\\whao-work\\src\\test_web\\src_server\\beans.xml");;  
  32.   
  33.              ctx.getBean("myService_server");;  
  34.   
  35.                    System.out.println("Server started");;  
  36.   
  37.          }  
  38.   
  39. }  



这样，我们的服务接口和实现类的代码一行不用动，而变成rmi协议的服务已经以rmi://localhost/myService_server 的url启动了。 

然后在把客户端的配置略微调整一下： 
Java代码  收藏代码
  1. <bean id="myServiceClient" class="org.springframework.remoting.rmi.RmiProxyFactoryBean">  
  2.   
  3.    <property name="serviceUrl">  
  4.   
  5.        <value>rmi://localhost/myService_server</value>  
  6.   
  7.    </property>  
  8.   
  9.    <property name="serviceInterface">  
  10.   
  11.        <value>whao.test.hessian.server.MyService</value>  
  12.   
  13.    </property>  
  14.   
  15. </bean>  

客户端的代码也一行不动，在执行下，输出依然是： 

HAHAHA: mmmmmmmmm 

ok! 

然而，我们的remoting其实已经由基于http的hessian改成了rmi。果然不错啊，除了hessian,rmi之外，现在spring支持的remoting协议还包括jax-rpc，burlap，httpinvoker，也就是说我们的remoting操作协议在这些中间切换时，利用spring remoting框架，都可以不用改一行代码，已经非常强大了，只是现在还没有corba的支持。
分享到：
| ContextLoaderListener作用详解
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Hessian（Spring集成的）的应用与研究

    本文将深入探讨Hessian在Spring中的应用以及相关研究。 一、Hessian简介 Hessian是一种基于HTTP的二进制协议，它以简洁的二进制格式传输数据，相比于XML-RPC或JSON-RPC等文本协议，Hessian具有更高的传输效率和更快...

    hessian

    Hessian是一种二进制Web服务协议，由Caucho Technology公司开发，主要用于提供轻量级、高效的远程方法调用（Remote Method ...通过深入研究源码和利用相关工具，我们可以更好地利用Hessian的优势来优化我们的应用程序。

    Spring中集成Hessian的问题

    而Spring框架如何与Hessian进行集成，包括服务注册、请求处理和代理创建等，也值得研究。 **工具支持** 为了方便调试和测试，可以使用一些工具，如Hessian Proxy Factory（一个命令行工具）或者Hessian Browser（一...

    hessian学习基础篇——序列化和反序列化

    在实际项目中，结合标签中的“源码”和“工具”，深入研究Hessian的源码和相关工具，可以帮助我们更好地应用这一技术。而“stxm”可能是对某种特定场景或功能的缩写，具体的含义可能需要更多的上下文信息来解读。

    hessian-example

    在IT行业中，Hessian是一种二进制Web服务协议，它被设计..."hessian-example"项目提供了学习和实践Hessian的实例，通过阅读相关博客和研究示例代码，开发者可以快速掌握Hessian的使用，提升其在实际项目中的应用能力。

    Java Hessian小试(转)

    Java Hessian小试(转) Java Hessian是一种二进制的RPC（远程过程调用）协议，由Caucho...在压缩包子文件"**Hessian**"中，可能包含了一些示例代码或者Hessian的实现细节，对于学习和研究Hessian的源码有一定的帮助。

    Hessian矩阵以及在血管增强中的应用—OpenCV3和c++版本代码工程

    Hessian矩阵是图像处理和计算机视觉领域中一个重要的数学工具，尤其在特征检测和结构分析中扮演着关键角色。在本项目中，它被应用于血管增强，这是一个在医学成像和图像分析中常见的任务，目的是突出血管结构，以...

    Hessian实例下载

    然后，你可以通过下载提供的`Hessian`和`HessianClient`示例，研究其源代码，理解如何设置服务端和客户端，以及它们如何通过Hessian协议进行通信。此外，官方文档和网络上的教程资源也是学习Hessian的重要参考资料。...

    基于matlab使用 hessian 特征值增强 2D3D 图像中的血管脊状结构

    在图像处理领域，特别是在医学成像中，检测和分析血管结构是至关重要的任务。这篇教程主要探讨了如何利用MATLAB编程环境以及Hessian矩阵来增强2D和3D图像...这对于医学成像分析，尤其是血管研究，具有很高的实用价值。

    hessian-4.0.51-src

    《深入解析Hessian 4.0.51源码》 Hessian，作为一个高效轻量级的二进制Web服务协议，广泛应用于分布式系统中，它允许开发者...对于想深入理解分布式通信机制的开发者来说，研究Hessian源码无疑是一次宝贵的学习机会。

    hessian-4.0.7jar文件与源代码.rar

    通过深入研究Hessian的源代码，开发者可以定制化Hessian的行为，例如添加自定义的序列化策略，或者优化现有的序列化过程，以满足特定项目的需求。此外，源代码的学习也有助于培养面向服务架构（SOA）的编程思维，...

    hessian轻量级 rpc实现

    通过学习和研究这个示例项目，开发者可以更好地理解Hessian的工作流程，以及如何在自己的项目中部署和使用Hessian RPC。 总结，Hessian作为一种轻量级的RPC解决方案，以其高效、简单和易于集成的特性在分布式系统中...

    Hessian-4.0.7（Jar包 + 源码）

    Hessian是一种轻量级的二进制Web服务协议，它由Caucho Technology开发，用于提高远程调用的效率和速度。...通过深入研究其源码，开发者可以更好地利用这一协议，并根据需求进行定制，以满足特定项目的需求。

    Hessian源代码

    总之，深入研究Hessian源代码不仅可以帮助我们优化远程服务的性能，还能提升我们在分布式系统和网络通信领域的专业技能。通过实践和调试，我们可以更好地掌握这一工具，从而在实际项目中发挥其最大潜力。

    hessian4.0.7结合spring2.5.6的bug

    通过研究这些文件，开发者可以直接看到问题的现象，理解问题的上下文，并尝试各种解决方案，如更新Hessian到兼容的版本、调整Spring配置、修复序列化类或者优化异常处理逻辑。 总的来说，Hessian 4.0.7与Spring ...

    Hessian 的字段序列化小记

    在IT行业中，序列化是一个非常重要的概念，尤其是在分布式系统、网络通信和持久化存储等领域。Hessian是一种二进制的序列化协议，由...通过深入研究源码，我们可以进一步挖掘其潜力，并根据具体需求进行定制和优化。

    论文研究-Efficient Pairing Computation on Elliptic Curves in Hessian form.pdf

    当前，对于Hessian形式的椭圆曲线上的双线性对的计算算法研究较少。Tate配对是双线性对的一种，本文提出了一种在Hessian形式椭圆曲线上的Tate配对的计算方法，并通过分析表明该算法比目前已知的Weierstrass和Edwards...

Magicbox
Global site tag (gtag.js) - Google Analytics