Hessian解析及應用（整合Spring）

        Hessian是一個輕量級的remoting onhttp工具，使用簡單的方法提供了RMI的功能。 相比WebService，Hessian更簡單、快捷。------來自百度百科。

        看官網簡介吧：http://hessian.caucho.com/index.xtp

        The Hessian binary web service protocol makes web services usable without requiring a large framework, and without learning yet another alphabet soup of protocols. Because it is a binary protocol, it is well-suited to sending binary data without any need to extend the protocol with attachments.

        此文使用hessian為hessian-4.0.7，源碼及jar包請自行下載。------當然是java版了，咱也不會別的。

        開搞吧！

        除了提供下載，Hessian官網上貌似就下面幾句話有用了（可能是Hessian使用起來很簡單的原因吧）。

        開搞吧，兩個應用，Client（hessianclient）調用Server（hessianserver）提供的服務並展示返回內容。

        創建公共接口（單獨打包成Jar，方便多個項目使用）。

package com.skyjoo.hessiancommon.interfaces; public interface HessianExampleInterface { public String hello(String name); }

        就一個hello方法，返回String......

        在Server中提供該接口的實現。

package com.skyjoo.hessianserver.interfacesImpl; import com.skyjoo.hessiancommon.interfaces.HessianExampleInterface; public class HessianExampleInterfaceImpl implements HessianExampleInterface { @Override public String hello(String name) { return "Hello " + name + ",Welcome to Hessian World!!!"; } }

        像上面這樣肯定是沒法工作的，只要有WebService經驗或了解過Axis的類似開源框架的童鞋肯定都知道關鍵的是發布服務......

        介紹中的"輕量級"說明發布服務應該是很簡單的......

        本文結合Spring，看一下配置吧。

<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
        <property name="order" value="100" />
        <property name="urlMap">
            <map>
                <entry key="/remote/hessianService.htm" value-ref="exampleService" />
            </map>
        </property>
</bean>
<bean id="exampleService" class="org.springframework.remoting.caucho.HessianServiceExporter">
        <property name="service" ref="hessianExampleService" />
        <property name="serviceInterface" value="com.skyjoo.hessiancommon.interfaces.HessianExampleInterface" />
</bean>
<bean id="hessianExampleService" class="com.skyjoo.hessianserver.interfacesImpl.HessianExampleInterfaceImpl" />

    

    <entry key="/remote/hessianService.htm" value-ref="exampleService" />

    將某個地址對應到Bean上，這里的Bean為org.springframework.remoting.caucho.HessianServiceExporter。該Bean的service屬性即服務端對公共接口的實現，serviceInterface即公共接口。還是很容易就能理解的。
    接着就是Client的內容。

    <bean id="hessianService" class="org.springframework.remoting.caucho.HessianProxyFactoryBean">
        <property name="serviceUrl" value="http://localhost:8090/hessianserver/remote/hessianService.htm" />
        <property name="serviceInterface" value="com.skyjoo.hessiancommon.interfaces.HessianExampleInterface" />
    </bean>

        使用org.springframework.remoting.caucho.HessianProxyFactoryBean，serviceUrl為服務地址，serviceInterface為公共接口。看serviceUrl的內容

    http://localhost:8090/hessianserver/remote/hessianService.htm

    前半部分是服務部署地址，后半部分為<entry key="/remote/hessianService.htm" value-ref="exampleService"/>配置中指定的key。

    然后......然后就沒有了，Spring怎么裝配Bean的，平時怎么使用Bean的，就怎么玩吧。
    測試內容

@Controller public class Test { @Autowired private HessianExampleInterface hessianService; @RequestMapping("/hello") public void hello(@RequestParam("username") String username, ModelMap model) { model.put("helloUser", hessianService.hello(username)); } }

        和使用普通的Bean一模一樣。

（這圖上的好無聊~~~~~~~~~~~）

 只是簡單的實現了一個例子，還沒能深入的學習、理解hessian的內容。
