对使用Hessian协议调用在程序中应用的理解

Hessian是romote procedure call协议。这个协议是一个二进制协议。在应用过程中的流程是“客户端－>序列化写到输出流—>远程方法（服务器端）—>序列化写到输出流 —>客户端读取输入流—>输出结果”。

在我们的项目RingMaster中的应用是这样的。

首先，需要定义一个接口，这个接口是服务器端和客户端公用的。我们的项目中是RemoteInterface。

其次，在客户端需要通过HessianProxyFactory hessianFactory = new HessianProxyFactory();来获取一个hessianFactory的实例。调用factory.create(apiClass, url); 返回一个Proxy对象的实例，这个实例指出了handler是HessianProxy。

那么在我们的项目中，将这些部分结合起来，最终的调用将由HessianProxy来实现调用。在HessianProxy的invoke函数中，进行了最基本的http的链接，发送数据给Hessian的server端。同时，处理server端返回的内容进行反序列化转化成对象返回。

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 new Boolean(false);

HessianProxy handler = (HessianProxy) Proxy.getInvocationHandler(value);

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;
URLConnection conn = null;
HttpURLConnection httpConn = null;

try {
if (log.isLoggable(Level.FINER))
log.finer("Hessian[" + _url + "] calling " + mangleName);

conn = sendRequest(mangleName, args);

if (conn instanceof HttpURLConnection) {
httpConn = (HttpURLConnection) conn;
int code = 500;

try {
code = httpConn.getResponseCode();
} catch (Exception e) {
}

parseResponseHeaders(conn);

if (code != 200) {
StringBuffer sb = new StringBuffer();
int ch;

try {
is = httpConn.getInputStream();

if (is != null) {
while ((ch = is.read()) >= 0)
sb.append((char) ch);

is.close();
}

is = httpConn.getErrorStream();
if (is != null) {
while ((ch = is.read()) >= 0)
sb.append((char) ch);
}
} catch (FileNotFoundException e) {
throw new HessianConnectionException("HessianProxy cannot connect to '" + _url, e);
} catch (IOException e) {
if (is == null)
throw new HessianConnectionException(code + ": " + e, e);
else
throw new HessianConnectionException(code + ": " + sb, e);
}

if (is != null)
is.close();

throw new HessianConnectionException(code + ": " + sb.toString());
}
}

is = conn.getInputStream();

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

AbstractHessianInput in = _factory.getHessianInput(is);

in.startReply();

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

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

return value;
} 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 (httpConn != null)
httpConn.disconnect();
} catch (Exception e) {
log.log(Level.FINE, e.toString(), e);
}
}
}