使用 Spring Boot 和 Netty 打造实时聊天系统

用户8589624

发布于 2025-11-14 09:34:59

2270

文章被收录于专栏：nginxnginx

使用 Spring Boot 和 Netty 打造实时聊天系统

1. 引言

在现代 Web 应用中，实时通信系统（如聊天应用、通知系统等）变得越来越重要。传统的 HTTP 协议是一种请求-响应模型，不适合实时通信。为了解决这个问题，WebSocket 协议被引入，它允许在客户端和服务器之间建立全双工的通信通道。Netty 是一个基于 NIO（非阻塞 I/O）的高性能网络框架，非常适合构建基于 WebSocket 的实时应用。本文将介绍如何使用 Spring Boot 和 Netty 构建一个简单的实时聊天系统。

2. 项目结构

在本项目中，我们将使用 Spring Boot 来管理依赖和配置，并使用 Netty 作为 WebSocket 服务器来处理实时消息传输。项目的结构如下：

springboot-netty-chat/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   ├── com/
│   │   │   │   ├── example/
│   │   │   │   │   ├── chat/
│   │   │   │   │   │   ├── ChatApplication.java
│   │   │   │   │   │   ├── config/
│   │   │   │   │   │   │   ├── NettyConfig.java
│   │   │   │   │   │   ├── handler/
│   │   │   │   │   │   │   ├── WebSocketServerHandler.java
│   │   │   │   │   │   ├── service/
│   │   │   │   │   │   │   ├── ChatService.java
│   │   │   │   │   │   ├── model/
│   │   │   │   │   │   │   ├── ChatMessage.java
│   │   │   │   │   │   │   ├── User.java
│   │   │   │   │   │   │   ├── MessageType.java
│   │   │   │   │   │   │   ├── ResponseMessage.java
│   │   │   │   │   │   ├── controller/
│   │   │   │   │   │   │   ├── ChatController.java

3. 依赖管理

首先，我们需要在 pom.xml 中添加必要的依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>io.netty</groupId>
        <artifactId>netty-all</artifactId>
        <version>4.1.71.Final</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
    </dependency>
</dependencies>

4. Netty 配置

我们需要在 Spring Boot 中配置 Netty 服务器来处理 WebSocket 连接。

4.1 NettyConfig.java

package com.example.chat.config;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.HttpServerCodec;
import io.netty.handler.codec.http.websocketx.WebSocketServerProtocolHandler;
import io.netty.handler.stream.ChunkedWriteHandler;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;

@Component
public class NettyConfig {

    private final int port = 8080;

    @PostConstruct
    public void start() throws InterruptedException {
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();

        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast(new HttpServerCodec());
                            ch.pipeline().addLast(new ChunkedWriteHandler());
                            ch.pipeline().addLast(new HttpObjectAggregator(8192));
                            ch.pipeline().addLast(new WebSocketServerProtocolHandler("/chat"));
                            ch.pipeline().addLast(new WebSocketServerHandler());
                        }
                    })
                    .option(ChannelOption.SO_BACKLOG, 128)
                    .childOption(ChannelOption.SO_KEEPALIVE, true);

            ChannelFuture future = serverBootstrap.bind(port).sync();
            future.channel().closeFuture().sync();
        } finally {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }
}

在这个配置中，我们配置了 Netty 服务器在端口 8080 上监听，并设置了 WebSocket 协议处理器。WebSocketServerHandler 是自定义的处理器，用于处理 WebSocket 连接和消息。

5. WebSocket 处理器

5.1 WebSocketServerHandler.java

package com.example.chat.handler;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.codec.http.websocketx.TextWebSocketFrame;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.example.chat.model.ChatMessage;

public class WebSocketServerHandler extends SimpleChannelInboundHandler<TextWebSocketFrame> {

    private ObjectMapper objectMapper = new ObjectMapper();

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, TextWebSocketFrame msg) throws Exception {
        String message = msg.text();
        ChatMessage chatMessage = objectMapper.readValue(message, ChatMessage.class);

        // 广播消息给所有连接的客户端
        ctx.channel().parent().writeAndFlush(new TextWebSocketFrame(objectMapper.writeValueAsString(chatMessage)));
    }

    @Override
    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
        System.out.println("Client connected: " + ctx.channel().id().asLongText());
    }

    @Override
    public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
        System.out.println("Client disconnected: " + ctx.channel().id().asLongText());
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

WebSocketServerHandler 处理 WebSocket 消息，并将接收到的消息广播给所有连接的客户端。为了简化开发，我们使用 Jackson 将 JSON 消息转换为 Java 对象。

6. 消息模型

6.1 ChatMessage.java

package com.example.chat.model;

public class ChatMessage {
    private String sender;
    private String content;
    private MessageType type;

    public enum MessageType {
        CHAT,
        JOIN,
        LEAVE
    }

    // Getters and Setters
}

ChatMessage 是我们的消息模型，包含了消息的发送者、内容和类型。

7. WebSocket 控制器

虽然 Netty 已经处理了 WebSocket 通信，但我们仍然可以使用 Spring MVC 来处理一些 RESTful API。

7.1 ChatController.java

package com.example.chat.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api")
public class ChatController {

    @GetMapping("/status")
    public String getStatus() {
        return "Chat server is running...";
    }
}

这个简单的控制器提供了一个 RESTful 接口，用于检查聊天服务器的状态。

8. 前端 WebSocket 客户端

为了测试我们的聊天系统，我们可以创建一个简单的 HTML 页面，使用 WebSocket API 进行连接。

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Netty Chat</title>
</head>
<body>
    <div>
        <h2>Chat Room</h2>
        <input type="text" id="username" placeholder="Enter your name">
        <input type="text" id="message" placeholder="Enter your message">
        <button onclick="sendMessage()">Send</button>
    </div>
    <div id="chat-box"></div>

    <script>
        const socket = new WebSocket("ws://localhost:8080/chat");

        socket.onmessage = function(event) {
            const chatBox = document.getElementById('chat-box');
            const newMessage = document.createElement('p');
            newMessage.textContent = event.data;
            chatBox.appendChild(newMessage);
        };

        function sendMessage() {
            const username = document.getElementById('username').value;
            const message = document.getElementById('message').value;
            const chatMessage = {
                sender: username,
                content: message,
                type: 'CHAT'
            };
            socket.send(JSON.stringify(chatMessage));
        }
    </script>
</body>
</html>

这个简单的客户端

允许用户输入用户名和消息，并将消息发送到服务器。服务器会将消息广播给所有连接的客户端。

9. 启动应用并测试

启动 Spring Boot 应用后，打开浏览器并访问我们的 HTML 页面，输入用户名和消息，然后点击“Send”按钮。你可以在多个浏览器窗口中打开该页面，并在不同的窗口中发送消息，观察实时聊天的效果。

10. 结论

通过本文，我们构建了一个简单的实时聊天系统，展示了如何使用 Spring Boot 和 Netty 结合 WebSocket 技术实现实时通信。这个系统虽然简单，但可以作为一个基础项目，用于进一步扩展和开发更复杂的聊天功能。你可以基于此项目添加更多功能，如用户认证、消息持久化、群聊等，逐步构建一个功能完善的聊天应用。

Spring Boot 和 Netty 的结合使得开发和维护高性能、实时响应的 Web 应用变得更加容易。通过这种方式，我们可以充分利用 Java 生态系统中的优秀工具，构建现代化的 Web 应用程序。

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2024-08-09，如有侵权请联系 cloudcommunity@tencent.com 删除

boot