多用户在线交流系统（Java）

最新推荐文章于 2024-12-20 09:06:01 发布

富江！

最新推荐文章于 2024-12-20 09:06:01 发布

阅读量1.2k

点赞数 27

文章标签： java 开发语言

本文链接：https://blog.youkuaiyun.com/qq_45014958/article/details/134984001

版权

多用户在线交流系统

客户端

在这里插入图片描述

服务器端

在这里插入图片描述

本项目是在韩顺平java学习基础的指导下完成的，视频连接：韩顺平Java基础
该项目主要包括以下两个端口：Client、Server。
该项目主要包括：多线程技术、面向对象编程技术、IO流技术、网络编程。

主要功能

显示在线登录用户列表

在这里插入图片描述

私聊

客户端1
在这里插入图片描述
客户端2

服务器端

在这里插入图片描述

群发消息

客户端1
在这里插入图片描述
客户端2

客户端3
在这里插入图片描述

服务器端
在这里插入图片描述

发送文件

客户端1
在这里插入图片描述
客户端2

结果：

客户端：

在这里插入图片描述

推送消息

服务器端
在这里插入图片描述
客户端1

客户端2
在这里插入图片描述

客户端3
在这里插入图片描述

退出系统

在这里插入图片描述

1、Client端

qqcommon包

Message

package com.hspedu.qqcommon;

import java.io.Serializable;

/**
 * 表示客户端和服务端通信时的消息对象
 * */
public class Message implements Serializable {
    private static final long serialVersionUID = 1L;
    private String sender;
    private String getter;
    private String content;
    private String sendTime;
    private String mesType;
    private byte[] fileBytes;
    private int fileLength = 0;
    private String dest;//文件传输的目的地
    private String src;//源文件路径

    public byte[] getFileBytes() {
        return fileBytes;
    }

    public void setFileBytes(byte[] fileBytes) {
        this.fileBytes = fileBytes;
    }

    public int getFileLength() {
        return fileLength;
    }

    public void setFileLength(int fileLength) {
        this.fileLength = fileLength;
    }

    public String getDest() {
        return dest;
    }

    public void setDest(String dest) {
        this.dest = dest;
    }

    public String getSrc() {
        return src;
    }

    public void setSrc(String src) {
        this.src = src;
    }

    public String getSender() {
        return sender;
    }

    public void setSender(String sender) {
        this.sender = sender;
    }

    public String getGetter() {
        return getter;
    }

    public void setGetter(String getter) {
        this.getter = getter;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public String getSendTime() {
        return sendTime;
    }

    public void setSendTime(String sendTime) {
        this.sendTime = sendTime;
    }

    public String getMesType() {
        return mesType;
    }

    public void setMesType(String mesType) {
        this.mesType = mesType;
    }
}

MessageType

package com.hspedu.qqcommon;
/***
 * 表示消息类型
 */
public interface MessageType {
    String MESSAGE_LOGINF_SUCCEED = "1";
    String MESSAGE_LOGINF_Fail = "2";
    String MESSAGE_COMM_MES = "3";//普通信息包
    String MESSAGE_GET_ONLINE_FRIEND = "4";//要求返回在线用户列表
    String MESSAGE_RETURN_ONLINE_FRIEND = "5";//返回在线用户列表
    String MESSAGE_CLIENT_EXIT= "6";//客户端请求退出
    String MESSAGE_TO_ALL_MES= "7";//群发消息
    String MESSAGE_File_MES= "8";//文件消息发送

}

User

package com.hspedu.qqcommon;

import java.io.Serializable;
//使用对象流需要进行序列化
public class User implements Serializable {
    private static final long serialVersionUID = 1L;
    private String userId;
    private String passwd;
    public User(){}
    public User(String userId, String passwd) {
        this.userId = userId;
        this.passwd = passwd;
    }

    public String getUserId() {
        return userId;
    }

    public void setUserId(String userId) {
        this.userId = userId;
    }

    public String getPasswd() {
        return passwd;
    }

