`

Hessian源码分析

阅读更多

hessian的主要结构分客户端与服务端,中间基于http传输。客户端主要做的事情是把对远程接口调用序列化为流,并传输到服务端;服务端主要做的事情是把传输过来的流反序列化为对服务的请求,调用相应服务后把结果序列化为流返回给客户端。一次完整的调用如下图所示:

HessianProxy是hessian client处理客户端请求的核心类,它采用proxy的设计模式,代理客户端对远程接口的调用,hessian client的主流程的时序图如下所示:

 

HessianSkeleton是hessian server端的核心类,从输入流中返序列化出客户端调用的方法和参数,对服务端服务进行调用,然后把处理结果返回给客户端,主要流程时序图如下所示:

 

 

 

Hessian在客户端一块采用Proxy模式,当客户端调用远程接口时,HessianProxy会代理这个动作,在invoke方法中,把客户端请求的方法和参数序列化为预订格式的输出流,主要流程如下图所示:

 

下面我将详细解析一下invoke源码:

 

[java] view plaincopy
  1. public Object invoke(Object proxy, Method method, Object []args)  
  2.     throws Throwable  
  3.   {  
  4.     String mangleName;  
  5.     synchronized (_mangleMap) {  
  6.       mangleName = _mangleMap.get(method);  
  7.     }  
  8.     if (mangleName == null) {  
  9.       String methodName = method.getName();  
  10.       Class []params = method.getParameterTypes();  
  11.       // equals and hashCode are special cased  
  12.       if (methodName.equals("equals")  
  13.       && params.length == 1 && params[0].equals(Object.class)) {  
  14.     Object value = args[0];  
  15.     if (value == null || ! Proxy.isProxyClass(value.getClass()))  
  16.       return new Boolean(false);  
  17.     HessianProxy handler = (HessianProxy) Proxy.getInvocationHandler(value);  
  18.     return new Boolean(_url.equals(handler.getURL()));  
  19.       }  
  20.       else if (methodName.equals("hashCode") && params.length == 0)  
  21.     return new Integer(_url.hashCode());  
  22.       else if (methodName.equals("getHessianType"))  
  23.     return proxy.getClass().getInterfaces()[0].getName();  
  24.       else if (methodName.equals("getHessianURL"))  
  25.     return _url.toString();  
  26.       else if (methodName.equals("toString") && params.length == 0)  
  27.     return "HessianProxy[" + _url + "]";  
  28.         
  29.       if (! _factory.isOverloadEnabled())  
  30.     mangleName = method.getName();  
  31.       else  
  32.         mangleName = mangleName(method);  
  33.       synchronized (_mangleMap) {  
  34.     _mangleMap.put(method, mangleName);  
  35.       }  
  36.     }  
  37.     ......  
  38. }  

 

这是invoke的开头,主要干的事情是把methodName缓存起来和过滤一些特殊调用,java反射是个比较耗性能的操作,把methodName缓存起来可以避免每次调用都要从method里得到methodName。另外,对equals、hashCode、getHessianType、getHessianURL等特殊方法的远程调用,HessianProxy不会走远程调用,而是直接返回。

接着往下看:

 

[java] view plaincopy
  1. public Object invoke(Object proxy, Method method, Object []args)  
  2.     throws Throwable  
  3.   {  
  4.     ......  
  5.     InputStream is = null;  
  6.     URLConnection conn = null;  
  7.     HttpURLConnection httpConn = null;  
  8.       
  9.     try {  
  10.              
  11.       conn = sendRequest(mangleName, args);  
  12.      ......  
  13.     } catch (HessianProtocolException e) {  
  14.       throw new HessianRuntimeException(e);  
  15.     } finally {  
  16.      ......  
  17.      }  
  18.   }  

 

这段主要是把方法名和参数序列化为网络输出流,并做网络请求,具体逻辑包装在sendRequest方法中:

 

[java:nogutter] view plaincopy
  1. protected URLConnection sendRequest(String methodName, Object []args)  
  2.     throws IOException  
  3.   {  
  4.     URLConnection conn = null;  
  5.       
  6.     conn = _factory.openConnection(_url);  
  7.     boolean isValid = false;  
  8.     try {  
  9.       // Used chunked mode when available, i.e. JDK 1.5.  
  10.       if (_factory.isChunkedPost() && conn instanceof HttpURLConnection) {  
  11.     try {  
  12.       HttpURLConnection httpConn = (HttpURLConnection) conn;  
  13.       httpConn.setChunkedStreamingMode(8 * 1024);  
  14.     } catch (Throwable e) {  
  15.     }  
  16.       }  
  17.       
  18.       addRequestHeaders(conn);  
  19.       OutputStream os = null;  
  20.       try {  
  21.     os = conn.getOutputStream();  
  22.       } catch (Exception e) {  
  23.     throw new HessianRuntimeException(e);  
  24.       }  
  25.       if (log.isLoggable(Level.FINEST)) {  
  26.     PrintWriter dbg = new PrintWriter(new LogWriter(log));  
  27.     os = new HessianDebugOutputStream(os, dbg);  
  28.       }  
  29.         
  30.       AbstractHessianOutput out = _factory.getHessianOutput(os);  
  31.       out.call(methodName, args);  
  32.       out.flush();  
  33.       isValid = true;  
  34.       return conn;  
  35.     } finally {  
  36.       if (! isValid && conn instanceof HttpURLConnection)  
  37.     ((HttpURLConnection) conn).disconnect();  
  38.     }  
  39.   }  

 

sendRequest的主要流程是先初始化网络连接,然后用AbstractHessianOutput包装网络输出流,调用AbstractHessianOutput.call(methodName, args)完成网络输出,这个方法的细节会在hessian io的源码解析中详细分析。

下面接着看invoke方法:

 

[java:nogutter] view plaincopy
  1. public Object invoke(Object proxy, Method method, Object []args)  
  2.     throws Throwable  
  3.   {  
  4.       ......  
  5.       is = conn.getInputStream();  
  6.       AbstractHessianInput in = _factory.getHessianInput(is);  
  7.       in.startReply();  
  8.       Object value = in.readObject(method.getReturnType());  
  9.       if (value instanceof InputStream) {  
  10.     value = new ResultInputStream(httpConn, is, in, (InputStream) value);  
  11.     is = null;  
  12.     httpConn = null;  
  13.       }  
  14.       else  
  15.     in.completeReply();  
  16.       ......  
  17.   }  

 

这一段主要是把输入流中取得返回值,具体是用AbstractHessianInput包装网络输入流,然后调用AbstractHessianInput.readObject从网络流中反序列化到实际返回值。

 

HessianSkeleton是Hessian server端的核心类,主要功能是接收网络输入流(被包装为AbstractHessianInput),反序列化输入流得到methodName和参数,然后调用服务端的服务,得到结果后序列化为输出流,返回给客户端,主要流程如下图所示:

HessianSkeleton的核心代码如下所示:

 

[java:nogutter] view plaincopy
  1. public void invoke(Object service,  
  2.              AbstractHessianInput in,  
  3.              AbstractHessianOutput out)  
  4.     throws Exception  
  5.   {  
  6.     ......      
  7.     String methodName = in.readMethod();  
  8.     Method method = getMethod(methodName);  
  9.     ......  
  10.     Class []args = method.getParameterTypes();  
  11.     Object []values = new Object[args.length];  
  12.     for (int i = 0; i < args.length; i++) {  
  13.       values[i] = in.readObject(args[i]);  
  14.     }  
  15.     Object result = null;  
  16.       
  17.     try {  
  18.       result = method.invoke(service, values);  
  19.     } catch (Throwable e) {  
  20.       ......  
  21.     }  
  22.     // The complete call needs to be after the invoke to handle a  
  23.     // trailing InputStream  
  24.     in.completeCall();  
  25.       
  26.     out.startReply();  
  27.     out.writeObject(result);  
  28.       
  29.     out.completeReply();  
  30.     out.close();  
  31.   }  

 

主流程代码非常清晰,不需要太多解释,关键的地方在于对网络流的序列化和反序列化,我会在hessian io分析的部分中进行详细阐述

 

分享到:
评论

相关推荐

    Hessian源码分析和Hack.doc

    《Hessian源码分析与Hack:携带远程调用端信息》 Hessian作为一种轻量级的RPC(远程过程调用)框架,因其高效、简洁的二进制协议,被广泛应用于构建Web服务。然而,在实际应用中,有时我们需要获取到远程调用端的IP...

    hessian最新源码分析.pdf

    总结一下,Hessian的源码分析主要关注客户端的`HessianProxy`和服务器端的`HessianSkeleton`这两个核心类。它们分别负责客户端的调用代理和服务器端的请求处理。源码中包含了方法名缓存、特殊方法的本地处理、以及...

    Hessian

    **五、源码分析** 对于深入理解Hessian的工作机制,阅读和分析源码是必不可少的。Caucho Technology提供了Hessian的开源实现,开发者可以通过阅读源码了解其内部细节,如序列化和反序列化的具体实现、类型转换逻辑...

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

    在源码分析方面,理解Hessian的内部工作机制是提升开发技能的重要步骤。通过阅读和分析Hessian的源码,我们可以了解其如何编码和解码各种数据类型,以及如何优化序列化和反序列化的过程。这对于优化自定义序列化逻辑...

    Spring中集成Hessian的问题

    Hessian的源码分析可以帮助我们更深入地理解其工作原理。Hessian服务端的序列化和反序列化过程、HTTP请求处理以及异常处理等都是关键部分。而Spring框架如何与Hessian进行集成,包括服务注册、请求处理和代理创建等...

    hessian

    在【标签】中,"源码"可能指的是查看或分析Hessian协议的底层实现,这对于理解其工作原理和优化性能非常有帮助。"工具"可能指的是使用Hessian相关的开发工具或框架,例如HessianProxyFactory、HessianServlet等。 ...

    hessian-4.0.51-src

    《深入解析Hessian 4.0.51源码》 ...本文将基于Hessian 4.0.51的源码包,探讨其核心设计理念、实现机制以及如何在JDK 1.7环境下...对于想深入理解分布式通信机制的开发者来说,研究Hessian源码无疑是一次宝贵的学习机会。

    hessian php与java通讯demo源码

    Hessian是一种二进制协议,它允许在不同的编程语言之间进行高效的远程方法调用(RPC)。...通过分析和实践这些示例代码,你可以更好地掌握Hessian的工作原理和使用方式,为你的跨语言项目打下坚实的基础。

    Hessian 学习 例子 实例

    至于标签"源码",学习Hessian时查看源码有助于理解其内部工作原理,比如数据如何被编码和解码。你可以通过阅读开源的Hessian库,如Caucho Hessian的Java实现,来了解其底层细节。 至于"工具",有一些工具可以帮助...

    Hessian 的字段序列化小记

    4. **源码分析** - 分析Hessian的源码可以帮助我们理解其内部实现,比如如何优化序列化过程,如何处理异常情况,以及如何实现类型兼容性等。这对于我们自定义序列化逻辑或优化现有应用的性能都非常有价值。 5. **...

    闲着没事Hessian开发WebService的总结(一)

    读者可能能从中了解到如何集成Hessian到他们的项目中,以及如何通过源码分析来调试和优化Hessian服务。 从压缩包子文件的文件名称“BurlapWS”来看,这可能是与Burlap相关的,Burlap是Hessian的一个变种,也是一个...

    spring整合hessian进行远程通讯

    3. **使用源码分析**: Hessian库提供了`HessianProxyFactoryBean`和`HessianServiceExporter`这两个关键类。前者用于客户端创建Hessian服务的代理,后者在服务端用于导出Hessian服务。通过阅读这些类的源码,我们...

    dubbo源码分析pdf.zip

    《Dubbo源码分析》是一套深入探讨Apache Dubbo这一著名Java开源框架的书籍,旨在帮助开发者更好地理解和应用Dubbo。Dubbo是一个高性能、轻量级的服务治理框架,广泛应用于微服务架构中,以实现服务的发布、发现、...

    hessian4.0.7结合spring2.5.6的bug

    总的来说,Hessian 4.0.7与Spring 2.5.6的结合使用时出现的bug,可能涉及多个层面,需要综合运用源码阅读、调试技巧以及社区资源来定位和修复。在这个过程中,对Java、Spring和Hessian的深入理解,以及对问题排查的...

    Hessian源代码

    此外,分析示例代码可以让我们了解如何在Java应用中集成Hessian,例如: - **服务发布**:如何使用Hessian的Server类来发布一个可远程调用的服务。 - **客户端调用**:客户端如何通过HessianProxyFactory来创建代理...

    自己写了个Hessian

    通过分析这些测试代码,我们可以更深入地了解Hessian的工作原理,以及如何在不同的场景下使用它。 总之,"自己写了个Hessian" 是一个关于实现Hessian协议的个人项目,涉及到对象序列化、HTTP通信、RPC服务等多个IT...

    hessian-4.0.7.jar + src

    本次我们将深入探讨Hessian 4.0.7版本,包括其jar包的使用以及源码分析,帮助开发者更好地理解和应用这个强大的工具。 一、Hessian 4.0.7.jar——核心库 `hessian-4.0.7.jar`是Hessian的核心库文件,它包含了...

    dubbo的源码分析

    深入源码分析,我们可以看到Dubbo如何通过Netty框架来实现异步非阻塞的网络通信,以及如何通过Hessian或Protobuf等序列化库进行数据交换。 接下来,我们关注服务注册与发现。Dubbo提供了Zookeeper、Eureka、Redis等...

    Hessian 入门介绍

    通过运行和分析`HessianDemo`,你可以更深入地理解Hessian的工作流程,包括如何创建服务端的Hessian服务,如何在客户端使用Hessian Proxy进行调用,以及如何处理返回结果。 总之,Hessian作为一种高效的RPC协议,...

Global site tag (gtag.js) - Google Analytics