Resolving circular dependency between two classes

The simple solution to this is to recognise that Controller doesn't need a dependency on Messenger, it needs a dependency on send. So provide it with that dependency:

interface Sender {
    void send(Object payload);
}

class Messenger implements WebsocketHandler, Sender { …

class Controller
{
    Sender sender;

    void messageReceived(Object payload)
    {
        // do something with payload
    }

    void notifyClients()
    {
        sender.send(...);
    }
}

Now, Controller just has a dependency on the Sender interface, removing that circular dependency.

UPDATE

As the OP points out, the above removes the direct circular dependency between Controller and Messenger. However, if constructor injection is used, the dependency still exists at the point of creation of the objects: we need to create Sender first to satisfy Controller's need for a Sender, but we need to create Controller first as Messenger needs to call controller.messageReceived(payload).

There are various ways of working around this, such as supporting property injection. But my personally favourite, for languages that support functions as first class citizens is to fully decouple the two objects via functions.

Such a solution, expressed as C# (as I'm more familiar with that language), might look like:

class Messenger : WebsocketHandler
{
    private readonly Action<object> _messageReceived;
    private readonly IEnumerable<WebsocketSession> _websocketSessions;

    public Messenger(Action<object> messageReceived) 
        => _messageReceived = messageReceived;


    public void Receive(object payload) => _messageReceived(payload);

    public void Send(Object payload)
    {
        foreach (var session in _websocketSessions)
        {
            session.Send(payload);
        }
    }
}

class Controller
{
    private readonly Action<object> _send;

    public Controller(Action<object> send) => _send = send;

    public void MessageReceived(object payload)
    {
        // do something with payload
    }

    public void NotifyClients() => _send(null);
}

And then the code to couple the two objects at runtime might be something like:

void Setup()
{
    Controller controller = null;
    var messenger = new Messenger(MessageReceiver);
    controller = new Controller(Sender);

    void MessageReceiver(object payload) => controller.MessageReceived(payload);
    void Sender(object payload) => messenger.Send(payload);
}

Java these days supports such an approach too. I do not know though how well this would work with IoC frameworks like Spring.

The Messenger component has a dependency on the Controller component to be able notify the controller of incoming messages.

OMG java does not have events!!!

It does have several alternatives though. For example

https://docs.oracle.com/javase/6/docs/api/java/util/Observable.html

Here you would make your Messenger implement Observable and have the Controller call addObserver The Messenger can then notify the Controller of incoming messages with its notifyObservers() function without having to reference the Controller class.

There are several variations on the technique.

https://docs.oracle.com/javase/tutorial/uiswing/events/index.html

The Idea is that you pass in to the messenger the function to call when a message comes in rather than passing in the whole controller class.

In that particular case (when you need to notify someone about something), you can use an aggregator\messenger.

One of my favorite (from C# though) is this one: https://github.com/NimaAra/Easy.MessageHub

You create a message class, you subscribe your service, you fire the message from another service - that's it. Behind the scenes, aggregator just defines the list of subscribers, who should be notified for the particular message.

I'm pretty sure Java should have something similar.