基于Netty+WebSocket+DeepSeek AI 实现即时聊天功能

在现代Web应用中，即时聊天与AI交互已成为高频需求。本文将基于Netty搭建WebSocket服务，结合DeepSeek AI接口，实现"客户端-服务端-AI"的全流程即时聊天功能，全程结合完整代码拆解实现逻辑，兼顾技术深度与落地性，帮助开发者快速掌握Netty+WebSocket+AI接入的核心要点。

核心技术栈：Netty（高性能网络通信）+ WebSocket（全双工即时通信）+ DeepSeek AI（智能对话）+ Spring Boot（依赖管理与注入），代码可直接复用，适配中小型项目的AI聊天场景。

一、整体架构设计（先懂全局，再拆细节）

本次实现的AI聊天系统，核心分为4个核心模块，各模块职责清晰、联动高效，整体架构如下：

1. Netty WebSocket服务端：基于Netty搭建高性能WebSocket服务器，负责监听客户端连接、接收客户端消息、推送AI响应消息，是整个系统的通信中枢。

2. WebSocket消息处理器：自定义消息处理器，负责解析客户端消息（登录绑定、聊天请求）、维护客户端通道映射、转发消息至AI服务。

3. DeepSeek AI服务：封装DeepSeek AI接口调用逻辑，处理超时重试、请求构建、响应解析，将AI的智能回复返回至服务端。

4. 工具类封装：提供AI接口调用的基础工具，便于后续扩展与维护（本文中工具类可作为测试与参考）。

核心流程：客户端通过WebSocket连接服务端 → 客户端登录绑定用户ID → 客户端发送聊天消息 → 服务端解析消息并调用DeepSeek AI → AI返回智能回复 → 服务端将回复推送至客户端 → 客户端展示AI消息。

二、核心模块实现（结合代码，逐行解析）

模块1：Netty WebSocket服务端（CoordinationNettyServer）

Netty是高性能的NIO框架，相比传统Socket，能更好地处理高并发连接，适合WebSocket这种长连接场景。本模块的核心作用是启动WebSocket服务，配置通道处理器，绑定监听端口。

@Configuration // 标记为配置类，Spring启动时自动加载
public class CoordinationNettyServer {

    @Autowired
    private CoordinationSocketHandler coordinationSocketHandler; // 注入自定义消息处理器

    public void start() throws Exception {
        // 1. 初始化Netty线程池（BossGroup负责接收连接，WorkerGroup负责处理连接后的IO操作）
        EventLoopGroup bossGroup = new NioEventLoopGroup(); // 监听线程组（1个线程即可）
        EventLoopGroup workerGroup = new NioEventLoopGroup(); // 工作线程组（默认CPU核心数*2）
        try {
            // 2. 配置ServerBootstrap（Netty服务端启动器）
            ServerBootstrap sb = new ServerBootstrap();
            sb.option(ChannelOption.SO_BACKLOG, 1024) // 队列大小，用于接收等待处理的连接
                    .group(workerGroup, bossGroup) // 绑定线程池（注意顺序：workerGroup在前，bossGroup在后）
                    .channel(NioServerSocketChannel.class) // 指定使用NIO通道
                    .localAddress(8004) // 绑定监听端口8004（可根据需求修改）
                    .childHandler(new ChannelInitializer<SocketChannel>() { // 客户端连接时触发的初始化操作
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            // 3. 配置WebSocket相关处理器（核心关键）
                            // WebSocket基于HTTP协议，先添加HTTP编解码器
                            ch.pipeline().addLast(new HttpServerCodec());
                            // 处理大文件传输的处理器（避免内存溢出）
                            ch.pipeline().addLast(new ChunkedWriteHandler());
                            // 聚合HTTP请求（将HTTP消息聚合为FullHttpRequest/FullHttpResponse）
                            ch.pipeline().addLast(new HttpObjectAggregator(8192));
                            // WebSocket核心处理器：指定WebSocket路径、支持的子协议、允许跨域、设置最大帧大小
                            ch.pipeline().addLast(new WebSocketServerProtocolHandler("/ws", "WebSocket", true, 65536 * 10));
                            // 自定义消息处理器：处理客户端发送的文本消息
                            ch.pipeline().addLast(coordinationSocketHandler);
                        }
                    });
            // 4. 启动服务并阻塞等待关闭
            ChannelFuture cf = sb.bind().sync(); // 异步绑定端口，sync()阻塞等待绑定完成
            System.out.println(CoordinationNettyServer.class + "已启动，正在监听： " + cf.channel().localAddress());
            cf.channel().closeFuture().sync(); // 阻塞等待通道关闭（服务停止）
        } finally {
            // 5. 优雅关闭线程池，释放资源
            workerGroup.shutdownGracefully().sync();
            bossGroup.shutdownGracefully().sync();
        }
    }
}

