Java聊天室之实现聊天室服务端功能

目录

• 一、题目描述
• 二、解题思路
• 三、代码详解
• 多学一个知识点

一、题目描述

题目实现：实现聊天室服务器端功能。运行程序，服务端等待客户端连接，并显示客户端的连接信息。

二、解题思路

创建一个服务类：ChatServerFrame，继承JFrame类

定义一个Hashtable对象，用于存储登录用户的用户名和套接字对象。

定义createSocket()方法，用于创建服务器套接字对象、获得连接到服务器的客户端套接字对象以及启动线程对象对客户端发送的信息进行处理。

定义内部线程类ServerThread用于对客户端的连接信息以及发送的信息进行处理和转发。

技术重点：

本实例使用Hashtable类来存储连接到服务器的用户名和套接字对象，并使用String类的 startWith()方法判断客户端发送信息的类型，从而实现了向服务器端添加登录用户、发送退出信息、通过服务器转发客户端发送的信息等功能，最终完成了聊天室服务器端程序的开发。

三、代码详解

引入hutool的pom

        <dependency>
			<groupId>cn.hutool</groupId>
			<artifactId>hutool-core</artifactId>
			<version>5.6.5</version>
		</dependency>

ChatServerFrame

package com.xiaoxuzhu;
import cn.hutool.core.io.resource.ResourceUtil;

import java.awt.BorderLayout;
import java.awt.Frame;
import java.awt.Image;
import java.awt.MenuItem;
import java.awt.PopupMenu;
import java.awt.SystemTray;
import java.awt.TrayIcon;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.URL;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Set;
import java.util.Vector;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
/**
 * Description:
 *
 * @author xiaoxuzhu
 * @version 1.0
 *
 * <pre>
 * 修改记录:
 * 修改后版本	        修改人		修改日期			修改内容
 * 2022/6/5.1	    xiaoxuzhu		2022/6/5		    Create
 * </pre>
 * @date 2022/6/5
 */

public class ChatServerFrame extends JFrame {
    private JTextArea ta_info;
    private ServerSocket server; // 声明ServerSocket对象
    private Socket socket; // 声明Socket对象socket
    private Hashtable<String, Socket> map = new Hashtable<String, Socket>();// 用于存储连接到服务器的用户和客户端套接字对象

