欢迎您光临本小站。希望您在这里可以找到自己想要的信息。。。

Hessian通信基础、原理分析

Java Web water 2263℃ 0评论

一、首先先说Hessian是什么?
   Hessian:hessian是一个轻量级的remoting onhttp工具,使用简单的方法提供了RMI的功能,相比WebService,Hessian更简单、快捷。采用的是二进制RPC协议,因为采用了二 进制协议,所以它很适合于发送二进制数据,Hessian主要作面向对象的消息通信。Hessian的初衷就是支持动态类型,格式紧凑,跨语言 Hessian是使用自己的序列化机制实现的编组和反编组,其支持的数据类型是有限制的,不支持复杂的对象,可以穿透防火墙,在这里不得不说一下RMI:RMI是一组用户开发分布式应用程序的API。他使用的是java序列化机制实现调用及返回值的编组于反编组。它使用Java语言接口定义了远程对象,它集合了Java序列化和Java远程方法协议(Java Remote Method Protocol)。他可以被看做是RPC的Java版本,因为传统的RPC并不能很好的应用于分布式对象系统。而Java RMI则支持存储于不同地址空间的程序级对象之间彼此进行通信,实现远程对象之间的无缝远程调用。他也有它的缺点,他只能通过RMI协议来进行访问无法通过HTTP协议访问,无法穿透防火墙。
   还有一种远程调用方法就是HttpInvoker:他也是将参数和返回值通过Java的序列化机制进行编组和反编组,它具有RMI的支持所有可序列化对象的优点。试使用Http协议传输二进制流的,同时又具有Hessian、Burlap(传输xml文本)的优点。
二、写一个简单的hessian通信所需要知道写哪些内容?
Hessian:写一个Hessian需要注意的问题:
    1、JAVA服务器端必须具备以下几点:
       包含Hessian的jar包
       设计一个接口,用来给客户端调用
       实现该接口的动能
       配置web.xml,配置相应的servlet
       对象必须实现Serializable接口
       对于复杂对象可以使用Map的方法传递
    2、客户端必须具备以下几点:
       java客户端包含Hessian.jar包
       具有和服务器端结构一样的接口和实体类。包括命名空间都最好一样。利用HessianProxyFactory调用远程接口
三、简单hessian实例:
1、在服务端的接口:
public interface IHello {

   String sayHello();
  
}
2、在服务端的实现类:
public class IHelloImpl extends HessianServlet implements IHello {

   @Override
   public String sayHello() {
       // TODO Auto-generated method stub
       return “Hello,I from HessianService”;
   }

}
3、在客户端的类:
public class ClientTest {

   public static String url = “http://127.0.0.1:8080/HessianService/Hello”;
   public static void  main(String[] args){
       HessianProxyFactory factory = new HessianProxyFactory();
       try {
           IHello iHello = (IHello) factory.create(IHello.class, url);
           System.out.println(iHello.sayHello());
       } catch (MalformedURLException e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
       }
   }
}
3、先将服务器端的类link到客户端,或者是将服务器端打包放到客户端,
4、在web.xml中进行配置:
服务器端: <servlet>
   <servlet-name>Hello</servlet-name>
   <servlet-class>com.caucho.hessian.server.HessianServlet</servlet-class>
   <init-param>
     <param-name>home-class</param-name>
     <param-value>com.kcpt.hessian.service.IHelloImpl</param-value>
   </init-param>
   <init-param>
     <param-name>home-api</param-name>
     <param-value>com.kcpt.hessian.service.IHello</param-value>
   </init-param>
   <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
   <servlet-name>Hello</servlet-name>
   <url-pattern>/Hello</url-pattern>
</servlet-mapping>