--------------------------------------------------------------------華麗麗的分割線---------------------------------------------------------------

 未完待續......
 
 昨天只是簡單的例子，現在續上......
 Hessian在Spring中的工作流程如下：
 （1）客戶端：
 a.發送遠程請求：
 客戶端程序-->調用公共接口的方法-->Hessian攔截器攔截請求-->封裝遠程調用請求-->Hessian代理-->通過HTTP協議發送遠程請求代理到服務端
 b.接收遠程調用響應：
 遠程調用結果-->HTTP響應-->客戶端
 （2）服務端：
 a.接收遠程調用請求：
 HessianServiceExporter接收請求-->將遠程調用對象封裝為HessianSkeleton框架-->HessianSkeleton處理遠程調用請求
    b.返回遠程調用響應：
        HessianSkeleton封裝遠程調用處理結果-->HTTP響應-->客戶端
    下圖是通過hessian一次完成調用的示意圖

    在上面的例子中，Spring通過HessianProxyFactoryBean管理Hessian客戶端。
    HessianProxyFactoryBean.java

public class HessianProxyFactoryBean extends HessianClientInterceptor implements FactoryBean<Object> {
    //遠程調用代理對象
    private Object serviceProxy;
    //Spring IoC依賴注入完成后的回調方法
    @Override
    public void afterPropertiesSet() {
        super.afterPropertiesSet();
        //設置遠程代理對象，getServiceInterface()即獲取配置中的serviceInterface（公共接口）
        //HessianProxyFactoryBean 繼HessianClientInterceptor ，本身就是一個攔截器，所以傳入攔截器為this
        this.serviceProxy = new ProxyFactory(getServiceInterface(), this).getProxy(getBeanClassLoader());
    }

    //返回遠程調用代理對象
    public Object getObject() {
        return this.serviceProxy;
    }
    //獲取對象類型（即公共接口）
    public Class<?> getObjectType() {
        return getServiceInterface();
    }
    //判斷是否是單例,Spring默認管理對象都是單例的
    public boolean isSingleton() {
        return true;
    }

}

    HessianProxyFactoryBean最核心的功能是在IoC容器回調方法中產生遠程調用代理對象，將代理對象的攔截器設置為HessianClientInterceptor。

