Hessian 的基本使用

客户端必须具备以下几点：

• java 客户端包含 Hessian.jar 的包。
• 具有和服务器端结构一样的接口。
• 利用 HessianProxyFactory 调用远程接口。
• 使用 spring 方式需要配置 HessianProxyFactoryBean

注意：使用 resin 容器时，resin 已经包含了 hessian.jar 包

JAVA 服务器端必须具备以下几点：

• 包含 Hessian 的 jar 包。
• 设计一个接口，用来给客户端调用。
• 实现该接口的功能。
• 配置 web.xml，配好相应的 servlet。
• 对象必须实现 Serializable 接口。
• 对于 spring 方式 DispatcherServlet 拦截 url，HessianServiceExporter 提供 Bean 服务

完整代码下载

zml/HessianDemo Hessian的服务器端集成以及客户端调用 Gitee - gitee.com

引入必要 jar 包

<dependency>
      <groupId>com.caucho</groupId>
      <artifactId>hessian</artifactId>
      <version>4.0.51</version>
</dependency>

定义接口

实现接口
package top.wuyongshi.service.impl;
/**
 * Created by 郑明亮 on 2017/10/10 16:27.
 */

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.UUID;

import top.wuyongshi.model.CommonVO;
import top.wuyongshi.model.PageInfo;
import top.wuyongshi.model.TaskEntity;
import top.wuyongshi.service.ITaskRPC;


/**
 * @author 郑明亮   @email 1072307340@qq.com
 * @version 1.0
 * @time 2017/10/10 16:27
 * @description <p> </p>
 */
public class TaskRPCImpl implements ITaskRPC {

    @Override
    public PageInfo<TaskEntity> queryTaskByName(String taskName, CommonVO commonVO) {
        return null;
    }

    @Override
    public PageInfo<TaskEntity> queryAll(CommonVO commonVO) {
        return getTask(commonVO);
    }

    @Override
    public List<TaskEntity> queryAll() {
        return getTask();
    }

   static final String frequentness[] = {"日报","月报","季报","半年报","年报"};


    @Override
    public List<String> querySourcePools() {
       return getSourcePools();
    }

    @Override
    public List<String> queryTargetPools() {
        return getTargetPools();
    }

    /**
     * 模拟作业数据
     * @return
     */
    public static List<TaskEntity> getTask(){
        List<TaskEntity> list = new ArrayList<>();
        Random random = new Random();
        initTask(list, frequentness[random.nextInt(1000) % 5]);
        return list;
    }

    private static void initTask(List<TaskEntity> list, String frequentness) {
        for (int i = 0; i < 30; i++) {
            TaskEntity task = new TaskEntity();
            task.setId(""+i);
            task.setTaskName("task"+ getRandomCode(4));
            task.setTaskDesc("作业描述"+ UUID.randomUUID().toString());
            task.setTaskCreator("郑明亮");
            task.setTaskFrequentness(frequentness);
            task.setLimitTime(10);
            list.add(task);
        }
    }

    public static PageInfo<TaskEntity> getTask(CommonVO commonVO){
        List<TaskEntity> list = new ArrayList<>();
        Random random = new Random();
        initTask(list, frequentness[random.nextInt(1000)%5]);
        PageInfo pageInfo = new PageInfo();
        pageInfo.setList(list);
        pageInfo.setPageSize(commonVO.getPageSize());
        pageInfo.setTotal(30);
        pageInfo.setPages(((int) Math.ceil(30.0 / commonVO.getPageSize())));
        pageInfo.setPageNum(commonVO.getPageNo());
        return pageInfo;
    }
    public static List<String> getSourcePools() {
        List<String> soucePools = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            soucePools.add("源连接池"+(i+1));
        }
        return soucePools;
    }

    public List<String> getTargetPools() {
        List<String> targetPools = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            targetPools.add("目标连接池"+(i+1));
        }
        return targetPools;
    }

    public static String getRandomCode(int number) {
        String codeNum = "";
        int[] code = new int[3];
        Random random = new Random();
        for (int i = 0; i < number; i++) {
            int num = random.nextInt(10) + 48;
            int uppercase = random.nextInt(26) + 65;
            int lowercase = random.nextInt(26) + 97;
            code[0] = num;
            code[1] = uppercase;
            code[2] = lowercase;
            codeNum += (char) code[random.nextInt(3)];
        }
        System.out.println(codeNum);

        return codeNum;
    }
}


传输对象

需要实现 java.io.Serializable 接口进行序列化

