You can inject a reference to the a instance using the @Client annotation:

This allows you to use the same service discovery and load balancing features for WebSocket clients.

Once you have a reference to the interface you can use the method to obtain a connected instance of a bean annotated with @ClientWebSocket.

For example consider the following implementation:

WebSocket Chat Example

import io.micronaut.http.HttpRequest;
import io.micronaut.websocket.WebSocketSession;
import io.micronaut.websocket.annotation.ClientWebSocket;
import io.micronaut.websocket.annotation.OnMessage;
import io.micronaut.websocket.annotation.OnOpen;
import io.reactivex.Single;
import java.util.Collection;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.Future;
@ClientWebSocket("/chat/{topic}/{username}") (1)
public abstract class ChatClientWebSocket implements AutoCloseable { (2)
    private WebSocketSession session;
    private HttpRequest request;
    private String topic;
    private String username;
    private Collection<String> replies = new ConcurrentLinkedQueue<>();
    @OnOpen
    public void onOpen(String topic, String username, WebSocketSession session, HttpRequest request) { (3)
        this.topic = topic;
        this.username = username;
        this.session = session;
        this.request = request;
    }
    public String getTopic() {
        return topic;
    }
    public String getUsername() {
        return username;
    }
        return replies;
    }
    public WebSocketSession getSession() {
        return session;
    }
    public HttpRequest getRequest() {
        return request;
    }
    @OnMessage
    public void onMessage(
            String message) {
        replies.add(message); (4)
    }

import io.micronaut.http.HttpRequest
import io.micronaut.websocket.WebSocketSession
import io.micronaut.websocket.annotation.ClientWebSocket
import io.micronaut.websocket.annotation.OnMessage
import io.micronaut.websocket.annotation.OnOpen
import io.reactivex.Single
import java.util.concurrent.ConcurrentLinkedQueue
import java.util.concurrent.Future
@ClientWebSocket("/chat/{topic}/{username}") (1)
abstract class ChatClientWebSocket implements AutoCloseable { (2)
    private WebSocketSession session
    private HttpRequest request
    private String topic
    private String username
    private Collection<String> replies = new ConcurrentLinkedQueue<>()
    @OnOpen
        this.topic = topic
        this.username = username
        this.session = session
        this.request = request
    }
    String getTopic() {
        topic
    }
    String getUsername() {
        username
    }
    Collection<String> getReplies() {
        replies
    }
    WebSocketSession getSession() {
        session
    }
    HttpRequest getRequest() {
        request
    }
    @OnMessage
    void onMessage(
            String message) {
        replies.add(message) (4)
    }

WebSocket Chat Example

You can also define abstract methods that start with either send or broadcast and these methods will be implemented for you at compile time. For example:

WebSocket Send Methods

public abstract void send(String message);

Note by returning void this tells Micronaut that the method is a blocking send. You can instead define methods that return either futures or a :

WebSocket Send Methods

public abstract io.reactivex.Single<String> send(String message);

WebSocket Send Methods

The above example defines a send method that executes asynchronously and returns a Future to access the results.

Once you have defined a client class you can connect to the client socket and start sending messages:

Connecting a Client WebSocket

ChatClientWebSocket chatClient = webSocketClient.connect(ChatClientWebSocket.class, "/chat/football/fred").blockingFirst();
chatClient.send("Hello World!");