执行成功:输出Hello,I from HessianService,这是简单的hessian实现方式,看起来比较简单
四、hessian与spring结合.
在实际应用中,我们不只是简单的只使用hessian来进行通信的,如果方法多得话,还不如直接写在客户端来调用,然而:当hessian与spring 结合后,大大减少了这些操作,将dao层的操作全部放在hessian服务端,将业务逻辑全部放在hessian客户端,这样的话我们的hessian客 户端和服务端完全分离,因此我们的业务逻辑和dao层就真正的达到了分离,就可以放在不同的服务器上,当然hessian的通信的作用不仅仅只有这些。
接口和实现和上边的一样:只是在web.xml中配置比较麻烦:
例子:
1、服务器端:增加remoting-servlet.xml配置文件:用来配置bean,并将bean导出为hessian服务:
<?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:aop = “http://www.springframework.org/schema/aop”
      xmlns:tx = “http://www.springframework.org/schema/tx”
      xsi:schemaLocation = “http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
          http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
          http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd” >    
         
<!– 定义普通的bean实例 –>
<bean id=”Hello” class=”com.kcpt.hessian.service.IHelloImpl”/>
   <!–  使用HessianServiceExporter 将普通bean导出成Hessian服务–>
   <bean name=”/remoting” class=”org.springframework.remoting.caucho.HessianServiceExporter”>
   <!–  需要导出的目标bean–>
    <property name=”service” ref=”Hello”/>
      <!–  Hessian服务的接口–>
    <property name=”serviceInterface” value=”com.kcpt.hessian.service.IHello”/>
   </bean>
</beans>
2、web.xml文件的配置:
首先是监听器:spring的监听器
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> <!–添加监听器 –>
</listener>
<!– 指定spring的配置文件在哪里,在这个配置文件中导出了Hessian服务 –>
<context-param>
   <param-name>contextConfigLocation</param-name>
   <param-value>/WEB-INF/remoting-servlet.xml</param-value> 
