Java编写网络聊天程序实验

本文实例为大家分享了Java编写网络聊天程序的具体代码,供大家参考,具体内容如下

课程名称 高级Java程序设计

实验项目 Java网络编程

实验目的:

使用客户机/服务器模式、基于TCP协议编写一对多“群聊”程序。其中客户机端单击“连接服务器”或“断开连接”按钮,均能即时更新服务器和所有客户机的在线人数和客户名。

实验要求:

设计一对多的网络聊天程序,要求:

1、基于TCP/IP设计聊天程序
2、采用图形界面设计
3、能够进行一对多聊天

项目截图

服务器端代码:

import javax.swing.*;
import javax.swing.border.TitledBorder;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Vector;
 
 
public class Server extends JFrame {
    // TODO 该图形界面拥有三块区域,分别位于上、中、下 (up、middle、down)。
    private JPanel panUp = new JPanel();
    private JPanel panMid = new JPanel();
    private JPanel panDown = new JPanel();
 
    // panUp 区域的子节点定义,标签、输入框、按钮
    private JLabel lblLocalPort = new JLabel("本机服务器监听端口:");
    protected JButton butStart = new JButton("启动服务器");
    protected JTextField tfLocalPort = new JTextField(25);
 
    // panMid 区域的子节点定义,显示框 以及 滚动条
    protected JTextArea taMsg = new JTextArea(25, 25);
    JScrollPane scroll = new JScrollPane(taMsg);
 
    // panDown 区域的子节点定义,lstUsers在线用户界面
    JList lstUsers = new JList();
 
    // TODO 以下是存放数据的变量
    public static int localPort = 8000;     // 默认端口 8000
    static int SerialNum = 0;       // 用户连接数量
    ServerSocket serverSocket;      // 服务器端 Socket
    ArrayList<AcceptRunnable.Client> clients = new ArrayList<>();        // 用户连接对象数组
    Vector<String> clientNames = new Vector<>();       // lstUsers 中存放的数据
 
    // TODO 构造方法
    public Server() {
        init();
    }
 
    // TODO 初始化方法:初始化图形界面布局
    private void init() {
        // panUp 区域初始化:流式区域
        panUp.setLayout(new FlowLayout());
        panUp.add(lblLocalPort);
        panUp.add(tfLocalPort);
        panUp.add(butStart);
        tfLocalPort.setText(String.valueOf(localPort));
        butStart.addActionListener(new startServerHandler());   // 注册 "启动服务器" 按钮点击事件
 
        // panMid 区域初始化
        panMid.setBorder(new TitledBorder("监听消息"));
        taMsg.setEditable(false);
        panMid.add(scroll);
 
        // panDown 区域初始化
        panDown.setBorder(new TitledBorder("在线用户"));
        panDown.add(lstUsers);
        lstUsers.setVisibleRowCount(10);
 
        // 图形界面的总体初始化 + 启动图形界面
        this.setTitle("服务器端");
        this.add(panUp, BorderLayout.NORTH);
        this.add(panMid, BorderLayout.CENTER);
        this.add(panDown, BorderLayout.SOUTH);
        this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        this.setPreferredSize(new Dimension(600, 400));
        this.pack();
        this.setVisible(true);
    }
 
    // TODO “启动服务器”按钮的动作事件监听处理类
    private class startServerHandler implements ActionListener {
        @Override
        public void actionPerformed(ActionEvent e) {
            try {
                // 当点击按钮时,获取端口设置并启动新进程、监听端口
                localPort = Integer.parseInt(tfLocalPort.getText());
                serverSocket = new ServerSocket(localPort);
                Thread acptThrd = new Thread(new AcceptRunnable());
                acptThrd.start();
                taMsg.append("**** 服务器(端口" + localPort + ")已启动 ****\n");
            } catch (Exception ex) {
                System.out.println(ex);
            }
        }
    }
 
