1. Python技术站首页
  2. 其他
  3. Java

java局域网聊天小程序

• Java

Java局域网聊天小程序攻略

简介

本攻略介绍如何使用Java编写一个局域网聊天小程序。可以在同一局域网内的多台计算机之间进行聊天。

步骤

1. 创建Java项目

创建一个新的Java项目，命名为“ChatApp”。

2. 添加GUI

在项目中创建一个新的GUI类，命名为“ChatWindow”。在界面中添加一个文本区域用于显示聊天记录，一个文本框用于输入聊天内容，一个按钮用于发送消息。

import javax.swing.*;

public class ChatWindow extends JFrame {
    private JTextArea chatTextArea;
    private JTextField messageTextField;
    private JButton sendButton;

    public ChatWindow() {
        chatTextArea = new JTextArea();
        chatTextArea.setEditable(false);
        JScrollPane scrollPane = new JScrollPane(chatTextArea);

        messageTextField = new JTextField();

        sendButton = new JButton("发送");

        JPanel panel = new JPanel();
        panel.setLayout(new BoxLayout(panel, BoxLayout.PAGE_AXIS));
        panel.add(scrollPane);
        panel.add(messageTextField);
        panel.add(sendButton);

        this.add(panel);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.pack();
        this.setVisible(true);
    }
}

3. 创建服务器

创建一个新的服务器类，命名为“ChatServer”。在服务器中监听来自客户端的连接请求，并使用多线程处理每个客户端的消息。

示例代码如下：

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;

public class ChatServer {
    private ServerSocket serverSocket;
    private List<ClientHandler> clients;

    public ChatServer(int port) throws IOException {
        serverSocket = new ServerSocket(port);
        clients = new ArrayList<>();
        System.out.println("服务器已启动，正在监听端口 " + port + "...");
        while (true) {
            Socket socket = serverSocket.accept();
            System.out.println("接收到来自 " + socket.getInetAddress().getHostAddress() + " 的连接请求");
            ClientHandler client = new ClientHandler(socket, this);
            client.start();
            clients.add(client);
            broadcastMessage("系统消息：欢迎 " + client.getUsername() + " 进入聊天室");
        }
    }

    public void removeClient(ClientHandler client) {
        clients.remove(client);
        broadcastMessage("系统消息：" + client.getUsername() + " 离开聊天室");
    }

    public void broadcastMessage(String message) {
        for (ClientHandler client : clients) {
            client.sendMessage(message);
        }
    }

    public static void main(String[] args) throws IOException {
        new ChatServer(8888);
    }
}

4. 创建客户端

创建一个新的客户端类，命名为“ChatClient”。在客户端中连接到服务器，并使用多线程处理消息的接收和发送。

示例代码如下：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

public class ChatClient {
    private String serverHost;
    private int serverPort;
    private Socket socket;
    private BufferedReader reader;
    private PrintWriter writer;
    private ChatWindow chatWindow;