package top.wuyongshi.model;
import java.io.Serializable;
import java.util.Date;

import javax.persistence.Column;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.Transient;

@Table(name = "T_TASK")
public class TaskEntity implements Serializable {
    /**
     * 任务ID，32位uuid
     */
    @Id
    @Column(name = "ID")
    @GeneratedValue(generator = "UUID")
    private String id;

    /**
     * 调度任务id
     */
    @Column(name = "SCHEDULE_ID")
    private String scheduleId;


    /**
     * 任务名称
     */
    @Column(name = "TASK_NAME")
    private String taskName;

    /**
     * 任务描述
     */
    @Column(name = "TASK_DESC")
    private String taskDesc;

    /**
     * 任务频度描述||如月报、季报、年报
     */
    @Column(name = "TASK_FREQUENTNESS")
    private String taskFrequentness;

    /**
     * 源连接池
     */
    @Column(name = "SOURCE_POOL")
    private String sourcePool;

    /**
     * 目标连接池
     */
    @Column(name = "TARGET_POOL")
    private String targetPool;

    /**
     * 任务创建者
     */
    @Column(name = "TASK_CREATOR")
    private String taskCreator;

    /**
     * 任务创建时间
     */
//    @JSONField(format = "yyyy-MM-dd HH:mm:ss")
    @Column(name = "CREATE_TIME")
    private Date createTime;

    /**
     * 任务修改者
     */
    @Column(name = "TASK_MENDER")
    private String taskMender;

    /**
     * 任务修改时间
     */
//    @JSONField(format = "yyyy-MM-dd HH:mm:ss")
    @Column(name = "TASK_UPDATE_TIME")
    private Date taskUpdateTime;

    /**
     * 任务参数  以json集合形式存储;类型为List<Map>
     */
    @Column(name = "TASK_PARAMS")
    private String taskParams;

    /**
     * 超时时间,时间单位分钟，默认值 10分钟
     */
    @Column(name = "LIMIT_TIME")
    private Integer limitTime;

     /**
     * 记录id，主要用于标记调度任务计划执行过程中，某次运行的记录id
     */
    @Transient
    private String scheduleRecordId;



    private static final long serialVersionUID = 1L;


    /**
     * 获取 任务ID，32位uuid
     */
    public String getId() {
        return this.id;
    }

    /**
     * 设置 任务ID，32位uuid
     */
    public void setId(String id) {
        this.id = id;
    }

    /**
     * 获取 任务名称
     */
    public String getTaskName() {
        return this.taskName;
    }

    /**
     * 设置 任务名称
     */
    public void setTaskName(String taskName) {
        this.taskName = taskName;
    }

    /**
     * 获取 任务描述
     */
    public String getTaskDesc() {
        return this.taskDesc;
    }

    /**
     * 设置 任务描述
     */
    public void setTaskDesc(String taskDesc) {
        this.taskDesc = taskDesc;
    }

    /**
     * 获取 任务频度描述||如月报、季报、年报
     */
    public String getTaskFrequentness() {
        return this.taskFrequentness;
    }

    /**
     * 设置 任务频度描述||如月报、季报、年报
     */
    public void setTaskFrequentness(String taskFrequentness) {
        this.taskFrequentness = taskFrequentness;
    }


    /**
     * 获取 任务创建者
     */
    public String getTaskCreator() {
        return this.taskCreator;
    }

    /**
     * 设置 任务创建者
     */
    public void setTaskCreator(String taskCreator) {
        this.taskCreator = taskCreator;
    }

    /**
     * 获取 任务创建时间
     */
    public Date getCreateTime() {
        return this.createTime;
    }

    /**
     * 设置 任务创建时间
     */
    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    /**
     * 获取 任务修改者
     */
    public String getTaskMender() {
        return this.taskMender;
    }

    /**
     * 设置 任务修改者
     */
    public void setTaskMender(String taskMender) {
        this.taskMender = taskMender;
    }

    /**
     * 获取 任务修改时间
     */
    public Date getTaskUpdateTime() {
        return this.taskUpdateTime;
    }

    /**
     * 设置 任务修改时间
     */
    public void setTaskUpdateTime(Date taskUpdateTime) {
        this.taskUpdateTime = taskUpdateTime;
    }

    /**
     * 获取 任务参数  以json集合形式存储;类型为List<Map>
     */
    public String getTaskParams() {
        return this.taskParams;
    }

    /**
     * 设置 任务参数  以json集合形式存储;类型为List<Map>
     */
    public void setTaskParams(String taskParams) {
        this.taskParams = taskParams;
    }