    // TODO 接受用户连接请求的线程关联类
    private class AcceptRunnable implements Runnable {
        public void run() {
            // 持续监听端口,当有新用户连接时 再开启新进程
            while (true) {
                try {
                    Socket socket = serverSocket.accept();
                    // 新的用户已连接,创建 Client 对象
                    Client client = new Client(socket);
                    taMsg.append("——客户【" + client.nickname + "】加入\n");
                    Thread clientThread = new Thread(client);
                    clientThread.start();
                    clients.add(client);
                } catch (Exception ex) {
                    System.out.println(ex);
                }
            }
        }
 
        // TODO 服务器存放用户对象的客户类(主要编程)。每当有新的用户连接时,该类都会被调用
        // TODO 该类继承自 Runnable,内部含有 run()方法
        private class Client implements Runnable {
            private Socket socket;      // 用来保存用户的连接对象
            private BufferedReader in;   // IO 流
            private PrintStream out;
            private String nickname;        // 保存用户昵称
 
            // Client类的构建方法。当有 新用户 连接时会被调用
            public Client(Socket socket) throws Exception {
                this.socket = socket;
                InputStream is = socket.getInputStream();
                in = new BufferedReader(new InputStreamReader(is));
                OutputStream os = socket.getOutputStream();
                out = new PrintStream(os);
                nickname = in.readLine();     // 获取用户昵称
                for (Client c : clients) {   // 将新用户的登录消息发给所有用户
                    c.out.println("——客户【" + nickname + "】加入\n");
                }
            }
 
            //客户类线程运行方法   
            public void run() {
                try {
                    while (true) {
                        String usermsg   = in.readLine();   //读用户发来消息
                        String secondMsg = usermsg.substring(usermsg.lastIndexOf(":") + 1);   // 字符串辅助对象
 
                        // 如果用户发过来的消息不为空
                        if (usermsg != null && usermsg.length() > 0) {
                            // 如果消息是 bye,则断开与此用户的连接 并 告知所有用户当前信息,跳出循环终止当前进程
                            if (secondMsg.equals("bye")) {
                                clients.remove(this);
                                for (Client c : clients) {
                                    c.out.println(usermsg);
                                }
                                taMsg.append("——客户离开:" + nickname + "\n");
                                // 更新在线用户数量 lstUsers的界面信息
                                updateUsers();
                                break; 
                            }
 
                            /**
                             * 每当有新用户连接时,服务器就会接收到 USERS 请求
                             * 当服务器接收到此请求时,就会要求现在所有用户更新 在线用户数量 的列表
                             * */
                            if (usermsg.equals("USERS")) {
                                updateUsers();
                                continue;
                            }
 
                            // 当用户发出的消息都不是以上两者时,消息才会被正常发送
                            for (Client c : clients) {
                                c.out.println(usermsg);
                            }
 
                        }
                    }
                    socket.close();
                } catch (Exception ex) {
                    System.out.println(ex);
                }
            }
 
            // TODO 更新在线用户数量 lstUsers 信息,并要求所有的用户端同步更新
            public void updateUsers() {
                // clientNames 是 Vector<String>对象,用来存放所有用户的名字
                clientNames.removeAllElements();
                StringBuffer allname = new StringBuffer();
                for (AcceptRunnable.Client client : clients) {
                    clientNames.add(0, client.nickname);
                    allname.insert(0, "|" + client.nickname);
                }
                panDown.setBorder(new TitledBorder("在线用户(" +clientNames.size() + "个)"));
                // 要求所有的用户端同步更新
                for (Client c : clients) {
                    c.out.println(clientNames);
                }
                lstUsers.setListData(clientNames);
            }
        }
    }
 
    // TODO 主方法
    public static void main(String[] args) {
        new Server();
    }
}

客户端代码:

import javax.swing.*;
import javax.swing.border.TitledBorder;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.Socket;
import java.util.Vector;
 
 
public class Client extends JFrame {      //客户机窗体类
    // TODO 该图形界面拥有四块区域,分别位于上、左、中、下 (up、Left、middle、down)。
    private JPanel panUp = new JPanel();
    private JPanel panLeft = new JPanel();
    private JPanel panMid = new JPanel();
    private JPanel panDown = new JPanel();
 