    public void setPasswd(String passwd) {
        this.passwd = passwd;
    }
}

qqcilen.View包

QQView

package com.hspedu.qqcilen.view;

import com.hspedu.qqcilen.service.MessageClientService;
import com.hspedu.qqcilen.service.UserClientService;
import com.hspedu.qqcilen.service.fileClientService;

import java.util.Scanner;

public class QQView {
    private boolean loop = true;//控制是否显示菜单
    private String key = "";//接收用户的输入系统
    private UserClientService userClientService = new UserClientService();//用于登录服务器和登录用户
    private MessageClientService messageClientService = new MessageClientService();//用于消息用户私聊群聊
    private fileClientService  fileClientService1 = new fileClientService();//该对象用于传输文件
    public static void main(String[] args) {
        new QQView().mainMenu();
        System.out.println("客户端退出系统");
    }
    private void mainMenu(){
        while (loop){
            System.out.println("=======欢迎登录网络通讯系统=======");
            System.out.println("\t\t 1 登录系统");
            System.out.println("\t\t 9 退出系统");
            System.out.println("请输入你的选择：");
            key = Utility.readString(1);
            switch (Integer.parseInt(key)){
                case 1:
                    System.out.println("请输入用户号");
                    String userId = Utility.readString(50);
                    System.out.println("请输入密 码");
                    String passwd = Utility.readString(20);
                    //需要到服务器端验证该用户是否合法
                    if (userClientService.checkUser(userId,passwd)){
                        System.out.println("=======欢迎(用户"+userId+")=======" );
//                        进入二级菜单
                        while (loop){
                            System.out.println("\n=======网络通信系统二级菜单(用户"+userId+")=====");
                            System.out.println("\t\t 1 显示在线用户列表");
                            System.out.println("\t\t 2 群发消息");
                            System.out.println("\t\t 3 私聊消息");
                            System.out.println("\t\t 4 发送文件");
                            System.out.println("\t\t 9 退出系统");
                            System.out.println("请输入你的选择：");
                            key = Utility.readString(1);
                            switch (key){
                                case "1":
                                    System.out.println("显示在线用户列表");
                                    userClientService.onlineFriendList();
                                    break;
                                case "2":
//                                    System.out.println("群发消息");
                                    System.out.println("请输入你想对大家说的话：");
                                    String content1 = Utility.readString(1000);
//                                    调用一个方法将消息封装到message中，发送给服务端
                                    messageClientService.sendMessageToAll(content1,userId);
                                    break;
                                case "3":
                                    System.out.print("请输入你想私聊的用户(在线)：");
                                    String getId = Utility.readString(50);
                                    System.out.println("请输入想说的话：");
                                    String content = Utility.readString(1000);
//编写一个方法，将消息发送给服务器
                                    messageClientService.sendOneMessage(content,userId,getId);
//                                    System.out.println("私聊消息");
                                    break;

                                case "4":
                                    System.out.print("请输入你想发送文件的用户(在线)：");
                                    String getId1 = Utility.readString(50);
                                    System.out.println("请输入发送的文件完整路径(形式d:\\xxx.jpg)");
                                    String src = Utility.readString(1000);
                                    System.out.println("" +
                                            "请输入发送到对方的路径(形式d:\\xxx.jpg)");
                                    String dest = Utility.readString(1000);
                                    fileClientService1.sendFileToOne(src,dest,userId,getId1);
//                                    System.out.println("发送文件");
                                    break;

                                case "9":
                                    userClientService.logout();
                                    loop = false;
                            }
                        }
                    }else {
                        System.out.println("=======登录失败=====");

                    }
                    break;
                case 9:
                    loop = false;
                    break;
            }
        }

    }

}

Utility

package com.hspedu.qqcilen.view;
/**
 工具类的作用:
 处理各种情况的用户输入，并且能够按照程序员的需求，得到用户的控制台输入。
 */

import java.util.*;
/**


 */
public class Utility {
    //静态属性。。。
    private static Scanner scanner = new Scanner(System.in);


    /**
     * 功能：读取键盘输入的一个菜单选项，值：1——5的范围
     * @return 1——5
     */
    public static char readMenuSelection() {
        char c;
        for (; ; ) {
            String str = readKeyBoard(1, false);//包含一个字符的字符串
            c = str.charAt(0);//将字符串转换成字符char类型
            if (c != '1' && c != '2' &&
                    c != '3' && c != '4' && c != '5') {
                System.out.print("选择错误，请重新输入：");
            } else break;
        }
        return c;
    }

    /**
     * 功能：读取键盘输入的一个字符
     * @return 一个字符
     */
    public static char readChar() {
        String str = readKeyBoard(1, false);//就是一个字符
        return str.charAt(0);
    }
    /**
     * 功能：读取键盘输入的一个字符，如果直接按回车，则返回指定的默认值；否则返回输入的那个字符
     * @param defaultValue 指定的默认值
     * @return 默认值或输入的字符
     */

    public static char readChar(char defaultValue) {
        String str = readKeyBoard(1, true);//要么是空字符串，要么是一个字符
        return (str.length() == 0) ? defaultValue : str.charAt(0);
    }

