我有一个客户端在服务器上启动一个长时间运行的进程。每隔一段时间,我想向用户展示后台发生的事情。最简单的方法是轮询服务器,但我想知道是否没有办法为此实现观察者模式。不幸的是,我正在使用 RMI 与服务器通信,我担心我必须为此将我的客户端变成 RMI 服务器。
还有另一种我想念的方式吗?
我有一个客户端在服务器上启动一个长时间运行的进程。每隔一段时间,我想向用户展示后台发生的事情。最简单的方法是轮询服务器,但我想知道是否没有办法为此实现观察者模式。不幸的是,我正在使用 RMI 与服务器通信,我担心我必须为此将我的客户端变成 RMI 服务器。
还有另一种我想念的方式吗?
RMI 通常可以支持双向通信。(是的,RMI 是一个可以设置的 PITA,可以用来做任何其他事情。)
但是,通过 CGI 脚本(!)工作的 HTTP 传输不支持它。
在这里合并所有答案,我在客户端和服务器之间实现了 2 路 RMI,服务器使用 Registry 公开其存根
下面的代码将给出一个更好的主意
import java.rmi.*;
import java.rmi.registry.*;
import java.rmi.server.*;
import java.util.Observable;
import java.util.Observer;
import java.net.*;
import javax.rmi.ssl.SslRMIClientSocketFactory;
import javax.rmi.ssl.SslRMIServerSocketFactory;
interface ReceiveMessageInterface extends Remote
{
/**
* @param x
* @throws RemoteException
*/
void receiveMessage(String x) throws RemoteException;
/**
* @param observer
* @throws RemoteException
*/
void addObserver(Remote observer) throws RemoteException;
}
/**
*
*/
class RmiClient extends UnicastRemoteObject
{
/**
* @param args
*/
static public void main(String args[])
{
ReceiveMessageInterface rmiServer;
Registry registry;
String serverAddress = args[0];
String serverPort = args[1];
String text = args[2];
System.out.println("sending " + text + " to " + serverAddress + ":" + serverPort);
try
{ // Get the server's stub
registry = LocateRegistry.getRegistry(serverAddress, (new Integer(serverPort)).intValue());
rmiServer = (ReceiveMessageInterface) (registry.lookup("rmiServer"));
// RMI client will give a stub of itself to the server
Remote aRemoteObj = (Remote) UnicastRemoteObject.exportObject(new RmiClient(), 0);
rmiServer.addObserver(aRemoteObj);
// call the remote method
rmiServer.receiveMessage(text);
// update method will be notified
}
catch (RemoteException e)
{
e.printStackTrace();
}
catch (NotBoundException e)
{
System.err.println(e);
}
}
public void update(String a) throws RemoteException
{
// update should take some serializable object as param NOT Observable
// and Object
// Server callsbacks here
}
}
/**
*
*/
class RmiServer extends Observable implements ReceiveMessageInterface
{
String address;
Registry registry;
/**
* {@inheritDoc}
*/
public void receiveMessage(String x) throws RemoteException
{
System.out.println(x);
setChanged();
notifyObservers(x + "invoked me");
}
/**
* {@inheritDoc}
*/
public void addObserver(final Remote observer) throws RemoteException
{
// This is where you plug in client's stub
super.addObserver(new Observer()
{
@Override
public void update(Observable o,
Object arg)
{
try
{
((RmiClient) observer).update((String) arg);
}
catch (RemoteException e)
{
}
}
});
}
/**
* @throws RemoteException
*/
public RmiServer() throws RemoteException
{
try
{
address = (InetAddress.getLocalHost()).toString();
}
catch (Exception e)
{
System.out.println("can't get inet address.");
}
int port = 3232;
System.out.println("this address=" + address + ",port=" + port);
try
{
registry = LocateRegistry.createRegistry(port);
registry.rebind("rmiServer", this);
}
catch (RemoteException e)
{
System.out.println("remote exception" + e);
}
}
/**
*
* @param args
*/
static public void main(String args[])
{
try
{
RmiServer server = new RmiServer();
}
catch (Exception e)
{
e.printStackTrace();
System.exit(1);
}
}
}
我不认为你缺少任何东西。仅有的两种方法是定期调用服务器并检查状态(轮询)或注册服务器定期调用的回调(您的客户端必须公开一个方法)。IMO,轮询是处理此问题的一种完全合理的方式。