    public void createSocket() {
        try {
            server = new ServerSocket(9527);// 创建服务器套接字对象
            while (true) {
                ta_info.append("等待新客户连接......\n");
                socket = server.accept();// 获得套接字对象
                ta_info.append("客户端连接成功。" + socket + "\n");
                new ServerThread(socket).start();// 创建并启动线程对象
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    class ServerThread extends Thread {
        Socket socket;
        public ServerThread(Socket socket) {
            this.socket = socket;
        }
        public void run() {
            try {
                ObjectInputStream ins = new ObjectInputStream(socket
                        .getInputStream());
                while (true) {
                    Vector v = null;
                    try {
                        v = (Vector) ins.readObject();
                    } catch (ClassNotFoundException e) {
                        e.printStackTrace();
                    }
                    if (v != null && v.size() > 0) {
                        for (int i = 0; i < v.size(); i++) {
                            String info = (String) v.get(i);// 读取信息
                            String key = "";
                            if (info.startsWith("用户：")) {// 添加登录用户到客户端列表
                                key = info.substring(3, info.length());// 获得用户名并作为键使用
                                map.put(key, socket);// 添加键值对
                                Set<String> set = map.keySet();// 获得集合中所有键的Set视图
                                Iterator<String> keyIt = set.iterator();// 获得所有键的迭代器
                                while (keyIt.hasNext()) {
                                    String receiveKey = keyIt.next();// 获得表示接收信息的键
                                    Socket s = map.get(receiveKey);// 获得与该键对应的套接字对象
                                    PrintWriter out = new PrintWriter(s
                                            .getOutputStream(), true);// 创建输出流对象
                                    Iterator<String> keyIt1 = set.iterator();// 获得所有键的迭代器
                                    while (keyIt1.hasNext()) {
                                        String receiveKey1 = keyIt1.next();// 获得键，用于向客户端添加用户列表
                                        out.println(receiveKey1);// 发送信息
                                        out.flush();// 刷新输出缓冲区
                                    }
                                }
                            } else if (info.startsWith("退出：")) {
                                key = info.substring(3);// 获得退出用户的键
                                map.remove(key);// 添加键值对
                                Set<String> set = map.keySet();// 获得集合中所有键的Set视图
                                Iterator<String> keyIt = set.iterator();// 获得所有键的迭代器
                                while (keyIt.hasNext()) {
                                    String receiveKey = keyIt.next();// 获得表示接收信息的键
                                    Socket s = map.get(receiveKey);// 获得与该键对应的套接字对象
                                    PrintWriter out = new PrintWriter(s
                                            .getOutputStream(), true);// 创建输出流对象
                                    out.println("退出：" + key);// 发送信息
                                    out.flush();// 刷新输出缓冲区
                                }
                            } else {// 转发接收的消息
                                key = info.substring(info.indexOf("：发送给：") + 5,
                                        info.indexOf("：的信息是："));// 获得接收方的key值,即接收方的用户名
                                String sendUser = info.substring(0, info
                                        .indexOf("：发送给："));// 获得发送方的key值,即发送方的用户名
                                Set<String> set = map.keySet();// 获得集合中所有键的Set视图
                                Iterator<String> keyIt = set.iterator();// 获得所有键的迭代器
                                while (keyIt.hasNext()) {
                                    String receiveKey = keyIt.next();// 获得表示接收信息的键
                                    if (key.equals(receiveKey) && !sendUser.equals(receiveKey)) {// 与接受用户相同，但不是发送用户
                                        Socket s = map.get(receiveKey);// 获得与该键对应的套接字对象
                                        PrintWriter out = new PrintWriter(s.getOutputStream(), true);// 创建输出流对象
                                        out.println("MSG:" + info);// 发送信息
                                        out.flush();// 刷新输出缓冲区
                                    }
                                }
                            }
                        }
                    }
                }
            } catch (IOException e) {
                ta_info.append(socket + "已经退出。\n");
            }
        }
    }

    public static void main(String args[]) {
        ChatServerFrame frame = new ChatServerFrame();
        frame.setVisible(true);
        frame.createSocket();
    }

    /**
     * Create the frame
     */
    public ChatServerFrame() {
        super();
        addWindowListener(new WindowAdapter() {
            public void windowIconified(final WindowEvent e) {
                setVisible(false);
            }
        });
        setTitle("聊天室服务器端");
        setBounds(100, 100, 385, 266);

        final JScrollPane scrollPane = new JScrollPane();
        getContentPane().add(scrollPane, BorderLayout.CENTER);

        ta_info = new JTextArea();
        scrollPane.setViewportView(ta_info);

        //托盘
        if (SystemTray.isSupported()){                                      // 判断是否支持系统托盘
            URL url= ResourceUtil.getResource("server.png",null);         // 获取图片所在的URL
            ImageIcon icon = new ImageIcon(url);                            // 实例化图像对象
            Image image=icon.getImage();                                    // 获得Image对象
            TrayIcon trayIcon=new TrayIcon(image);                          // 创建托盘图标
            trayIcon.addMouseListener(new MouseAdapter(){                   // 为托盘添加鼠标适配器
                public void mouseClicked(MouseEvent e){                     // 鼠标事件
                    if (e.getClickCount()==2){                              // 判断是否双击了鼠标
                        showFrame();                                    // 调用方法显示窗体
                    }
                }
            });
            trayIcon.setToolTip("系统托盘");                                    // 添加工具提示文本
            PopupMenu popupMenu=new PopupMenu();                    // 创建弹出菜单
            MenuItem exit=new MenuItem("退出");                           // 创建菜单项
            exit.addActionListener(new ActionListener() {                   // 添加事件监听器
                public void actionPerformed(final ActionEvent arg0) {
                    System.exit(0);                                     // 退出系统
                }
            });
            popupMenu.add(exit);                                        // 为弹出菜单添加菜单项
            trayIcon.setPopupMenu(popupMenu);                           // 为托盘图标加弹出菜弹
            SystemTray systemTray=SystemTray.getSystemTray();           // 获得系统托盘对象
            try{
                systemTray.add(trayIcon);                               // 为系统托盘加托盘图标
            }catch(Exception e){
                e.printStackTrace();
            }
        }
    }
    public void showFrame(){
        this.setVisible(true);                                              // 显示窗体
        this.setState(Frame.NORMAL);
    }
}

服务器启动

系统托盘

多学一个知识点

想把这个项目代码打成Jar包，独立运行，脱离IDEA，可以吗？

按照上一题学到的方式，来试试

1、把项目打成jar包：利用maven 的clean install

会在target目录下生成jar包

2、进入target目录，使用java -cp的命令运行指定的类

java -cp 命令中 cp 指的就是classpath。使用该命令可以运行jar中的某个指定的类(要包含全路径的包名)

进入cmd命令模式

运行服务端

java -cp basics99-1.0-SNAPSHOT.jar com.xiaoxuzhu.ChatServerFrame

看报错了

这是因为项目引用了第三方jar包，maven打jar时，只是打当前的项目的内容，没有把第三方Jar包打进去。

解决方案：

使用maven的插件 maven-assembly-plugin

pom的配置如下，可参考

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.xiaoxuzhu</groupId>
    <artifactId>basics99</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-core</artifactId>
            <version>5.6.5</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <artifactId>maven-assembly-plugin</artifactId>
                <configuration>
                    <archive>
                        <manifest>
                            <!--这里要替换成jar包main方法所在类 -->
                            <mainClass>com.xiaoxuzhu.ChatServerFrame</mainClass>
                        </manifest>
                        <manifestEntries>
                            <Class-Path>.</Class-Path>
                        </manifestEntries>
                    </archive>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                    <appendAssemblyId>false</appendAssemblyId>
                </configuration>
                <executions>
                    <execution>
                        <id>make-assembly</id> <!-- this is used for inheritance merges -->
                        <phase>package</phase> <!-- 指定在打包节点执行jar包合并操作 -->
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

还是使用maven 的clean install，会在target目录下生成jar包

进入target目录，进入CMD命令模式

java -jar basics99-1.0-SNAPSHOT.jar

启动效果：

到此这篇关于Java聊天室之实现聊天室服务端功能的文章就介绍到这了,更多相关Java聊天室内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！