Java IM系统入门教程

本文将介绍如何搭建和优化Java IM系统，涵盖用户注册、登录、消息传输及存储等核心功能。Java IM系统凭借其跨平台兼容性和丰富的开发库，成为构建即时通讯应用的理想选择。通过详细步骤，您将掌握从环境搭建到实现一对一聊天和群聊功能的全过程。本文还将提供性能优化和安全保障方面的建议，帮助您完善Java IM系统。

Java IM 系统简介

即时通讯系统（Instant Messaging System，简称IM）是一种提供实时在线通信的软件系统。在即时通讯系统中，用户可以实时发送和接收文本消息、文件、语音、视频等信息，使交流变得更加高效和便捷。即时通讯系统广泛应用于个人社交、企业内部通信、客户服务和在线协作等多个场景。

即时通讯系统的核心功能包括：

• 用户注册与登录
• 用户关系管理（如好友添加、分组管理等）
• 消息的发送与接收
• 在线状态显示
• 历史消息存储与检索

Java IM 系统的应用场景

即时通讯系统在多个应用场景中发挥着重要作用：

• 个人社交：如QQ、微信等，这些系统为用户提供了一个方便的平台来实时交流和分享信息。
• 企业内部通信：企业可以使用即时通讯系统进行内部员工之间的在线协作，促进信息传递，提高工作效率。
• 客户服务：企业可以利用即时通讯系统与客户进行实时沟通，提供快速有效的客户服务支持。
• 在线教育：教育机构可以利用即时通讯系统来进行在线课堂互动、作业提交、在线讨论等，极大地提升了教学效率和互动性。
• 远程协作：即时通讯系统支持远程团队协作，可以有效解决地理位置分散带来的沟通障碍。

Java IM 系统的优势

Java IM 系统的优势主要体现在以下几个方面：

• 跨平台兼容性：Java 是一种跨平台语言，使用 Java 开发的 IM 系统可以在任何安装了 Java 虚拟机（JVM）的操作系统上运行。
• 丰富的开发库：Java 提供了大量的开发库和框架，如 Java Socket 编程、Java NIO（New IO）、Java WebSocket 等，这些库为开发复杂的网络应用提供了便利。
• 强大的社区支持：Java 社区非常活跃，有大量的开发者和社区支持，可以获取到丰富的资源和技术支持。
• 安全性：Java 本身提供了许多安全特性，如 JVM 的安全模型、Java 安全管理器等，可以在一定程度上保证系统的安全性。
• 易于维护和扩展：Java 的面向对象特性使得代码易于维护和扩展，可以灵活地调整和扩展系统功能。

快速搭建 Java IM 系统环境

安装 Java 开发环境

要搭建 Java 开发环境，首先要确保计算机上安装了最新版本的 Java 开发工具包（JDK）。以下步骤是 Windows 平台下的安装步骤，其他操作系统安装方法略有不同。

1. 访问 Oracle 官方网站或下载 OpenJDK：https://www.oracle.com/java/technologies/javase-jdk11-downloads.html 或 https://openjdk.java.net/
2. 下载对应操作系统的 JDK 安装包。
3. 双击安装包，按照安装向导完成安装。
4. 配置环境变量：安装完成后，需要配置环境变量，确保系统能够找到 JDK 路径。

在命令行中输入以下命令检查是否安装成功：

java -version

选择适合的开发工具

选择一个适合的开发工具对于开发 Java 应用至关重要。以下是一些常用的 Java 开发工具：

• Eclipse： Eclipse 是一个开源的集成开发环境（IDE），支持多种编程语言，包括 Java。它提供了强大的代码编辑、调试和项目管理功能。
• IntelliJ IDEA： IntelliJ IDEA 是一个功能强大的 Java 开发 IDE，提供了代码高亮、自动补全、编译、调试等功能。
• NetBeans： NetBeans 是另一个开源的 Java IDE，支持 Java SE、Java EE、PHP、JavaScript 等多种语言。
• Visual Studio Code： Visual Studio Code（简称 VS Code）是一款轻量级、高扩展性的代码编辑器，支持多种编程语言，包括 Java。

