B站韩顺平java学习笔记（二十一）-- 多用户即时通讯系统章节

最新推荐文章于 2023-10-16 19:00:02 发布

一颗毛李子

最新推荐文章于 2023-10-16 19:00:02 发布

阅读量2.1k

点赞数 14

分类专栏： java 文章标签：学习 java 开发语言

本文链接：https://blog.csdn.net/lw_20180806/article/details/124339957

版权

java 专栏收录该内容

26 篇文章 50 订阅

订阅专栏

（1）编写用户、消息对象类，并编写消息类型接口

一项目设计的技术

1 项目框架设计

2 Java面向对象编程

3 网络编程

4 多线程

5 IO流

6 Mysql

二项目开发流程简介

需求分析→设计阶段→实现阶段→测试阶段→实施阶段→维护阶段。

三需求分析

1 用户登录

2 拉取在线用户列表

3 无异常退出（客户端、服务端）

4 私聊

5 群聊

6 发文件

7 服务器推送新闻

四通讯系统整体分析

五系统代码设计流程

1 功能实现-用户登录

功能说明：因为还没学数据库，人为规定用户名/ID = 100，密码 = 123456，就可以登录，其他都不可以登录，之后使用HashMap模拟数据库，可以多个用户登录。

（1）编写用户、消息对象类，并编写消息类型接口

这几种在QQserver和QQclient中共享。

//Message类
/**
 * 表示客户端和服务器端通讯时的消息对象
 */
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;//消息类型【在接口定义已知类型】

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

//User类
/**
 * 表示一个用户信息
 */
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;
    }

}

//MessageType接口类
/**
 * 表示消息类型
 */
public interface MessageType {
    //接口种定义了不同常量，不同常量代表不同的消息类型。
    String MESSAGE_LOGIN_SUCCEED = "1";//表示登陆成功
    String MESSAGE_LOGIN_FAIL = "2";//表示登陆成功
}

（2）编写用户显示界面

编写QQClient项目

//QQView类
/**
 *用户界面，一级二级菜单
 */
public class QQView {

    private boolean loop = true;//控制是否显示菜单
    private String key = ""; //接受用户的键盘输入

    public static void main(String[] args) {
        new QQView().mainMenu();
        System.out.println("客户端退出系统");
    }
    //显示主菜单
    private void mainMenu(){
        while (loop){
            System.out.println("=========欢迎登录网络通信系统=========");
            System.out.println("\t\t1 登录系统");
            System.out.println("\t\t9 退出系统");

            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);
                    //需要到服务端验证该用户是否合法（即是否存在该用户）
                    if(false){//假设合法
                        System.out.println("=========欢迎用户 "+userId+" 登录成功=========");
                        //进入二级菜单
                        while (loop){
                            System.out.println("=========网络通信系统二级菜单（用户 "+userId+" ）=========");
                            System.out.println("\t\t1 显示在线用户列表");
                            System.out.println("\t\t2 群发消息");
                            System.out.println("\t\t3 私聊消息");
                            System.out.println("\t\t4 发送文件");
                            System.out.println("\t\t9 退出系统");
                            System.out.print("请输入你的选择：");
                            key = Utility.readString(1);
                            switch (key){
                                case "1":
                                    System.out.println("显示在线用户列表");
                                    break;
                                case "2":
                                    System.out.println("群发消息");
                                    break;
                                case "3":
                                    System.out.println("私聊消息");
                                    break;
                                case "4":
                                    System.out.println("发送文件");
                                    break;
                                case "9":
                                    loop = false;
//                                    System.out.println("退出系统");
                                    break;
                            }
                        }
                    }else {//登录服务器失败
                        System.out.println("========登陆失败========");
                    }
                    break;
                case "9":
                    loop = false;
//                    System.out.println("退出系统");
                    break;

            }
        }
    }
}

（3）编写验证用户登录模块

