韩顺平Java-第二十二章：多用户即时通讯系统

最新推荐文章于 2024-10-20 13:40:40 发布

weixin_47199727

最新推荐文章于 2024-10-20 13:40:40 发布

阅读量1.9k

点赞数 57

文章标签： java

本文链接：https://blog.csdn.net/weixin_47199727/article/details/141279960

版权

一项目设计的技术

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(true){//假设合法
                        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("========登陆失败========");
                    }
            }
        }
    }

}

（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();

知识点

在这里插入图片描述

weixin_47199727

关注

57
点赞
踩
53

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

韩顺平Java-第二十二章：多用户即时通讯系统

一 项目设计的技术

二 项目开发流程简介

三 需求分析

1 用户登录

2 拉取在线用户列表

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

4 私聊

5 群聊

6 发文件

7 服务器推送新闻

四 通讯系统整体分析

五 系统代码设计流程

1 功能实现-用户登录

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

（1）功能说明

（2）修改QQClient类

（3）修改QQServer项目

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

（1）客户端解决方法

（2）服务器端

（3）客户端代码

（4）服务端代码

4 功能实现 - 私聊

（1）客户端分析

（2）服务端分析

（3）客户端代码

（4）服务端代码

5 功能实现 - 群聊

（1）用户端代码

（2）服务端代码

6 功能实现 - 发文件

（1）客户端思路

（2）服务端思路

（3）客户端代码

（4）服务端代码

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

（1）服务器端思路

（2）服务器端代码

知识点

一项目设计的技术

二项目开发流程简介

三需求分析

四通讯系统整体分析

五系统代码设计流程