如何获得等于和哈希码以与Java RMI一起使用？

Question

I'm trying to learn Java RMI and I need to compare some objects. Specifically, I want to know if a set already contains an element, but it doesn't detect that an object is already present in the set. I don't have any other communication problems with RMI in general.

I've tried overriding hashcode() and equals(Object obj) in my remote object implementation, which is what I have to do from my understanding.

Here's some code:

public class ChatClientImpl extends UnicastRemoteObject implements ChatClient {

    private static final long serialVersionUID = 3056117484716596895L;
    private String id = null;

    // some other stuff...

    @Override
    public boolean equals(Object obj) {
        if (obj == this) {
            return true;
        }
        if (obj == null || !(obj instanceof ChatClientImpl)) {
            return false;
        }
        ChatClientImpl other = (ChatClientImpl) obj;
        return this.id.equals(other.id);
    }

    @Override
    public int hashCode() {
        return this.id.hashCode();
    } 
}

Set#contains and List#contains just don't work. Is there some other trick to this?

Some more complete code:

public void processMessage(MessageImpl inMessage) throws java.rmi.RemoteException {
        // check the message to see if we have processed it before - discard if so
        if( this.processedMessages.contains(inMessage.id) ) {
            System.err.println("Ignoring duplicate message: " + inMessage.id);
            return;
        }
        else {
            System.out.println("Processing message: " + inMessage.id);
            this.processedMessages.add(inMessage.id);
            System.out.println(this.processedMessages.size() + " messages have been processed");
        }
        // update the GUI display with the new message
        this.gui.updateDisplay(inMessage);

        // add this client to the set of clients that have seen the message
        inMessage.addRecipient(this);

        // pass the message on to one of the clients that haven't seen it yet
        sendMessage(inMessage);
    }

        private void sendMessage(MessageImpl msg) {
                Iterator<ChatClient> clientIterator;
                try {
                    // list of all known clients fetched from a server via RMI call
                    clientIterator = server.getClients().iterator();
                } catch (RemoteException e) {
                    // log the error...
                    return;
                }
                // clients that have already seen the message
                Set<ChatClient> alreadyPassedThru = msg.getRecipients(); 
                boolean messageSent = false;

                while ( ! messageSent && clientIterator.hasNext() ){
                    ChatClient knownClient = clientIterator.next();
                    try {
                        // clients that are in alreadyPassedThru are NOT detected...
                        if ( alreadyPassedThru.contains(knownClient) ){  
                            System.out.println("Skipping client that has already seen the message: " + knownClient.getName());
                        } else {
                            knownClient.processMessage(msg);
                            System.out.println("Message has been sent to " + knownClient.getName());
                            messageSent = true;
                        }
                    } catch (RemoteException e) {
                        // client couldn't be contacted
                        clientIterator.remove();
                    }
                }
            }

It's worth mentioning that if I replace the code if ( alreadyPassedThru.contains(knownClient) ) (which is where the problem is) with some code that iterates over the set alreadyPassedThru and manually checks if any of the elements match knownClient by comparing their respective clientName variables, then everything works fine.

The MessageImpl code:

public class MessageImpl implements java.io.Serializable, Message {

    private static final long serialVersionUID = 8914588083609635659L;

    /** 
     * The globally unique identifier for this message 
     */
    public final GUID id;

    /** 
     * All remote clients that have seen this message so far
     */
    public final Set<ChatClient> passedThrough = new HashSet<ChatClient>();

    /**
     * The content of the message. 
     */
    private String messageContent = null;

    /**
     * The client who created the object
     */
    private ChatClient author = null; 

    /** 
     * Create a new Message instance. 
     */
    public MessageImpl(ChatClient auth, String msg) {
        this.id = new GUID(auth);
        this.author = auth; 
        this.messageContent = msg; 
        addRecipient(auth); // the author has seen the message
    }

    @Override
    public void addRecipient(ChatClient client) {
        this.passedThrough.add(client);
    }

    @Override
    public Set<ChatClient> getRecipients() {
        return this.passedThrough;
    }

    @Override
    public String getContent() {
        return this.messageContent; 
    }

    public String getSource() {
        try {
            return this.author.getName();   
        } catch (Exception e) {
            return "[Unknown User]";
        }
    }
}

Just to clarify the difference between when the application works and when it doesn't work: if I replace this:

if ( alreadyPassedThru.contains(knownClient) ){...

where alreadyPassedThru is a HashSet<ChatClient> and knownClient is a ChatClient with this code:

// RMI call on ChatClient - simply returns clientName field
String knownClientName = knownClient.getName();
for (ChatClient client : alreadyPassedThru) {
   if ( client.getName().equals(knownClientName) ){
       return true;
   }
}

...then it works.

Answer 1

You should try using instanceof instead of the getClass() method.

if (obj == null || !(obj instanceof MyRemote)) {
    ...
}

This is, at the very least, more efficient and may be the cause of your issue.

You might also want to consider simplifying your logic a bit. Right now, you have 3 return points in your code and the intent is not immediately clear. Try this:

public boolean equals(Object obj) {
    if (obj instanceof MyRemoteImpl) {
        MyRemoteImpl other = (MyRemoteImpl) obj;
        return this.id.equals(other.id);
    }
    return false;
}

Answer 2

They already work with Java RMI.

Remote objects and their stubs have the same hashcodes and equals() behaviour by default if the remote objects extend UnicastRemoteObject.

However you've broken that by overriding hashCode() and equals().

Just remove those overrides.

Answer 3

Try doing as follows:

public class ChatClientImpl extends UnicastRemoteObject implements ChatClient {

    private static final long serialVersionUID = 3056117484716596895L;
    private String id = null;

    // some other stuff...

    @Override
    public boolean equals(Object obj) {
        if (super.equals(obj)) {
            //Should also return true for stubs pointing to this
            return true;
        }
        if (obj == null || !(obj instanceof ChatClient)) { //Check against the interface
            return false;
        }
        //Only use the interface. obj might be a stub, not only an impl.
        ChatClient other = (ChatClient) obj;
        return getName().equals(obj.getName());
    }

    @Override
    public int hashCode() {
        return getName().hashCode();
    } 
}

I am definitely not sure this will work, but the specification for RemoteObject.equals makes me hope so.

EDIT

This can't work, because equals and hashCode are computed directly on the stub, regardless of what you implemented on your server.

This leaves you with two options:

1. (which I suggest) rely on the default equals. The client ID should be unique, and there should be no two clients with the same ID. That's clearly not the case in your implementation, because you're using an additional id field, implying the identity of an instance is not enough. I think it should be.

2. Wrap your ChatClient s in a CustomHashChatClient and use a Set<CustomHashChatClient> , with CustomHashChatClient computing a custom hash, based on the object name, id, or whatever you want (of course, you need to swallow the exceptions or fail on them, which makes this a not-so-good idea).