关键注意点：

• 线程组配置：BossGroup负责接收客户端连接，WorkerGroup负责处理连接后的IO读写，无需手动创建过多线程，Netty会自动优化。

• WebSocket处理器顺序：必须先添加HTTP相关处理器，再添加WebSocketServerProtocolHandler，最后添加自定义处理器，否则会导致消息解析失败。

• 端口绑定：8004端口需确保未被占用，若需修改，直接修改localAddress参数即可。

模块2：WebSocket消息处理器（CoordinationSocketHandler）

该模块是聊天功能的核心，负责维护客户端通道、解析客户端消息类型（登录绑定、聊天请求）、调用AI服务、推送响应消息。核心是继承SimpleChannelInboundHandler，重写通道生命周期方法和消息读取方法。

@Configuration
@ChannelHandler.Sharable // 标记处理器可共享，避免多客户端连接时创建多个实例
public class CoordinationSocketHandler extends SimpleChannelInboundHandler<TextWebSocketFrame> {

    @Autowired
    private DeepSeekService deepSeekService; // 注入AI服务

    // 存储用户ID与Channel的映射关系，ConcurrentHashMap保证线程安全（高并发场景必备）
    // key格式："user+用户ID"（普通用户）、"AI"（AI虚拟用户）
    private Map<String, Channel> cmap = new ConcurrentHashMap<>();

    /**
     * 通道激活（客户端与服务端建立连接时触发）
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        // 绑定AI的通道（AI无需登录，固定绑定为"AI"）
        cmap.put("AI", ctx.channel());
        System.out.println("与客户端建立连接，通道开启！");
    }

    /**
     * 通道关闭（客户端与服务端断开连接时触发）
     */
    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        // 可选优化：断开连接时，移除该通道对应的用户映射（本文暂未实现，可自行补充）
        System.out.println("与客户端断开连接，通道关闭！");
    }

    /**
     * 读取客户端发送的消息（TextWebSocketFrame类型，即文本消息）
     */
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, TextWebSocketFrame msg) throws Exception {
        // 1. 解析客户端发送的JSON消息（客户端消息格式：{"type":"xxx", "from":"用户ID", "data":"消息内容"}）
        Map map = JSON.parseObject(msg.text(), Map.class);
        String type = map.get("type").toString(); // 消息类型：bind（登录绑定）、chat（聊天）
        System.out.println("服务端收到：" + msg.text());

        // 2. 根据消息类型处理不同逻辑
        switch (type) {
            case "bind":
                websocketLogin(map, ctx); // 处理用户登录绑定（将用户ID与通道关联）
                break;
            case "chat":
                send(map); // 处理聊天请求（调用AI，推送回复）
                break;
            default:
                break;
        }
    }

    /**
     * 处理用户登录绑定逻辑
     * @param map 客户端发送的登录数据（包含from：用户ID）
     * @param ctx 通道上下文（获取当前客户端通道）
     */
    private void websocketLogin(Map map, ChannelHandlerContext ctx) {
        String uid = map.get("from").toString(); // 获取用户ID
        cmap.put("user"+uid, ctx.channel()); // 绑定用户ID与通道
        System.out.println(uid+"登录");
    }

    /**
     * 处理聊天请求：调用AI接口，获取回复并推送至客户端
     * @param map 客户端发送的聊天数据（包含from：用户ID、data：聊天内容）
     */
    private void send(Map map) {
        try {
            // 1. 调用DeepSeek AI服务，传入用户消息，获取AI响应
            String aiResponse = deepSeekService.deepSeek(map.get("data").toString());

            // 2. 解析AI响应结果（DeepSeek接口返回JSON格式，需提取content字段）
            JSONObject jsonObject = new JSONObject(aiResponse);
            JSONArray choices = jsonObject.getJSONArray("choices"); // 响应选项数组
            JSONObject firstChoice = choices.getJSONObject(0); // 取第一个选项（默认唯一）
            JSONObject messageText = firstChoice.getJSONObject("message"); // 消息对象
            String content = messageText.getString("content"); // AI回复内容

            // 3. 获取发送方（用户）的通道（根据用户ID从映射中获取）
            Channel channel = cmap.get("user"+map.get("from").toString());

            // 4. 构建AI回复消息（格式与客户端一致，便于客户端解析）
            Map<String,Object> responseObj = new HashMap<>();
            responseObj.put("type", "chat"); // 消息类型：聊天
            responseObj.put("from", "AI"); // 发送者：AI
            responseObj.put("sendAvatar", "http://localhost:8080/api/files/download/1740377255812_12.png"); // AI头像（可替换）
            responseObj.put("data", content); // AI回复内容

            // 5. 推送消息至客户端（TextWebSocketFrame格式）
            channel.writeAndFlush(new TextWebSocketFrame(JSON.toJSONString(responseObj)));
        } catch (IOException e) {
            e.printStackTrace(); // 实际项目中需替换为日志输出，避免控制台打印
        }
    }
}