    /**
     * 功能：读取键盘输入的整型，长度小于2位
     * @return 整数
     */
    public static int readInt() {
        int n;
        for (; ; ) {
            String str = readKeyBoard(10, false);//一个整数，长度<=10位
            try {
                n = Integer.parseInt(str);//将字符串转换成整数
                break;
            } catch (NumberFormatException e) {
                System.out.print("数字输入错误，请重新输入：");
            }
        }
        return n;
    }
    /**
     * 功能：读取键盘输入的 整数或默认值，如果直接回车，则返回默认值，否则返回输入的整数
     * @param defaultValue 指定的默认值
     * @return 整数或默认值
     */
    public static int readInt(int defaultValue) {
        int n;
        for (; ; ) {
            String str = readKeyBoard(10, true);
            if (str.equals("")) {
                return defaultValue;
            }

            //异常处理...
            try {
                n = Integer.parseInt(str);
                break;
            } catch (NumberFormatException e) {
                System.out.print("数字输入错误，请重新输入：");
            }
        }
        return n;
    }

    /**
     * 功能：读取键盘输入的指定长度的字符串
     * @param limit 限制的长度
     * @return 指定长度的字符串
     */

    public static String readString(int limit) {
        return readKeyBoard(limit, false);
    }

    /**
     * 功能：读取键盘输入的指定长度的字符串或默认值，如果直接回车，返回默认值，否则返回字符串
     * @param limit 限制的长度
     * @param defaultValue 指定的默认值
     * @return 指定长度的字符串
     */

    public static String readString(int limit, String defaultValue) {
        String str = readKeyBoard(limit, true);
        return str.equals("")? defaultValue : str;
    }


    /**
     * 功能：读取键盘输入的确认选项，Y或N
     * 将小的功能，封装到一个方法中.
     * @return Y或N
     */
    public static char readConfirmSelection() {
        System.out.println("请输入你的选择(Y/N): 请小心选择");
        char c;
        for (; ; ) {//无限循环
            //在这里，将接受到字符，转成了大写字母
            //y => Y n=>N
            String str = readKeyBoard(1, false).toUpperCase();
            c = str.charAt(0);
            if (c == 'Y' || c == 'N') {
                break;
            } else {
                System.out.print("选择错误，请重新输入：");
            }
        }
        return c;
    }

    /**
     * 功能： 读取一个字符串
     * @param limit 读取的长度
     * @param blankReturn 如果为true ,表示 可以读空字符串。
     * 					  如果为false表示 不能读空字符串。
     *
     *	如果输入为空，或者输入大于limit的长度，就会提示重新输入。
     * @return
     */
    private static String readKeyBoard(int limit, boolean blankReturn) {

        //定义了字符串
        String line = "";

        //scanner.hasNextLine() 判断有没有下一行
        while (scanner.hasNextLine()) {
            line = scanner.nextLine();//读取这一行

            //如果line.length=0, 即用户没有输入任何内容，直接回车
            if (line.length() == 0) {
                if (blankReturn) return line;//如果blankReturn=true,可以返回空串
                else continue; //如果blankReturn=false,不接受空串，必须输入内容
            }

            //如果用户输入的内容大于了 limit，就提示重写输入
            //如果用户如的内容 >0 <= limit ,我就接受
            if (line.length() < 1 || line.length() > limit) {
                System.out.print("输入长度（不能大于" + limit + "）错误，请重新输入：");
                continue;
            }
            break;
        }

        return line;
    }
}

qqcilen.service包

ClientConnectServerThread

package com.hspedu.qqcilen.service;

import com.hspedu.qqcommon.Message;
import com.hspedu.qqcommon.MessageType;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.net.Socket;

public class ClientConnectServerThread extends Thread{
//    该线程需要持有Socket,因此将Socket设置为属性
    private Socket socket;
    public ClientConnectServerThread(Socket socket){
        this.socket = socket;
    }
    @Override
    public void run() {
//        因为Thread需要在后台和服务器通信，因此我们要使用while循环
        while (true){
            try {
                System.out.println("客户端线程，等待从读取服务端发送的消息");
                ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
                Message ms =(Message) ois.readObject();//如果服务器没有发送Message对象，线程会阻塞在这里
//                判断该message的类型，然后做相应的业务处理
//                客户端发送的是获取在线列表收到的是返回在线列表
                if (ms.getMesType().equals(MessageType.MESSAGE_RETURN_ONLINE_FRIEND)){
//取出在线列表信息并显示
                 String[] onlineUsers = ms.getContent().split(" ");
                    System.out.println("=======当前在线用户列表如下=======");
                    for (int i = 0; i < onlineUsers.length; i++) {
                        System.out.println("用户："+ onlineUsers[i]);

                    }
                } else if (ms.getMesType().equals(MessageType.MESSAGE_COMM_MES)) {
// 把从服务器上转发的消息，显示出来
                    System.out.println("\n"+ms.getSender()
                            +"对"+ms.getGetter()+"说"
                            +ms.getContent());

                } else if (ms.getMesType().equals(MessageType.MESSAGE_File_MES)) {
                    System.out.println("\n"+ms.getSender()+"给"+ms.getGetter()+"发送件："+ms.getSrc()+"到："+ms.getDest());
//                    取出message的文件字节数组，通过文件输出流写入到磁盘
                    FileOutputStream fileOutputStream = new FileOutputStream(ms.getDest());
                    fileOutputStream.write(ms.getFileBytes());
                    fileOutputStream.close();
                    System.out.println("保存文件成功");
                } else if (ms.getMesType().equals(MessageType.MESSAGE_TO_ALL_MES)){
//                    显示在客户端的控制台
                    System.out.println("\n"+ms.getSender()+"对大家说："+ms.getContent());

                }else {

                    System.out.println("其他类型的message");
                }
            } catch (Exception e) {
                throw new RuntimeException(e);
            } finally {
            }
        }
    }
    public Socket getSocket() {
        return socket;
    }

