How Polling mechanism can be realized with RMI?

问题

Following the design/architecture i created for multiuser/network turn-based game with RMI server callbacks, I have tried to create a distributed animation in which my model(Ball) is remote object and it updates the clients via callback mechanism from server.

The current situation of code is :

The model remote object, which is iterating client list and calling update method of them,

public class BallImpl extends UnicastRemoteObject implements Ball,Runnable {


    private List<ICallback> clients = new ArrayList<ICallback>();


    protected static ServerServices chatServer;
    static ServerServices si;

    BallImpl() throws RemoteException {
        super();
}
 ....

    public  synchronized void move() throws RemoteException {
        loc.translate((int) changeInX, (int) changeInY);
    }

    public void start() throws RemoteException {
        if (gameThread.isAlive()==false )
            if (run==false){
                  gameThread.start();

            }
    }
    /** Start the ball bouncing. */

        // Run the game logic in its own thread.

            public void run() {

                while (true) {
                    run=true;
                    // Execute one game step
                    try {
                        updateClients();
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }

                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException ex) {
                    }
                }
            }
     public void updateClients() throws RemoteException {

        si = new ServerServicesImpl();
        List<ICallback> j = si.getClientNames();
        System.out.println("in messimpl " + j.size());
        if (j != null) {
            System.out.println("in ballimpl" + j.size());
            for (ICallback aClient : j) {
                aClient.updateClients(this);
            }

        } else
            System.err.println("Clientlist is empty");
       } 
    }

The client which is implementing callback interface and has update method implementation :

public final class thenewBallWhatIwant implements Runnable, ICallback {

.....

@Override
public void updateClients(final Ball ball) throws RemoteException {

    try {
        ball.move();
        try {
            Thread.sleep(50);
        } catch (Exception e) {
            System.exit(0);
        }
    } catch (Exception e) {
        System.out.println("Exception: " + e);
    }
}
 .....
}

My general perception is that i m implementing pushing mechanism with RMI and in that scenario i need to implement polling)

if that is the case how can i implement the polling mechanism with RMI?

thanks for any feedback.

jibbylala

回答1:

Polling is independent of the protocol you use to implement the client and server.

A client polls by looping endlessly. Inside the loop there's a request to the server for information. The server sends either the desired information or a "not ready" message back. The client does its thing and waits until the next request needs to be sent.

If you happen to choose RMI, it means an RMI client and server. But the polling mechanism is the same regardless.

Break the problem into pieces - it'll be easier to think about and solve that way.

Forget about polling to start. Can you write an RMI server, start it up, and create a separate client to make a single request? If you can do that, then you put it inside a loop with a sleep to implement the delay and you're done.

回答2:

I don't belive you can implement a callback via Java RMI. You need to either setup polling as you have suggested, or make your "client" RMI servers can you can send message to them directly.

How could you do this differently? I would suggest using JMS messaging to send command objects to the clients, this would handle all the distribution for you.

来源：https://stackoverflow.com/questions/3846422/how-polling-mechanism-can-be-realized-with-rmi