Hessian 与 Session close

Hessian 与 Session


作者：终南 <li.zhongnan@hotmail.com>


1. ServiceContext

ServiceContext 代表为 Hessian 客户端提供服务的上下文环境，用来处理与客户端请求有关的信息。在最简单和常用的应用中，在服务器端可以通过 ServiceContext 来获取代表客户端的 ServletRequest (在 HTTP 环境中为 HttpServletRequest)，因此就可以知道客户端的相关信息，如客户端的 IP 地址、端口、Header和用户名等，重要的是可以获取到代表会话的 Session 对象。

代码举例：
package example;

import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import com.caucho.services.server.ServiceContext;

public class BasicService implements Basic {
public String hello(String name) {
System.out.println("======== hello ========\n");
HttpServletRequest req = (HttpServletRequest) ServiceContext
.getContextRequest();
req.getSession().setAttribute("port", 1000);

System.out.println("getRemoteAddr() = " + req.getRemoteAddr());
System.out.println("getRemotePort() = " + req.getRemotePort());
System.out.println("getRemoteUser() = " + req.getRemoteUser());
System.out
.println("getSession().getId() = " + req.getSession().getId());
for (Enumeration<String> e = req.getHeaderNames(); e.hasMoreElements();) {
String headerName = e.nextElement();
System.out.println(headerName + " = " + req.getHeader(headerName));

}

return "Hello, " + name;
}
}
在上面的示例中，通过 ServiceContext 的静态方法 getContextRequest() 获取代表客户端请求的 HttpServletRequest 对象，然后就可以像普通 Web 编程那样使用 Request 和 Session 对象了。

2. Hessian 中 Sessian 的问题

一般来说，RPC 或 Web Service 这类的应用都是无状态的，但是有些应用则需要有状态的远程调用，比如先登录认证，然后再执行其他操作。
Hessian 本身也没有对有状态的应用提供直接支持。查看 HessianProxy 的代码可以发现，每次发送请求的时候，Hessain 都会调用 HessianProxyFactory 类的 openConnection 重新打开连接，并且在远程调用完成后关闭连接。

重新打开连接
protected URLConnection sendRequest(String methodName, Object []args)
throws IOException
{
URLConnection conn = null;

conn = _factory.openConnection(_url);
boolean isValid = false;

try {
// Used chunked mode when available, i.e. JDK 1.5.
if (_factory.isChunkedPost() && conn instanceof HttpURLConnection) {
try {
HttpURLConnection httpConn = (HttpURLConnection) conn;

httpConn.setChunkedStreamingMode(8 * 1024);
} catch (Throwable e) {
}
}

addRequestHeaders(conn);

OutputStream os = null;

try {
os = conn.getOutputStream();
} catch (Exception e) {
throw new HessianRuntimeException(e);
}

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

AbstractHessianOutput out = _factory.getHessianOutput(os);

out.call(methodName, args);
out.flush();

isValid = true;

return conn;
} finally {
if (! isValid && conn instanceof HttpURLConnection)
((HttpURLConnection) conn).disconnect();
}
}

关闭连接
public Object invoke(Object proxy, Method method, Object []args)
throws Throwable
{
...

conn = sendRequest(mangleName, args);

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

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

parseResponseHeaders(conn);
...

try {
if (httpConn != null)
httpConn.disconnect();
} catch (Exception e) {
log.log(Level.FINE, e.toString(), e);
}
}
}

在登录认证的应用中，在调用登录认证的方法后执行其他业务操作时，需要对用户是否登录进行验证，由于 Hessian 每次调用都会重新打开和关闭连接，因此每次调用都是一个新的 Session，前面是否登录的信息就不能获取到。

3. 扩展 Hessian 的客户端程序实现对 Sessian 的支持

HTTP 是一个无状态的协议，其状态的实现是通过 Cookie 来实现的，根据 HTTP 的这个特点，我们可以在 Hessian 客户端首次调用后的每次调用中，将首次调用得到的 Cookie 添加到 HTTP Header 中，从而模拟出有状态的 HTTP 连接。
通过查看 HessianProxy 类的代码发现，其中有两个没有实现内容方法，可以获取服务器端返回的头信息 和设置发送给服务器端的 HTTP 请求头信息：