    // panUp 区域的子节点定义,3个标签、3个输入框、2个按钮
    private JLabel lblLocalPort1 = new JLabel("服务器IP: ");
    private JLabel lblLocalPort2 = new JLabel("端口: ");
    private JLabel lblLocalPort3 = new JLabel("本人昵称: ");
    protected JTextField tfLocalPort1 = new JTextField(15);
    protected JTextField tfLocalPort2 = new JTextField(5);
    protected JTextField tfLocalPort3 = new JTextField(5);
    protected JButton butStart = new JButton("连接服务器");
    protected JButton butStop = new JButton("断开服务器");
    // TODO
 
    // panLeft 区域的子节点定义,显示框、滚动条
    protected JTextArea taMsg = new JTextArea(25, 25);
    JScrollPane scroll = new JScrollPane(taMsg);
 
    // panMid 区域的子节点定义,lstUsers在线用户界面
    JList lstUsers = new JList();
 
    // panDown 区域的子节点定义,标签,输入框
    private JLabel lblLocalPort4 = new JLabel("消息(按回车发送): ");
    protected JTextField tfLocalPort4 = new JTextField(20);
    /**
     * ===== 变量分割 =====
     * 上面是图形界面变量,下面是存放数据的变量
     */
    BufferedReader in;
    PrintStream out;
    public static int localPort = 8000;     // 默认端口
    public static String localIP = "127.0.0.1";     // 默认服务器IP地址
    public static String nickname = "Cat";      // 默认用户名
    public Socket socket;
    public static String msg;       // 存放本次发送的消息
    Vector<String> clientNames = new Vector<>();
 
    // TODO 构造方法
    public Client() {
        init();
    }
 
    // TODO 初始化方法:初始化图形界面
    private void init() {
        // panUp 区域初始化:流式面板,3个标签、3个输入框,2个按钮
        panUp.setLayout(new FlowLayout());
        panUp.add(lblLocalPort1);
        panUp.add(tfLocalPort1);
        panUp.add(lblLocalPort2);
        panUp.add(tfLocalPort2);
        panUp.add(lblLocalPort3);
        panUp.add(tfLocalPort3);
        tfLocalPort1.setText(localIP);
        tfLocalPort2.setText(String.valueOf(localPort));
        tfLocalPort3.setText(nickname);
        panUp.add(butStart);
        panUp.add(butStop);
        butStart.addActionListener(new linkServerHandlerStart());
        butStop.addActionListener(new linkServerHandlerStop());
        butStop.setEnabled(false);      // 断开服务器按钮的初始状态应该为 不可点击,只有连接服务器之后才能点击
 
        // 添加 Left
        taMsg.setEditable(false);
        panLeft.add(scroll);
        panLeft.setBorder(new TitledBorder("聊天——消息区"));
        scroll.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
        scroll.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
 
        // 添加 Middle
        panMid.setBorder(new TitledBorder("在线用户"));
        panMid.add(lstUsers);
        lstUsers.setVisibleRowCount(20);
 
        // 添加 Down
        // TODO 此处注意:JTextField输入框 的回车事件默认存在,无需添加
        panDown.setLayout(new FlowLayout());
        panDown.add(lblLocalPort4);
        panDown.add(tfLocalPort4);
        tfLocalPort4.addActionListener(new Client.SendHandler());
 
        // 图形界面的总体初始化 + 启动图形界面
        this.setTitle("客户端");
        this.add(panUp, BorderLayout.NORTH);
        this.add(panLeft, BorderLayout.WEST);
        this.add(panMid, BorderLayout.CENTER);
        this.add(panDown, BorderLayout.SOUTH);
        this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        this.addWindowListener(new WindowHandler());
        this.setPreferredSize(new Dimension(800, 600));
        this.pack();
        this.setVisible(true);
    }
 