public class HessianClientInterceptor extends UrlBasedRemoteAccessor implements MethodInterceptor {  
    //創建Hessiann代理工廠  
    private HessianProxyFactory proxyFactory = new HessianProxyFactory();  
    //Hessian代理  
    private Object hessianProxy;  
    //設置Hessian代理工廠  
    public void setProxyFactory(HessianProxyFactory proxyFactory) {  
        this.proxyFactory = (proxyFactory != null ? proxyFactory : new HessianProxyFactory());  
    }  
    //設置Hessian序列化工廠  
    public void setSerializerFactory(SerializerFactory serializerFactory) {  
        this.proxyFactory.setSerializerFactory(serializerFactory);  
    }  
    //設置Hessian是否發送java集合類型對象  
    public void setSendCollectionType(boolean sendCollectionType) {  
    this.proxyFactory.getSerializerFactory().setSendCollectionType(sendCollectionType);  
    }  
    //設置遠程調用時是否重載方法  
    public void setOverloadEnabled(boolean overloadEnabled) {  
        this.proxyFactory.setOverloadEnabled(overloadEnabled);  
    }  
    //設置遠程調用用戶名  
    public void setUsername(String username) {  
        this.proxyFactory.setUser(username);  
    }  
    //設置遠程調用密碼  
    public void setPassword(String password) {  
        this.proxyFactory.setPassword(password);  
    }  
    //設置是否使用Hessian的Debug調試模式  
    public void setDebug(boolean debug) {  
        this.proxyFactory.setDebug(debug);  
    }  
    //設置是否使用chunked端口發送Hessian請求  
    public void setChunkedPost(boolean chunkedPost) {  
        this.proxyFactory.setChunkedPost(chunkedPost);  
    }  
    //設置Hessian等待響應的超時時長  
    public void setReadTimeout(long timeout) {  
        this.proxyFactory.setReadTimeout(timeout);  
    }  
    //設置是否使用Hessain版本2協議解析請求和響應  
    public void setHessian2(boolean hessian2) {  
        this.proxyFactory.setHessian2Request(hessian2);  
        this.proxyFactory.setHessian2Reply(hessian2);  
    }  
    //設置是否使用Hessian版本2協議解析請求  
    public void setHessian2Request(boolean hessian2) {  
        this.proxyFactory.setHessian2Request(hessian2);  
    }  
    //設置是否使用Hessian版本2協議解析響應  
    public void setHessian2Reply(boolean hessian2) {  
        this.proxyFactory.setHessian2Reply(hessian2);  
    }  
//子類HessianProxyFactoryBean的回調方法調用此回調方法  
    public void afterPropertiesSet() {  
        //調用其父類UrlBasedRemoteAccessor的回調方法獲取客戶端配置的請求url  
        super.afterPropertiesSet();  
        //初始化Hessian代理  
        prepare();  
    }  
    //初始化Hessian代理  
    public void prepare() throws RemoteLookupFailureException {  
        try {  
            //創建Hessian代理  
            this.hessianProxy = createHessianProxy(this.proxyFactory);  
        }  
        catch (MalformedURLException ex) {  
            throw new RemoteLookupFailureException("Service URL [" + getServiceUrl() + "] is invalid", ex);  
        }  
    }  
    //創建Hessian代理  
    protected Object createHessianProxy(HessianProxyFactory proxyFactory) throws MalformedURLException {  
        Assert.notNull(getServiceInterface(), "'serviceInterface' is required");  
        //使用Hessian代理工廠創建Hessian代理  
        return proxyFactory.create(getServiceInterface(), getServiceUrl());  
    }  
    //攔截器客戶端請求的方法  
    public Object invoke(MethodInvocation invocation) throws Throwable {  
        if (this.hessianProxy == null) {  
            throw new IllegalStateException("HessianClientInterceptor is not properly initialized - " +  
                    "invoke 'prepare' before attempting any operations");  
        }  
        //獲取當前環境中線程類加載器  
        ClassLoader originalClassLoader = overrideThreadContextClassLoader();  
        try {  
        //調用Hessian代理的方法，是Hessian遠程調用的入口方法，使用JDK反射機制  
            return invocation.getMethod().invoke(this.hessianProxy, invocation.getArguments());  
        }  
        //處理Hessian遠程調用中的異常  
        catch (InvocationTargetException ex) {  
            Throwable targetEx = ex.getTargetException();  
            if (targetEx instanceof InvocationTargetException) {  
                targetEx = ((InvocationTargetException) targetEx).getTargetException();  
            }  
            if (targetEx instanceof HessianConnectionException) {  
                throw convertHessianAccessException(targetEx);  
            }  
            else if (targetEx instanceof HessianException || targetEx instanceof HessianRuntimeException) {  
                Throwable cause = targetEx.getCause();  
                throw convertHessianAccessException(cause != null ? cause : targetEx);  
            }  
            else if (targetEx instanceof UndeclaredThrowableException) {  
                UndeclaredThrowableException utex = (UndeclaredThrowableException) targetEx;  
                throw convertHessianAccessException(utex.getUndeclaredThrowable());  
            }  
            else {  
                throw targetEx;  
            }  
        }  
        catch (Throwable ex) {  
            throw new RemoteProxyFailureException(  
                    "Failed to invoke Hessian proxy for remote service [" + getServiceUrl() + "]", ex);  
        }  
        //重置類加載器  
        finally {  
            resetThreadContextClassLoader(originalClassLoader);  
        }  
    }  
    //將Hessian異常轉換為Spring遠程調用異常  
    protected RemoteAccessException convertHessianAccessException(Throwable ex) {  
        if (ex instanceof HessianConnectionException || ex instanceof ConnectException) {  
            return new RemoteConnectFailureException(  
                    "Cannot connect to Hessian remote service at [" + getServiceUrl() + "]", ex);  
        }  
        else {  
            return new RemoteAccessException(  
                "Cannot access Hessian remote service at [" + getServiceUrl() + "]", ex);  
        }  
    }  
}  

    上面源碼中最重要的方法是對遠程調用攔截的方法invoke，在該方法中使用JDK的反射機制調用Hessian代理對象的指定方法。而Hessian代理是由Hessain代理器工廠HessianProxyFactory產生的，這個Hessian代理器工廠是有Hessian提供的。
 接着看Hessian的具體實現，這塊已經和Spring沒有關系了。
 HessianProxy是hessian client處理客戶端請求的核心類，采用proxy模式，代理客戶端對遠程接口的調用，hessian client的主程序的時序圖如下：

    HessianProxy在invoke方法中實現對調用方法數參數的序列化為預定格式的輸出流，調用sendRequest發送請求，獲取返回輸入流。
    HessianProxy.java

