Java网上聊天项目（纯后端）--基于韩顺平老师的视频

最新推荐文章于 2024-05-06 10:37:06 发布

Dr_RR

最新推荐文章于 2024-05-06 10:37:06 发布

阅读量1k

点赞数 40

文章标签： java 开发语言网络

本文链接：https://blog.csdn.net/Dr_RR/article/details/137658407

版权

主要技术：JavaWeb网络编程，多线程，面向对象oop，io流等......

在继坦克大战之后我也是试着自己跟着视频学习了一下韩老师的qq项目，我所主要进行分享的是：

1，韩老师在项目视频最后实现离线发送消息的个人想法和思路

2，解决视频中的一些自己实际编写中遇到的异常问题

3，自己在上网查询之后写出的接收方指定将文件保存到电脑的xx位置

正文

离线留言的实现

韩顺平老师布置的任务离线发送消息的业务逻辑我的处理思路是：
（1）再在MessageType的接口中创建一个新的常量用于显示先前用户的留言信息

String MESSAGE_OFF_LINE = "9"; //查看离线留言

（2）客户端这边在MessageClientService类下再写一个方法getOfflineMessages用于向服务端发送显示留言的请求

public void getOfflineMessages(String userId) {
    // 构建一个消息对象，请求获取离线消息
    Message message = new Message();
    message.setMesType(MessageType.MESSAGE_OFF_LINE); // 设置消息类型为请求离线消息
    message.setGetter(userId); // 设置接收者为当前用户

    try {
        // 发送请求消息到服务器
        ObjectOutputStream oos = new ObjectOutputStream(ManageClientConnectServerThread
                .getClientConnectServerThread(userId).getSocket().getOutputStream());
        oos.writeObject(message);
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

（3）服务端这边我创建了一个新类，其作用是往ArrayList数组中存放消息并移除offLineDB中的离线用户

import com.ryy.qqcommon.Message;
import com.ryy.qqcommon.MessageType;

import java.util.ArrayList;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 用于实现离线聊天功能
 */
public class CheckIfOnLine {
    private static ConcurrentHashMap<String, ArrayList<Message>> offLineDB = new ConcurrentHashMap<>();

    //获得map以得到离线用户
    public static ConcurrentHashMap<String, ArrayList<Message>> getOffLineDB() {
        return offLineDB;
    }

    public static void saveMessage(String getter, Message message) {
        message.setMesType(MessageType.MESSAGE_OFF_LINE);
        ArrayList<Message> List = offLineDB.get(getter);
        if (List == null) {  //解决空指针异常问题
            List = new ArrayList<>();
            offLineDB.put(getter, List);
        }
        List.add(message);
    }

    //最后移除离线用户
    public static void removeGetter(String getter) {
        offLineDB.remove(getter);
    }
}

（4）随后在ServerConnectClientThread类中的run方法里增加一条检测显示留言的条件，并且在接收私聊消息的条件下增加一条检测是否在线的判断条件

else if (message.getMesType().equals(MessageType.MESSAGE_COMM_MES)) {
    //查看是否在线
    ServerConnectClientThread thread = ManageClientThreads.getServerConnectClientThread(message.getGetter());
    if (thread != null) {
        //根据message获取getter id，然后再得到对应线程
        ServerConnectClientThread serverConnectClientThread =
                ManageClientThreads.getServerConnectClientThread(message.getGetter());
        //得到对应socket的对象输出流，将message对象转发给指定的客户端
        ObjectOutputStream oos = new ObjectOutputStream
                (serverConnectClientThread.getSocket().getOutputStream());
        oos.writeObject(message);
    } else {
        CheckIfOnLine.saveMessage(message.getGetter(), message);
    }
} 

else if (message.getMesType().equals(MessageType.MESSAGE_OFF_LINE)) {
    //得到socket关联的对象输出流
    ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());

    // 检查离线消息
    ArrayList<Message> offLineMessages = CheckIfOnLine.getOffLineDB().get(userId);
    if (offLineMessages != null) {
        for (Message m : offLineMessages) {
            //将message对象发送给客户端
            oos.writeObject(m);
        }
        // 移除离线消息
        CheckIfOnLine.removeGetter(userId);
    }

（5）在客户端这边接收一下并打印

else if (message.getMesType().equals(MessageType.MESSAGE_OFF_LINE)) { //显示离线消息
    System.out.println("\n" + message.getSender() + "对你说:" + message.getContent());

（6）最后在qqView这边新增一个case"5"，调用MessageClientService类下的getOfflineMessages方法

case "5":
    messageClientService.getOfflineMessages(userId);
    break;

效果演示：

此时200不在线，如果登录200并且选择5就能看到用户100发来的消息

无异常退出问题

在无异常退出那一集中我在运行之后服务器端这边报了两个异常，一个是空指针异常，另一个是EOFException
（1）空指针异常是因为没有设置发送消息的message对象类型，需要在客户端的UserClientService类中的onlineFriendList()方法中加入以下代码：

message.setMesType(MessageType.MESSAGE_GET_ONLINE_FRIEND);

（2） EOFException是关于输入流的问题：表明在尝试读取对象时已经到达了流的末尾，意味着可能没有更多的数据可供读取了，确保在读取数据之前先检查流是否已经结束，如果捕获到 EOFException，可以认为服务器端已经关闭连接，可以在捕获该异常后退出循环，结束线程
代码添加如下：（位置在客户端的ClientConnectServerThread类中的run方法中）

   Message message = (Message) ois.readObject();
// 如果读取到的是服务端返回的在线用户列表
if (message.getMesType().equals(MessageType.MESSAGE_RET_ONLINE_FRIEND)) {
// 取出在线列表信息并显示
String[] onlineUsers = message.getContent().split(" ");
System.out.println("\n========当前在线用户列表========");
for (String user : onlineUsers) {
System.out.println("用户：" + user);
}
   两句catch中：
       catch (EOFException e) {
System.out.println("服务器已关闭连接，退出客户端线程。");
break; // 退出循环
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace(); // 输出异常信息
}

新增功能

新增功能为当对方发送文件到接收方电脑上时，接收方能够指定保存文件的路径，而不用再让发送方指定接收方的接收位置了
   主要思路是在客户端的主线程中启动两个子线程，这样就会防止在输入文件保存位置的时候和菜单输入发生冲突
   （1）现在主线程中通过函数式编程（匿名内部类）写一个子线程用来控制scanner阻塞主线程问题（由于scanner读行问题需要先输入一个回车）
   （2）再在匿名内部类里开一个新的子线程用于读取服务端发送过来的message对象中的文件字节数组
   （细节请看代码）

服务端的代码无需改动，只需要对客户端的代码进行改动即可

首先在ClientConnectServerThread类中新增一个类（线程）用来读取和保存文件

// 定义一个文件保存任务
class FileSavingTask implements Runnable {
    private Message message;
    private String dest;

    public FileSavingTask(Message message, String dest) {
        this.message = message;
        this.dest = dest;
    }

    @Override
    public void run() {
        try {
            System.out.print("\n" + message.getSender() + "给你发送文件"
                    + message.getSrc() + "到你的电脑目录" + dest);
            // 取出message的文件字节数组，通过文件输出流写到磁盘
            FileOutputStream fileOutputStream = new FileOutputStream(dest);
            fileOutputStream.write(message.getFileBytes());
            fileOutputStream.close();
            System.out.println("\n 保存文件成功~");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

然后开一个匿名内部类来启动一个子线程用来解决输入文件路径和主线程输入菜单选择信息发生冲突的问题

else if (message.getMesType().equals(MessageType.MESSAGE_FILE_MES)) { // 如果是文件消息
                    // 启动一个新线程来处理用户输入和文件保存
                    new Thread(() -> {
                        try {
                            // 提示用户输入文件保存路径
                            System.out.print("文件接收成功，请选择要保存的路径（形式 d:\\xx.png）[请先输入回车]：");
                            Scanner scanner = new Scanner(System.in);
                            String dest = scanner.nextLine();

                            // 启动文件保存线程
                            Thread fileSavingThread = new Thread(new FileSavingTask(message, dest));
                            fileSavingThread.start();
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }).start();

效果演示：

完整代码演示

Server端：

qqcommon包中

Message类：

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 boolean isOffline; // 新字段，指示消息是否为离线消息

    //进行扩展 和文件相关的成员
    private byte[] fileBytes;
    private int fileLen = 0;
    private String dest; //将文件传输到哪里
    private String src; //源文件路径

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

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

    public int getFileLen() {
        return fileLen;
    }

    public void setFileLen(int fileLen) {
        this.fileLen = fileLen;
    }

    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 getMesType() {
        return mesType;
    }

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

    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;
    }
}

MessageType接口：

/**
 * 表示消息类型
 */
public interface MessageType {
    //在接口中定义了一些常量
    //不同的常量的值，表示不同的消息类型
    String MESSAGE_LOGIN_SUCCEED = "1"; //表示登录成功
    String MESSAGE_LOGIN_FAIL = "2"; //表示登录失败
    String MESSAGE_COMM_MES = "3"; //普通信息包
    String MESSAGE_GET_ONLINE_FRIEND = "4"; //要求返回在线用户列表
    String MESSAGE_RET_ONLINE_FRIEND = "5"; //返回在线用户列表
    String MESSAGE_CLIENT_EXIT = "6"; //客户端请求退出
    String MESSAGE_TO_ALL_MES = "7"; //群发消息
    String MESSAGE_FILE_MES = "8"; //发送文件
    String MESSAGE_OFF_LINE = "9"; //查看离线留言
}

User类：

import java.io.Serializable;

/**
 * 表示一个用户信息
 */
public class User implements Serializable {

    private static final long serialVersionUID = 1L; //提升版本兼容性
    private String userId; //用户Id/用户名
    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类：

import com.ryy.qqserver.service.QQServer;

/**
 * 该类创建QQServer，启动后台服务
 */
public class QQFrame {
    public static void main(String[] args) {
        new QQServer();
    }
}

qqserver.service包中

CheckIfOnLine类：

import com.ryy.qqcommon.Message;
import com.ryy.qqcommon.MessageType;

import java.util.ArrayList;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 用于实现离线聊天功能
 */
public class CheckIfOnLine {
    private static ConcurrentHashMap<String, ArrayList<Message>> offLineDB = new ConcurrentHashMap<>();

    //获得map以得到离线用户
    public static ConcurrentHashMap<String, ArrayList<Message>> getOffLineDB() {
        return offLineDB;
    }

    public static void saveMessage(String getter, Message message) {
        message.setMesType(MessageType.MESSAGE_OFF_LINE);
        ArrayList<Message> List = offLineDB.get(getter);
        if (List == null) {  //解决空指针异常问题
            List = new ArrayList<>();
            offLineDB.put(getter, List);
        }
        List.add(message);
    }

    //最后移除离线用户
    public static void removeGetter(String getter) {
        offLineDB.remove(getter);
    }
}

ManageClientThreads类:

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

/**
 * 该类用于管理和客户端通讯的线程
 */
public class ManageClientThreads {
    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返回ServerConnectClientThread线程
    public static ServerConnectClientThread getServerConnectClientThread(String userId) {
        return hm.get(userId);
    }

    //增加一个方法，从集合中移除某个线程对象
    public static void removeServerConnectClientThread(String userId) {
        hm.remove(userId);
    }

    //这里编写方法，可以返回在线用户列表
    public static String getOnlineUser() {
        //集合遍历，遍历hashmap的key
        Iterator<String> iterator = hm.keySet().iterator();
        String onlineUserList = "";
        while (iterator.hasNext()){
            onlineUserList += iterator.next().toString() + " ";
        }
        return onlineUserList;
    }
}

QQServer类：

import com.ryy.qqcommon.Message;
import com.ryy.qqcommon.MessageType;
import com.ryy.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.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 这是服务端，在端口9999监听，等待客户端连接，并保持通信
 */
public class QQServer {
    private ServerSocket ss = null;
    //创建一个集合，存放多个用户，如果是这些用户登录，就认为是合法
    //这里也可以使用concurrentHashMap,可以处理并发的集合，没有线程安全
    //ConcurrentHashMap处理线程安全，即线程同步处理，在多线程情况下是安全的
    private static ConcurrentHashMap<String, User> validUsers = new ConcurrentHashMap<>();

    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("至尊宝", new User("至尊宝", "123456"));
        validUsers.put("紫霞仙子", new User("紫霞仙子", "123456"));
        validUsers.put("菩提老祖", new User("菩提老祖", "123456"));
    }

    //验证用户是否有效的方法
    private boolean checkUser(String userId, String passwd) {

        User user = validUsers.get(userId);
        if (user == null) { //说明userId没有存在validUsers的key中
            return false;
        }
        if (!user.getPasswd().equals(passwd)) { //userId正确，但是密码错误
            return false;
        }
        return true;
    }

    public QQServer() {
        //注意：端口可以写在配置文件
        try {
            System.out.println("服务器在9999端口监听...");
            //启动推送新闻的线程
            new Thread(new SendNewsToAllService()).start();
            ss = new ServerSocket(9999);

            while (true) { //当和某个客户端连接后，会继续监听，因此while
                Socket socket = ss.accept(); //如果没有客户端连接就会阻塞
                //得到socket关联的对象输入流
                ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
                //得到socket关联的对象输出流
                ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());

                User u = (User) ois.readObject(); //读取客户端发送的User对象
                //创建一个Message对象，准备回复客户端
                Message message = new Message();
                //验证
                if (checkUser(u.getUserId(), u.getPasswd())) { //登录成功
                    message.setMesType(MessageType.MESSAGE_LOGIN_SUCCEED);
                    //将message对象回复给客户端
                    oos.writeObject(message);
                    //创建一个线程，和客户端保持通信，该线程需要持有socket对象
                    ServerConnectClientThread serverConnectClientThread =
                            new ServerConnectClientThread(socket, u.getUserId());
                    //启动该线程
                    serverConnectClientThread.start();
                    //把该线程放入到一个集合中进行管理
                    ManageClientThreads.addClientThread(u.getUserId(), serverConnectClientThread);
                } else { //登录失败
                    message.setMesType(MessageType.MESSAGE_LOGIN_FAIL);
                    oos.writeObject(message);
                    //关闭socket
                    socket.close();
                }
            }

        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            //如果服务器退出了while循环，说明 服务器不再监听，因此关闭ServerSocket
            try {
                if (ss != null) {
                    ss.close();
                }
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

SendNewsToAllService类：

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

import java.io.IOException;
import java.io.ObjectOutputStream;
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
        while (true) {
            System.out.println("请输入服务器要推送的新闻/消息[输入exit表示退出推送服务]:");
            String news = Utility.readString(100);
            if("exit".equals(news)){
                break;
            }
            //构建一个消息，群发消息
            Message message = new Message();
            message.setSender("服务器");
            message.setMesType(MessageType.MESSAGE_TO_ALL_MES);
            message.setContent(news);
            message.setSendTime(new Date().toString());
            System.out.println("服务器推送消息给所有人说：" + news);

            //遍历当前所有的通信线程，得到socket并发送socket
            HashMap<String, ServerConnectClientThread> hm = ManageClientThreads.getHm();

            Iterator<String> iterator = hm.keySet().iterator();
            while (iterator.hasNext()) {
                String onLineUserId = iterator.next().toString();
                try {
                    ObjectOutputStream oos =
                            new ObjectOutputStream(hm.get(onLineUserId).getSocket().getOutputStream());
                    oos.writeObject(message);
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}

ServerConnectClientThread类：

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

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

/**
 * 该类的一个对象和某个客户端保持连接
 */
public class ServerConnectClientThread extends Thread {
    private Socket socket;
    private String userId; //连接到服务端的用户id

    public ServerConnectClientThread(Socket socket, String userId) {
        this.socket = socket; //此处的socket是sender的
        this.userId = userId;
    }

    public Socket getSocket() { //这里的socket才是getter的
        return socket;
    }

    @Override
    public void run() { //在这里线程处于run状态，可以发送/接收消息

        while (true) {
            try {
                System.out.println("服务端和客户端" + userId + "保持通信，读取数据...");
                //这里相当于是服务端读取从客户端发来的User对象中的message，后续传递消息都是通过Message类传递的
                ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
                Message message = (Message) ois.readObject();

                if (message.getMesType().equals(MessageType.MESSAGE_GET_ONLINE_FRIEND)) {
                    //客户端要在线用户列表
                    System.out.println(message.getSender() + "要在线用户列表");
                    //从管理线程的集合中获取在线用户信息
                    String onlineUser = ManageClientThreads.getOnlineUser();
                    //返回message

                    //构建一个Message对象，返回给客户端
                    Message message2 = new Message();
                    message2.setMesType(MessageType.MESSAGE_RET_ONLINE_FRIEND); //设置返回形式
                    message2.setContent(onlineUser); //设置内容是在线用户列表
                    message2.setGetter(message.getSender()); //设置把发送对象返回给接收对象

                    //返回给客户端
                    ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
                    oos.writeObject(message2);

                } else if (message.getMesType().equals(MessageType.MESSAGE_FILE_MES)) {
                    //根据getter id获取到对应的线程，将message对象转发
                    ObjectOutputStream oos = new ObjectOutputStream
                            (ManageClientThreads.getServerConnectClientThread(message.getGetter())
                                    .getSocket().getOutputStream());
                    //转发
                    oos.writeObject(message);
                } else if (message.getMesType().equals(MessageType.MESSAGE_COMM_MES)) {
                    //查看是否在线
                    ServerConnectClientThread thread = ManageClientThreads.getServerConnectClientThread(message.getGetter());
                    if (thread != null) {
                        //根据message获取getter id，然后再得到对应线程
                        ServerConnectClientThread serverConnectClientThread =
                                ManageClientThreads.getServerConnectClientThread(message.getGetter());
                        //得到对应socket的对象输出流，将message对象转发给指定的客户端
                        ObjectOutputStream oos = new ObjectOutputStream
                                (serverConnectClientThread.getSocket().getOutputStream());
                        oos.writeObject(message);
                    } else {
                        CheckIfOnLine.saveMessage(message.getGetter(), message);
                    }
                } else if (message.getMesType().equals(MessageType.MESSAGE_OFF_LINE)) {
                    //得到socket关联的对象输出流
                    ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());

                    // 检查离线消息
                    ArrayList<Message> offLineMessages = CheckIfOnLine.getOffLineDB().get(userId);
                    if (offLineMessages != null) {
                        for (Message m : offLineMessages) {
                            //将message对象发送给客户端
                            oos.writeObject(m);
                        }
                        // 移除离线消息
                        CheckIfOnLine.removeGetter(userId);
                    }
                } else if (message.getMesType().equals(MessageType.MESSAGE_TO_ALL_MES)) {
                    //需要遍历管理线程的集合，把所有线程的socket得到，然后把message进行转发即可
                    HashMap<String, ServerConnectClientThread> hm = ManageClientThreads.getHm();

                    for (String s : hm.keySet()) {
                        //取出在线用户id
                        String onlineUserId = s.toString();

                        if (!onlineUserId.equals(message.getSender())) { //排除发送消息的自己
                            //进行转发message
                            ObjectOutputStream oos = new ObjectOutputStream
                                    (hm.get(onlineUserId).getSocket().getOutputStream());
                            oos.writeObject(message);
                        }
                    }
                } else if (message.getMesType().equals(MessageType.MESSAGE_CLIENT_EXIT)) {
                    System.out.println(message.getSender() + "退出");
                    //将这个客户端对应线程从集合中删除
                    ManageClientThreads.removeServerConnectClientThread(message.getSender());
                    socket.close();
                    //退出线程
                    break;

                } else {
                    System.out.println("其他类型的message，暂时不做处理...");
                }
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    }
}

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表示 不能读空字符串。
     *                    <p>
     *                    如果输入为空，或者输入大于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;
    }
}

Client端：

qqcommon包和util包中的内容均相同

service包中

ClientConnectServerThread类：

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

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

public class ClientConnectServerThread extends Thread {
    //该线程需要持有socket
    private Socket socket;

    //构造器可以接收一个Socket对象
    public ClientConnectServerThread(Socket socket) {
        this.socket = socket;
    }

    public Socket getSocket() {
        return socket;
    }

    /**
     * EOFException 表明在尝试读取对象时已经到达了流的末尾，意味着可能没有更多的数据可供读取了
     * 确保在读取数据之前先检查流是否已经结束
     * 如果捕获到 EOFException，可以认为服务器端已经关闭连接，可以在捕获该异常后退出循环，结束线程
     */
    @Override
    public void run() {
        // 因为Thread需要在后台持续和服务器端通信，因此我们使用while循环
        while (true) {
            try {
                System.out.println("客户端线程，等待读取从服务器端发送的信息");
                ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
                // 如果服务器没有发送Message对象，线程会阻塞在这里
                Message message = (Message) ois.readObject();
                // 如果读取到的是服务端返回的在线用户列表
                if (message.getMesType().equals(MessageType.MESSAGE_RET_ONLINE_FRIEND)) {
                    // 取出在线列表信息并显示
                    String[] onlineUsers = message.getContent().split(" ");
                    System.out.println("\n========当前在线用户列表========");
                    for (String user : onlineUsers) {
                        System.out.println("用户：" + user);
                    }
                } else if (message.getMesType().equals(MessageType.MESSAGE_COMM_MES)) { // 普通的聊天消息
                    // 把从服务器转发的消息显示到控制台即可
                    System.out.println("\n" + message.getSender() + "对你说:" + message.getContent());
                } else if (message.getMesType().equals(MessageType.MESSAGE_OFF_LINE)) { //显示离线消息
                    System.out.println("\n" + message.getSender() + "对你说:" + message.getContent());
                } else if (message.getMesType().equals(MessageType.MESSAGE_TO_ALL_MES)) {
                    // 显示在客户端控制台
                    System.out.println("\n" + message.getSender() + "对大家说：" + message.getContent());
                } else if (message.getMesType().equals(MessageType.MESSAGE_FILE_MES)) { // 如果是文件消息
                    // 启动一个新线程来处理用户输入和文件保存
                    new Thread(() -> {
                        try {
                            // 提示用户输入文件保存路径
                            System.out.print("文件接收成功，请选择要保存的路径（形式 d:\\xx.png）[请先输入回车]：");
                            Scanner scanner = new Scanner(System.in);
                            String dest = scanner.nextLine();

                            // 启动文件保存线程
                            Thread fileSavingThread = new Thread(new FileSavingTask(message, dest));
                            fileSavingThread.start();
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }).start();

                } else {
                    System.out.println("是其他类型的message，暂时不处理...");
                }
            } catch (EOFException e) {
                System.out.println("服务器已关闭连接，退出客户端线程。");
                break; // 退出循环
            } catch (IOException | ClassNotFoundException e) {
                e.printStackTrace(); // 输出异常信息
            }
        }
    }
}

// 定义一个文件保存任务
class FileSavingTask implements Runnable {
    private Message message;
    private String dest;

    public FileSavingTask(Message message, String dest) {
        this.message = message;
        this.dest = dest;
    }

    @Override
    public void run() {
        try {
            System.out.print("\n" + message.getSender() + "给你发送文件"
                    + message.getSrc() + "到你的电脑目录" + dest);
            // 取出message的文件字节数组，通过文件输出流写到磁盘
            FileOutputStream fileOutputStream = new FileOutputStream(dest);
            fileOutputStream.write(message.getFileBytes());
            fileOutputStream.close();
            System.out.println("\n 保存文件成功~");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

FileClientService类：

import com.ryy.qqcommon.Message;
import com.ryy.qqcommon.MessageType;

import java.io.*;

/**
 * 该类完成文件传输服务
 */
public class FileClientService {
    /**
     * @param src      源文件
     * @param senderId 发送用户id
     * @param getterId 接收用户id
     */
    public void sendFileToOne(String src, String senderId, String getterId) {
        //读取src文件-->封装到message
        Message message = new Message();
        message.setMesType(MessageType.MESSAGE_FILE_MES);
        message.setSender(senderId);
        message.setGetter(getterId);
        message.setSrc(src);

        //需要将磁盘中的文件读取到程序
        FileInputStream fileInputStream = null;
        byte[] fileBytes = new byte[(int) new File(src).length()];

        try {
            fileInputStream = new FileInputStream(src);
            fileInputStream.read(fileBytes); //将文件读入到程序的字节数组
            //将文件对应的字节数组设置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);
                }
            }
        }
        //提示信息
        System.out.println("\n" + senderId + "给" + getterId + "发送文件：" + src + "对方电脑的目录");
        //发送
        try {
            ObjectOutputStream oos = new ObjectOutputStream
                    (ManageClientConnectServerThread.getClientConnectServerThread(senderId)
                            .getSocket().getOutputStream());
            oos.writeObject(message);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

ManageClientConnectServerThread类：

import java.util.HashMap;

/**
 * 该类管理客户端连接到服务器端的线程的类
 */
public class ManageClientConnectServerThread {
    //我们把多个线程放入一个HashMap集合，key就是用户id，value就是线程
    private static HashMap<String, ClientConnectServerThread> hm = new HashMap<>();
    //将某个线程加入到集合
    public static void addClientConnectServerThread(String userId, ClientConnectServerThread clientConnectServerThread){
        hm.put(userId, clientConnectServerThread);
    }
    //通过userId就能得到对应的线程
    public static ClientConnectServerThread getClientConnectServerThread(String userId){
        return hm.get(userId);
    }
}

MessageClientService类：

import com.ryy.qqcommon.Message;
import com.ryy.qqcommon.MessageType;

import java.io.IOException;
import java.io.ObjectOutputStream;

/**
 * 该类提供和消息相关的服务方法
 */
public class MessageClientService {

    /**
     *
     * @param content 内容
     * @param senderId 发送者
     */
    public void sendMessageToAll(String content, String senderId) {
        //构建message
        Message message = new Message();
        message.setMesType(MessageType.MESSAGE_TO_ALL_MES); //群发消息这种类型
        message.setSender(senderId);
        message.setContent(content);
        message.setSendTime(new java.util.Date().toString()); //发送对象设置到message对象
        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);
        }
    }

    /**
     *
     * @param content 内容
     * @param senderId 发送用户id
     * @param getterId 接收用户id
     */
    public void sendMessageToOne(String content, String senderId, String getterId) {
        //构建message
        Message message = new Message();
        message.setMesType(MessageType.MESSAGE_COMM_MES); //普通的聊天消息
        message.setSender(senderId);
        message.setGetter(getterId);
        message.setContent(content);
        message.setSendTime(new java.util.Date().toString()); //发送对象设置到message对象
        System.out.println(senderId + "对" + getterId + "说" + content);

        //发送给服务端
        try {
            ObjectOutputStream oos =
                    new ObjectOutputStream(ManageClientConnectServerThread.getClientConnectServerThread
                            (senderId).getSocket().getOutputStream());
            oos.writeObject(message);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
    public void getOfflineMessages(String userId) {
        // 构建一个消息对象，请求获取离线消息
        Message message = new Message();
        message.setMesType(MessageType.MESSAGE_OFF_LINE); // 设置消息类型为请求离线消息
        message.setGetter(userId); // 设置接收者为当前用户

        try {
            // 发送请求消息到服务器
            ObjectOutputStream oos = new ObjectOutputStream(ManageClientConnectServerThread
                    .getClientConnectServerThread(userId).getSocket().getOutputStream());
            oos.writeObject(message);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

UserClientService类：

import com.ryy.qqcommon.Message;
import com.ryy.qqcommon.MessageType;
import com.ryy.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 {
    //根据userId 和 pwd到服务器验证该用户是否合法

    //因为我们可能在其他地方使用user信息,因此做成成员属性以便使用getter setter方法
    private User u = new User();
    //因为Socket在其他地方也可能使用，因此做成属性
    private Socket socket;

    public boolean checkUser(String userId, String pwd) {
        boolean b = false;
        //创建User对象
        u.setUserId(userId);
        u.setPasswd(pwd);
        //链接到服务端，发送u对象

        try {
            //连接至9999端口
            socket = new Socket(InetAddress.getByName("127.0.0.1"), 9999);
            //得到ObjectOutputStream对象
            ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
            //把userId和密码发送给服务器端
            oos.writeObject(u);

            //读取从服务端返回的Message对象
            ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
            Message ms = (Message) ois.readObject();

            if (ms.getMesType().equals(MessageType.MESSAGE_LOGIN_SUCCEED)) { //代表登录成功
                //创建一个和服务器端保持通信的线程->创建一个类 ClientConnectServerThread
                ClientConnectServerThread clientConnectServerThread = new ClientConnectServerThread(socket);
                //启动客户端线程
                clientConnectServerThread.start();
                //这里为了后面客户端的扩展，我们将线程放入到集合管理
                ManageClientConnectServerThread.addClientConnectServerThread(userId, clientConnectServerThread);

                b = true;
            } else {
                //如果登录失败，我们就不能启动和服务器通信的线程，关闭socket
                socket.close();
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return b;
    }

    //向u服务器端请求在线用户列表
    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 (IOException e) {
            throw new RuntimeException(e);
        }
    }

    //编写方法退出客户端，并给服务端发送一个退出系统的message
    public void logout() {
        Message message = new Message();
        message.setContent(MessageType.MESSAGE_CLIENT_EXIT);
        message.setSender(u.getUserId()); //一定要指定我是哪个客户端id
        //解决服务端报出空指针异常问题
        message.setMesType(MessageType.MESSAGE_CLIENT_EXIT);

        //发送message
        try {
            //得到当前线程的Socket对应的ObjectOutputStream对象
            ObjectOutputStream oos =
                    new ObjectOutputStream(ManageClientConnectServerThread.getClientConnectServerThread
                            (u.getUserId()).getSocket().getOutputStream());
            oos.writeObject(message);
            System.out.println(u.getUserId() + "退出系统");
            System.exit(0);

        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

view包中：

QQView类：

import com.ryy.qqclient.service.FileClientService;
import com.ryy.qqclient.service.MessageClientService;
import com.ryy.qqclient.service.UserClientService;
import com.ryy.utils.Utility;

/**
 * 客户端的菜单界面
 */
public class QQView {
    private boolean loop = true; //控制是否显示菜单
    private String key = ""; //接收键盘的输入

    public static void main(String[] args) {
        new QQView().mainMenu();
    }
    private UserClientService userClientService = new UserClientService(); //对象是用于登陆服务/注册用户
    private MessageClientService messageClientService = new MessageClientService(); //对象用户私聊/群聊
    private FileClientService fileClientService = new FileClientService(); //该对象用于传输文件
    //显示主菜单
    private void mainMenu() {
        while (loop){
            System.out.println("==========欢迎登陆网络通信习通==========");
            System.out.println("\t\t 1 登录系统");
            System.out.println("\t\t 9 退出系统");
            System.out.print("请输入你的选择：");

            key = Utility.readString(1);

            //根据用户输入，来处理不同的逻辑
            switch (key) {
                case "1":
                    System.out.print("请输入用户号：");
                    String userId = Utility.readString(50);
                    System.out.print("请输入密  码：");
                    String pwd = Utility.readString(50);
                    //接下来要到服务器去验证该用户是否合法
                    //这里有很多代码，我们这里编写一个类 UserClientService[用户登录/注册]
                    if(userClientService.checkUser(userId, pwd)) {
                        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 5 显示留言信息");
                            System.out.println("\t\t 9 退出系统");
                            System.out.print("请输入你的选择：");

                            key = Utility.readString(1);
                            switch (key) {
                                case "1":
                                    System.out.println("显示在线用户列表");
                                    userClientService.onlineFriendList();
                                    break;
                                case "2":
                                    System.out.print("请输入想对大家说的话：");
                                    String s = Utility.readString(100);
                                    //调用一个方法，将消息封装成message对象，发送给服务端
                                    messageClientService.sendMessageToAll(s, userId);
                                    break;
                                case "3":
                                    System.out.print("请输入想聊天的用户号（在线）：");
                                    String getterId = Utility.readString(50);
                                    System.out.print("请输入想说的话：");
                                    String content = Utility.readString(100);
                                    //编写一个方法，将消息发送给服务器端
                                    messageClientService.sendMessageToOne(content, userId, getterId);
                                    System.out.println("私聊消息");
                                    break;
                                case "4":
                                    System.out.print("请输入你想把文件发送给的用户（在线用户）：");
                                    getterId = Utility.readString(50);
                                    System.out.print("请输入发送方文件的路径（形式 d:\\xx.png）");
                                    String src = Utility.readString(100);
                                    System.out.println("文件已发送");
                                    fileClientService.sendFileToOne(src, userId, getterId);
                                    break;
                                case "5":
                                    messageClientService.getOfflineMessages(userId);
                                    break;
                                case "9":
                                    //编写方法，给服务器发送一个退出系统的message
                                    userClientService.logout();
                                    loop = false;
                                    break;
                            }
                        }
                    }else { //提示登录失败
                        System.out.println("=========登录失败==========");
                    }
                    break;
                case "9":
                    loop = false;
                    break;
            }
        }
    }
}

以上就是这次项目的全部内容，制作不易点赞谢谢各位大佬了

Dr_RR

关注

40
点赞
踩
21

收藏

觉得还不错? 一键收藏
3
评论
Java网上聊天项目（纯后端）--基于韩顺平老师的视频

主要技术：JavaWeb网络编程，多线程，面向对象oop，io流等......在继坦克大战之后我也是试着自己跟着视频学习了一下韩老师的qq项目，我所主要进行分享的是：1，韩老师在项目视频最后实现离线发送消息的个人想法和思路2，解决视频中的一些自己实际编写中遇到的异常问题3，自己在上网查询之后写出的接收方指定将文件保存到电脑的xx位置。
复制链接

扫一扫