    public void setSocket(Socket socket) {
        this.socket = socket;
    }


}

fileClientService

package com.hspedu.qqcilen.service;

import com.hspedu.qqcommon.Message;
import com.hspedu.qqcommon.MessageType;

import java.io.*;

public class fileClientService {
    private FileInputStream fileInputStream = null;
    public void sendFileToOne(String src,String dest,String senderId,String getterId){
        Message message = new Message();
        message.setMesType(MessageType.MESSAGE_File_MES);
        message.setSender(senderId);
        message.setGetter(getterId);
        message.setSrc(src);
        message.setDest(dest);
        byte[] fileBytes = new byte[(int)new File(src).length()];
        try {
            fileInputStream = new FileInputStream(src);
            fileInputStream.read(fileBytes);//将src文件读入到程序的字节数组
//            将文件对应的字节数字设置到message
            message.setFileBytes(fileBytes);
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            if (fileInputStream != null){
                try {
                    fileInputStream.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                } finally {
                }
            }
        }
        System.out.println("\n"+senderId+"想给"+getterId+"发送文件："
                +src+"到对方电脑"+dest);
//        发送
        try {
            ObjectOutputStream oos =
                    new ObjectOutputStream(ManageClientConnectServerThread.getclientConnectServerThread(senderId).getSocket().getOutputStream());
            oos.writeObject(message);
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
        }

    }
}

ManageClientConnectServerThread

package com.hspedu.qqcilen.service;

import java.util.HashMap;
import java.util.concurrent.ConcurrentHashMap;

/***
 * 该类管理客户端连接到服务器端的线程
 */
public class ManageClientConnectServerThread {
// 将多个线程放入到一个HashMap集合，key就是用户id, value 就是线程