配置项目开发环境

在选择好开发工具后，需要配置项目开发环境。以下是在 Eclipse 中配置项目开发环境的步骤：

1. 启动 Eclipse。
2. 创建新项目：选择 File > New > Java Project。
3. 输入项目名称，例如 "JavaIMSystem"，点击 Next。
4. 选择项目配置：根据需要选择项目配置，例如 Java 编译器版本。
5. 点击 Finish 完成项目创建。

接下来，设置 Java 类路径和构建路径：

1. 右键点击项目，选择 Build Path > Configure Build Path。
2. 在 Libraries 选项卡下，点击 Add Library，选择 User Libraries。
3. 点击 New，创建一个新的用户库，例如 "JavaIMDependencies"，然后点击 OK。
4. 在 User Libraries 选项卡下，点击 Add Jars 或 Add External Jars，将所需依赖项添加到库中。
5. 完成配置后，点击 OK 保存设置。

Java IM 系统的核心概念与组件

基础网络通信协议

网络通信协议是即时通讯系统中最为基础的部分。常用的网络通信协议包括 TCP、UDP、WebSocket 等。

• TCP（Transmission Control Protocol）：TCP 是一种面向连接的、可靠的、基于字节流的传输层通信协议。它提供可靠的数据传输、流控制和错误恢复机制，适用于需要保证信息完整性的场景。TCP 通过三次握手建立连接，采用滑动窗口机制实现流量控制，保证数据的可靠传输。

• UDP（User Datagram Protocol）：UDP 是一种无连接的、不可靠的传输层通信协议。它不保证数据的顺序传输和数据完整性，但传输速度快，适用于实时性要求高的场景。UDP 的实现简单，不需要建立连接，直接发送数据包。

• WebSocket：WebSocket 是一种在单个持久连接上进行全双工通信的协议。它允许服务器主动向客户端推送数据，适用于实时通信场景，如即时消息、在线游戏等。WebSocket 协议基于 TCP，使用 HTTP/1.1 升级握手建立连接。

以下是一些示例代码，展示了如何使用 Java Socket 和 WebSocket：

// 使用 Java Socket
import java.io.*;
import java.net.*;