核心亮点：

• 线程安全：使用ConcurrentHashMap存储用户与通道的映射，避免高并发场景下的线程安全问题。

• 消息解耦：通过type字段区分消息类型（登录、聊天），便于后续扩展更多消息类型（如心跳检测、消息撤回）。

• 格式统一：客户端与服务端消息格式一致，降低前后端联调成本，AI回复消息直接适配客户端解析逻辑。

模块3：DeepSeek AI服务实现（DeepSeekServiceImpl + DeepSeekUtil）

该模块负责封装DeepSeek AI接口调用逻辑，解决超时、重试、请求构建、响应解析等问题，为消息处理器提供AI交互能力。其中DeepSeekUtil为基础工具类（可用于测试AI接口），DeepSeekServiceImpl为业务实现类（整合到Spring容器中）。

3.1 基础工具类（DeepSeekUtil）

用于测试DeepSeek AI接口是否可用，封装了简单的HTTP请求逻辑，可作为接口调试工具。

public class DeepSeekUtil {
    // 替换为你的DeepSeek API Key（从DeepSeek官网获取）
    private static final String API_KEY = "Bearer 替换为你的DeepSeek API Key";
    private static final String API_URL = "https://api.deepseek.com/chat/completions"; // DeepSeek聊天接口地址

    public static void main(String[] args) throws IOException {
        // 构建请求体（JSON格式，指定模型、用户消息等参数）
        String jsonBody = String.format("{\n"
                + "  \"model\": \"deepseek-chat\",\n"
                + "  \"messages\": [\n"
                + "    {\"role\": \"user\", \"content\": \"%s\"}\n"
                + "  ],\n"
                + "  \"temperature\": 0.7,\n"
                + "  \"top_p\": 0.8\n"
                + "}", "你好");

        // 初始化OkHttp客户端，发送POST请求
        OkHttpClient client = new OkHttpClient();
        RequestBody body = RequestBody.create(MediaType.get("application/json"), jsonBody);

        Request request = new Request.Builder()
                .url(API_URL)
                .post(body)
                .addHeader("Content-Type", "application/json")
                .addHeader("Accept", "application/json")
                .addHeader("Authorization", API_KEY) // 携带API Key认证
                .build();

        // 执行请求并打印响应结果
        try (Response response = client.newCall(request).execute()) {
            if (!response.isSuccessful()) {
                throw new IOException("请求失败: " + response);
            }
            System.out.println("响应结果:\\n" + response.body().string());
        }
    }
}

3.2 AI服务实现类（DeepSeekServiceImpl）

在工具类基础上，优化了请求构建方式（避免字符串拼接的转义问题）、增加超时重试机制、整合Spring注解，适配业务场景。

@Service // 标记为服务类，供消息处理器注入
public class DeepSeekServiceImpl implements DeepSeekService {

    private static final String API_KEY = "Bearer sk-e1e36cd653f94419bf2c12f3fd56e07f";
    private static final String API_URL = "https://api.deepseek.com/chat/completions";

    // 初始化OkHttp客户端，设置超时时间（解决AI接口超时问题，核心优化）
    private final OkHttpClient client = new OkHttpClient.Builder()
            .connectTimeout(30, TimeUnit.SECONDS)    // 连接超时30秒（适配AI接口响应速度）
            .readTimeout(60, TimeUnit.SECONDS)       // 读取超时60秒（重点加长，避免读取响应时超时）
            .writeTimeout(30, TimeUnit.SECONDS)      // 写入超时30秒
            .build();

