hessian应用举例

hessian简介

Hessian是一个由Caucho Technology开发的轻量级二进制RPC协议。和其他Web服务的实现框架不同的是，Hessian是一个使用二进制Web服务协议的框架，它的好处在于免除了一大堆附加的API包，例如XML的处理之类的jar包，这也就是为什么说它是一个轻量级的Web服务实现框架的原因，这个原因还在于手机上的应用程序可以通过Hessian提供的API很方便的访问Hessian的Web服务。

举例

一、配置一个servlet，用于提供hessian服务

//创建一个servlet，TestHessianServlet.java
public class TestHessianServlet extends HessianServlet implements TestHessianService{

    private static final long serialVersionUID = 1L;

    @Override
    public void testHessian() throws Exception {
        System.out.println("我是调用了TestHessianServlet 的服务");
    }

}

//接口类TestHessianService.java
@HessianService(configKey = "testHessianServiceUrl")
public interface TestHessianService {
    public void testHessian()throws  Exception;
}

//这里还用到了注解，调用hessian服务的站点用这个注解解析请求的serviceURL
@HessianService(configKey = "testHessianServiceUrl")
public interface TestHessianService {
    public void testHessian()throws  Exception;
}

//配置web.xml
<servlet>
    <servlet-name>testHessian</servlet-name>
    <servlet-class>
        com.i61.upload.servlet.TestHessianServlet
    </servlet-class>
    <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>testHessian</servlet-name>
    <url-pattern>/testHessian</url-pattern>
</servlet-mapping>

启动tomcat后访问这个servlet，如果有如下显示，则表示hessian服务正常

二、在另外一个调用hessian服务，直接上代码

//使用spring框架，在一个controller里加一个@requestMapping
@RequestMapping("/testHessian")
    public void testHessian() throws Exception{
        TestHessianService hessianService = HessianServiceUtils.createService(TestHessianService.class);
        hessianService.testHessian();
    }

再贴上我自己写得hessian工具类

//HessianServiceUtils.java  
import java.lang.annotation.Annotation;

import com.i61.common.config.ConfigInitManager;
import com.i61.common.hessian.HessianClientManager.HessianInput;


public class HessianServiceUtils {
    public static <T> T createService(Class<? extends T> classSrc){
        Annotation hessianService = classSrc.getAnnotation(HessianService.class);
        if(hessianService != null){
            String hessianServiceKey =(HessianService.class.cast(hessianService)).configKey();
            /*这个地方其实写的是hessian服务的http链接，就是上面截图的 http://10.10.10.11:8080/RBKD-UPLOADIMG/testHessian这玩意,我是从配置文件读出来的
            */
            //String serviceUrl = ConfigInitManager.getValue(hessianServiceKey);
            String serviceUrl = "http://10.10.10.11:8080/RBKD-UPLOADIMG/testHessian";
            return HessianClientManager.createHessianService(classSrc,serviceUrl);
        }
        return null;
    }

    /**
     * @param classSrc
     * @param hessianInput
     * @return
     */
    public static <T> T createService(Class<? extends T> classSrc,HessianInput hessianInput){
        Annotation hessianService = classSrc.getAnnotation(HessianService.class);
        if(hessianService != null){
            String hessianServiceKey =(HessianService.class.cast(hessianService)).configKey();
            String serviceUrl = ConfigInitManager.getValue(hessianServiceKey);
            return HessianClientManager.createHessianService(classSrc,serviceUrl,hessianInput);
        }
        return null;
    }


}

//HessianClientManager.java 

import java.net.MalformedURLException;
import java.util.concurrent.ConcurrentHashMap;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.caucho.hessian.client.HessianProxyFactory;

public class HessianClientManager {

    private static final Logger logger = LoggerFactory.getLogger(HessianClientManager.class);
    private static final HessianInput DEFALT_HESSIAN_INPUT = new HessianInput();
    private static final ConcurrentHashMap<String,HessianProxyFactory> hFactoryMap = new ConcurrentHashMap<String, HessianProxyFactory>();
    private static <T> T genObject(Class<T> api, String urlName) throws MalformedURLException {
        return api.cast(getHessianProxyFactory(DEFALT_HESSIAN_INPUT).create(api, urlName));
    }

    public static <T> T createHessianService(Class<T> api, String serverUrl) {
        T hfs = null;
        if (serverUrl != null) {
            if (!serverUrl.contains("http://")) {
                serverUrl = "http://" + serverUrl;
            }
            try {
                hfs = genObject(api, serverUrl);
            } catch (MalformedURLException e) {
                logger.error("Create HessianService failed:", e);
            }
        }
        return hfs;
    }
    public static <T> T createHessianService(Class<T> api, String serverUrl,HessianInput hessianInput) {
        T hfs = null;
        if(hessianInput!=null){
            if (serverUrl != null) {
                if (!serverUrl.contains("http://")) {
                    serverUrl = "http://" + serverUrl;
                }
                try {
                    HessianProxyFactory hFactory = getHessianProxyFactory(hessianInput);
                    hfs = api.cast(hFactory.create(api, serverUrl));
                } catch (MalformedURLException e) {
                    logger.error("Create HessianService failed:", e);
                }
            }
        }
        return hfs;
    }

    private static HessianProxyFactory getHessianProxyFactory(HessianInput hessianInput){
        HessianProxyFactory hFactory = hFactoryMap.get(hessianInput.toString());
        if(hFactory==null){
            hFactory = new HessianProxyFactory();
            hFactory.setOverloadEnabled(hessianInput.isOverloadEnabled());
            hFactory.setConnectTimeout(hessianInput.getConnectTimeout());
            hFactory.setReadTimeout(hessianInput.getReadTimeout());
            hFactoryMap.put(hessianInput.toString(), hFactory);
        }
        return hFactory;
    }

    //用于修改hessian请求时候的一些配置，比如链接超时时间和读取数据超时时间
    public static class HessianInput {

        private boolean isOverloadEnabled = true;   
        private long readTimeout = 60000;    //读数据超时时间  ms
        private long connectTimeout = 5000; //连接超时时间  ms

        public HessianInput(){
        }
        public HessianInput(boolean isOverloadEnabled,long readTimeOut,long connectTimeout){
            this.isOverloadEnabled = isOverloadEnabled;
            this.readTimeout = readTimeOut;
            this.connectTimeout = connectTimeout;
        }

        public String toString(){
            return ""+isOverloadEnabled+readTimeout+connectTimeout;
        }

        public boolean isOverloadEnabled() {
            return isOverloadEnabled;
        }
        public HessianInput setOverloadEnabled(boolean isOverloadEnabled) {
            this.isOverloadEnabled = isOverloadEnabled;
            return this;
        }
        public long getReadTimeout() {
            return readTimeout;
        }
        public HessianInput setReadTimeout(long readTimeout) {
            this.readTimeout = readTimeout;
            return this;
        }
        public long getConnectTimeout() {
            return connectTimeout;
        }
        public HessianInput setConnectTimeout(long connectTimeout) {
            this.connectTimeout = connectTimeout;
            return this;
        }

    }
}

启动tomcat调用后，在url输入链接：http://10.10.10.11:8080/RBKD/util/testHessian.json
如果在tomcat console打印如下信息，则表示hessian测试成功了