/**
* Method that allows subclasses to parse response headers such as cookies.
* Default implementation is empty.
* @param conn
*/
protected void parseResponseHeaders(URLConnection conn) {

}

/**
* Method that allows subclasses to add request headers such as cookies.
* Default implementation is empty.
*/
protected void addRequestHeaders(URLConnection conn) {

}

在使用 Hessian 进行远程调用时，addRequestHeaders 方法在 sendRequest 时调用，parseResponseHeaders 在成功发送请求后调用。因此我们可以扩展 HessianProxy 类，重新实现这两个方法，在首次调用时获取 Cookie 新，在随后的调用中 将 Cookie 添加到请求头信息中。
除了重新实现 HessianProxy 类外，还需要重新实现 HessianProxyFactory 类的 public Object create(Class api, String urlName, ClassLoader loader) 方法，以便让 HessianProxyFactory 使用重新实现的 HessianProxy 类。

重新实现的代码：
package example;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
import java.util.List;

import com.caucho.hessian.client.HessianProxy;
import com.caucho.hessian.client.HessianProxyFactory;
import com.caucho.hessian.io.HessianRemoteObject;

public class MyHessianProxyFactory extends HessianProxyFactory {

@Override
public Object create(Class api, String urlName, ClassLoader loader)
throws MalformedURLException {
if (api == null)
throw new NullPointerException(
"api must not be null for HessianProxyFactory.create()");
InvocationHandler handler = null;

URL url = new URL(urlName);
handler = new MyHessianProxy(url, this);

return Proxy.newProxyInstance(loader, new Class[] { api,
HessianRemoteObject.class }, handler);
}
}

class MyHessianProxy extends HessianProxy {
/** Variable for saving cookie list */
private List<String> cookies = null;

public MyHessianProxy(URL url, HessianProxyFactory factory) {
super(url, factory);
}

/** Get cookie list from the headers of response */
@Override
protected void parseResponseHeaders(URLConnection conn) {
List<String> _cookies = conn.getHeaderFields().get("Set-Cookie");
if (_cookies != null)
cookies = _cookies;
}

/** Add cookie list to request headers*/
@Override
protected void addRequestHeaders(URLConnection conn) {
if (cookies != null) {
for (String cookieString : cookies) {
conn.setRequestProperty("Cookie", cookieString);
}
}
}

}

4. 应用举例
接口：
package example;

import java.util.List;

public interface Basic {

public boolean login(String user, String password);
public int giveMeMoney();
public void increaseMyMoney() throws Exception;
}

实现接口的服务：
package example;

import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import com.caucho.services.server.ServiceContext;

public class BasicService implements Basic {

public boolean login(String user, String password) {
HttpServletRequest req = (HttpServletRequest) ServiceContext
.getContextRequest();
if (user.equals("user") && password.equals("password"))
{
req.getSession().setAttribute("user", user);
return true;
}
return false;
}
public int giveMeMoney()
{
HttpServletRequest req = (HttpServletRequest) ServiceContext
.getContextRequest();
if(req.getSession().getAttribute("user") != null)
return 1000;
return 0;
}
public void increaseMyMoney() throws Exception
{
HttpServletRequest req = (HttpServletRequest) ServiceContext
.getContextRequest();
if(req.getSession().getAttribute("user") != null)
{
System.out.println(req.getSession().getAttribute("user") + "'s money increased!!!");
}
else
throw new Exception("Invalid User");

}
}

客户端程序：
package example;
import java.net.MalformedURLException;

import com.caucho.hessian.client.HessianProxyFactory;

public class BasicClient {
public static void main(String []args) throws MalformedURLException
{
String url = "http://127.0.0.1:8080/hproj/hello";

HessianProxyFactory factory = new MyHessianProxyFactory();
factory.setUser("tomcat");
factory.setPassword("tomcat");
Basic basic = (Basic) factory.create(Basic.class, url);

try {
basic.increaseMyMoney();
} catch (Exception e) {
System.out.println("ERROR: " + e.getMessage());
}
basic.login("user", "password");
System.out.println(basic.giveMeMoney());
try {
basic.increaseMyMoney();
} catch (Exception e) {
System.out.println("ERROR: " + e.getMessage());
}
}
}

在客户端程序中，不在使用原来的 HessianProxyFactory， 而是使用重新实现的 MyHessianProxyFactory 类。