Hessian在实际项目中的使用

摘要：项目介绍最近在一个互联网跨境支付项目组，所使用的技术比较老，代码是写于年的，整个系统采用服务的架构模式，连接件使用进行同步调用，使用进行异步调用。言归正传，本文主要是讲一下，在该项目中的使用。封装了的功能，便于调用。主要包括枚举类和帮助类。

最近在一个互联网跨境支付项目组，所使用的技术比较老，代码是写于2006年的，整个系统采用服务的架构模式，连接件使用hessian进行同步调用，使用MQ进行异步调用。
跨境系统的服务分类上，主要有两类，一类是线上的，比如交易，网关，出金，入金等，一类是线下的，比如对账，核算等。这个分类方法，有点像之前金融市场业务功能分成前中后台子系统。言归正传，本文主要是讲一下，hessian在该项目中的使用。

整个工程分为两个WEB模块：客户调用模块client，服务处理模块handler。两个基本jar组件:服务注册组件register，hessian工具组件hessianutil.

register : 只有一个枚举，用于注册服务，一个服务一个枚举。是不是瞬间感觉低端了。
hessianutil : 提供了hessian操作的工具类套件。之所以将这两个分开，是因为hessianutil基本不变，而注册类就经常变动了
client : 服务调用者
handler : 服务提供者

public enum SerCode {
    SIMPLE_CALL_RETURN_STRING("000000","简单调用"),
    SIMPLE_CALL_RETURN_MAP("000001","返回字典");

    private String code;
    private String desc;

    SerCode(String code, String desc) {
        this.code = code;
        this.desc = desc;
    }

    public String getCode() {
        return code;
    }

    public String getDesc() {
        return desc;
    }
}

注意在hessian的service中传入了handler的服务调用地址，hessian会创建代理，来实现RPC调用

public void makeSimpleCall(){
        Map paraMap = new HashMap();
        String reqMsg = JSonUtil.toJSonString(paraMap);
        HessianInvokeParam param = HessianInvokeHelper.processRequest(reqMsg);
        String sysTraceNo = SysTraceNoService
                .generateSysTraceNo(SystemCodeEnum.WEBGATE.getCode());
        String result = clientHessianService.invoke(
                SerCode.SIMPLE_CALL_RETURN_STRING.getCode(), sysTraceNo,
                SystemCodeEnum.WEBGATE.getCode(),
                SystemCodeEnum.TXNCORE.getCode(),
                SystemCodeEnum.TXNCORE.getVersion(), param.getDataLength(),
                param.getMsgCompress(), param.getDataMsg());
        param.parse(result);
        HessianInvokeHelper.processResponse(param);
        result = param.getDataMsg();
        System.out.println("result:"+result);
    }

public class SimpleHandler implements EventHandler {
    public String handle(String dataMsg) throws HessianInvokeException {
        return "this is from simple handler";
    }
}

        contextConfigLocation
        
            classpath*:context/**/*.xml
        
    
    
        org.springframework.web.context.ContextLoaderListener
    
    
        remoting
        org.springframework.web.servlet.DispatcherServlet
        
            contextConfigLocation
            
                classpath*:remote/**/*.xml
            
        
    
    
        remoting
        /service/*
    

通过如上配置，客户端就可以通过访问http://localhost:8080/handler...和对应的code来访问handler了。

封装了hessian的功能，便于调用。里面的类就不一一做介绍了。主要包括枚举类和帮助类。

//所有handler必须实现的接口
public interface EventHandler {
    String handle(String dataMsg) throws HessianInvokeException;
}

//hessian调用时用的接口
public interface HessianInvokeService {
    /**
     * Hessian通讯服务接口
     *
     * @param serCode
     *            服务代码
     * @param sysTraceNo
     *            系统跟踪号
     * @param originNo
     *            源系统编号
     * @param targetNo
     *            目的系统编号
     * @param versionNo
     *            接口版本号 格式：1.0.0
     * @param dataLength
     *            消息正文长度
     * @param msgCompress
     *            消息正文是否压缩
     * @param dataMsg
     *            消息正文
     * @return
     */
    String invoke(String serCode, String sysTraceNo, String originNo,
                  String targetNo, String versionNo, int dataLength, int msgCompress,
                  String dataMsg);

}

//调用的主要方法类
public class HessianService implements HessianInvokeService {

    private final Log logger = LogFactory.getLog(HessianService.class);
    private Map eventHandlerMap;
    public void setEventHandlerMap(Map eventHandlerMap) {
        this.eventHandlerMap = eventHandlerMap;
    }
    @SuppressWarnings("unchecked")
    @Override
    public String invoke(String serCode, String sysTraceNo, String originNo,
                         String targetNo, String versionNo, int dataLength, int msgCompress,
                         String dataMsg) {

        logger.info("requet auth system:" + "serCode:" + serCode
                + "sysTraceNo:" + sysTraceNo + "originNo:" + originNo
                + "targetNo:" + targetNo + "versionNo:" + versionNo);

        if(logger.isDebugEnabled()){
            logger.info("dataMsg:" + dataMsg);
        }

        Map result = new HashMap();
        try {

            // 验证请求参数
            HessianInvokeHelper.validateReqParam(serCode, sysTraceNo, originNo,
                    targetNo, versionNo, dataLength, msgCompress, dataMsg);

            // 验证请求服务代码是否正确
            EventHandler handler = eventHandlerMap.get(serCode);
            if (handler == null) {
                throw new HessianInvokeException(
                        ResponseCodeEnum.UNDEFINED_SERVICE.getCode(),
                        ResponseCodeEnum.UNDEFINED_SERVICE.getDesc());
            }

            // 验证目标系统编码
            HessianInvokeHelper.validateTargetNo(targetNo,
                    SystemCodeEnum.TXNCORE.getCode());

            // 验证请求消息正文内容长度
            HessianInvokeHelper.validateDataMsgSize(dataLength, dataMsg);

            String reqMsg = dataMsg;
            // 判断是否需要解压请求消息正文内容
            if (msgCompress == 1) {
                try {
                    reqMsg = ZipUtil.uncompress(dataMsg);
                } catch (IOException e) {
                    throw new HessianInvokeException(
                            ResponseCodeEnum.UNCOMPRESS_FAILURE.getCode(),
                            ResponseCodeEnum.UNCOMPRESS_FAILURE.getDesc(), e);
                }
            }

            if(logger.isDebugEnabled()){
                logger.info("reqMsg:" + reqMsg);
            }

            Map map = JSonUtil.toObject(reqMsg, Map.class);
            map.put("sysTraceNo", sysTraceNo);
            String rsp = handler.handle(JSonUtil.toJSonString(map));

            return HessianInvokeHelper.buildResponse(serCode, sysTraceNo,
                    SystemCodeEnum.TXNCORE.getCode(), originNo, versionNo, rsp);

        } catch (Exception e) {
            logger.error(e.getMessage(), e);
            logger.error(e.getMessage(), e);
            result.put("responseCode",
                    ResponseCodeEnum.UNDEFINED_ERROR.getCode());
            result.put("responseDesc",
                    ResponseCodeEnum.UNDEFINED_ERROR.getDesc());
        }
        return HessianInvokeHelper.buildResponse(serCode, sysTraceNo,
                SystemCodeEnum.TXNCORE.getCode(), originNo, versionNo,
                JSonUtil.toJSonString(result));
    }
}