help with interface, static counter - RMI?

[Lynn Haley]

I have a chat application, and want to create a unique name to display for each chat client that gets created

i have an interface named Client and an implementation called ClientImpl

I tried creating a method on Client called, getIdentifier() and put the static counter in ClientImpl
since I cannot have a static variable in the interface

Its not working though. Any pointers?

This isn't because I am using RMI is it?

Thanks!

Lynn






Some code removed for clarity:


INTERFACE

 public interface Client extends Remote{

    
    //TODO: Make the update method throw an appropriate exception
    public void update(String message) throws RemoteException ;

    public int getIdentifier()  throws RemoteException ;
}   

IMPLEMENTATION

  public class ClientImpl implements Client {
  [b]  public static int counter = 0;[/b]
    /**
     * The text area into which the messages will be displayed
     */
    private JTextArea textArea;

    /**
     * Constructor to initialise the text area field
     *
     * @param textArea
     */
    public ClientImpl(JTextArea textArea) {
        this.textArea = textArea;
        this.counter++;
    }

    /**
     * Implements the remote method that the server will call when broadcasting messages to the registered clients
     */
    public void update(String message) {
        textArea.append(message + "\n");
        textArea.setCaretPosition(textArea.getText().length() - 1);
    }

[b]    public int getIdentifier()  {
        return counter++;
    }
[/b]

}  

HOW I WANT TO USE IT

 
public class ClientMain {

.
.
.

    public static void main(String[] args) throws Exception {
 
        //create simple an application frame (window)
        JFrame frame = new JFrame("RMI Chat Client");
        frame.setLayout(new BorderLayout());
        frame.addWindowListener(new WindowAdapter() {
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });

        //create a text area to display the messages in
        final JTextArea messageTextArea = new JTextArea();
        messageTextArea.setFont(new Font("Courier", Font.BOLD, 14));
        messageTextArea.setEditable(false);
        frame.add(new JScrollPane(messageTextArea), BorderLayout.CENTER);

        //hook into JNDI and locate the chat server
        Context ctx = new InitialContext();

        //TODO: Create a client object, export it, and then register it with the chat server

        //HINT: Create an instance of a ClientImpl object (passing it a reference to the messageTextArea  variable)
        Client client = new ClientImpl(messageTextArea);
        //HINT: Register it with the RMI runtime using the exportObject method
        UnicastRemoteObject.exportObject(client);

       //figure out the name of the PC that this client is running on
        final String hostName = InetAddress.getLocalHost().getHostName() + [b](client.getIdentifier());[/b]
       
        //HINT: lookup the "chat-server" in the JNDI context and cast the reference returned to the server field of this class
        //Server server = (Server) ctx.lookup("chat-server");

        Object narrowFrom = ctx.lookup("chat-server");
        server = (Server) PortableRemoteObject.narrow(narrowFrom, Server.class);


        //HINT: Invoke the registerClient method on the server variable and pass it the client object you just created
        server.registerClient(client);

        //create a text field to enter messages that we'll send
        final JTextField inputField = new JTextField();
        frame.add(inputField, BorderLayout.SOUTH);
        inputField.addActionListener(new ActionListener() {
            //when the user hits enter, send a message to the server
            public void actionPerformed(ActionEvent e) {
                String message = inputField.getText();
                inputField.setText("");
                try {
                    //TODO: Append the message text, from the input field, to the end of the string that is being sent to the server
                    server.acceptMessage("[" + hostName + "]> "+message);
                } catch (RemoteException re) {
                    re.printStackTrace();
                }
            }
        });

    }
}
   

[Steve Luke]

How is it not working? What is it doing that it shouldn't be (or what is it not doing that it should be)?

    public int getIdentifier()  {
        return counter++;
    }

This increments the counter for each time the getIdentifier method is called. So if you had one client and you called getIdentifier 3 times, it would look like there were 3 different clients. It looks like you are also doing it in the constructor - so the getIdentifier would increment 4 times.

If you wanted to keep a count of how many times the ClientImpl was created, you want to keep a (private) static counter that you increment and store (as a private final) instance variable in the ClientImpl constructor. Something like this:

public class ClientImpl implements Client
{
    private static int counter = 0;

    private final int id;
    ...

    public ClientImpl(...)
    {
        id = ++counter; //store the current count of ClientImpl instances, starting at 1
        ...
    }

    public int getIdentifier()
    {
        return id;
    }
...
}

[Lynn Haley]

Oh dear, thanks!

In my main method, the value is always 1. It never gets incremented to 2 when I create another client.

Sorry to have not stated the actual problem.

Lynn

[Steve Luke]

When do you create a second client? The code you provide creates exactly one Client, in the main method. It then creates a final hostName String that the actionPerformed method uses. So there is only 1 Client, and even if you had 2, since the same hostName String is being used, the new one will never be reflected in the output.

[Steve Luke]

Unless when you mean you make a new client you mean running a second instance of the Java application.

If that is what you mean then you have a problem - variables, static or not, exist only in the scope of the local JVM. When you run the application a second time you get a new Virtual Machine, so the static variable counter gets re-initialized to 0.

You have to store the count in some location external to the JVM instance running. It helps that you are in a Client - Server scenario. When I have done things like this in the past (not using RMI though) I had the server tell the client which instance for that host as part of the registration process.

In my case, I had a handshake where the client connected to the server. The server received the client, checked the IP address for the client, and generated an ID. It then responded to the client with the ID, and to finish the handshake the client responded back to the server with the id.

Other means of doing the same thing might be to use a database, a file to store the current count of objects, or an external service (on the Client machine) listening on a socket that the client talks to to get the id.

I am not sure how RMI modifies these approaches...

[Lynn Haley]

oh dear...

missed that completely!

maybe i will put it on the server ... grrr....



Lynn

[Lynn Haley]

Thank you!

Yes, I had a serverMain to register the server with RMI, and a clientMain to start a client and register it with the server.

I did not realize it was a separate JVM! Ugh. THANKS!!!

I was able to get it work in the manner I wished, by adding the static int counter to the serverImpl.
Every time a client registered with the server, I incremented the value and returned it, adding it to the hostname.

THANKS AGAIN!

Lynn