通过使用JDK 1.3中引入的RMI和Proxy API，本篇文章讨论了一种允许一台或多台servlet服务器在一台或多台对话服务器上维护对话信息的技术，采用这种技术后，单一点故障就不会再出现了。

　　如果系统中有一台或多台servlet服务器，对话信息只存在于运行着JVM的一台servlet服务器上，而不会被传输给其他servlet服务器。如果该servlet服务器当机或因为维护而被关机，任何保存在对话中的信息都会丢失。如果一个系统中有多台servlet服务器，一个带有对话的用户需要访问对话中的任何信息，都需要被重新定向到同一台servlet服务器。曾经有专家建议采用关系数据库保存所有的对话信息，但这仍然存在单一点故障的危险，那就是运行关系数据库的服务器。而且如果数据库出了故障，所有的servlet服务器就都不能再访问对话信息了。另外，在数据库中保存可串行化的对象在有些数据库中是比较难以实现的。

　　多服务器对话管理的另一个可能的途径是利用JavaSpaces API来维护对话对象中的记录。当然，如果运行JavaSpaces的服务器由于维护或故障而被关机，也会丢失所有的对话信息，我们再一次遇到了单一点故障的问题。

　　要实现带有N个节点的分布式对话服务器，我们必须解决如下的三个问题：

　　━━如何建立一个库来存贮对话信息。

　　━━如何对分布式对话信息存贮库进行同步。

　　━━在一个对话信息存贮库脱离网络后，如何使该服务器从下一个对话信息存贮库中访问对话信息。


　　Mnemosyne的简介

　　我们用来存贮对话信息的库是Mnemosyne界面的执行。执行Mnemosyne的对象负责管理对话信息存贮库中的所有对象，任何试图写、访问或删除库中对象的对象都必须调用Mnemosyne的相应的方法来实现相应的操作。

　　一个对象要存贮在Mnemosyne，就必须执行Memory界面，该界面定义了equalsMemory()操作来探测二个内存对象是否相同，这就使 Mnemosyne判断出应当把哪个对象返回给read要求或take要求。Memory界面也可以进行串行化扩充，以便我们可以用RMI在网络上传输该对象。


　　Mnemosyne使用三种界面表达其状态。

　　1、CommonContext界面存贮Mnemosyne的全部信息。每个Mnemosyne都有一个CommonContext对象的实例，以便read、write、take Memory对象时在各个方法之间进行同步。在write或者take说Memory对象时，CommonContext对象既定义“silent”方法也定义“loud”方法，当在不进行事件通知的情况下添加对象时，就会用到“silent”方法。例如，当Mnemosyne对象接收到WriteRemoteEvent（向一个远程Mnemosyne对象写对象的告示。）事件后，如果它也希望向CommonContext对象写另一个对象，它就无需通知其他的远程CommonContext对象，最初的Mnemosyne已经通知了它们，因此这种写是通过调用CommonContext对象的silentWrite()方法“静悄悄”地完成的。而“loud”方法则在有对象第一次被添加时将这一事件的详细信息通知所有被调用的监听对象。

　　2、Transaction对象用于在read、write、take Memory对象时进行分布式事务处理，这意味在Mnemosyne对象上可能会有多步骤的操作。

　　3、TransactionContext界面管理分布式事务，使得系统可以中止或提交一个事务。

　　保持Mnemosynes的同步是通过synchronize()和notify()这二个由 Mnemosyne定义的方法完成的。synchronize()可以使一个本地的Mnemosyne与其他Mnemosyne的Vector保持同步（这些Mnemosyne可以是本地的或远程的，为简明起见，我们假定它们是远程的。）下面是synchronize()的一个例子：


public void synchronize(Vector Mnemosynes)
throws RemoteException, TransactionException
{

file:// MatchAllMemory对象是一个有效类
file://对任何二个Memory对象进行比较
MatchAllMemory matchAllMemory = new MatchAllMemory();

file:// 从Primary中获得所有Memory
Mnemosyne Mnemosyne = (Mnemosyne) Mnemosynes.firstElement();
Vector allMemories = Mnemosyne.readAll(matchAllMemory,null);


commonContext.silentWriteAll(allMemories);

// 注册进行发送、接收事件
Enumeration enumeration = Mnemosynes.elements();
while(enumeration.hasMoreElements())
{
Mnemosyne nextMnemosyne = (Mnemosyne) enumeration.nextElement();

file://注册接收通知
nextMnemosyne.addTakeRemoteEventListener(this, matchAllMemory);
nextMnemosyne.addWriteRemoteEventListener(this, matchAllMemory);

file:// 注册发送通知
addTakeRemoteEventListener(nextMnemosyne, matchAllMemory);
addWriteRemoteEventListener(nextMnemosyne, matchAllMemory);
}

// ...
}