    // TODO “连接服务器”按钮的动作事件监听处理类:
    private class linkServerHandlerStart implements ActionListener {
        @Override
        public void actionPerformed(ActionEvent e) {
            // 当点击"连接服务器"按钮之后,该按钮被禁用(不可重复点击)。同时"断开服务器按钮"被恢复使用
            butStart.setEnabled(false);
            butStop.setEnabled(true);
            localIP = tfLocalPort1.getText();
            localPort = Integer.parseInt(tfLocalPort2.getText());
            nickname = tfLocalPort3.getText();
            linkServer();   // 连接服务器
            Thread acceptThread = new Thread(new Client.ReceiveRunnable());
            acceptThread.start();
        }
    }
 
    // TODO “断开服务器”按钮的动作事件监听处理类
    private class linkServerHandlerStop implements ActionListener {
        /**
         * 当点击该按钮之后,断开服务器连接、清空图形界面所有数据
         */
        @Override
        public void actionPerformed(ActionEvent e) {
            taMsg.setText("");
            clientNames = new Vector<>();
            updateUsers();
            out.println("——客户【" + nickname + "】离开:bye\n");
            butStart.setEnabled(true);
            butStop.setEnabled(false);
        }
    }
 
    // TODO 连接服务器的方法
    public void linkServer() {
        try {
            socket = new Socket(localIP, localPort);
        } catch (Exception ex) {
            taMsg.append("==== 连接服务器失败~ ====");
        }
    }
 
    // TODO 接收服务器消息的线程关联类
    private class ReceiveRunnable implements Runnable {
        public void run() {
            try {
                in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                out = new PrintStream(socket.getOutputStream());
                out.println(nickname);      // 当用户首次连接服务器时,应该向服务器发送自己的用户名、方便服务器区分
                taMsg.append("——本人【" + nickname + "】成功连接到服务器......\n");
                out.println("USERS");       // 向服务器发送"神秘代码",请求 当前在线用户 列表
                while (true) {
                    msg = in.readLine();       // 读取服务器端的发送的数据
                    // 此 if 语句的作用是:过滤服务器发送过来的 更新当前在线用户列表 请求
                    if (msg.matches(".*\\[.*\\].*")) {
                        clientNames.removeAllElements();
                        String[] split = msg.split(",");
                        for (String single : split) {
                            clientNames.add(single);
                        }
                        updateUsers();
                        continue;
                    }
 
                    // 更新 "聊天——消息区" 信息
                    taMsg.append(msg + "\n");
 
                    // 此 if 语句作用:与服务器进行握手确认消息。
                    // 当接收到服务器端发送的确认离开请求bye 的时候,用户真正离线
                    msg = msg.substring(msg.lastIndexOf(":") + 1);
                    if (msg.equals(nickname)) {
                        socket.close();
                        clientNames.remove(nickname);
                        updateUsers();
                        break;       // 终止线程
                    }
                }
            } catch (Exception e) {
            }
        }
    }
 
    // TODO "发送消息文本框" 的动作事件监听处理类
    private class SendHandler implements ActionListener {
        @Override
        public void actionPerformed(ActionEvent e) {
            out.println("【" + nickname + "】:" + tfLocalPort4.getText());
            tfLocalPort4.setText("");       // 当按下回车发送消息之后,输入框应该被清空
        }
    }
 
    // TODO 窗口关闭的动作事件监听处理类
    // 当用户点击 "x" 离开窗口时,也会向服务器发送 bye 请求,目的是为了同步更新数据。
    private class WindowHandler extends WindowAdapter {
        @Override
        public void windowClosing(WindowEvent e) {
            cutServer();
        }
    }
 
    private void cutServer() {
        out.println("——客户【" + nickname + "】离开:bye");
    }
 
    // TODO 更新 "在线用户列表" 的方法
    public void updateUsers() {
        panMid.setBorder(new TitledBorder("在线用户(" + clientNames.size() + "个)"));
        lstUsers.setListData(clientNames);
    }
 
    // TODO 主方法
    public static void main(String[] args) {
        new Client();
    }
}

如何同时开启两个客户端进行聊天?

将上述的 Client 类复制一份,改名为 Client2 ,然后同时启动 Client 和 Client2 程序。

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

时间: 2022-08-09

基于Java的Socket多客户端Client-Server聊天程序的实现