    public ChatClient(String serverHost, int serverPort) throws IOException {
        this.serverHost = serverHost;
        this.serverPort = serverPort;
        socket = new Socket(serverHost, serverPort);
        reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        writer = new PrintWriter(socket.getOutputStream(), true);
        chatWindow = new ChatWindow();
        chatWindow.setSendButtonActionListener(e -> {
            sendMessage();
        });
        Thread receiveThread = new Thread(() -> {
            try {
                while (true) {
                    String message = reader.readLine();
                    if (message == null) {
                        break;
                    }
                    chatWindow.appendMessage(message);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        });
        receiveThread.start();
    }

    public void sendMessage() {
        String message = chatWindow.getMessage();
        writer.println(message);
        chatWindow.clearMessage();
    }

    public static void main(String[] args) throws IOException {
        String serverHost = "127.0.0.1";
        int serverPort = 8888;
        new ChatClient(serverHost, serverPort);
    }
}

5. 创建消息处理类

创建一个新的消息处理类，命名为“MessageHandler”。在处理消息时，需要判断消息类型，并将不同类型的消息分别处理。

示例代码如下：

public class MessageHandler {
    private String message;
    private ChatServer chatServer;
    private ClientHandler sender;

    public MessageHandler(String message, ChatServer chatServer, ClientHandler sender) {
        this.message = message;
        this.chatServer = chatServer;
        this.sender = sender;
    }

    public void handle() {
        if (message.startsWith("@")) {
            handlePrivateMessage();
        } else {
            handlePublicMessage();
        }
    }

    private void handlePrivateMessage() {
        int index = message.indexOf(" ");
        if (index == -1) {
            sender.sendMessage("系统消息：私聊消息格式不正确");
            return;
        }
        String receiverName = message.substring(1, index);
        String content = message.substring(index + 1);
        for (ClientHandler client : chatServer.getClients()) {
            if (client.getUsername().equals(receiverName)) {
                client.sendMessage(sender.getUsername() + " 对你说：" + content);
                sender.sendMessage("你对 " + client.getUsername() + " 说：" + content);
                return;
            }
        }
        sender.sendMessage("系统消息：找不到用户 " + receiverName);
    }

    private void handlePublicMessage() {
        chatServer.broadcastMessage(sender.getUsername() + " 说：" + message);
    }
}

6. 创建客户端处理类

创建一个新的客户端处理类，命名为“ClientHandler”。在处理消息时，需要将消息发送给服务器进行转发，并处理服务器发送的消息。

示例代码如下：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Random;

public class ClientHandler extends Thread {
    private Socket socket;
    private ChatServer chatServer;
    private BufferedReader reader;
    private PrintWriter writer;
    private String username;

    public ClientHandler(Socket socket, ChatServer chatServer) throws IOException {
        this.socket = socket;
        this.chatServer = chatServer;
        reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        writer = new PrintWriter(socket.getOutputStream(), true);
        username = "Guest" + new Random().nextInt(1000);
        writer.println("系统消息：欢迎你，" + username);
    }

    public String getUsername() {
        return username;
    }

    public void sendMessage(String message) {
        writer.println(message);
    }

    @Override
    public void run() {
        try {
            while (true) {
                String message = reader.readLine();
                if (message == null) {
                    break;
                } else {
                    MessageHandler messageHandler = new MessageHandler(message, chatServer, this);
                    messageHandler.handle();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            chatServer.removeClient(this);
            try {
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

示例说明

示例一

假设局域网内有三台计算机，分别为“A”、“B”、“C”。执行以下步骤：

  1. 在计算机“A”中启动服务器：
    java
    new ChatServer(8888);
  2. 在计算机“B”中启动客户端：
    java
    new ChatClient("A计算机的IP地址", 8888);
  3. 在计算机“C”中启动客户端：
    java
    new ChatClient("A计算机的IP地址", 8888);
  4. 在客户端“B”中输入一个公共消息：
    Hello, world!
  5. 在客户端“C”中可以看到以下聊天记录：
    A用户：系统消息：欢迎Guest123进入聊天室
    B用户：系统消息：欢迎Guest456进入聊天室
    B用户：B 说：Hello, world!
  6. 在客户端“C”中输入一个公共消息：
    Hi!
  7. 在客户端“B”中可以看到以下聊天记录：
    A用户：系统消息：欢迎Guest123进入聊天室
    B用户：系统消息：欢迎Guest456进入聊天室
    B用户：B 说：Hello, world!
    C用户：C 说：Hi!

示例二

假设局域网内有两台计算机，分别为“D”、“E”。执行以下步骤：

  1. 在计算机“D”中启动服务器：
    java
    new ChatServer(8888);
  2. 在计算机“E”中启动客户端：
    java
    new ChatClient("D计算机的IP地址", 8888);
  3. 在客户端“E”中输入一个私人消息，发送给“D”：
    @Guest123 Hi, D!
  4. 在客户端“D”中可以看到以下聊天记录：
    A用户：系统消息：欢迎Guest123进入聊天室
    D用户：Guest123 对你说：Hi, D!
  5. 在客户端“E”中可以看到以下聊天记录：
    D用户：系统消息：欢迎Guest456进入聊天室

本站文章如无特殊说明，均为本站原创，如若转载，请注明出处：java局域网聊天小程序 - Python技术站

赞 (0)
0 0 打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
上一篇 2023年5月23日
下一篇 2023年5月23日

相关文章

  • Java中常用的6种排序算法详细分解

    Java中常用的6种排序算法详细分解 在Java中，常用的排序算法主要有六种：冒泡排序、选择排序、插入排序、希尔排序、归并排序和快速排序。下面将详细讲解这六种算法的原理和实现过程。 冒泡排序 冒泡排序是一种简单的排序算法，它的原理是通过重复地遍历要排序的列表，每遍历一次就把相邻的两个元素比较大小并交换位置。具体实现过程如下： public static vo…

    Java 2023年5月19日
    00

  • 学习SpringMVC——国际化+上传+下载详解

    以下是关于“学习SpringMVC——国际化+上传+下载详解”的完整攻略，其中包含两个示例。 学习SpringMVC——国际化+上传+下载详解 SpringMVC是一种常用的Web开发框架，它提供了许多有用的功能，如国际化、文件上传和下载等。在本文中，我们将讲解如何在SpringMVC中实现国际化、文件上传和下载功能。 国际化 国际化是一种将应用程序适应不同…

    Java 2023年5月17日
    00

  • tomcat部署java web项目遇到的问题及解决方法

    Tomcat部署Java Web项目遇到的问题及解决方法 Tomcat是非常常用的Java Web服务器，但在部署Java Web项目时，也经常会遇到一些问题。本篇攻略将讲解一些可能遇到的问题及解决方法，希望对大家有所帮助。 问题一：Tomcat启动出错，指定端口已被占用 在启动Tomcat时，可能会遇到指定的端口已被占用的情况。这时候，需要找到占用该端口的…

    Java 2023年6月2日
    00

  • SpringBoot 整合mybatis+mybatis-plus的详细步骤

    下面是 “SpringBoot整合MyBatis和MyBatis-Plus的详细步骤”。 1. 添加依赖 首先，在 pom.xml 中添加以下依赖： <!– SpringBoot 整合 MyBatis 依赖 –> <dependency> <groupId>org.mybatis.spring.boot</gro…

    Java 2023年5月20日
    00

  • 深入讲解Java Maven配置

    下面是“深入讲解Java Maven配置”的完整攻略。 一、什么是Maven Apache Maven（简称Maven）是一个Java项目的管理和构建工具。它可以帮助开发人员自动化构建过程，生成具有标准目录结构的项目骨架以及管理项目依赖。使用Maven可以简化项目开发过程，节省时间和人力成本。 二、Maven的配置步骤 2.1 安装Maven 首先需要在官网…

    Java 2023年5月20日
    00

  • java算法之静态内部类实现雪花算法

    下面我来为您详细讲解Java算法之静态内部类实现雪花算法的完整攻略。 什么是雪花算法 雪花算法是分布式系统中生成唯一ID的一种算法，其核心思想是在64位的二进制数中，用前41位作为时间戳，后23位作为机器标识和序列号，从而可以实现在分布式系统中生成唯一ID。 静态内部类实现雪花算法 算法设计思路 定义一个类Snowflake，其构造方法接收两个参数：机器ID…

    Java 2023年5月26日
    00

  • 通过Ajax两种方式讲解Struts2接收数组表单的方法

    接下来我将详细讲解通过Ajax两种方式讲解Struts2接收数组表单的方法的完整攻略。 前置知识 在开始之前，需要对以下几个知识点有所了解： Struts2框架：Struts2是一个基于MVC设计模式的Web框架，用于开发JavaEE应用程序。 Ajax：Ajax是一种基于JavaScript和XML技术的Web开发技术，用于在Web页面上实现异步数据交互。…

    Java 2023年5月26日
    00

  • Tomcat安装shell脚本的方法步骤

    下面是详细讲解Tomcat安装shell脚本的方法步骤： 1. 确定Tomcat版本和安装路径 首先需要确定需要安装的Tomcat版本和安装路径。可以去Tomcat官方网站下载最新的安装包，解压后确定解压后文件夹的路径。 2. 创建安装脚本 在Linux系统中创建一个新的文本文件，扩展名为“.sh”，例如“install_tomcat.sh”。并使用任意文本…

    Java 2023年5月19日
    00
合作推广
合作推广
分享本页
返回顶部