　　本地的Mnemosyne对象读取Vector中第一个Mnemosyne对象的所有Memory对象，并采用“silent”方法将它们写到其CommonContext对象中。然后，本地Mnemosyne将自己作为TakeRemoteEventListener和WriteRemoteListener添加到所有的远程Mnemosyne中，这就意味着任何对远程Mnemosynes的take或read操作都将调用本地Mnemosyne的notify()方法。最后，本地Mnemosyne将远程Mnemosyne添加到其TakeRemoteEventListeners和WriteRemoteListeners队列中，确保对本地Mnemosyne的write或take操作都会通知远程Mnemosyne。

　　当添加或删除一个Memory对象时，经过同步的本地Mnemosyne对象需要对所有的Mnemosyne进行更新，可以通过notify()方法来完成这一任务。无论是发生write或take事件，Mnemosyne都会针对发生的事件调用适当的监听者的notify()方法。在synchronize()方法中，我们把本地Mnemosyne注册为所有远程Mnemosyne的take和write事件的监听者，一旦远程Mnemosyne上有take和write事件发生，就会调用本地 Mnemosyne的notify()方法。然后，本地Mnemosyne必须对事件作出反应。下面是Mnemosyne如何与远程Mnemosyne进行同步的例子：


public void notify(RemoteEvent remoteEvent) throws RemoteException
{
// 回写被写的内存，但无需通知所有的Mnemosyne
if(remoteEvent instanceof WriteRemoteEvent)
{
WriteRemoteEvent wre = (WriteRemoteEvent) remoteEvent;
commonContext.silentWrite(wre.getMemory());
}

file:// 取被写的Memory，但无需通知所有的Mnemosyne
if(remoteEvent instanceof TakeRemoteEvent)
{
TakeRemoteEvent tre = (TakeRemoteEvent) remoteEvent;
commonContext.silentTake(tre.getMemory());
}
}



　　现在已经创建了一个控制所有memory对象的Mnemosyne，它自动与远程Mnemosyne保持同步，如果任何一个远程Mnemosynes得到或失去一个Memory对象时，都可以使它保持最新的状态。

　　要通过Mnemosyne管理HTTP对话，servlet需要创建HttpSession的实例（从HttpServletRequest中使用getSession()），在实现Memory对象的类中封装对话，并调用Mnemosyne对象的write()方法把封装类写到一个Mnemosyne中。

　　通过调用write()方法，封装着对话的Memory对象沿着网络传送给Mnemosyne，并通知远程机器。当对象被写到Mnemosyne时，WriteRemoteEvent被发送给在Mnemosyne上注册的所有WriteRemoteEventListeners，这样，所有其他的Mnemosynes就能将新的对象作为Mnemosynes添加到它们的对话信息存贮库中。

　　要对存贮的对话进行查询，servlet调用read()方法查找包含对话的Memory对象，如果Mnemosyne找到了要查找的对象，则该对象通过RMI返回到servlet服务器。

　　最后，要删除对话，servlet就会调用Mnemosyne的take()方法，Mnemosyne将象有read事件发生那样退还Memory对象，同时从其存贮对象库中删除该Memory对象。同时，向其所有TakeRemoteEventListeners发送TakeRemoteEvent事件，通知所有的远程Mnemosynes该Memory对象已经被删除了。

　　建立对话服务器

　　上面我们已经讨论了如何在多服务器上维护对话存贮库，下面我们将讨论如何建立对话服务器。在初始化过程中，对话服务器完成下列任务：

　　━━创建本地Mnemosyne对象。

　　━━把本地Mnemosyne绑定到RMI。

　　━━把本地Mnemosyne与其他的远程Mnemosyne进行同步。

　　首先，对话服务器将获得Mnemosyne对象的一个实例，该实例被绑定到对话服务器的本地IP上。