public Object invoke(Object proxy, Method method, Object []args)
    throws Throwable
  {
    String mangleName;

    synchronized (_mangleMap) {
      mangleName = _mangleMap.get(method);
    }

    if (mangleName == null) {
      String methodName = method.getName();
      Class<?> []params = method.getParameterTypes();

      // equals and hashCode are special cased
      if (methodName.equals("equals")
      && params.length == 1 && params[0].equals(Object.class)) {
    Object value = args[0];
    if (value == null || ! Proxy.isProxyClass(value.getClass()))
      return Boolean.FALSE;

    Object proxyHandler = Proxy.getInvocationHandler(value);

    if (! (proxyHandler instanceof HessianProxy))
      return Boolean.FALSE;
    
    HessianProxy handler = (HessianProxy) proxyHandler;

    return new Boolean(_url.equals(handler.getURL()));
      }
      else if (methodName.equals("hashCode") && params.length == 0)
    return new Integer(_url.hashCode());
      else if (methodName.equals("getHessianType"))
    return proxy.getClass().getInterfaces()[0].getName();
      else if (methodName.equals("getHessianURL"))
    return _url.toString();
      else if (methodName.equals("toString") && params.length == 0)
    return "HessianProxy[" + _url + "]";
      
      if (! _factory.isOverloadEnabled())
    mangleName = method.getName();
      else
        mangleName = mangleName(method);

      synchronized (_mangleMap) {
    _mangleMap.put(method, mangleName);
      }
    }

    InputStream is = null;
    HessianConnection conn = null;
    
    try {
      if (log.isLoggable(Level.FINER))
    log.finer("Hessian[" + _url + "] calling " + mangleName);
      
      conn = sendRequest(mangleName, args);

      is = conn.getInputStream();

      if (log.isLoggable(Level.FINEST)) {
    PrintWriter dbg = new PrintWriter(new LogWriter(log));
    HessianDebugInputStream dIs
      = new HessianDebugInputStream(is, dbg);

    dIs.startTop2();
    
    is = dIs;
      }

      AbstractHessianInput in;

      int code = is.read();

      if (code == 'H') {
    int major = is.read();
    int minor = is.read();

    in = _factory.getHessian2Input(is);

    Object value = in.readReply(method.getReturnType());

    return value;
      }
      else if (code == 'r') {
    int major = is.read();
    int minor = is.read();
    
    in = _factory.getHessianInput(is);

    in.startReplyBody();

    Object value = in.readObject(method.getReturnType());

    if (value instanceof InputStream) {
      value = new ResultInputStream(conn, is, in, (InputStream) value);
      is = null;
      conn = null;
    }
    else
      in.completeReply();

    return value;
      }
      else
    throw new HessianProtocolException("'" + (char) code + "' is an unknown code");
    } catch (HessianProtocolException e) {
      throw new HessianRuntimeException(e);
    } finally {
      try {
    if (is != null)
      is.close();
      } catch (Exception e) {
    log.log(Level.FINE, e.toString(), e);
      }
      
      try {
    if (conn != null)
      conn.destroy();
      } catch (Exception e) {
    log.log(Level.FINE, e.toString(), e);
      }
    }
  }

    1~47行主要是把methodName緩存起來和過濾一些特殊調用，java反射是個比較耗性能的操作，把methodName緩存起來可以避免每次調用都要從method里得到methodName。另外，對equals、hashCode、getHessianType、getHessianURL等特殊方法的遠程調用，直接在本地處理。56行調用了sendRequest方法，在sendRequest方法中初始化連接，調用AbstractHessianOutput包裝網絡輸出流，通過AbstractHessianOutput.call(methodName, args)完成網絡輸出。
    到這里client先告一段落吧，網絡怎么輸出的等等沒去看......


    Server端通過HessianServiceExporter處理遠程調用請求。HessianServiceExporter實現了HttpRequestHandler接口，通過handleRequest方法處理請求。

