Creating real-time applications with WebSocket support in Micronaut is definitely a game-changer for anyone looking to build interactive and responsive systems. Micronaut, being a modern JVM-based framework, is super efficient and easy to use, making it a great choice for developers. Here’s how to set up WebSocket support in Micronaut and get a real-time application up and running.

Getting Started with Micronaut

First things first—you need to be set up with the right tools. JDK 17 or later is a must, and you should have a solid text editor or IDE like IntelliJ IDEA. Micronaut is pretty flexible in terms of languages, but let’s stick with Java for simplicity.

Setting Up Your Micronaut Project

Starting a new Micronaut project is a breeze. You can use the Micronaut CLI or your preferred IDE to generate a project template. With the CLI, you just need to run this command:

mn create-app my-websocket-app

This will set up the basic structure of your Micronaut application.

Adding WebSocket Dependencies

To add WebSocket support, you’ll need to include some dependencies. If you’re using Gradle, your build.gradle should include:

dependencies {
    implementation "io.micronaut:micronaut-websocket"
    implementation "io.micronaut.reactor:micronaut-reactor-http-client"
    implementation "io.micronaut.serde:micronaut-serde-jackson"
    runtimeOnly "ch.qos.logback:logback-classic"
}

If you’re on Maven, add these to your pom.xml:

<dependencies>
    <dependency>
        <groupId>io.micronaut</groupId>
        <artifactId>micronaut-websocket</artifactId>
    </dependency>
    <dependency>
        <groupId>io.micronaut.reactor</groupId>
        <artifactId>micronaut-reactor-http-client</artifactId>
    </dependency>
    <dependency>
        <groupId>io.micronaut.serde</groupId>
        <artifactId>micronaut-serde-jackson</artifactId>
    </dependency>
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-classic</artifactId>
        <scope>runtime</scope>
    </dependency>
</dependencies>

Creating a WebSocket Server

Next up, you need a WebSocket server to handle connections. Here’s a simple example of a chat server:

@ServerWebSocket("/chat/{topic}")
public class ChatServer {
    private static final List<WebSocketSession> sessions = new ArrayList<>();

    @OnOpen
    public void onOpen(WebSocketSession session, String topic) {
        sessions.add(session);
        System.out.println("Client connected to topic: " + topic);
    }

    @OnMessage
    public void onMessage(WebSocketSession session, String message) {
        for (WebSocketSession s : sessions) {
            if (s.isOpen()) {
                s.sendSync(message);
            }
        }
    }

    @OnClose
    public void onClose(WebSocketSession session) {
        sessions.remove(session);
        System.out.println("Client disconnected");
    }
}

This ChatServer class is pretty straightforward—it manages client connections, broadcasts messages to all clients, and handles disconnections.

Creating a WebSocket Client

To hook up to the server, you’ll need a client. Here’s how you can set that up:

@ClientWebSocket("/chat/{topic}")
public class ChatClient implements AutoCloseable {
    private final WebSocketSession session;
    private final Scanner scanner;

    public ChatClient(WebSocketSession session) {
        this.session = session;
        this.scanner = new Scanner(System.in);
    }

    @OnOpen
    public void onOpen() {
        System.out.println("Connected to the server");
    }

    @OnMessage
    public void onMessage(String message) {
        System.out.println("Received message: " + message);
    }

    @OnClose
    public void onClose() {
        System.out.println("Disconnected from the server");
    }

    @OnError
    public void onError(Throwable throwable) {
        System.out.println("Error occurred: " + throwable.getMessage());
    }

    public void sendMessage(String message) {
        session.sendSync(message);
    }

    @Override
    public void close() {
        session.close();
    }

    public static void main(String[] args) {
        try (ChatClient client = new ChatClient(WebSocketClient.connect("/chat/topic").blockFirst())) {
            while (true) {
                System.out.print("Enter your message: ");
                String message = scanner.nextLine();
                client.sendMessage(message);
            }
        } catch (Exception e) {
            System.out.println("Error connecting to the server: " + e.getMessage());
        }
    }
}

This ChatClient class handles connecting to the server, sending messages, and receiving messages. It’s a super simple implementation but gets the job done.

Running the Application

To get your Micronaut application running, just execute:

./gradlew run

Or, if you’re using Maven:

./mvnw mn:run

This will start your application on port 8080. Now you can connect to the WebSocket server with your client.

Testing the Application

Once everything’s set up, it’s important to make sure it all works as expected. Here’s an example of how you might test your WebSocket connection:

@MicronautTest
public class ChatServerTest {
    @Test
    public void testWebSocketConnection() {
        WebSocketClient client = WebSocketClient.create("ws://localhost:8080/chat/topic");
        WebSocketSession session = client.connect(ChatClient.class, "/chat/topic").blockFirst();

        await().atMost(10, TimeUnit.SECONDS).until(() -> session.isOpen());

        session.sendSync("Hello, server!");
        await().atMost(10, TimeUnit.SECONDS).until(() -> session.hasReceivedMessage());

        assertTrue(session.hasReceivedMessage());
    }
}

This test connects to the WebSocket server, sends a message, and waits for a response.

Wrapping It Up

Building real-time applications with WebSockets in Micronaut is pretty straightforward and definitely powerful. With these steps, you can set up a robust, interactive system that takes advantage of Micronaut’s efficiency and features. Whether it’s a chat app or any other real-time system, Micronaut has got you covered, helping you get started quickly and effectively. So dive in and start building something awesome!