protected void bindMnemosyne()
{

file://得到Mnemosyne
Mnemosyne Mnemosyne = null;
try
{
Mnemosyne = MnemosyneFactory.getMnemosyne();
}
catch(RemoteException remoteException)
{
System.out.println("Internal error:");
System.out.println("Can´t create a Mnemosyne");
System.exit(1);
}
// 把Mnemosyne绑定到MnemosyneImpl
try
{
String rmiURL = "//" + _localIP + "/MnemosyneImpl";
Naming.rebind(rmiURL, Mnemosyne);
}
catch(ArrayIndexOutOfBoundsException ArrayIndexOutOfBoundsException)
{
throw new IllegalArgumentException("LocalIP is invalid");
}
catch(MalformedURLException malformedURLException)
{
throw new IllegalArgumentException("LocalIP is invalid");
}
catch(RemoteException remoteException)
{
System.out.println("Internal error:");
System.out.println("Can´t rebind a Mnemosyne to MnemosyneImpl");
System.exit(1);
}

}



　　通过把本地Mnemosyne上一系列代表RMI名字符号的URL赋予远程对话服务器，就能引发同步操作，这些URL存贮在一个被称作rmiURL的字符串数组中。在SessionServer的符号中，URL是作为参数从命令行命令中获得的，但它可以来自其他渠道：


protected void synchronizeMnemosyne()
{
file://获得本地Mnemosyne
Mnemosyne localMnemosyne = null;
try
{
localMnemosyne = (Mnemosyne) Naming.lookup(_localIP);
}
catch(Exception exception)
{
System.out.println("Internal error:");
System.out.println("Can´t lookup local MnemosyneImpl");
System.exit(1);
}

file://获得同步用的远程Mnemosynes
Vector remoteMnemosynes = new Vector();

// _rmiURLS对象是代表需要进行同步的远程服务器的字符串数组
for(int index = 1;index < _rmiURLS.length;index++)
{
try
{
remoteMnemosynes.add(Naming.lookup(_rmiURLS[index]));
}
catch(Exception exception)
{
}
}

file:// 同步
try
{
if(remoteMnemosynes.size() > 1)
localMnemosyne.synchronize(remoteMnemosynes);
}
catch(Exception exception)
{
System.out.println("Internal error:");
System.out.println("Can&acute;t synchronize local MnemosyneImpl");
System.exit(1);
}
}

　　远程访问Mnemosyne

　　下面我们来讨论在servlet服务器上访问远程Mnemosyne的方法。要在无需特定服务器在线的情况下加载一个包含对话信息的Mnemosyne，需要创建一个FailoverHandler的实例，FailoverHandler利用JDK 1.3中的Proxy API处理对话服务器当机的问题。FailoverHandler把一个代表访问远程对话服务器的RMI URL的字符串数组作为参数，然后，从Proxy类中获取Mnemosyne实例。下面的SessionManager类中的initializeMnemosyne()方法可以显示出这一切是如何完成的：


public static void initializeMnemosyne(String[] rmiURLs)
{
// 设置当机服务器的处理程序
FailoverHandler fh = new FailoverHandler(null, rmiURLs);

// 得到Mnemosyne. 的一个实例
_Mnemosyne =
(Mnemosyne)Proxy.newProxyInstance(Mnemosyne.class.getClassLoader(),
new Class[] { Mnemosyne.class },
fh );
}



　　如果用Proxy类获取Mnemosyne的实例，所有的方法调用必须通过FailoverHandler的 invoke()方法进行。当有方法访问Mnemosyne时，FailoverHandler将试着调用该方法访问一个远程对象。如果方法调用失败（例如服务器关机），FailoverHandler将从提供给构造器的URL清单中再取得下一个URL，这样就会无缝地转向下一个对话服务器。


// 建立远程加载类的URL清单
public FailoverHandler(Remote delegate, String[] delegateURLS)
{
this.delegateURLS = delegateURLS;

// 如果这个URL无效，则获取下一个有效的URL
try {
this.delegate =
((delegate == null)?getNextValidDelegate():delegate);
} catch (RemoteException ex) {
// 如果发生远程意外错误，则该URL不能使用，向调用者发送一个 //IllegalArgumentException事件
throw new IllegalArgumentException("Remote URLs could not "
+ "be found");
}

}

public Object invoke(Object proxy,
Method method,
Object[] arguments)
throws Throwable
{
while(true)
{
try
{
file:// 尝试对获得的最后一个URL调用被调用的方法
return method.invoke(delegate, arguments);
}
catch(InvocationTargetException invocationTargetException)
{
file://如果获得的URL无效，则取下一个URL
try
{
throw invocationTargetException.getTargetException();
}
catch(RemoteException remoteException)
{
delegate = getNextValidDelegate();
}
}
}
}