public class HessianServiceExporter extends HessianExporter implements HttpRequestHandler {

    /**
     * Processes the incoming Hessian request and creates a Hessian response.
     */
    public void handleRequest(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {

        if (!"POST".equals(request.getMethod())) {
            throw new HttpRequestMethodNotSupportedException(request.getMethod(),
                    new String[] {"POST"}, "HessianServiceExporter only supports POST requests");
        }

        response.setContentType(CONTENT_TYPE_HESSIAN);
        try {
          invoke(request.getInputStream(), response.getOutputStream());
        }
        catch (Throwable ex) {
          throw new NestedServletException("Hessian skeleton invocation failed", ex);
        }
    }

}

    HessianServiceExporter繼承了HessianExporter，調用父類的invoke處理輸入流。在HessianExporter的invoke中調用了HessianSkeleton.invoke(InputStream is, OutputStream os)。
    HessianSkeleton是Hessian server端的核心類，主要功能是接收網絡輸入流（被包裝為AbstractHessianInput），反序列化輸入流得到methodName和參數，然后根據配置的service，通過反射調用實現類的方法，得到結果后序列化為輸出流返回給客戶端，流程如下：

    HessianSkeleton核心的反射調用非常清晰

public void invoke(Object service,
                     AbstractHessianInput in,
                     AbstractHessianOutput out)
    throws Exception
  {
    ServiceContext context = ServiceContext.getContext();

    // backward compatibility for some frameworks that don't read
    // the call type first
    in.skipOptionalCall();

    // Hessian 1.0 backward compatibility
    String header;
    while ((header = in.readHeader()) != null) {
      Object value = in.readObject();

      context.addHeader(header, value);
    }

    String methodName = in.readMethod();
    int argLength = in.readMethodArgLength();

    Method method;

    method = getMethod(methodName + "__" + argLength);

    if (method == null)
      method = getMethod(methodName);

    if (method != null) {
    }
    else if ("_hessian_getAttribute".equals(methodName)) {
      String attrName = in.readString();
      in.completeCall();

      String value = null;

      if ("java.api.class".equals(attrName))
        value = getAPIClassName();
      else if ("java.home.class".equals(attrName))
        value = getHomeClassName();
      else if ("java.object.class".equals(attrName))
        value = getObjectClassName();

      out.writeReply(value);
      out.close();
      return;
    }
    else if (method == null) {
      out.writeFault("NoSuchMethodException",
                     "The service has no method named: " + in.getMethod(),
                     null);
      out.close();
      return;
    }

    Class<?> []args = method.getParameterTypes();

    if (argLength != args.length && argLength >= 0) {
      out.writeFault("NoSuchMethod",
                     "method " + method + " argument length mismatch, received length=" + argLength,
                     null);
      out.close();
      return;
    }

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

    for (int i = 0; i < args.length; i++) {
      // XXX: needs Marshal object
      values[i] = in.readObject(args[i]);
    }

    Object result = null;

    try {
      result = method.invoke(service, values);
    } catch (Exception e) {
      Throwable e1 = e;
      if (e1 instanceof InvocationTargetException)
        e1 = ((InvocationTargetException) e).getTargetException();

      log.log(Level.FINE, this + " " + e1.toString(), e1);

      out.writeFault("ServiceException", e1.getMessage(), e1);
      out.close();
      return;
    }

    // The complete call needs to be after the invoke to handle a
    // trailing InputStream
    in.completeCall();

    out.writeReply(result);

    out.close();
  }

    關鍵在於輸入輸出流的序列化，這部分內容暫未了解......