    /**
     * 获取 源连接池
     */
    public String getSourcePool() {
        return this.sourcePool;
    }

    /**
     * 设置 源连接池
     */
    public void setSourcePool(String sourcePool) {
        this.sourcePool = sourcePool;
    }

    /**
     * 获取 源连接池
     */
    public String getTargetPool() {
        return this.targetPool;
    }

    /**
     * 设置 源连接池
     */
    public void setTargetPool(String targetPool) {
        this.targetPool = targetPool;
    }

    /**
     * 获取 调度任务id
     */
    public String getScheduleId() {
        return this.scheduleId;
    }

    /**
     * 设置 调度任务id
     */
    public void setScheduleId(String scheduleId) {
        this.scheduleId = scheduleId;
    }

    /**
     * 获取 超时时间  时间单位分钟，默认值 10分钟
     */
    public Integer getLimitTime() {
//        if (this.limitTime == null){
//            limitTime = 10;
//        }
        return this.limitTime;
    }

    /**
     * 设置 超时时间 时间单位分钟，默认值 10分钟
     */
    public void setLimitTime(Integer limitTime) {
        this.limitTime = limitTime;
    }

    @Override
    public String toString() {
        return "TaskEntity{" +
                "id='" + id + '\'' +
                ", scheduleId='" + scheduleId + '\'' +
                ", taskName='" + taskName + '\'' +
                ", taskDesc='" + taskDesc + '\'' +
                ", taskFrequentness='" + taskFrequentness + '\'' +
                ", sourcePool='" + sourcePool + '\'' +
                ", targetPool='" + targetPool + '\'' +
                ", taskCreator='" + taskCreator + '\'' +
                ", createTime=" + createTime +
                ", taskMender='" + taskMender + '\'' +
                ", taskUpdateTime=" + taskUpdateTime +
                ", taskParams='" + taskParams + '\'' +
                ", limitTime=" + limitTime +
                "} " + super.toString();
    }

    /**
     * 获取 记录id，主要用于标记调度任务计划执行过程中，某次运行的记录id
     */
    public String getScheduleRecordId() {
        return this.scheduleRecordId;
    }

    /**
     * 设置 记录id，主要用于标记调度任务计划执行过程中，某次运行的记录id
     */
    public void setScheduleRecordId(String scheduleRecordId) {
        this.scheduleRecordId = scheduleRecordId;
    }
}

web.xml 配置 hessian


注意要将对外暴露的 接口 和 接口实现 声明到配置文件中，接口 可以缺省配置，这个网上的好多资料都比较坑，说多了都是泪...
查看过 HessianServlet 其实就会注意到，它里面方法 public void init(ServletConfig config) 在实例化的时候默认会取的初始化参数名为 home-class、service-class、object-class（接口实现类）、home-api、api-class、object-api（接口）


<servlet>
    <servlet-name>hessianServlet</servlet-name>
    <servlet-class>com.caucho.hessian.server.HessianServlet</servlet-class>
    <init-param>
    <!--接口实现类，此处param-name可配置的名称有：home-class、service-class、object-class-->
      <param-name>home-class</param-name>
      <param-value>top.wuyongshi.service.impl.TaskRPCImpl</param-value>
    </init-param>
      <init-param>
      <!--接口，param-name可配置的名称有：home-api、api-class、object-api（可不配置）-->
          <param-name>home-api</param-name>
          <param-value>top.wuyongshi.service.ITaskRPC</param-value>
      </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>hessianServlet</servlet-name>
    <url-pattern>/hessian</url-pattern>
 </servlet-mapping>

客户端调用

先启动服务器端，浏览器访问配置的路径，出现以下图片内容，说明配置成功



private String url;

    @Test
    public void testQueryAll() throws MalformedURLException {
        HessianProxyFactory factory = new HessianProxyFactory();
        url = "http://localhost:8088/HessianDemo2/hessian";
//        url = "http://localhost:8087/ScheduleTask/hessian";
        ITaskRPC taskRPC = (ITaskRPC) factory.create(ITaskRPC.class, url);
        List<TaskEntity> taskEntityPageInfo = taskRPC.queryAll();
        System.out.println(JSON.toJSONString(taskEntityPageInfo,true));
        List<String> strings = taskRPC.querySourcePools();
        for (String string : strings) {
            System.out.println(string);
        }
    }

测试结果

出处

文章首次发布于个人博客：吾勇士的博客http://wuyongshi.top/hessian-basic-use