    private  static ConcurrentHashMap<String,ClientConnectServerThread> hm = new ConcurrentHashMap<>();
//    将某个集合加入到线程中
    public  static void addClientConnectServerThreadC(String useId,ClientConnectServerThread clientConnectServerThread){
        hm.put(useId, clientConnectServerThread);
    }
//    通过userId可以得到对应线程
    public static ClientConnectServerThread getclientConnectServerThread(String userId){
       return hm.get(userId);
    }
}

MessageClientService

package com.hspedu.qqcilen.service;

import com.hspedu.qqcommon.Message;
import com.hspedu.qqcommon.MessageType;

import java.io.*;

public class MessageClientService {
    public void sendOneMessage(String content,String sendId,String getId){
        Message message = new Message();
        message.setMesType(MessageType.MESSAGE_COMM_MES);
        message.setSender(sendId);
        message.setGetter(getId);
        message.setContent(content);
        message.setSendTime(new java.util.Date().toString());//发送时间
        System.out.println(sendId+"对"+getId+"说"+content);
//发送给服务端
        try {
            ObjectOutputStream oos= new ObjectOutputStream(ManageClientConnectServerThread.
                    getclientConnectServerThread(sendId)
                    .getSocket().getOutputStream());
            oos.writeObject(message);
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
        }
    }
    public void sendMessageToAll(String content,String senderId){
        Message message = new Message();
        message.setMesType(MessageType.MESSAGE_TO_ALL_MES);
        message.setSender(senderId);
        message.setContent(content);
        message.setSendTime(new java.util.Date().toString());//发送时间
        System.out.println(senderId+"对家大说"+content);
//发送给服务端
        try {
            ObjectOutputStream oos= new ObjectOutputStream(ManageClientConnectServerThread.
                    getclientConnectServerThread(senderId)
                    .getSocket().getOutputStream());
            oos.writeObject(message);
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
        }

    }


}

UserClientService

package com.hspedu.qqcilen.service;

import com.hspedu.qqcommon.Message;
import com.hspedu.qqcommon.MessageType;
import com.hspedu.qqcommon.User;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.InetAddress;
import java.net.Socket;


/***
 * 该类完成用户登录验证和用户注册等功能
 */
public class UserClientService {
  private User u =   new User();//方便在其他地方使用user信息，因此做成成员属性
//    根据userId和pwd到服务器验证该用户是否合法
    private Socket socket;
    private boolean b;
    public boolean checkUser(String userId,String pwd) {
     u.setUserId(userId);
     u.setPasswd(pwd);
//     连接到服务器发送对象
        try {
            socket = new Socket(InetAddress.getByName("127.0.0.1"),9999);
            ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
            oos.writeObject(u);//发送对象
            ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
            Message ms = (Message) ois.readObject();//接收对象
            if (ms.getMesType().equals(MessageType.MESSAGE_LOGINF_SUCCEED)){
                b = true;
//创建一个和服务器保持通讯的线程->创建线程类
                ClientConnectServerThread clientConnectServerThreadst = new ClientConnectServerThread(socket);
                clientConnectServerThreadst.start();
//                为了方便管理将线程放入到集合中
                ManageClientConnectServerThread.addClientConnectServerThreadC(userId,clientConnectServerThreadst);

            }else{
//                如果登录失败就关闭socket
                socket.close();
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
        }
        return b;
    }
//向服务器端请求在线用户列表
    public void onlineFriendList(){
//发送一个message，类型为MESSAGE_GET_ONLINE_FRIEND
        Message message = new Message();
        message.setMesType(MessageType.MESSAGE_GET_ONLINE_FRIEND);
        message.setSender(u.getUserId());
//        发送给服务器
//        获取到当前线程的socket对应的Objectoutputstream对象
        try {
//
            ObjectOutputStream oos= new ObjectOutputStream(ManageClientConnectServerThread.
                    getclientConnectServerThread(u.getUserId()).
                    getSocket().getOutputStream());
            oos.writeObject(message);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
//    编写方法，退出客户端，并给服务端发送一个退出系统的message对象
    public void logout(){
        Message message = new Message();
        message.setMesType(MessageType.MESSAGE_CLIENT_EXIT);
        message.setSender(u.getUserId());//指定是哪个客户端要退出
        try {
            ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
            oos.writeObject(message);
            System.out.println(u.getUserId()+"退出系统");
            System.exit(0);//结束进程
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
        }
    }
}

2、Server端

qqcommon

Message

package com.hspedu.qqcommon;

import java.io.Serializable;

/**
 * 表示客户端和服务端通信时的消息对象
 * */
public class Message implements Serializable {
    private static final long serialVersionUID = 1L;
    private String sender;
    private String getter;
    private String content;
    private String sendTime;
    private String mesType;
    private byte[] fileBytes;
    private int fileLength = 0;
    private String dest;//文件传输的目的地
    private String src;//源文件路径

    public byte[] getFileBytes() {
        return fileBytes;
    }

    public void setFileBytes(byte[] fileBytes) {
        this.fileBytes = fileBytes;
    }

    public int getFileLength() {
        return fileLength;
    }

    public void setFileLength(int fileLength) {
        this.fileLength = fileLength;
    }

    public String getDest() {
        return dest;
    }

    public void setDest(String dest) {
        this.dest = dest;
    }

    public String getSrc() {
        return src;
    }

    public void setSrc(String src) {
        this.src = src;
    }

    public String getSender() {
        return sender;
    }

    public void setSender(String sender) {
        this.sender = sender;
    }

    public String getGetter() {
        return getter;
    }

    public void setGetter(String getter) {
        this.getter = getter;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public String getSendTime() {
        return sendTime;
    }

    public void setSendTime(String sendTime) {
        this.sendTime = sendTime;
    }

    public String getMesType() {
        return mesType;
    }

    public void setMesType(String mesType) {
        this.mesType = mesType;
    }
}

MessageType

package com.hspedu.qqcommon;
/***
 * 表示消息类型
 */
public interface MessageType {
    String MESSAGE_LOGINF_SUCCEED = "1";
    String MESSAGE_LOGINF_Fail = "2";
    String MESSAGE_COMM_MES = "3";//普通信息包
    String MESSAGE_GET_ONLINE_FRIEND = "4";//要求返回在线用户列表
    String MESSAGE_RETURN_ONLINE_FRIEND = "5";//返回在线用户列表
    String MESSAGE_CLIENT_EXIT= "6";//客户端请求退出
    String MESSAGE_TO_ALL_MES= "7";//群发消息
    String MESSAGE_File_MES= "8";//文件消息发送
}

User

package com.hspedu.qqcommon;

import java.io.Serializable;
//使用对象流需要进行序列化
public class User implements Serializable {
    private static final long serialVersionUID = 1L;
    private String userId;
    private String passwd;

    public User(String userId, String passwd) {
        this.userId = userId;
        this.passwd = passwd;
    }

    public String getUserId() {
        return userId;
    }

    public void setUserId(String userId) {
        this.userId = userId;
    }

    public String getPasswd() {
        return passwd;
    }

    public void setPasswd(String passwd) {
        this.passwd = passwd;
    }
}

qqFrame

QQFrame

package com.hspedu.qqFrame;

import com.hspedu.qqserver.service.QQServer;

/***
 * 该类创建QQServe,启动后台的服务
 */
public class QQFrame {
    public static void main(String[] args) {

        new QQServer();
    }
}

qqserver.service

ManageClientThread

package com.hspedu.qqserver.service;

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

public class ManageClientThread {
    private static HashMap<String,ServerConnectClientThread> hm = new HashMap<>();

    public static HashMap<String, ServerConnectClientThread> getHm() {
        return hm;
    }

    //    添加线程对象到hm集合
    public static void addClientThread(String userId,ServerConnectClientThread serverConnectClientThread){
        hm.put(userId,serverConnectClientThread);
    }
//    根据userId返回ServerConnectThread
    public static ServerConnectClientThread getServerConnectThread(String userId){
        return hm.get(userId);
    }
//    编写方法，可以返回在线用户列表
    public static String getOnlineUser(){
//        集合遍历，遍历hashMap的key
        String onlineUserList = "";
        Iterator<String> iterator = hm.keySet().iterator();
        while (iterator.hasNext()) {
             onlineUserList +=  iterator.next() + " ";
        }
        return onlineUserList;
    }
//    增加一个方法,从集合中，一处某个线程对象
    public static void removeClientThread(String userId){
        hm.remove(userId);
    }
}

QQServer

package com.hspedu.qqserver.service;

import com.hspedu.qqcommon.Message;
import com.hspedu.qqcommon.MessageType;
import com.hspedu.qqcommon.User;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.HashMap;

/***
 * 服务端，监听9999端口，等待客户端连接，并保持通信
 */
public class QQServer {
    private ServerSocket ss = null;
//    创建一个集合，存放多个用户，如果是这些用户登录，旧任务是合法的
    private static HashMap<String,User> validUsers = new HashMap<>();

    public static void main(String[] args) {
        new QQServer();
    }
    static {//在静态代码块中，初始化 validUsers
        validUsers.put("100",new User("100","123456"));
        validUsers.put("200",new User("200","123456"));
        validUsers.put("300",new User("300","123456"));
        validUsers.put("400",new User("400","123456"));
        validUsers.put("至尊宝",new User("至尊宝","123456"));
        validUsers.put("紫霞仙子",new User("紫霞仙子","123456"));
        validUsers.put("菩提老祖",new User("菩提老祖","123456"));
    }
    private boolean checkUser(String useId, String passwd){
        User user = validUsers.get(useId);
        if (user == null){
            return false;
        }
        if (!(user.getPasswd().equals(passwd))){
            return false;
        }
        return true;
    }
    public QQServer(){
//        注意：端口可以写在配置文件，
        try {
            new Thread(new SendNewsToAllService()).start();
            System.out.println("服务器端在9999端口监听...");
            ss = new ServerSocket(9999);
//            是个循环监听的过程
            while (true){//当和某个客户端连接后，会继续监听
                Socket socket = ss.accept();//如果没有客户端连接，将会阻塞在这里
//                得到客户端发送的user对象
                ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
                User u = (User) ois.readObject();//读取客户端发送的user对象
//                创建一个Message对象，准备回复客户端
                Message message = new Message();
                ObjectOutputStream oos  = new ObjectOutputStream(socket.getOutputStream());
                if (checkUser(u.getUserId(), u.getPasswd())){//登录成功
//                登录成功向客户端发送Message对象
                      message.setMesType(MessageType.MESSAGE_LOGINF_SUCCEED);
                      oos.writeObject(message);
//                      创建一个线程，和客户端保持通信，该线程需要有socekt对象
                    ServerConnectClientThread serverConnectClientThread = new ServerConnectClientThread(socket, u.getUserId());
                    serverConnectClientThread.start();
//                    把该线程放到一个集合中，进行管理
                    ManageClientThread.addClientThread(u.getUserId(), serverConnectClientThread);

                }else {//登录失败
                    System.out.println("用户 id="+u.getUserId()+"pwd="+u.getPasswd()+"验证失败");
                    message.setMesType(MessageType.MESSAGE_LOGINF_Fail);
                    oos.writeObject(message);
                    socket.close();

                }
            }

        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
//      如果服务器退出了while，说明服务器不在监听，因此需要关闭ServerSocket
            try {
                ss.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

SendNewsToAllService

package com.hspedu.qqserver.service;

import com.hspedu.qqcommon.Message;
import com.hspedu.qqcommon.MessageType;
import com.hspedu.utils.Utility;

import java.io.IOException;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Scanner;

public class SendNewsToAllService implements Runnable{
    @Override
    public void run() {
        while (true) {//为了可以推送多次新闻可以使用while循环
            System.out.println("请输入服务器要推送的新闻/消息(输入exit表示退出推送服务)");
            String news = Utility.readString(10000);
            if ("exit".equals(news)){
                break;
            }
//        构建一个消息，群发消息
            Message message = new Message();
            message.setSender("服务器");
            message.setContent(news);
            message.setSendTime(new Date().toString());
            message.setMesType(MessageType.MESSAGE_TO_ALL_MES);
            System.out.println("服务器推送消息给所有人说：" + news);
//        遍历当前所有的通信线程，得到socket，并转发message对象
            HashMap<String, ServerConnectClientThread> hm = ManageClientThread.getHm();
            Iterator<String> iterator = hm.keySet().iterator();
            while (iterator.hasNext()) {
                String onileUserId = iterator.next();
                Socket socket = hm.get(onileUserId).getSocket();
                try {
                    ObjectOutputStream obs = new ObjectOutputStream(socket.getOutputStream());
                    obs.writeObject(message);
                } catch (IOException e) {
                    throw new RuntimeException(e);
                } finally {
                }
            }
        }
    }
}

ServerConnectClientThread

package com.hspedu.qqserver.service;

import com.hspedu.qqcommon.Message;
import com.hspedu.qqcommon.MessageType;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.util.HashMap;
import java.util.Iterator;

public class ServerConnectClientThread extends Thread{
    private Socket socket;
    private String userId;
    public ServerConnectClientThread(Socket socket, String userId) {
        this.socket = socket;
        this.userId = userId;
    }

    public Socket getSocket() {
        return socket;
    }

    @Override
    public void run() {//线程处于run状态，可以接收和发送消息
        while (true){
            System.out.println("服务端和客户端"+userId+"保持通信，读取数据。。。");
            try {
                ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
                Message ms =  (Message)ois.readObject();
                if (ms.getMesType().equals(MessageType.MESSAGE_GET_ONLINE_FRIEND)){
                    System.out.println(ms.getSender()+"要在线用户列表");
                    String onlineUser = new ManageClientThread().getOnlineUser();
//                    构建messge对象返回给客户端
                    Message message2 = new Message();
                    message2.setMesType(MessageType.MESSAGE_RETURN_ONLINE_FRIEND);
                    message2.setContent(onlineUser);
                    message2.setGetter(ms.getSender());
//                    返回给客户端
                    ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
                    oos.writeObject(message2);
                }else if (ms.getMesType().equals(MessageType.MESSAGE_COMM_MES)){
//                    根据message获取getid，然后在得到对应的线程
                    Socket socket1  = ManageClientThread.getServerConnectThread(ms.getGetter()).socket;
//                    准备转发
                    ObjectOutputStream oos = new ObjectOutputStream(socket1.getOutputStream());
                    oos.writeObject(ms);//转发，提示如果客户不在线，可以保存到数据库，这样就可以实现离线留言

                } else if (ms.getMesType().equals(MessageType.MESSAGE_TO_ALL_MES)) {
                    HashMap<String, ServerConnectClientThread> hm = ManageClientThread.getHm();//返回所有线程
                    Iterator<String> iterator = hm.keySet().iterator();
//                    遍历线程的KeySet
                    while (iterator.hasNext()) {
                        String onlineUserId =  iterator.next().toString();
                        if (!onlineUserId.equals(ms.getSender())){//排除群发消息的用户
                            Socket socket2 = ManageClientThread.getServerConnectThread(onlineUserId).socket;
//                            ObjectOutputStream oos = new ObjectOutputStream(socket2.getOutputStream());
                            ObjectOutputStream oos = new ObjectOutputStream(hm.get(onlineUserId).socket.getOutputStream());
                            oos.writeObject(ms);
                        }
                    }


                } else if (ms.getMesType().equals(MessageType.MESSAGE_File_MES)) {
//                    根据getteri将message对象zhuanfa
                    ObjectOutputStream oos =
                           new ObjectOutputStream(ManageClientThread.getServerConnectThread(ms.getGetter()).socket.getOutputStream()) ;
                    oos.writeObject(ms);
                } else if(ms.getMesType().equals(MessageType.MESSAGE_CLIENT_EXIT)){
                    System.out.println(ms.getSender()+"退出系统");
//                    将客户端对应的线程从及集合中删除
                    ManageClientThread.removeClientThread(ms.getSender());
                    socket.close();//关闭当前线程所持有的socket，即关闭连接
//                    退出线程
                    break;
                }else{
                    System.out.println("其他类型的message，暂时不处理");
                }
            } catch (Exception e) {
                throw new RuntimeException(e);
            } finally {
            }
        }
    }
}

utils

Utility

package com.hspedu.utils;
/**
 工具类的作用:
 处理各种情况的用户输入，并且能够按照程序员的需求，得到用户的控制台输入。
 */

import java.util.Scanner;

/**


 */
public class Utility {
    //静态属性。。。
    private static Scanner scanner = new Scanner(System.in);


    /**
     * 功能：读取键盘输入的一个菜单选项，值：1——5的范围
     * @return 1——5
     */
    public static char readMenuSelection() {
        char c;
        for (; ; ) {
            String str = readKeyBoard(1, false);//包含一个字符的字符串
            c = str.charAt(0);//将字符串转换成字符char类型
            if (c != '1' && c != '2' &&
                    c != '3' && c != '4' && c != '5') {
                System.out.print("选择错误，请重新输入：");
            } else break;
        }
        return c;
    }

    /**
     * 功能：读取键盘输入的一个字符
     * @return 一个字符
     */
    public static char readChar() {
        String str = readKeyBoard(1, false);//就是一个字符
        return str.charAt(0);
    }
    /**
     * 功能：读取键盘输入的一个字符，如果直接按回车，则返回指定的默认值；否则返回输入的那个字符
     * @param defaultValue 指定的默认值
     * @return 默认值或输入的字符
     */

    public static char readChar(char defaultValue) {
        String str = readKeyBoard(1, true);//要么是空字符串，要么是一个字符
        return (str.length() == 0) ? defaultValue : str.charAt(0);
    }

    /**
     * 功能：读取键盘输入的整型，长度小于2位
     * @return 整数
     */
    public static int readInt() {
        int n;
        for (; ; ) {
            String str = readKeyBoard(10, false);//一个整数，长度<=10位
            try {
                n = Integer.parseInt(str);//将字符串转换成整数
                break;
            } catch (NumberFormatException e) {
                System.out.print("数字输入错误，请重新输入：");
            }
        }
        return n;
    }
    /**
     * 功能：读取键盘输入的 整数或默认值，如果直接回车，则返回默认值，否则返回输入的整数
     * @param defaultValue 指定的默认值
     * @return 整数或默认值
     */
    public static int readInt(int defaultValue) {
        int n;
        for (; ; ) {
            String str = readKeyBoard(10, true);
            if (str.equals("")) {
                return defaultValue;
            }

            //异常处理...
            try {
                n = Integer.parseInt(str);
                break;
            } catch (NumberFormatException e) {
                System.out.print("数字输入错误，请重新输入：");
            }
        }
        return n;
    }

    /**
     * 功能：读取键盘输入的指定长度的字符串
     * @param limit 限制的长度
     * @return 指定长度的字符串
     */

    public static String readString(int limit) {
        return readKeyBoard(limit, false);
    }

    /**
     * 功能：读取键盘输入的指定长度的字符串或默认值，如果直接回车，返回默认值，否则返回字符串
     * @param limit 限制的长度
     * @param defaultValue 指定的默认值
     * @return 指定长度的字符串
     */

    public static String readString(int limit, String defaultValue) {
        String str = readKeyBoard(limit, true);
        return str.equals("")? defaultValue : str;
    }


    /**
     * 功能：读取键盘输入的确认选项，Y或N
     * 将小的功能，封装到一个方法中.
     * @return Y或N
     */
    public static char readConfirmSelection() {
        System.out.println("请输入你的选择(Y/N): 请小心选择");
        char c;
        for (; ; ) {//无限循环
            //在这里，将接受到字符，转成了大写字母
            //y => Y n=>N
            String str = readKeyBoard(1, false).toUpperCase();
            c = str.charAt(0);
            if (c == 'Y' || c == 'N') {
                break;
            } else {
                System.out.print("选择错误，请重新输入：");
            }
        }
        return c;
    }

    /**
     * 功能： 读取一个字符串
     * @param limit 读取的长度
     * @param blankReturn 如果为true ,表示 可以读空字符串。
     * 					  如果为false表示 不能读空字符串。
     *
     *	如果输入为空，或者输入大于limit的长度，就会提示重新输入。
     * @return
     */
    private static String readKeyBoard(int limit, boolean blankReturn) {

        //定义了字符串
        String line = "";

        //scanner.hasNextLine() 判断有没有下一行
        while (scanner.hasNextLine()) {
            line = scanner.nextLine();//读取这一行

            //如果line.length=0, 即用户没有输入任何内容，直接回车
            if (line.length() == 0) {
                if (blankReturn) return line;//如果blankReturn=true,可以返回空串
                else continue; //如果blankReturn=false,不接受空串，必须输入内容
            }

            //如果用户输入的内容大于了 limit，就提示重写输入
            //如果用户如的内容 >0 <= limit ,我就接受
            if (line.length() < 1 || line.length() > limit) {
                System.out.print("输入长度（不能大于" + limit + "）错误，请重新输入：");
                continue;
            }
            break;
        }

        return line;
    }
}