任务要求 编写一个简单的Socket多客户端聊天程序: 客户端程序,从控制台输入字符串,发送到服务器端,并将服务器返回的信息显示出来 服务器端程序,从客户机接收数据并打印,同时将从标准输入获取的信息发送给客户机 满足一个服务器可以服务多个客户 低配版本链接 实现代码 工具类 import java.io.DataOutputStream; import java.io.IOException; import java.io.OutputStream; import java.net.Socket

java中UDP简单聊天程序实例代码

学过计算机网络通信的都知道,计算机之间传送数据由两种,即TCP通信和UDP通信.TCP是可靠的面向连接的通信协议,二UDP是不可靠的面向无连接的通信协议. java中有基于TCP的网络套接字通信,也有基于UDP的用户数据报通信,UDP的信息传输速度快,但不可靠! 基于UDP通信的基本模式: (1)将数据打包,称为数据包(好比将信件装入信封一样),然后将数据包发往目的地. (2)接受别人发来的数据包(好比接收信封一样),然后查看数据包中的内容. 客户机 复制代码 代码如下: package com

java基于C/S模式实现聊天程序(客户端)

经过这几天对java的学习,用java做了这个计算机网络的课程设计,基于C/S模式的简单聊天程序,此篇文章介绍一些客户端的一些东西. 先讲一讲此聊天程序的基本原理,客户端发送消息至服务器,服务器收到消息之后将其转发给连接服务器的所有客户端,来自客户端的消息中包含发件人的名字. 客户端的主要功能是发送消息和接收消息,客户端设置好了端口和服务器地址,并创立客户端自己的套接字,用作和服务器通信的一个标识.布局就不多说了,主要说说监视器和两个重要的线程:发送和接收. 监视器中,登录按钮触发的功能是设置用

java基于TCP协议实现聊天程序

JAVA程序设计之基于TCP协议的socket聊天程序 ,供大家参考,具体内容如下 一.程序实现的功能 1.进入客户端界面 2.创建昵称 3.群发信息 4.@私聊 5.下线通知 6.在线人数统计 二.整体架构图 三.简单介绍 本程序实现了基于TCP通信的聊天程序: 1 服务器端: 服务器端继承JFrame框架,添加组件.创建服务器端的socket,起一个线程池,每接收到一个客户端的连接,分配给其一个线程处理与客户端的通信,将每个客户端的昵称和服务器分配给其的输出流存储到哈希表中.通过检索哈希表中

java网络编程学习java聊天程序代码分享

