Java custom event handler and listeners

Question

I'm currently playing around with a Java implementation of Socket.io, available here: netty-socketio

I've got the server up and running, and its receiving/sending messages nicely between client and server, but I need to have events trigger on certain messages being received, and that's where I'm confused.

Here's my code:

server.addEventListener("message", clientData.class, new DataListener<clientData>() {
    @Override
    public void onData(SocketIOClient client, clientData data, AckRequest ackRequest) throws Exception {
                System.out.println("Message from client: " + data.getMessage());

    }
});


public class ClientData{

    String message;

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

}

Essentially what I'd like to happen is when a particular message is received from a client, I need a function within another class to run. I've spent the last two hours reading about Observable, Observer, Interfaces and event handlers, but I'm really not sure how to set this up.

The library also makes mention of this DataListener, but I've no idea what that is, as there's little documentation in the library.

Any input or advice on this would be greatly appreciated.

Answer 1

Let's say your class that raises the event is called A. And the class that needs to listen for the event is called B. And the event is called SomeEvent.

First, create an interface called SomeEventListener:

public interface SomeEventListener {
    void onSomeEvent ();
}

If there are arguments that you want to pass when the event occurs (typically something about the event), you can add it to the method.

Then in A, you add a field:

private SomeEventListener listener;

and a method:

public void setSomeEventListener (SomeEventListener listener) {
    this.listener = listener;
}

This way, B can call setSomeEventListener to set the listener.

When the event occurs, A should call

if (listener != null) listener.onSomeEvent ();

And that's all there is to A!

In B, you need to implement the interface:

public class B implements SomeEventListener {
    public void onSomeEvent () {
        //do whatever you like when SomeEvent happens.
    }
}

And you can listen for SomeEvent like this:

someInstanceOfA.setSomeEventListener (this);

And after this call, all the SomeEvent raised by A can be listened by B!

Using the Observable and Observer pattern, we can see that A is an Observable and B is an Observer.

That's easy!