public class SimpleSocketServer {
    public static void main(String[] args) {
        try {
            ServerSocket serverSocket = new ServerSocket(8080);
            System.out.println("Server started, waiting for connections...");
            Socket clientSocket = serverSocket.accept();
            InputStream in = clientSocket.getInputStream();
            BufferedReader reader = new BufferedReader(new InputStreamReader(in));
            String message = reader.readLine();
            System.out.println("Received: " + message);
            clientSocket.close();
            serverSocket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public class SimpleSocketClient {
    public static void main(String[] args) {
        try {
            Socket socket = new Socket("localhost", 8080);
            OutputStream out = socket.getOutputStream();
            PrintWriter writer = new PrintWriter(out, true);
            writer.println("Hello, server!");
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

// 使用 Java WebSocket
import javax.websocket.*;
import java.io.IOException;

@ServerEndpoint("/chat")
public class WebSocketServer {
    @OnOpen
    public void onOpen(Session session) {
        System.out.println("New client connected");
    }

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

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

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

import javax.websocket.ContainerProvider;
import javax.websocket.Session;
import javax.websocket.WebSocketContainer;
import java.net.URI;
import java.util.Scanner;

public class WebSocketClient {
    public static void main(String[] args) {
        try {
            WebSocketContainer container = ContainerProvider.getWebSocketContainer();
            Session session = container.connectToServer(WebSocketClient.class, URI.create("ws://localhost:8080/chat"));
            Scanner scanner = new Scanner(System.in);
            while (scanner.hasNextLine()) {
                String message = scanner.nextLine();
                session.getMessageAsync(message, null);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

用户认证与授权

用户认证与授权是即时通讯系统中非常重要的组成部分，用于确保只有合法用户才能访问系统中的资源。常见的用户认证与授权技术包括：

• 用户名和密码：最常用的认证方式，用户通过输入用户名和密码进行身份验证。例如，以下是一个简单的用户注册和登录功能的示例：

import java.util.HashMap;
import java.util.Map;

public class UserRegistry {
    private Map<String, String> users = new HashMap<>();

    public boolean registerUser(String username, String password) {
        if (users.containsKey(username)) {
            return false;
        }
        users.put(username, password);
        return true;
    }

    public boolean loginUser(String username, String password) {
        String storedPassword = users.get(username);
        return storedPassword != null && storedPassword.equals(password);
    }
}

• 令牌（Token）：令牌是一种特殊的字符串，用于表示用户身份。常见的令牌类型有 JSON Web Token（JWT）、OAuth 等。
• OAuth 2.0：OAuth 2.0 是一个常用的授权框架，允许第三方应用在不暴露用户密码的情况下访问用户资源。OAuth 2.0 支持多种授权方式，如授权码、客户端凭证、隐式授权等。

以下是一个使用 Java 实现 OAuth 2.0 授权的示例：

import com.nimbusds.oauth2.sdk.*;
import com.nimbusds.oauth2.sdk.http.HTTPResponse;
import com.nimbusds.oauth2.sdk.id.ClientID;
import com.nimbusds.oauth2.sdk.util.UriUtils;

public class OAuth2Authorization {
    public static void main(String[] args) {
        String authorizationEndpoint = "https://api.example.com/oauth2/v1/authorize";
        ClientID clientID = new ClientID("client_id");
        String redirectURI = "http://localhost:8080/callback";
        String responseType = "code";
        String state = "1234567890";
        String scope = "read write";
        AuthorizationRequest request = new AuthorizationRequest(
                new ClientID(clientID),
                new Scope(scope),
                redirectURI,
                responseType,
                state
        );
        AuthorizationResponse response = AuthorizationResponse
                .successful()
                .setCode(new AuthorizationCode("auth_code"))
                .setRedirectURI(new URI(redirectURI))
                .setState(new State(state))
                .build();
        AuthorizationResponse authorizationResponse = AuthorizationResponse.parse(response);
        AuthorizationSuccessResponse authorizationSuccessResponse = (AuthorizationSuccessResponse) authorizationResponse;
        String authorizationCode = authorizationSuccessResponse.getCode().getValue();
        String tokenEndpoint = "https://api.example.com/oauth2/v1/token";
        TokenRequest tokenRequest = new TokenRequest(
                new ClientID(clientID),
                "client_secret",
                new AuthorizationCode(BearerToken.parse(authorizationCode)),
                new Scope(scope)
        );
        TokenResponse tokenResponse = TokenResponse.parse(
                HTTPResponse.parse(
                        HTTPResponse.POST(
                                new URI(tokenEndpoint),
                                tokenRequest.toHTTPRequest()
                        )
                )
        );
        AccessToken token = tokenResponse.getAccessToken();
        System.out.println("Access Token: " + token.getValue());
    }
}

消息传输与处理

消息传输与处理是即时通讯系统的核心功能之一，涉及到消息的发送、接收、存储和检索等。消息传输通常使用 TCP 或 WebSocket 协议，而消息处理则涉及到消息的解析、格式化和存储等。

以下是一些示例代码，展示了如何使用 Java 实现消息传输与处理：

import java.io.*;
import java.net.Socket;

public class SimpleMessageServer {
    public static void main(String[] args) {
        try {
            ServerSocket serverSocket = new ServerSocket(8080);
            System.out.println("Server started, waiting for connections...");
            Socket clientSocket = serverSocket.accept();
            InputStream in = clientSocket.getInputStream();
            BufferedReader reader = new BufferedReader(new InputStreamReader(in));
            String message = reader.readLine();
            System.out.println("Received: " + message);
            clientSocket.close();
            serverSocket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public class SimpleMessageClient {
    public static void main(String[] args) {
        try {
            Socket socket = new Socket("localhost", 8080);
            OutputStream out = socket.getOutputStream();
            PrintWriter writer = new PrintWriter(out, true);
            writer.println("Hello, server!");
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

编写简单的 Java IM 系统

创建用户列表功能

用户列表功能是指在系统中展示所有在线用户列表，使用户能够查看当前系统中的在线用户。实现这一功能需要以下几个步骤：

1. 用户注册与登录：用户需要注册一个账户并登录系统。
2. 在线状态管理：系统需要跟踪用户的在线状态。
3. 用户列表维护：系统需要维护一个在线用户列表。

以下是一些示例代码，展示了如何使用 Java 实现用户注册和登录功能：

import java.util.HashMap;
import java.util.Map;

public class UserRegistry {
    private Map<String, String> users = new HashMap<>();

    public boolean registerUser(String username, String password) {
        if (users.containsKey(username)) {
            return false;
        }
        users.put(username, password);
        return true;
    }

    public boolean loginUser(String username, String password) {
        String storedPassword = users.get(username);
        return storedPassword != null && storedPassword.equals(password);
    }
}

以下是一些示例代码，展示了如何使用 Java 实现在线状态管理和用户列表维护功能：

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

public class UserStatusManager {
    private Map<String, Boolean> userStatus = new ConcurrentHashMap<>();

    public void setUserOnline(String username, boolean online) {
        userStatus.put(username, online);
    }

    public boolean isUserOnline(String username) {
        return userStatus.getOrDefault(username, false);
    }

    public Map<String, Boolean> getUserStatusMap() {
        return userStatus;
    }
}

实现一对一聊天功能

一对一聊天功能是指两个用户之间进行实时消息传递。实现这一功能需要以下几个步骤：

1. 创建通信连接：建立两个用户之间的通信连接。
2. 消息发送与接收：实现消息的发送与接收功能。
3. 消息存储：将发送的消息存储在数据库中，以便以后查看历史记录。

以下是一些示例代码，展示了如何使用 Java 实现一对一聊天功能：

import java.io.*;
import java.net.Socket;

public class SimpleChatServer {
    public static void main(String[] args) {
        try {
            ServerSocket serverSocket = new ServerSocket(8080);
            System.out.println("Chat server started, waiting for connections...");
            Socket clientSocket = serverSocket.accept();
            InputStream in = clientSocket.getInputStream();
            BufferedReader reader = new BufferedReader(new InputStreamReader(in));
            String message = reader.readLine();
            System.out.println("Received: " + message);
            clientSocket.close();
            serverSocket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public class SimpleChatClient {
    public static void main(String[] args) {
        try {
            Socket socket = new Socket("localhost", 8080);
            OutputStream out = socket.getOutputStream();
            PrintWriter writer = new PrintWriter(out, true);
            writer.println("Hello, server!");
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

添加群聊功能

群聊功能是指一组用户之间进行实时消息传递。实现这一功能需要以下几个步骤：

1. 创建群组：用户可以创建和加入群组。
2. 消息发送与接收：实现群聊消息的发送与接收功能。
3. 群聊管理：管理群组成员和群组信息。

以下是一些示例代码，展示了如何使用 Java 实现群聊功能：

import java.util.*;
import java.io.*;
import java.net.Socket;
import java.util.concurrent.ConcurrentHashMap;

public class GroupChatServer {
    private Map<String, Set<String>> groups = new ConcurrentHashMap<>();
    private Map<String, Set<Socket>> groupMembers = new ConcurrentHashMap<>();

    public void addGroup(String groupName) {
        groups.putIfAbsent(groupName, new HashSet<>());
        groupMembers.putIfAbsent(groupName, new HashSet<>());
    }

    public void addUserToGroup(String groupName, String username, Socket socket) {
        groups.get(groupName).add(username);
        groupMembers.get(groupName).add(socket);
    }

    public void sendMessageToGroup(String groupName, String sender, String message) {
        Set<Socket> members = groupMembers.get(groupName);
        for (Socket member : members) {
            try {
                OutputStream out = member.getOutputStream();
                PrintWriter writer = new PrintWriter(out, true);
                writer.println(sender + ": " + message);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        GroupChatServer server = new GroupChatServer();
        server.addGroup("chatroom");
        server.addUserToGroup("chatroom", "user1", null);
        server.addUserToGroup("chatroom", "user2", null);
        server.sendMessageToGroup("chatroom", "user1", "Hello, user2!");
    }
}

Java IM 系统的优化与扩展

优化消息的实时性

优化消息的实时性可以通过以下几种方式进行：

• 使用 WebSocket：WebSocket 是一种全双工的通信协议，可以在客户端和服务器之间建立持久连接，实现双向实时通信。
• 心跳检测：通过定期发送心跳数据包来检测客户端是否在线，避免连接意外断开。
• 消息压缩：通过压缩消息数据，减少传输时间和带宽消耗。
• 消息优先级：为消息设置优先级，优先处理高优先级的消息。

以下是一些示例代码，展示了如何使用 Java 实现 WebSocket 消息实时传输、心跳检测和消息压缩：

import javax.websocket.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;

@ServerEndpoint("/chat")
public class WebSocketServer {
    private static ConcurrentHashMap<String, Session> clients = new ConcurrentHashMap<>();
    private static CopyOnWriteArrayList<String> messages = new CopyOnWriteArrayList<>();

    @OnOpen
    public void onOpen(Session session) {
        clients.put(session.getId(), session);
        System.out.println("New client connected");
    }

    @OnMessage
    public void onMessage(String message) {
        messages.add(message);
        for (Session client : clients.values()) {
            try {
                client.getAsyncRemote().sendText(message);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    @OnClose
    public void onClose(Session session) {
        clients.remove(session.getId());
        System.out.println("Client disconnected");
    }

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

public class WebSocketClient {
    public static void main(String[] args) {
        try {
            WebSocketContainer container = ContainerProvider.getWebSocketContainer();
            Session session = container.connectToServer(WebSocketClient.class, URI.create("ws://localhost:8080/chat"));
            Scanner scanner = new Scanner(System.in);
            while (scanner.hasNextLine()) {
                String message = scanner.nextLine();
                session.getMessageAsync(message, null);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

提高系统的稳定性与可靠性

提高系统的稳定性与可靠性可以通过以下几种方式进行：

• 错误处理与恢复：实现完善的错误处理机制，确保系统能够从错误中恢复。
• 负载均衡：使用负载均衡技术来分发请求，提高系统的处理能力。
• 数据备份与恢复：定期备份数据，并在系统发生故障时能够快速恢复。
• 高可用架构：采用分布式架构，实现系统的高可用性。

以下是一些示例代码，展示了如何使用 Java 实现简单的错误处理机制：

import java.io.IOException;
import java.net.Socket;

public class ReliableSocketClient {
    public static void main(String[] args) {
        try {
            Socket socket = new Socket("localhost", 8080);
            OutputStream out = socket.getOutputStream();
            PrintWriter writer = new PrintWriter(out, true);
            writer.println("Hello, server!");
            socket.close();
        } catch (IOException e) {
            System.err.println("Error occurred: " + e.getMessage());
            // 添加错误恢复逻辑
        }
    }
}

扩展其他功能（如文件传输）

扩展即时通讯系统的其他功能，如文件传输，可以通过以下方式进行：

• 文件传输协议：使用 FTP、SFTP 或者 HTTP 协议来传输文件。
• 文件分片传输：将大文件拆分成多个小文件进行传输，提高传输效率。
• 文件索引管理：实现文件索引管理，方便用户查找和管理传输的文件。

以下是一些示例代码，展示了如何使用 Java 实现文件传输功能：

import java.io.*;
import java.net.Socket;

public class FileTransferServer {
    public static void main(String[] args) {
        try {
            ServerSocket serverSocket = new ServerSocket(8080);
            Socket clientSocket = serverSocket.accept();
            InputStream in = clientSocket.getInputStream();
            FileOutputStream out = new FileOutputStream("received_file.txt");
            byte[] buffer = new byte[1024];
            int bytesRead;
            while ((bytesRead = in.read(buffer)) != -1) {
                out.write(buffer, 0, bytesRead);
            }
            out.close();
            in.close();
            clientSocket.close();
            serverSocket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public class FileTransferClient {
    public static void main(String[] args) {
        try {
            Socket socket = new Socket("localhost", 8080);
            InputStream in = new FileInputStream("send_file.txt");
            OutputStream out = socket.getOutputStream();
            byte[] buffer = new byte[1024];
            int bytesRead;
            while ((bytesRead = in.read(buffer)) != -1) {
                out.write(buffer, 0, bytesRead);
            }
            in.close();
            out.close();
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

常见问题和解决方案

常见错误及调试方法

在开发 Java IM 系统时，可能会遇到一些常见的错误，如连接失败、消息丢失、资源泄露等。以下是一些常见错误及其调试方法：

• 连接失败：检查服务器地址和端口是否正确，确保服务器已经启动并监听指定端口。
• 消息丢失：检查消息发送和接收逻辑是否正确，确保消息能够正确发送和接收。
• 资源泄露：确保在代码中正确关闭网络连接和文件流，避免资源泄露。

以下是一些示例代码，展示了如何使用 Java 进行调试：

import java.io.IOException;
import java.net.Socket;

public class DebuggableSocketClient {
    public static void main(String[] args) {
        try {
            Socket socket = new Socket("localhost", 8080);
            OutputStream out = socket.getOutputStream();
            PrintWriter writer = new PrintWriter(out, true);
            writer.println("Hello, server!");
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
            // 添加调试信息
        }
    }
}

性能优化技巧

性能优化是提升即时通讯系统性能的重要手段，可以通过以下几种方式进行：

• 减少网络延迟：优化网络架构，减少网络通信延迟。
• 提高并发能力：使用多线程或多进程提高系统并发处理能力。
• 优化数据结构：选择合适的数据结构，提高数据处理效率。
• 代码优化：通过代码优化减少不必要的计算和资源消耗。

以下是一些示例代码，展示了如何使用 Java 进行代码优化：

import java.util.*;

public class OptimizedDataStructure {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        for (int i = 0; i < 100000; i++) {
            list.add("item" + i);
        }
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            list.get(0);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("ArrayList get time: " + (endTime - startTime));

        list = new LinkedList<>();
        for (int i = 0; i < 100000; i++) {
            list.add("item" + i);
        }
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            list.get(0);
        }
        endTime = System.currentTimeMillis();
        System.out.println("LinkedList get time: " + (endTime - startTime));
    }
}

如何安全地运行 IM 系统

安全地运行即时通讯系统需要采取一系列的安全措施，如加密通信、防止 SQL 注入、用户认证和授权等。以下是一些示例代码，展示了如何使用 Java 实现加密通信、防止 SQL 注入、防止 XSS 攻击、防止 CSRF 攻击：

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.util.Base64;

public class SecureCommunication {
    private static final String ALGORITHM = "AES";
    private static final String TRANSFORMATION = "AES/ECB/PKCS5Padding";

    public static void main(String[] args) {
        try {
            String secretKey = "secretkey12345678";
            SecretKeySpec keySpec = new SecretKeySpec(secretKey.getBytes(), ALGORITHM);
            Cipher cipher = Cipher.getInstance(TRANSFORMATION);
            cipher.init(Cipher.ENCRYPT_MODE, keySpec);

            String message = "Hello, server!";
            byte[] encrypted = cipher.doFinal(message.getBytes(StandardCharsets.UTF_8));
            String encoded = Base64.getEncoder().encodeToString(encrypted);
            System.out.println("Encrypted message: " + encoded);

            cipher.init(Cipher.DECRYPT_MODE, keySpec);
            byte[] decoded = Base64.getDecoder().decode(encoded);
            byte[] decrypted = cipher.doFinal(decoded);
            System.out.println("Decrypted message: " + new String(decrypted, StandardCharsets.UTF_8));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

通过以上步骤，可以搭建和优化一个完整的 Java IM 系统，确保其功能完善、性能优越且安全可靠。