</context-param>
<!– Hessian通过Servlet提供远程服务,需要将某个匹配的模式映射到hessian服务中,spring的dispatcherServlet能 完成此功能,DispatcherServlet可将匹配模式的请求转发到Hessian服务,web.xml只是定义了“请求转发器”,该转发器将匹配 /remoting/*的请求截获,转发给context的bean处理。而HessianServiceExporter提供bean服务。 –>
<servlet>
  <servlet-name>remoting</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
          <load-on-startup>1</load-on-startup>
   </servlet>
<servlet-mapping>
<servlet-name>remoting</servlet-name>
<url-pattern>/remoting/*</url-pattern>
</servlet-mapping>
3、在客户端:
同样要加spring监听器和context-param指定bean的文件
声明bean的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:aop = “http://www.springframework.org/schema/aop”
      xmlns:tx = “http://www.springframework.org/schema/tx”
      xsi:schemaLocation = “http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
          http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
          http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd” >    
<bean id=”myServiceClient” class=”org.springframework.remoting.caucho.HessianProxyFactoryBean”>
<property name=”serviceUrl”>            //hessian的地址和名称请求转发的名称
<value>http://127.0.0.1:8080/HessianService/remoting</value>
</property>                          
<property name=”serviceInterface”>   //hessian所要调用的接口
<value>com.kcpt.hessian.service.IHello</value>
</property>
</bean>
</beans>
4、客户端的程序中要写:
ApplicationContext context = new ClassPathXmlApplicationContext(“com/kcpt/hessian/client/remoting-client.xml”);  //这里只是你声明的bean的xml文件所在的路径
       IHello b = (IHello) context.getBean(“myServiceClient”);
来获取到ihello这个接口,从而就能够调用这个接口里的方法进行操作

Hessian 原理分析

一.      远程通讯协议的基本原理

网络通信需要做的就是将流从一台计算机传输到另外一台计算机,基于传输协议和网络 IO 来实现,其中传输协议比较出名的有 http 、 tcp 、 udp 等等, http 、 tcp 、 udp 都是在基于 Socket 概念上为某类应用场景而扩展出的传输协议,网络 IO ,主要有 bio 、 nio 、 aio 三种方式,所有的分布式应用通讯都基于这个原理而实现,只是为了应用的易用,各种语言通常都会提供一些更为贴近应用易用的应用层协议。

二.      应用级协议 Binary-RPC

Binary-RPC 是一种和 RMI 类似的远程调用的协议,它和 RMI 的不同之处在于它以标准的二进制格式来定义请求的信息 ( 请求的对象、方法、参数等 ) ,这样的好处是什么呢,就是在跨语言通讯的时候也可以使用。

来看下 Binary -RPC 协议的一次远程通信过程:

1 、客户端发起请求,按照 Binary -RPC 协议将请求信息进行填充;

2 、填充完毕后将二进制格式文件转化为流,通过传输协议进行传输;

3 、接收到在接收到流后转换为二进制格式文件,按照 Binary -RPC 协议获取请求的信息并进行处理;

4 、处理完毕后将结果按照 Binary -RPC 协议写入二进制格式文件中并返回。

问题总结:

1 、传输的标准格式是?

标准格式的二进制文件。

2 、怎么样将请求转化为传输的流?

将二进制格式文件转化为流。

3 、怎么接收和处理流?

通过监听的端口获取到请求的流,转化为二进制文件,根据协议获取请求的信息,进行处理并将结果写入 XML 中返回。

4 、传输协议是?

Http 。

三.      Hessian ——一种实现远程通讯的 library

Hessian 是由 caucho 提供的一个基于 binary-RPC 实现的远程通讯 library 。

1 、是基于什么协议实现的?

基于 Binary-RPC 协议实现。

2 、怎么发起请求?

需通过 Hessian 本身提供的 API 来发起请求。

3 、怎么将请求转化为符合协议的格式的?

Hessian 通过其自定义的串行化机制将请求信息进行序列化,产生二进制流。

4 、使用什么传输协议传输?

Hessian 基于 Http 协议进行传输。

5 、响应端基于什么机制来接收请求?

响应端根据 Hessian 提供的 API 来接收请求。

6 、怎么将流还原为传输格式的?

Hessian 根据其私有的串行化机制来将请求信息进行反序列化,传递给使用者时已是相应的请求信息对象了。

7 、处理完毕后怎么回应?

处理完毕后直接返回, hessian 将结果对象进行序列化,传输至调用端。

四.      Hessian 源码分析

以 hessian 和 spring dm server 整合环境为例。

  1. 客户端发起请求

Hessian 的这个远程过程调用,完全使用动态代理来实现的。有客户端可以看出。

除去 spring 对其的封装,客户端主要是通过 HessianProxyFactory 的 create 方法就是创建接口的代理类,该类实现了接口, JDK 的 proxy 类会自动用 InvocationHandler 的实现类(该类在 Hessian 中表现为 HessianProxy )的 invoke 方法体来填充所生成代理类的方法体。

客户端系统启动时:

根据 serviceUrl 和 serviceInterface 创建代理。

HessianProxyFactoryBean 类

 

HessianClientInterceptor 类

createHessianProxy(HessianProxyFactory proxyFactory)

 

HessianProxyFactory 类

public Object create(Class api, String urlName)

 

客户端调用 hessian 服务时:

HessianProxy 类的 invoke(Object proxy, Method method, Object []args) 方法

String methodName = method.getName();// 取得方法名

Object value = args[0]; // 取得传入参数

conn = sendRequest(mangleName, args) ;      // 通过该方法和服务器端取得连接

 

httpConn = (HttpURLConnection) conn;

code = httpConn.getResponseCode();    // 发出请求

 

// 等待服务器端返回相应…………

 

is = conn.getInputStream();

Object value = in.readObject(method.getReturnType()); // 取得返回值

 

HessianProxy 类的 URLConnection sendRequest(String methodName, Object []args) 方法:

URLConnection  conn = _factory.openConnection(_url);      // 创建 URLConnection

OutputStream os = conn.getOutputStream();

 

AbstractHessianOutput out = _factory.getHessianOutput(os); // 封装为 hessian 自己的输入输出 API

out.call(methodName, args);

return conn;

 

 

  1. 服务器端接收请求并处理请求

服务器端截获相应请求交给:

org.springframework.remoting.caucho.HessianServiceExporter

具体处理步骤如下:

  1. a) HessianServiceExporter 类

(HessianExporter) invoke(request.getInputStream(), response.getOutputStream());

 

  1. b) HessianExporter 类

(Hessian2SkeletonInvoker) this.skeletonInvoker.invoke(inputStream, outputStream);

  1. c) Hessian2SkeletonInvoker 类

将输入输出封转化为转化为 Hessian 特有的 Hessian2Input 和 Hessian2Output

Hessian2Input in = new Hessian2Input(isToUse);

in.setSerializerFactory(this.serializerFactory);

 

AbstractHessianOutput out = null;

int major = in.read();

int minor = in.read();

out = new Hessian2Output(osToUse);

out = new HessianOutput(osToUse);

out.setSerializerFactory(this.serializerFactory);

(HessianSkeleton) this.skeleton.invoke(in, out);

 

  1. d) HessianSkeleton 类

读取方法名

String methodName = in.readMethod();

Method method = getMethod(methodName);

读取方法参数

Class []args = method.getParameterTypes();

Object []values = new Object[args.length];

 

执行相应方法并取得结果

result = method.invoke(service, values);

 

结果写入到输出流

out.writeObject(result);

 

总结: 由上面源码分析可知,客户端发起请求和服务器端接收处理请求都是通过 hessian 自己的 API 。输入输出流都要封装为 hessian 自己的 Hessian2Input 和 Hessian2Output ,接下来一节我们将去了解 hessian 自己封装的输入输出到底做了些什么!

五.      Hessian 的序列化和反序列化实现

hessian 源码中 com.caucho.hessian.io 这个包是 hessian 实现序列化与反序列化的核心包。其中 AbstractSerializerFactory , AbstractHessianOutput , AbstractSerializer , AbstractHessianInput , AbstractDeserializer 是 hessian 实现序列化和反序列化的核心结构代码。

 

  1. AbstractSerializerFactory ,它有 2 个抽象方法:

根据类来决定用哪种序列化工具类

abstract public Serializer getSerializer(Class cl)  throws HessianProtocolException;

根据类来决定用哪种反序列化工具类

abstract public Deserializer getDeserializer(Class cl)  throws HessianProtocolException;

  1. SerializerFactory 继承 AbstractSerializerFactory 。

在 SerializerFactory 有很多静态 map 用来存放类与序列化和反序列化工具类的映射,这样如果已经用过的序列化工具就可以直接拿出来用,不必再重新实例化工具类。

在 SerializerFactory 中,实现了抽象类的 getSerializer 方法,根据不同的需要被序列化的类来获得不同的序列化工具,一共有 17 种序列化工具, hessian 为不同的类型的 java 对象实现了不同的序列化工具,默认的序列化工具是 JavaSerializer 。

在 SerializerFactory 中,也实现了抽象类的 getDeserializer 方法,根据不同的需要被反序列化的类来获得不同的反序列化工具,默认的反序列化工具类是 JavaDeserializer 。

  1. HessianOutput 继承 AbstractHessianOutput 成为序列化输出流的一种实现。

它会实现很多方法,用来做流输出。

需要注意的是方法,它会先调用 serializerFactory 根据类来获得 serializer 序列化工具类

public void writeObject(Object object)

throws IOException

{

if (object == null) {

writeNull();

return;

}

 

Serializer serializer;

 

serializer = _serializerFactory.getSerializer(object.getClass());

 

serializer.writeObject(object, this);

}

  1. 现在我们来看看 AbstractSerializer 。

其 writeObject 是必须在子类实现的方法, AbstractSerializer 有 17 种子类实现, hessian 根据不同的 java 对象类型来实现了不同的序列化工具类,其中默认的是 JavaSerializer 。

而 JavaSerializer 的 writeObject 方法的实现,遍历 java 对象的数据成员,根据数据成员的类型来获得各自的 FieldSerializer ,一共有 6 中默认的 FieldSerializer 。

拿默认的 FieldSerializer 举例,还是调用 AbstractHessianOutput 的子类来 writeObject ,这个时候,肯定能找到相应的 Serializer 来做序列化

 

同理可以反推出 hessian 的反序列化机制。 SerializerFactory 可以根据需要被反序列化的类来获得反序列化工具类来做反序列化操作。

 

总结:得益于 hessian 序列号和反序列化的实现机制, hessian 序列化的速度很快,而且序列化后的字节数也较其他技术少。

转载请注明:学时网 » Hessian通信基础、原理分析

喜欢 (0)or分享 (0)

您必须 登录 才能发表评论!