How to make clients receive updates

[Maki Jav]

Hi,


How to make clients receive updates automatically. The clients will be Swing desktop clients and the application will be a rmi application on the server accessible via net. there is no issue of firewall :0

Thanks,

Maki Jav

[Maki Jav]

I think that something like Observer/observed ie Observer pattern pattern will be used?

Thank you,

Maki Jav

[William Brogden]

There are lots of ways for a client application to register with a server to receive messages. Java Message Service, JavaSpaces, even email. In Java one of the easiest approaches would be to use a HTTPserver and have the clients periodically query it for new data.

How big is a data update?
Can updates be plain text? XML? Some other file format?
Whats the maximum acceptable delay between an update being made available and all clients having the data?

Bill

[Maki Jav]

Thank you William Brogden for responding me. I am interested in RMI solution. The data will not be big.

I have made a observer/Observable paradigm classes. The idea is that I have a observable object which will keep on running on the server and I have various Observer instances. Any change in the Observable is notified to the Observers over rmi. I have compiled these classes using JDK1.4.


RemoteObservable.java
RemoteObservableImpl.java
RemoteObserver.java
RemoteObserverImpl.java

And after that I compiled them using:
rmic -d . RemoteObservable RemoteObservableImpl RemoteObserver RemoteObserverImpl

The package is adil.

Q. 1) Why am I getting RemoteObservableImpl_Skel.class and RemoteObserverImpl_Skel.class in addtion to RemoteObservableImpl_Stub.class and RemoteObserverImpl_Stub.class? I heard that newer compilers do not create skelton classes.

After starting rmiregistry I run RemoteObservableImpl using the following

java -Djava.security.policy=./java.policy adil.RemoteObservableImpl

Now the test in which I am getting problem.

The tester class is

class Tester.java

import adil.RemoteObserverImpl;
import adil.RemoteObservableImpl;
 
import java.rmi.*;
import java.rmi.server.*;
import java.net.*;
 