file://从构造器中的URL清单中获得下一个URL
protected Remote getNextValidDelegate() throws RemoteException
{
for(int i = 0; i < delegateURLS.length;i++)
{
try
{
return Naming.lookup(delegateURLS[i]);
}
catch(Exception exception)
{
}
}

throw new RemoteException("All lookup failed");
}


　　当使用FailoverHandler对象时，从一个对话服务器向另一个对话服务器的转换对于调用Mnemosyne的任何用户端机器都是透明的。

　　尽管我们已经能够访问对话服务器，而且可以避免单一点故障，我们还必须为HttpSession建立一个封装对象，而SessionWrapper就是这样一个对象，而且，它还假定HttpSession的执行也是串行化的。如果它不是串行化的，可以很方便地修改封装对象将对话的信息转移到一个哈希表中并在其他成员变量中保留其他信息（ID、创作时间等信息。）。


public interface SessionWrapper extends Memory
{
/**
* 得到HttpSession的信息。
*/
public HttpSession getSession();
}

public class SessionWrapperImpl implements SessionWrapper
{

/**识别该对话的关键字 */
protected String _id;
/** 当前HttpSession的信息。 */
protected HttpSession _sess;

/**
* 建立ID，但没有建立对话的其他信息，可用于通过read寻找一个对话。
*/
public SessionWrapper(String id) {
_id = id;
}

/**
* 建立一个带对话的SessionWrapper。其ID与对话的ID相同。
*/
public SessionWrapper(HttpSession sess) {
_sess = sess;
_id = sess.getId();
}

/**
* 如果Memory对象是SessionWrapper的一个实例，当前的SessionWrapper
* 已经建立了与对象相同的ID，则此方法返回的值为真。
*/
public boolean equalsMemory(Memory m) {
return (m instanceof SessionWrapper
&& _id != null
&& _id.equals(((SessionWrapper)m)._id));
}

/**
* 得到HttpSession的信息。
*/
public HttpSession getSession() {
return _sess;
}
}



　　SessionWrapper类执行了Memory的界面，因此，HttpSession对象的ID可以与远程对话的ID进行比较。

　　最后需要创建read()、write()和delete()，以对远程对话进行管理。我们向SessionManager类添加三个静态类：


/**
* 从在初始化时建立的Mnemosyne中得到HttpSession信息。
*/
public static HttpSession getSession(String id)
throws RemoteException
{
try {
SessionWrapper result
= (SessionWrapper)_Mnemosyne.read(new SessionWrapper(id),
null);
return result.getSession();
} catch (TransactionException ex) {
// 由于没有处理事物，因此不会有事务意外被放弃。
ex.printStackTrace();
}
return null;
}

/**
* 在初始化时指定的Mnemosyne中保存对话信息。
*/
public static void saveSession(HttpSession sess)
throws RemoteException
{
try {
_Mnemosyne.write(new SessionWrapper(sess), null);
} catch (TransactionException ex) {
file://由于没有处理事物，因此不会有事务意外被放弃。
ex.printStackTrace();
}
}

/**
* 从在初始化时指定的Mnemosyne中删除一个对话。
*/
public static void removeSession(String id)
throws RemoteException
{
try {
_Mnemosyne.take(new SessionWrapper(id), null);
} catch (TransactionException ex) {
// /由于没有处理事物，因此不会有事务意外被放弃。
ex.printStackTrace();
}
}


　　在servlet中，可以以如下方式管理对话：

public void init(ServletConfig conf) throws ServletException {
// 调用一个方法得到指示对话服务器位置的RMI URL清单
// 例如：//server1.foo.com/MnemosyneImpl, //server2.foo.com/MnemosyneImpl，等
String[] urls = getURLs(conf); // Method to get the URLs from properties for the session servers
SessionManager.initializeMnemosyne(urls)
}

public void doGet(HttpServletRequest req, HttpServletResponse rsp) throws IOException {

file:// 得到存贮在cookie中的对话，仅仅是为了得到其ID。
HttpSession baseSess = req.getSession()
file://根据得到的ID，从Mnemosyne中得到真正的对话
HttpSession realSess = SessionManager.getSession(base.getId());

SessionManager.saveSession(realSess);
}

　　结论

　　尽管这篇文章讨论了一个分布式对话管理的例子，但我们可以将这一技术用于管理必须容忍任一节点出错的分布式内存管理系统中。Mnemosyne还可以用在成员不断加入和离开的P2P应用中。通过使用Mnemosyne，任何一个成员都可以与系统进行快速同步，而无需要求为保持系统有效而必须保证某一结点不出故障。