    @Override
    public String deepSeek(String data) throws IOException {
        int retryCount = 3; // 重试次数（防止偶发超时、网络波动）
        while (retryCount > 0) {
            try {
                // 1. 构建JSON请求体（使用JSONObject，避免字符串拼接的转义问题，更安全）
                JSONObject requestBody = new JSONObject();
                requestBody.put("model", "deepseek-chat"); // 指定DeepSeek模型（deepseek-chat为通用聊天模型）

                // 构建消息数组（用户角色+消息内容）
                JSONArray messages = new JSONArray();
                JSONObject message = new JSONObject();
                message.put("role", "user"); // 角色：user（用户）、assistant（AI）、system（系统）
                message.put("content", data); // 用户发送的消息内容
                messages.put(message);

                requestBody.put("messages", messages);
                requestBody.put("temperature", 0.7); // 随机性（0-1，越小越严谨）
                requestBody.put("top_p", 0.8); // 多样性（0-1，越小越集中）

                // 2. 创建HTTP请求（POST方式，携带请求体和请求头）
                RequestBody body = RequestBody.create(
                        MediaType.get("application/json; charset=utf-8"),
                        requestBody.toString()
                );

                Request request = new Request.Builder()
                        .url(API_URL)
                        .post(body)
                        .addHeader("Content-Type", "application/json")
                        .addHeader("Accept", "application/json")
                        .addHeader("Authorization", API_KEY) // 认证关键：携带API Key
                        .build();

                // 3. 执行请求并返回响应结果
                try (Response response = client.newCall(request).execute()) {
                    if (!response.isSuccessful()) {
                        throw new IOException("DeepSeek接口返回异常: " + response.code());
                    }
                    return response.body().string(); // 返回AI响应的原始JSON字符串
                }
            } catch (SocketTimeoutException e) {
                // 处理超时异常：重试3次，每次重试前等待1秒
                retryCount--;
                System.out.println("DeepSeek接口超时，剩余重试次数：" + retryCount);
                if (retryCount == 0) {
                    throw new IOException("DeepSeek接口超时（已重试3次）", e);
                }
                TimeUnit.SECONDS.sleep(1); // 重试间隔
            }
        }
        throw new IOException("DeepSeek接口调用失败");
    }
}

关键优化点：

• 超时设置：加长读取超时时间至60秒，适配DeepSeek AI接口的响应速度，避免因AI思考时间过长导致超时。

• 重试机制：针对超时异常重试3次，降低网络波动、接口偶发故障的影响，提升系统稳定性。

• 请求体构建：使用JSONObject构建请求体，避免字符串拼接导致的JSON格式错误（如特殊字符转义问题）。

• Spring整合：使用@Service注解，将AI服务纳入Spring容器，支持依赖注入，便于后续扩展（如切换AI模型、多AI源适配）。

三、功能测试与落地注意事项

3.1 测试流程

1. 替换API Key：将代码中的API_KEY替换为自己从DeepSeek官网获取的有效Key（注意前缀"Bearer "不能省略）。

2. 启动服务：启动Spring Boot项目，Netty服务会自动启动（可通过@PostConstruct注解触发start()方法，本文暂未实现，可自行补充）。

3. 客户端连接：使用WebSocket客户端（如在线WebSocket测试工具、前端Vue/React项目）连接ws://localhost:8004/ws。

4. 登录绑定：发送消息{"type":"bind", "from":"1001"}（1001为用户ID，可自定义），服务端打印"1001登录"。

5. 发送聊天消息：发送消息{"type":"chat", "from":"1001", "data":"你好"}，服务端调用AI接口，返回AI回复并推送至客户端。

3.2 落地注意事项（提升系统稳定性与可维护性）

• 日志优化：将System.out.println替换为SLF4J+Logback日志框架，便于问题排查（如消息发送失败、AI接口异常）。

• 异常处理：补充更多异常场景（如客户端断开连接时移除通道映射、AI接口返回错误格式时的降级处理）。

• 端口配置：将监听端口（8004）、AI接口地址、API Key配置到application.yml中，避免硬编码，便于部署修改。

• 线程池优化：根据服务器配置调整Netty线程组的线程数量，避免线程过多导致资源浪费。

• 安全防护：添加WebSocket连接认证（如Token验证），防止非法连接；限制单用户发送消息频率，避免恶意请求。

四、总结与扩展

本文通过Netty+WebSocket+DeepSeek AI，完整实现了即时AI聊天功能，核心亮点在于：

1. 高性能：Netty的NIO模型支持高并发连接，相比传统WebSocket实现，响应速度更快、资源占用更低。

2. 高可用：AI服务添加超时重试机制，WebSocket处理器保证线程安全，降低系统故障概率。

3. 易扩展：各模块职责解耦，可轻松扩展功能（如添加多用户聊天、AI模型切换、消息持久化等）。

扩展方向：

• 多用户聊天：修改消息处理器，支持用户之间的点对点聊天（不仅仅是用户与AI聊天）。

• AI模型扩展：封装多AI接口（如ChatGPT、文心一言），根据业务需求动态切换AI源。

• 消息持久化：将聊天记录存储到数据库（如MySQL、Redis），支持聊天记录查询、回溯。

• 前端整合：结合Vue/React+Element UI，实现可视化的AI聊天界面，完善用户体验。

如果在实现过程中遇到问题，可结合Netty官方文档和DeepSeek API文档排查，也可留言交流探讨。