public class Tester
{
    public static void main (String[] args)
    {
        try
        {
 
RemoteObserverImpl obs =new RemoteObserverImpl();
 
         [B] RemoteObservableImpl ro = (RemoteObservableImpl)
          Naming.lookup("//" +
      InetAddress.getLocalHost().getHostName() +
      "/RemoteObservableServer"); [/B]
 
System.out.println(ro);
            ro.addObserver (obs);
 
            ro.setChanged (true);
 
            ro.notifyObservers (args[1]);
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
}

I am using this command:
java -classpath adil;. Tester


java.lang.ClassCastException: adil.RemoteObservableImpl_Stub
at Tester.main(Tester.java:25)

Q. 2) I am getting the above exception. Why am I getting a stub instead of RemoteObservableImpl Object from rmiregistry? And how to deal with it? How to use it?


Thank you,

Maki Jav

ps: William Brogden i have your book too.
[ December 30, 2007: Message edited by: Maki Jav ]

[William Brogden]

Alas, I can not help with those questions:

1. It has been a long time since I used RMI
2. I no longer have a JDK 1.4 anywhere, all my systems have Java 1.6 as the normal Java.

Maybe it is time for you to update to 1.6 also.

Bill

[Maki Jav]

I am successful in implementing Observer/Observable pattern atlast. it was a long standing desire!

I used three clients to test it from three different folders. The first client reflected it when
the second client logged on; the fist and second clients reflected it when the third client
logged on. The first client showed 3 messages, the second shwoed 2 and the last showed 1 message.


First client window
RemoteObservableImpl_Stub[RemoteStub [ref: [endpoint:[127.0.0.1:1045](remote),ob
jID:[e53108:117309386e9:-8000, 0]]]]
HELLO 1
RemoteObservableImpl_Stub[RemoteStub [ref: [endpoint:[127.0.0.1:1045](remote),ob
jID:[e53108:117309386e9:-8000, 0]]]]
HELLO 2
RemoteObservableImpl_Stub[RemoteStub [ref: [endpoint:[127.0.0.1:1045](remote),ob
jID:[e53108:117309386e9:-8000, 0]]]]
HELLO 3



Second client window
RemoteObservableImpl_Stub[RemoteStub [ref: [endpoint:[127.0.0.1:1045](remote),ob
jID:[e53108:117309386e9:-8000, 0]]]]
HELLO 2
RemoteObservableImpl_Stub[RemoteStub [ref: [endpoint:[127.0.0.1:1045](remote),ob
jID:[e53108:117309386e9:-8000, 0]]]]
HELLO 3



Third client window
RemoteObservableImpl_Stub[RemoteStub [ref: [endpoint:[127.0.0.1:1045](remote),ob
jID:[e53108:117309386e9:-8000, 0]]]]
HELLO 3

I was getting java.net.Connection Exception earlier in RemoteObservableImpl but then I turned
off the computer and now I am not getting any such exception.

So now the bare bones application is ready on which any command promt, Swing-based or other applications
can be built.

I now want to have help from you guys in improving this code. Maybe I am making some mistake/logical
error somewhere in my classes.

Tester code is above.

It needs correction:

 
RemoteObservable ro = (RemoteObservable)
          Naming.lookup("//" +
      InetAddress.getLocalHost().getHostName() +
      "/RemoteObservableServer");
 
------------------------------------------------------------
 
[B]RemoteObserver.java[/B]
 
import java.rmi.*;
import java.net.*;
 
public interface RemoteObserver extends Remote
{
    /**
     * @param   observable  a reference to the object being observed
     * @param   arg         the arguments being passed to the observer
     */
    public void update (RemoteObservable observable, Object arg)
        throws java.rmi.RemoteException,NotBoundException, MalformedURLException,
        java.net.UnknownHostException;
 
}
 

[B]RemoteObserverImpl.java[/B]
 
import java.rmi.*;
import java.rmi.server.*;
import java.net.*;
 

public class RemoteObserverImpl extends UnicastRemoteObject
 
  implements RemoteObserver
 
{
 

    public RemoteObserverImpl() throws RemoteException {
 super();
 
    }
 
    /**
     * @param   observable  a reference to the object being observed
     * @param   arg         the arguments being passed to the observer
     */
    public void update (RemoteObservable observable, Object arg)
        throws java.rmi.RemoteException,NotBoundException, MalformedURLException,
        java.net.UnknownHostException
        {
 

 
System.out.println(observable);
System.out.println(arg);
 

 
}
 
}
 

 

[B]RemoteObservable.java[/B]
 
import java.rmi.Remote;
import java.rmi.RemoteException;
 
public interface RemoteObservable extends Remote
{
 
    /*
        The semantics are identical to the respective
        methods in java.util.Observable.
    */
    public void addObserver (RemoteObserver observer) throws java.rmi.RemoteException;
 
    public void deleteObserver (RemoteObserver observer) throws java.rmi.RemoteException;
 
    public void deleteObservers ()throws java.rmi.RemoteException;
 
    public int countObservers ()throws java.rmi.RemoteException;
 
    public boolean hasChanged ()throws java.rmi.RemoteException;
 
    public void clearChanged ()throws java.rmi.RemoteException;
 
    public void setChanged (boolean changed)throws java.rmi.RemoteException;
 
    /**
     * An overloaded form of notifyObservers that takes no argument. The semantics
     * are identical to calling notifyObservers (..., null).
     * @exception   RemoteException     thrown by a remote implementation of RemoteObserver
     * @exception   EJBException        thrown by a remote implementation of RemoteObserver
     */
    public void notifyObservers () throws RemoteException;
 
