精华内容
下载资源
问答
  • Hessian

    2019-03-02 10:01:06
    Hessian是什么 * Hessian是一个轻量级的remoting on http工具,使用简单的方法提供了RMI(Remote Method Invocation)的功能。相比Webservice,Hessian更简单、快捷。采用的是二进制RPC(Remote Procedure Call ...

    ​Hessian是什么

        * Hessian是一个轻量级的remoting on http工具,使用简单的方法提供了RMI(Remote Method Invocation)的功能。相比Webservice,Hessian更简单、快捷。采用的是二进制RPC(Remote Procedure Call 远程过程调用:它是一种通过网络从远程计算机程序上请求服务,而不需要了解底层网络技术的协议)协议,因为采用的是二进制协议,所以它很适合发送二进制数据。

        * Hessian通过Servlet提供远程服务。需要将匹配某个模式的请求映射到Hessian服务。Spring的DispatcherServlet可以完成该功能,DispatcherServlet可将匹配模式的请求转发到Hessian服务。Hessian的server端提供一个servlet基类, 用来处理发送的请求,而Hessian的这个远程过程调用,完全使用动态代理来实现的,,推荐采用面向接口编程,因此,Hessian服务建议通过接口暴露

        

    Hessian处理过程示意图

        客户端——>序列化写到输出流——>远程方法(服务器端)——>序列化写到输出流 ——>客户端读取输入流——>输出结果

     

    环境搭建

        Hessian的下载和安装请按如下步骤进行:

        * 如果项目中使用maven,直接将hessian依赖加入到pom.xml文件

            <dependency>

                <groupId>com.caucho</groupId>

                <artifactId>hessian</artifactId>

                <version>4.0.7</version>

            </dependency>

        * 进入Hessian官网下载Hessian,把Hessian相应的Jar包放到Web应用下,所有的jar文件都应该放在WEB-INF/lib下

     

    使用hessian的两种方式

        单独使用hessian(不常用)

            这种方式主要是适用于工程中没有适用像spring框架的情况下,好处是配置方便,但是当内容多的情况下,配置的内容很多

     

    • 定义接口

    public interface UserService {

     

    public String sayHello(String text);

     

    public List<User> getUsers();

    }

    • 接口实现类

    public class UserServiceImpl implements UserService {

     

    @Override

    public String sayHello(String text) {

    return "hello hessian: " + text;

    }

     

    @Override

    public List<User> getUsers() {

     

    List<User> users = new ArrayList<User>();

    users.add(new User(1, "zhangshan", "123456"));

    users.add(new User(2, "lisi", "123456"));

    users.add(new User(3, "wangwu", "123456"));

     

    return users;

    }

    }

    • 配置hessian接口服务

    <servlet>

    <servlet-name>UserService</servlet-name>

    <!-- hessian提供的servlet -->

    <servlet-class>com.caucho.hessian.server.HessianServlet</servlet-class>

    <init-param>

    <param-name>home-class</param-name>

    <!-- 服务接口的实现类 -->

    <param-value>com.znsd.hessian.service.impl.UserServiceImpl</param-value>

    </init-param>

    <init-param>

    <param-name>home-api</param-name>

    <!-- 服务接口 -->

    <param-value>com.znsd.hessian.service.UserService</param-value>

    </init-param>

    <load-on-startup>1</load-on-startup>

    </servlet>

     

    <servlet-mapping>

    <servlet-name>UserService</servlet-name>

    <url-pattern>/userService</url-pattern>

    </servlet-mapping>

    • 客户端调用(客户端远程调用服务器端提供的接口,利用的就是Hessian的HessianProxyFactory,来实现远程代理)

    public static void main(String[] args) {

    // 接口服务地址

    String serverUrl = "http://localhost:8080/hessian-service-web/userService";

    // 创建hessian代理对象

    HessianProxyFactory factory = new HessianProxyFactory();

    try {

    // 调用远程方法

    UserService userService = (UserService) factory.create(UserService.class, serverUrl);

    System.out.println(userService.sayHello("王麻子"));

    // 调用远程方法获取user对象集合

    List<User> userList = userService.getUsers();

     

    for (User user : userList) {

    System.out.println(user);

    }

    } catch (MalformedURLException e) {

    e.printStackTrace();

    }

    }

    • 输出结果

    hello hessian: 王麻子

    User [id=1, username=zhangshan, password=123456]

    User [id=2, username=lisi, password=123456]

    User [id=3, username=wangwu, password=123456]

     

        hessian 整合 spring使用推荐

            相比上一种方式,这个方式就有点麻烦。Hessian 通过 Servlet提供远程服务。需要将匹配某个模式的请求映射到Hessian服务。Spring的DispatcherServlet可以完成该功能,DispatcherServlet可将匹配模式的请求转发到Hessian服务,web.xml只是定义了“请求转发器”,该转发器将匹配/remoting/*的请求截获,转发给context的bean处理。而HessianServiceExporter提供bean服务。所以Hessian与Spring整合主要就是一下两个工作:

            1. 通过DispatcherServlet来拦截URL请求

            2. HessianServiceExporter提供bean服务,Spring使用HessianServiceExporter,将一个常规bean导出成Hessian服务

            3. 修改web.xml

     

    <servlet>

    <servlet-name>remoting</servlet-name>

    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

    <init-param>

    <param-name>contextConfigLocation</param-name>

    <!-- 配置springmvc文件路径 -->

    <param-value>classpath:remoting-servlet.xml</param-value>

    </init-param>

    <load-on-startup>1</load-on-startup>

    </servlet>

    <servlet-mapping>

    <servlet-name>remoting</servlet-name>

    <url-pattern>/remoting/*</url-pattern>

    </servlet-mapping>

    • remoting-servlet.xml

    <beans xmlns="http://www.springframework.org/schema/beans"

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"

    xsi:schemaLocation="http://www.springframework.org/schema/beans

    http://www.springframework.org/schema/beans/spring-beans.xsd

    http://www.springframework.org/schema/context

    http://www.springframework.org/schema/context/spring-context-4.2.xsd">

     

    <!-- 定义用户service实现类的bean实例 -->

    <bean id="userService" class="com.znsd.hessian.service.impl.UserServiceImpl"></bean>

     

    <!-- 使用HessianServiceExporter 将普通bean导出成Hessian服务 -->

    <bean name="/userService" class="org.springframework.remoting.caucho.HessianServiceExporter">

    <!-- 需要导出的目标bean -->

    <property name="service" ref="userService" />

    <!-- Hessian服务的接口 -->

    <property name="serviceInterface" value="com.znsd.hessian.service.UserService" />

    </bean>

    </beans>

    • 通过main方法测试调用

    public static void main(String[] args) {

    // 接口服务地址

    //String serverUrl = "http://localhost:8080/hessian-service-web/userService";

    String serverUrl = "http://localhost:8080/hessian-service-web/remoting/userService";

    // 创建hessian代理对象

    HessianProxyFactory factory = new HessianProxyFactory();

    try {

    // 调用远程方法

    UserService userService = (UserService) factory.create(UserService.class, serverUrl);

    System.out.println(userService.sayHello("王麻子"));

    // 调用远程方法获取user对象集合

    List<User> userList = userService.getUsers();

     

    for (User user : userList) {

    System.out.println(user);

    }

    } catch (MalformedURLException e) {

    e.printStackTrace();

    }

    }

    通过spring整合web项目调用hessian服务

    • 客户端定义一个remoting-client.xml文件

    <!-- 配置服务端调用代理对象 -->

    <bean id="userService" class="org.springframework.remoting.caucho.HessianProxyFactoryBean">

    <!-- hessian服务地址 -->

    <property name="serviceUrl" value="http://localhost:8080/hessian-service-web/remoting/userService"/>

    <!-- hessian服务的接口 -->

    <property name="serviceInterface" value="com.znsd.hessian.service.UserService"/>

    </bean>

    • 在控制器中注入接口对象实现远程方法调用

    @Controller

    public class UserController {

     

    @Autowired

    private UserService userService;

     

    @ResponseBody

    @RequestMapping(value = "/list")

    public List<User> list(Model model) {

    List<User> userList = userService.getUsers();

    return userList;

    }

    }

    • 通过debug调试我们可以查看到userService其实上是spring生成的一个代理对象

     

    在进行基于Hessian的项目开发时,应当注意一下几点:

        Java服务器端必须具备:

            * 包含Hessian的jar包

            * 设计一个接口,用来给客户端调用

            * 实现该接口的功能

            * 配置web.xml,配置好相应的servlet

            * 由于使用二进制RPC协议传输数据,对象必须进行序列化,实现Serializable接口

            * 对于复杂对象可以使用Map的方法传递

        Java客户端必须具备:

            * Java客户端包含Hessian的jar包

            * 具有和服务器端结构一样的接口,包括命名空间都最好一样

            * 利用HessianProxyFactory调用远程接口

     

    hessian优缺点

        优点:

            1. 简单易用,面向接口,通过接口暴露服务,jar包只有200、300k,不需要配置防火墙

            2. 效率高,复杂对象序列化速度仅次于RMI,简单对象序列化优于RMI,二进制传输

            3. 多语言支持:wiki、Java、Flash/Flex、Python、C++、.NET C#、PHP、Ruby、Objective-C

            4. 可与spring集成,配置简单,使用HessianServiceExporter提供bean服务

        缺点:

            1. 缺乏安全机制,传输没有加密处理

            2. 异常机制不完善,总是报一些错误,错误原因也是千奇百怪,提示信息不足

            3. 事务处理欠缺

            4. 版本问题,spring 2.5.6对照3.1.3版,spring 3对照4.0及以上版本,需要使用spring MVC部分内容

     

     

    展开全文
  • hessian

    2017-05-10 15:14:37
    一、首先先说Hessian是什么? Hessian:hessian是一个轻量级的remoting onhttp工具,使用简单的方法提供了RMI的功能,相比WebService,Hessian更简单、快捷。采用的是二进制RPC协议,因为采用了二进制协议,所以它很...
    一、首先先说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这个接口,从而就能够调用这个接口里的方法进行操作
    
    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 33,067
精华内容 13,226
关键字:

hessian