编写一个 UserClientService 类，首先用户端在登陆时候会给服务端发送一个User对象，服务器端收到后会进行验证，然后返回给用户端要给Message对象来告知用户端是否合法。创建一个线程类 ClientConnectServerThread 用于保持用户端和服务器端的连接。

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

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


    @Override
    public void run() {
        //因为在Thread需要在后台和服务器一直保持通信，因此我们while循环
        while (true){
            System.out.println("客户端线程，在等待读取从服务器端返回的消息");
            try {
                ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
                //如果服务器没有发送的Message对象，线程会堵塞在这里。
                Message ms = (Message)ois.readObject();
            } catch (Exception e) {
                e.printStackTrace();
            }

        }
    }

    //为了更方便的得到Socket
    public Socket getSocket() {
        return socket;
    }
}

//UserClientService类
/**
 * 该类完成用户登录验证和用户注册功能等
 */
public class UserClientService {

    //创建User属性,因为可能在其他地方使用User信息
    // 在User类中创建一个无参构造器
    private User u = new User();
    //因为Socket在其他地方也可能使用到，因此做成属性
    private Socket socket;

    //根据userId 和 pwd 到服务器端验证用户是否合法
    public boolean checkUser(String userId ,String pwd) throws Exception{
        //创建User对象
        u.setUserId(userId);
        u.setPasswd(pwd);
        //连接到服务端，发送u对象

        socket = new Socket(InetAddress.getByName("127.0.0.1"),9999);
        //得到ObjectOutputStream对象
        ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
        oos.writeObject(u);//发送User对象

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

        if (ms.getMesType().equals(MessageType.MESSAGE_LOGIN_SUCCEED)){//登陆成功

            //创建一个和服务器端保持通信的线程 -> 创建一个类， ClientConnectServerThread



            return true;
        }else {//登陆失败
            return false;
        }
    }
}

（4）创建一个管理ClientConnectServerThread 的类ManageClientConnectServerThread，用于当线程过多时，能够进行有效的管理。

//ManageClientConnectServerThread类
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);
    }
}

并修改UserClientService类

//UserClientService类
/**
 * 该类完成用户登录验证和用户注册功能等
 */
public class UserClientService {

    //创建User属性,因为可能在其他地方使用User信息
    // 在User类中创建一个无参构造器
    private User u = new User();
    //因为Socket在其他地方也可能使用到，因此做成属性
    private Socket socket;

    //根据userId 和 pwd 到服务器端验证用户是否合法
    public boolean checkUser(String userId ,String pwd) throws Exception{
        boolean b = false;
        //创建User对象
        u.setUserId(userId);
        u.setPasswd(pwd);
        //连接到服务端，发送u对象

        socket = new Socket(InetAddress.getByName("127.0.0.1"),9999);
        //得到ObjectOutputStream对象
        ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
        oos.writeObject(u);//发送User对象

        //读取服务器返回的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();
            //客户端可能会有多个Socket线程，为了方便管理和扩展，可以放在集合中。
            ManageClientConnectServerThread.addClientConnectServerThread(userId,clientConnectServerThread);
            b = true;
        }else {
            //登陆失败,不能启动和服务器通信的线程，关闭Socket
            socket.close();
        }
        return b;
    }

}

并且在QQView类中对判断用户是否登录成功的判断条件设置为

userClientService.checkUser(userId,pwd)

（5）对QQServer项目进行编写，首先建立一个QQserver类，在9999端口循环监听【while循环】，如果有一个客户端连接到服务器端就继续往下执行【没有则堵塞等待】，得到可u护短其发送的User对象流，并判断是否是正确的，如果是正确的，返回Message对象流，然后建立一个线程时刻监听来自客户端的信息；如果不是正确的，则也返回一个Message对象流，并关闭socket对象，执行完后，又从头开始继续监听。当while循环退出了，即不再监听来自客户端的连接，则把serversocket对象关掉即可。

//QQServer类
/**
 * 服务端，在监听9999，等待客户端的连接，保持通信
 */
public class QQServer {

    private ServerSocket ss = null;//因为后面会用到，所以定义为一个属性