    /**
     * If this object has changed as indicated by the hasChanged method,
     * notify all observers and call clearChanged to reset the hasChanged indicator.
     * @param arg   any object
     * @exception   RemoteException     thrown by a remote implementation of RemoteObserver
     * @exception   EJBException        thrown by a remote implementation of RemoteObserver
     */
    public void notifyObservers (Object arg) throws RemoteException;
 

}
 

[B]RemoteObservableImpl.java[/B]
 
import java.rmi.RMISecurityManager;
import java.rmi.Naming;
import java.rmi.*;
import java.rmi.server.*;
import java.util.Set;
import java.util.HashSet;
import java.net.*;
import java.util.Iterator;
 

public class RemoteObservableImpl extends UnicastRemoteObject
 
  implements RemoteObservable
 
{
 

    /**
     * The collection of observers. Using a Set will guarantee
     * no duplicate observers.
     */
 
    protected Set mObservers = new HashSet();
    protected boolean mChanged = false;
 
    public RemoteObservableImpl() throws RemoteException {
 super();
 
    }
 
      public static void main(String args[]) {
 
  // Create and install a security manager
  if (System.getSecurityManager() == null) {
      System.setSecurityManager(new RMISecurityManager());
  }
 
  try {
      RemoteObservableImpl obj = new RemoteObservableImpl();
 
      // Bind this object instance to the name "RemoteObservableServer"
      Naming.rebind("//" +
  InetAddress.getLocalHost().getHostName()+"/RemoteObservableServer", obj);
 
      System.out.println("RemoteObservableServer bound in registry");
  } catch (Exception e) {
      System.out.println("RemoteObservable err: " + e.getMessage());
      e.printStackTrace();
  }
 
   }
 
    /*
        The methods for adding, deleting, and counting observers are
        all trivial, as are the methods for checking and setting the
        'changed' indicator.
 
        Their semantics are identical to the respective
        methods in java.util.Observable.
    */
    public void addObserver (RemoteObserver observer)
    {
        mObservers.add (observer);
    }
 
    public void deleteObserver (RemoteObserver observer)
    {
        mObservers.remove (observer);
    }
 
    public void deleteObservers ()
    {
        mObservers.clear();
    }
 
    public int countObservers ()
    {
        return mObservers.size();
    }
 
    public boolean hasChanged ()
    {
        return mChanged;
    }
 
    public void clearChanged ()
    {
        this.setChanged (false);
    }
 
    public void setChanged (boolean changed)
    {
        mChanged = changed;
    }
 
    /**
     * An overloaded form of notifyObservers that takes no argument. The semantics
     * are identical to calling notifyObservers (..., null).
     * @exception   RemoteException     thrown by a remote implementation of RemoteObserver
     */
    public void notifyObservers () throws RemoteException
    {
        this.notifyObservers (null);
    }
 
    /**
     * If this object has changed as indicated by the hasChanged method,
     * notify all observers and call clearChanged to reset the hasChanged indicator.
     * @param arg   any object
     * @exception   RemoteException     thrown by a remote implementation of RemoteObserver
     */
    public void notifyObservers (Object arg) throws RemoteException
    {
        if (this.hasChanged())
        {
            for (Iterator i = mObservers.iterator(); i.hasNext(); )
            {
                RemoteObserver obs = null;
                try{
 
                  obs = (RemoteObserver) i.next();
                  obs.update (this, arg);
 
                  }catch(java.rmi.NotBoundException nbe){
 
System.out.println("RemoteObservableImpl: "+nbe); }
 
                    catch(java.net.MalformedURLException murle){
 
        System.out.println("RemoteObservableImpl: "+murle); }
 
                     catch(java.net.UnknownHostException uhe){
 
System.out.println("RemoteObservableImpl: "+uhe); }
 
                    catch(Exception ce){
 
        System.out.println("RemoteObservableImpl: "+ce);  }
 

            }
 
            this.clearChanged();
 
        }
 

    }
 

}
 

[Maki Jav]

Hi,

I have been able to run rmiregistry and bind remote object locally and access that object via a Servlet from my account at myjavaserver.com