复制代码 代码如下: package com.neusoft.edu.socket;import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;import java.io.PrintWriter;import java.net.ServerSocket;import java.net.Socket;/** * 服务器端代码 * 获取客户端发送的信息,显示并且返回对应的回复 *

详解基于java的Socket聊天程序——服务端(附demo)

写在前面: 昨天在博客记录自己抽空写的一个Socket聊天程序的初始设计,那是这个程序的整体设计,为了完整性,今天把服务端的设计细化记录一下,首页贴出Socket聊天程序的服务端大体设计图,如下图: 功能说明: 服务端主要有两个操作,一是阻塞接收客户端的socket并做响应处理,二是检测客户端的心跳,如果客户端一段时间内没有发送心跳则移除该客户端,由Server创建ServerSocket,然后启动两个线程池去处理这两件事(newFixedThreadPool,newScheduledThrea

详解基于java的Socket聊天程序——初始设计(附demo)

写在前面: 可能是临近期末了,各种课程设计接踵而来,最近在csdn上看到2个一样问答,那就是编写一个基于socket的聊天程序,正好最近刚用socket做了一些事,出于兴趣,自己抽了几个晚上的空闲时间敲了一个,目前仅支持单聊,群聊,文件传送这些功能.首先,贴出一个丑丑的程序图(UI是用java swing写的,这个早就忘光了,无奈看着JDK的API写了一个),如下图:  服务端设计: 服务端主要有两个操作,一是阻塞接收客户端的socket并做响应处理,二是检测客户端的心跳,如果客户端一段时间内没

java实现简单TCP聊天程序

本文实例为大家分享了java实现TCP聊天程序的具体代码,供大家参考,具体内容如下 服务端代码: package com.test.server; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.IOException; import java.net.ServerSocket; import java.net.Socket; public class Server { public

详解基于java的Socket聊天程序——客户端(附demo)

写在前面: 上周末抽点时间把自己写的一个简单Socket聊天程序的初始设计和服务端细化设计记录了一下,周二终于等来毕业前考的软考证书,然后接下来就是在加班的日子度过了,今天正好周五,打算把客户端的详细设计和Common模块记录一下,因为这个周末开始就要去忙其他东西了. 设计: 客户端设计主要分成两个部分,分别是socket通讯模块设计和UI相关设计. 客户端socket通讯设计: 这里的设计其实跟服务端的设计差不多,不同的是服务端是接收心跳包,而客户端是发送心跳包,由于客户端只与一个服务端进行通

java实现基于Tcp的socket聊天程序

对于步入编程行业不深的初学者或是已经有所领会的人来说,当学习一项新的技术的时候,非常渴望有一个附上注释完整的Demo.本人深有体会,网上的例子多到是很多,但是很杂不完整,写代码这种东西来不得半点马虎,要是错了一点,那也是运行不了的.这对于初学者来说更加的头疼,因为他根本不知道错在哪里,盲目的改只能错上加错.最后不得不去找找看看有没有能够直接运行的例子再加以模仿. 下面是博主在学习Java的socket时写的一个完整的例子,并且带上了完整的注释.它是一个简单的聊天程序,但是它可以设置任意多用户同时

JAVA实现基于Tcp协议的简单Socket通信实例

好久没写博客了,前段时间忙于做项目,耽误了些时间,今天开始继续写起~ 今天来讲下关于Socket通信的简单应用,关于什么是Socket以及一些网络编程的基础,这里就不提了,只记录最简单易懂实用的东西.  1.首先先来看下基于TCP协议Socket服务端和客户端的通信模型: Socket通信步骤:(简单分为4步) 1.建立服务端ServerSocket和客户端Socket 2.打开连接到Socket的输出输入流 3.按照协议进行读写操作 4.关闭相对应的资源 2.相关联的API: 1.首先先来看下

Java基于Tcp的基础聊天功能实例

本文实例讲述了Java基于Tcp的基础聊天功能.分享给大家供大家参考,具体如下: 最基础的聊天,用户端和服务器端每次说一句,而且严格规定了先后到顺序. 服务器端: import java.io.*; import java.net.*; public class ChatServer { public static void main(String[] args) { ServerSocket server = null; try { server = new ServerSocket(1213

Java实现基于TCP的通讯程序实例解析

Java中的TCP通信程序 TCP可以实现两台计算机之间的数据交互通信的两端,要严格区分客户端与服务端 两端通信时的步骤: 1.服务端程序,需要事先启动,等待客户端连接 2.客户端主动连接服务器端,才能成功通信,服务器端不可以主动链接客户端 在java中两个类用于实现TCP通信程序: 客户端: java.net.Socket 类表示.创建 Socket 对象,向服务端发出连接请求,服务端响应请求,两者建 立连接开始通信. 服务端: java.net.ServerSocket 类表示.创建 Ser

Python基于TCP实现会聊天的小机器人功能示例

本文实例讲述了Python基于TCP实现会聊天的小机器人功能.分享给大家供大家参考,具体如下: 一 代码 1.服务端程序 import socket words ={'how are you?':'Fine,thank you.', 'how old are you?':'38', 'what is your name?':'Dong FuGuo', "what's your name?":'Dong FuGuo', 'where do you work?':'SDIBT', 'bye

基于python3的socket聊天编程

本文实例为大家分享了基于python3的socket聊天编程,供大家参考,具体内容如下 阶段一:最简易的聊天系统 缺点:程序不够完善,只能一来一回,且没人每次只能说一句话 server端: import socket HostPort = ('127.0.0.1',9999) s = socket.socket(socket.AF_INET,socket.SOCK_STREAM) s.bind(HostPort) s.listen(1) conn,addr = s.accept() #print