    public QQServer(){
        //注意端口可以放在一个配置文件中，可以改变
        try {
            System.out.println("服务端在9999端口监听");
            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 user = (User)ois.readObject();//读取客户端发送的User对象
                //创建一个Message对象，准备回复客户端
                Message message = new Message();
                if(user.getUserId().equals("100") && user.getPasswd().equals("123456")){//登陆成功
                    message.setMesType(MessageType.MESSAGE_LOGIN_SUCCEED);
                    oos.writeObject(message);
                    //创建一个线程，和客户端保持通信，该线程要有Socket对象
                    ServerConnectClientThread serverConnectClientThread =
                            new ServerConnectClientThread(socket, user.getUserId());
                    //启动该线程
                    serverConnectClientThread.start();
                    //把该线程对象放到一个集合中进行管理
                    ManageServerConnectClientThread.addServerConnectClientThread(user.getUserId(),serverConnectClientThread);
                }else {//登录失败
                    message.setMesType(MessageType.MESSAGE_LOGIN_FAIL);
                    oos.writeObject(message);
                    //登录失败，关闭socket
                    socket.close();
                }

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

//ManageServerConnectClientThread类
/**
 * 该类用于管理和客户端通信的线程
 */
public class ManageServerConnectClientThread {
    //把多个线程放入到要给HashMap集合，key 是用户的id，value就是线程
    private static HashMap<String,ServerConnectClientThread> hm = new HashMap<>();

    //将某个线程加入到集合
    public static void addServerConnectClientThread(String userId, ServerConnectClientThread serverConnectClientThread){
        hm.put(userId,serverConnectClientThread);
    }
    //通过userId得到相应的线程
    public static ServerConnectClientThread getServerConnectClientThread(String userId){
        return hm.get(userId);
    }

}

//ServerConnectClientThread类
/**
 * 该类的一个对象和某个客户端保持通信
 */
public class ServerConnectClientThread extends Thread{
    private Socket socket;//该线程需要持有Socket保持通信
    private String userId;//连接到服务器端的用户Id

    public ServerConnectClientThread(Socket socket, String userId) {
        this.socket = socket;
        this.userId = userId;
    }

    @Override
    public void run() {//这里线程处于run状态，可以发送或接收到客户端消息
        while (true){
            try {
                System.out.println("服务器端和客户端"+ userId +"保持通信，读取数据");
                ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
                Message ms = (Message)ois.readObject();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    }
}

（6）更新QQserver类，创建一个结合用于存放用户信息，这样就可以有多个用户同时登录了，并且把判断用户信息是否合法的代码放在一个方法checkUser里面。

//QQServer类
/**
 * 服务端，在监听9999，等待客户端的连接，保持通信
 */
public class QQServer {

    private ServerSocket ss = null;//因为后面会用到，所以定义为一个属性
    //创建一个集合，存放多个用户，如果是这些用户登录，就认为是合法登录
    //这里我们也可以使用 ConcurrentHashMap, 可以处理并发的集合，没有线程安全
    //HashMap 没有处理线程安全，因此在多线程情况下是不安全
    //ConcurrentHashMap 处理的线程安全,即线程同步处理, 在多线程情况下是安全
    private static HashMap<String,User> validUsers = new HashMap<>();
    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 pwd){
//        for (int i = 0; i < validUsers.size(); i++) {
//            User user = validUsers.get(i);
//            if (userId.equals(user.getUserId()) && pwd.equals(user.getPasswd())){
//                return true;
//            }
//        }
//        return false;
        User user = validUsers.get(userId);
        if (user == null){//不存在直接返回false
            return false;
        }
        if (!(pwd.equals(user.getPasswd()))){//id正确，但是密码错误
            return false;
        }
        return true;
    }

    public QQServer(){
        //注意端口可以放在一个配置文件中，可以改变
        try {
            System.out.println("服务端在9999端口监听");
            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 user = (User)ois.readObject();//读取客户端发送的User对象
                //创建一个Message对象，准备回复客户端
                Message message = new Message();
                if(checkUser(user.getUserId(),user.getPasswd())){//登陆成功
                    message.setMesType(MessageType.MESSAGE_LOGIN_SUCCEED);
                    oos.writeObject(message);
                    //创建一个线程，和客户端保持通信，该线程要有Socket对象
                    ServerConnectClientThread serverConnectClientThread =
                            new ServerConnectClientThread(socket, user.getUserId());
                    //启动该线程
                    serverConnectClientThread.start();
                    //把该线程对象放到一个集合中进行管理
                    ManageServerConnectClientThread.addServerConnectClientThread(user.getUserId(),serverConnectClientThread);
                }else {//登录失败
                    System.out.println("用户Id：" + user.getUserId() + "pwd: "+ user.getPasswd() +"验证失败");
                    message.setMesType(MessageType.MESSAGE_LOGIN_FAIL);
                    oos.writeObject(message);
                    //登录失败，关闭socket
                    socket.close();
                }

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

2 功能实现 - 拉取在线用户列表

（1）功能说明

（2）修改QQClient类

增加messageType类型，在UserClientService类中加入向服务器端请求在线用户列表的onlineFriendList方法，在 ClientConnectServerThread 类中的run()方法中加入判断message类型，然后做相应的业务处理

//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"; //客户端请求退出
}

//UserClientService类
/**
 * 该类完成用户登录验证和用户注册功能等
 */
public class UserClientService {

    //创建User属性,因为可能在其他地方使用User信息
    // 在User类中创建一个无参构造器
    private User u = new User();
    //因为Socket在其他地方也可能使用到，因此做成属性
    private Socket socket;

    //根据userId 和 pwd 到服务器端验证用户是否合法
    public boolean checkUser(String userId ,String pwd) throws Exception{
        boolean b = false;
        //创建User对象
        u.setUserId(userId);
        u.setPasswd(pwd);
        //连接到服务端，发送u对象

        socket = new Socket(InetAddress.getByName("127.0.0.1"),9999);
        //得到ObjectOutputStream对象
        ObjectOutputStream oos =
                new ObjectOutputStream(socket.getOutputStream());
        oos.writeObject(u);//发送User对象

        //读取服务器返回的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();
            //客户端可能会有多个Socket线程，为了方便管理和扩展，可以放在集合中。
            ManageClientConnectServerThread.addClientConnectServerThread(userId,clientConnectServerThread);
            b = true;
        }else {
            //登陆失败,不能启动和服务器通信的线程，关闭Socket
            socket.close();
        }
        return b;
    }
    //向服务器端请求在线用户列表
    public void onlineFriendList(){
        //发送一个message，类型MESSAGE_GET_ONLINE_FRIEND
        Message message = new Message();
        message.setSender(u.getUserId());
        message.setMesType(MessageType.MESSAGE_GET_ONLINE_FRIEND);
        //发送给服务器
        try {
            //从管理线程的集合中，通过userId，得到这个线程
            ClientConnectServerThread clientConnectServerThread =
                    ManageClientConnectServerThread.getClientConnectServerThread(u.getUserId());
            //得到这个线程关联的socket
            Socket socket = clientConnectServerThread.getSocket();
            //得到当先socket对应的ObjectOutPutStream对象
            ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
            //向服务器端发送message对象，要求服务器要求在线用户列表
            oos.writeObject(message);

        } catch (IOException e) {
            e.printStackTrace();
        }


    }

}

//ClientConnectServerThread类
public class ClientConnectServerThread extends Thread {
    private Socket socket;//

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


    @Override
    public void run() {
        //因为在Thread需要在后台和服务器一直保持通信，因此我们while循环
        while (true){
            System.out.println();
            System.out.println("客户端线程，在等待读取从服务器端返回的消息");
            try {
                ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
                //如果服务器没有发送的Message对象，线程会堵塞在这里。
                Message ms = (Message)ois.readObject();
                //判断这个message类型，然后做相应的业务处理
                //如果读取到的是服务端返回的在线用户列表
                if (ms.getMesType().equals(MessageType.MESSAGE_RET_ONLINE_FRIEND)){
                    //取出在线列表信息，并显示
                    //规定
                    String[] onlineUsers = ms.getContent().split(" ");
                    System.out.println();
                    System.out.println("========在线用户列表========");
                    for (int i = 0; i < onlineUsers.length; i++) {
                        System.out.println("用户:" + onlineUsers[i]);
                        
                    }
                }else {
                    System.out.println("是其他类型的message，暂时不处理..");
                }
            } catch (Exception e) {
                e.printStackTrace();
            }

        }
    }

    //为了更方便的得到Socket
    public Socket getSocket() {
        return socket;
    }
}

（3）修改QQServer项目

首先在 ServerConnectClientThread 类中的run()方法，判断message类型，然后做相应的业务处理，在 ManageServerConnectClientThread 类中添加返回在线用户列表的方法。

//ServerConnectClientThread类
/**
 * 该类的一个对象和某个客户端保持通信
 */
public class ServerConnectClientThread extends Thread{
    private Socket socket;//该线程需要持有Socket保持通信
    private String userId;//连接到服务器端的用户Id

    public ServerConnectClientThread(Socket socket, String userId) {
        this.socket = socket;
        this.userId = userId;
    }

    @Override
    public void run() {//这里线程处于run状态，可以发送或接收到客户端消息
        while (true){
            try {
                System.out.println("服务器端和客户端"+ userId +"保持通信，读取数据");
                ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
                Message ms = (Message)ois.readObject();
                //判断这个message类型，然后做相应的业务处理
                if (ms.getMesType().equals(MessageType.MESSAGE_GET_ONLINE_FRIEND)){
                    //客户端要在线用户列表
                    //在线用户列表格式 100 200 紫霞仙子
                    System.out.println(ms.getSender() + " 要在线用户列表");
                    String onlineUser = ManageServerConnectClientThread.getOnlineUser();
                    //返回message
                    Message message2 = new Message();
                    message2.setMesType(MessageType.MESSAGE_RET_ONLINE_FRIEND);
                    message2.setContent(onlineUser);
                    message2.setGetter(ms.getGetter());
                    //返回给客户端
                    ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
                    oos.writeObject(message2);

                }else {
                    System.out.println("其他的处理");
                }
            } catch (IOException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    }
}

//ManageServerConnectClientThread类
/**
 * 该类用于管理和客户端通信的线程
 */
public class ManageServerConnectClientThread {
    //把多个线程放入到要给HashMap集合，key 是用户的id，value就是线程
    private static HashMap<String,ServerConnectClientThread> hm = new HashMap<>();

    //将某个线程加入到集合
    public static void addServerConnectClientThread(String userId, ServerConnectClientThread serverConnectClientThread){
        hm.put(userId,serverConnectClientThread);
    }
    //通过userId得到相应的线程
    public static ServerConnectClientThread getServerConnectClientThread(String userId){
        return hm.get(userId);
    }
    //编写方法，可以返回在线用户列表
    public static String getOnlineUser() {
        //集合遍历，遍历 hashMap的key
        Iterator<String> iterator = hm.keySet().iterator();
        String onlineUserList = "";
        while (iterator.hasNext()){
            onlineUserList += iterator.next() + " ";
        }
        return onlineUserList;
    }
}

3 功能实现 - 无异常退出系统

（1）客户端解决方法

① 调用方法，给服务器端发送一个退出系统的message对象；

② 调用System.exit(0)//正常退出。

（2）服务器端

① 服务器端和某个客户端通信的线程如果接收到了一个退出系统的message后；

② 把持有的socket关闭；

③ 退出线程。

（3）客户端代码

在客户端UserClientService类中添加向服务端发送关闭的信息方法，然后在QQView中调用该方法。

//编写方法，退出客户端，并给服务端发送一个退出系统的message对象
    public void logout(){
        Message message = new Message();
        message.setMesType(MessageType.MESSAGE_CLIENT_EXIT);
        message.setSender(u.getUserId());//指出是哪个用户id

        //发送message
        try {
            OutputStream outputStream = socket.getOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(outputStream);
            oos.writeObject(message);
            System.out.println(u.getUserId() + " 退出系统");
            System.exit(0);//结束进程
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

//调用方法，给服务器发送一个退出系统的message
userClientService.logout();

（4）服务端代码

在 ManageServerConnectClientThread 类中添加将某个线程从集合移除的方法，在ServerConnectClientThread类中，若信息类型为退出，则将对应的线程从线程集合移除，关闭连接，退出线程。

//ManageServerConnectClientThread类
//将某个线程从集合移除
    public static void removeServerConnectClientThread(String userId){
        hm.remove(userId);
    }

//ServerConnectClientThread类
if (ms.getMesType().equals(MessageType.MESSAGE_CLIENT_EXIT)){
                    System.out.println(ms.getSender() + " 退出系统");
                    //将对应的线程从线程集合移除
                   
                    ManageServerConnectClientThread.removeServerConnectClientThread(ms.getSender());
                    socket.close();//关闭连接
                    break;//退出线程
}

4 功能实现 - 私聊

（1）客户端分析

① 【发送消息者】接收用户希望给某个其他在线用户聊天的内容；

② 【发送消息者】将消息构建成Message对象，通过对应的socket发送给服务器；

③ 【接受消息者】在他的线程（通信线程中），读取到发送的message消息，并显示即可

（2）服务端分析

① 可以读取到客户端发送给某个客户的消息；

② 从管理线程的集合中，根据message对象的getterid，获取到对象线程的socket；

③ 然后将message对象转发给指定客户。

（3）客户端代码

首先，新建一个类【用于提供和消息相关的方法】，在类中新建一个方法用于发送私聊消息

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

    //创建User属性,因为可能在其他地方使用User信息
    // 在User类中创建一个无参构造器

    /**
     *
     * @param senderId  发送者id
     * @param getterId  接收者id
     * @param sendContent  发送内容
     */
    //发送私聊消息
    public void sendPrivateMessage(String senderId ,String getterId,String sendContent){
        Message message = new Message();
        message.setMesType(MessageType.MESSAGE_COMM_MES);
        message.setSender(senderId);
        message.setGetter(getterId);
        message.setContent(sendContent);
        message.setSendTime(new Date().toString());//设置时间
        //获取ObjectOutputStream
        try {
            ObjectOutputStream oos = new ObjectOutputStream(ManageClientConnectServerThread.getClientConnectServerThread(senderId).getSocket().getOutputStream());
            oos.writeObject(message);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在QQView类中调用该方法，注意要在该类属性中定义MessageClientService 类。

System.out.print("请输入要私聊的姓名（在线的）：");
String getterId = Utility.readString(50);
System.out.print("请输入要私聊的内容：");
String sendContent = Utility.readString(100);
messageClientService.sendPrivateMessage(userId,getterId,sendContent);

在 ClientConnectServerThread 类内

if (ms.getMesType().equals(MessageType.MESSAGE_COMM_MES)){
    //显示信息即可
    System.out.println(ms.getContent());
}

（4）服务端代码

编写若处理该信息类型的情况

if (ms.getMesType().equals(MessageType.MESSAGE_COMM_MES)){
                    System.out.println(ms.getSender() + " 要和" + ms.getGetter() + " 私聊");
                    //获取接收消息的用户线程
                    ServerConnectClientThread scct = ManageServerConnectClientThread.getServerConnectClientThread(ms.getGetter());
                    //判断是否在线,存在线程就不在线
                    if (scct == null){//不在线，就告知发送消息者
                        System.out.println(ms.getGetter() + " 不在线");
                        Message message3 = new Message();
                        message3.setContent("\n" + ms.getGetter() + " 不在线,无法私聊");
                        message3.setMesType(MessageType.MESSAGE_COMM_MES);
                        message3.setGetter(ms.getSender());
                        //返回给客户端
                        ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
                        oos.writeObject(message3);
                    }else {//在线，就给接收者发送消息，并告知发送者对方已收到消息
                        Message message4 = new Message();
                        message4.setMesType(MessageType.MESSAGE_COMM_MES);
                        message4.setSender(ms.getSender());
                        message4.setGetter(ms.getGetter());
                        message4.setContent("\n" + ms.getSender() + " 对 "+ ms.getGetter() + " 说： " + ms.getContent());
                        //获取接收者和发送者的线程
                        ServerConnectClientThread scct1 = ManageServerConnectClientThread.getServerConnectClientThread(ms.getGetter());
                        ServerConnectClientThread scct2 = ManageServerConnectClientThread.getServerConnectClientThread(ms.getSender());
                        //获取接收者线程的socket关联的对象输出流，并发送数据
                        ObjectOutputStream oos1 = new ObjectOutputStream(scct1.socket.getOutputStream());
                        ObjectOutputStream oos2 = new ObjectOutputStream(scct2.socket.getOutputStream());
                        oos1.writeObject(message4);
                        oos2.writeObject(message4);
                        System.out.println(ms.getSender() + " 在和 " + ms.getGetter() + " 私聊");
                    }
                }

5 功能实现 - 群聊

（1）用户端代码

在MessageType接口添加新的类型

String MESSAGE_TO_ALL_MES = "7"; //群发消息报

在MessageClientService 类中编写方法

public void sendPublicMessage(String senderId ,String sendAllContent){
        Message message = new Message();
        message.setSender(senderId);
        message.setContent(sendAllContent);
        message.setSendTime(new Date().toString());
        message.setMesType(MessageType.MESSAGE_TO_ALL_MES);
        try {
            ObjectOutputStream oos = new ObjectOutputStream(ManageClientConnectServerThread.getClientConnectServerThread(senderId).getSocket().getOutputStream());
            oos.writeObject(message);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

在QQView类的相应位置

System.out.print("请输入要群聊的内容：");
String sendAllContent = Utility.readString(100);                              messageClientService.sendPublicMessage(userId,sendAllContent);

（2）服务端代码

在 ServerConnectClientThread 类中判断该条件

if(ms.getMesType().equals(MessageType.MESSAGE_TO_ALL_MES)){
                    Iterator<String> iterator = ManageServerConnectClientThread.getHm().keySet().iterator();
       while (iterator.hasNext()){
       String s = iterator.next();
       Message message = new Message();
       message.setMesType(MessageType.MESSAGE_TO_ALL_MES);
       message.setSendTime(new Date().toString());
       message.setContent(ms.getSender() +" 对大家伙说 "+ms.getContent());
       message.setSender(ms.getSender());
       message.setGetter(s);
       ObjectOutputStream oos = new ObjectOutputStream(ManageServerConnectClientThread.getServerConnectClientThread(s).getSocket().getOutputStream());
                        oos.writeObject(message);
                    }

                }

6 功能实现 - 发文件

（1）客户端思路

① 先把文件a.jpg 读取到客户端，字节数组；

② 把文件对于的字节数组封装到message对象，【包含文件内容，sender，getter】；

③ 将message对象发送给客户端；

④ 在接收到包含有文件的消息后，将该文件保存到磁盘。

（2）服务端思路

① 接收到message对象；

② 拆解message对象的getterid，获取该用户的通信线程；

③ 把message对象转发给指定用户。

（3）客户端代码

在MessageType接口添加

String MESSAGE_FILE_MES = "8"; //文件消息(发送文件)

在Message中添加

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

在FileClientService类中添加发送文件的消息

//FileClientService类
public class FileClientService {
    //发送文件的消息
    public void sendFile(String senderId, String getterId, String fileSrc, String fileDesc){
        Message message = new Message();
        message.setSender(senderId);
        message.setGetter(getterId);
        message.setSendTime(new Date().toString());
        message.setMesType(MessageType.MESSAGE_FILE_MES);
        message.setSrc(fileSrc);
        message.setDest(fileDesc);
        String fileContext = "";
        BufferedInputStream bis = null;
        try {
            bis = new BufferedInputStream(new FileInputStream(fileSrc));
            byte[] fileBytes = new byte[(int)new File(fileSrc).length()];
            bis.read(fileBytes);
            message.setFileBytes(fileBytes);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if (bis != null){
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        try {
            ObjectOutputStream oos = new ObjectOutputStream(ManageClientConnectServerThread.getClientConnectServerThread(message.getSender()).getSocket().getOutputStream());
            oos.writeObject(message);
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println(message.getSender() +" 给 " +message.getGetter() + " 发文件，保存到 " +message.getDest());
    }
}

在QQView类中相应位置添加如下代码

System.out.print("请输入要发送给谁文件（在线的）：");
String getterFileId = Utility.readString(50);
System.out.print("请输入文件的源路径：");
String fileSrc = Utility.readString(100);
System.out.print("请输入文件保存的存储路径：");
String fileDesc = Utility.readString(100);                     fileClientService.sendFile(userId,getterFileId,fileSrc,fileDesc);

在ClientConnectServerThread 类中添加如下代码

if (ms.getMesType().equals(MessageType.MESSAGE_FILE_MES)){
       byte[] fileBytes = ms.getFileBytes();
       String dest = ms.getDest();
       BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(dest));
       bos.write(fileBytes,0,fileBytes.length);
       bos.close();
       System.out.println("\n"+ms.getSender() +" 给 " +ms.getGetter() + " 发文件，保存到 " +ms.getDest());
}

（4）服务端代码

在 ServerConnectClientThread 类中添加

if(ms.getMesType().equals(MessageType.MESSAGE_FILE_MES)){
                    String fileGetter = ms.getGetter();
                    ServerConnectClientThread scct = ManageServerConnectClientThread.getServerConnectClientThread(fileGetter);
                    //判断是否在线
                    Message message = new Message();
                    if (scct == null){

                        message.setGetter(ms.getSender());
                        message.setMesType(MessageType.MESSAGE_COMM_MES);
                        message.setContent(ms.getGetter() + " 不在线，无法发送");
                        ObjectOutputStream OOS = new ObjectOutputStream(ManageServerConnectClientThread.getServerConnectClientThread(ms.getSender()).getSocket().getOutputStream());
                        OOS.writeObject(message);
                    }else {
                        ObjectOutputStream oos = new ObjectOutputStream(scct.getSocket().getOutputStream());
                        oos.writeObject(ms);
                    }
}

7 功能实现 - 服务端推送消息

（1）服务器端思路

① 推送消息/新闻，本质就是群发消息；

② 在服务器启动一条线程，专门负责发送推送新闻。

（2）服务器端代码

加入工具包，编写 SendNewsToAllService 类，发送推送新闻

//SendNewsToAllService类
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,并发送message

            HashMap<String, ServerConnectClientThread> hm = ManageServerConnectClientThread.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) {
                    e.printStackTrace();
                }
            }
        }

    }
}

在QQView类中的构造器中

//启动推送新闻的线程
new Thread(new SendNewsToAllService()).start();

知识点

1 一个idea项目多次允许

一颗毛李子

关注

14
点赞
踩
41

收藏

觉得还不错? 一键收藏
0
评论
B站韩顺平java学习笔记（二十一）-- 多用户即时通讯系统章节

一项目设计的技术1 项目框架设计2 Java面向对象编程3 网络编程4 多线程5 IO流6 Mysql二项目开发流程简介需求分析→设计阶段→实现阶段→测试阶段→实施阶段→维护阶段。三需求分析1 用户登录2 拉取在线用户列表3 无异常退出（客户端、服务端）4 私聊5 群聊6 发文件7 服务器推送新闻四通讯系统整体分析...
复制链接

扫一扫