日期: 11/20/2021

上一篇 Java语言实战开发 @网络聊天室 (一) 简单实现用户发消息给后台管理员

1. 探索服务端接收消息的机制

在上一次的实践中，使用缓冲输入输出流通过套接字进行网络通信，但是目前只能实现使用客户端发送消息给服务端，服务端无法做出回应，这一次就对此问题进行优化。

由于是初次使用 ServerSocket 类，有一些机制需要自己探索，比如在Server中这段：

while(true){ Socket accept = serverSocket.accept(); BufferedReader r = new BufferedReader(new InputStreamReader(accept.getInputStream())); String message; while((message = r.readLine()) != null) System.out.println("收到: " + message);

最外层使用一个while循环不断执行，接收客户端套接字的程序，同时根据套接字的字节输入流而创建缓冲输入流，进而读取来自客户端的数据，那么服务端最终会执行多少次 while (true) 呢？
是否在客户端发送一次消息过后，服务端就结束一次while循环了呢？只需一个变量就可以解决这个疑问，测试代码如下：

int i = 0; 
while(true){
	// ... 前面部分和之前一样
	System.out.println("-----" + (++i));
接下来先后打开服务端、客户端，并在客户端发送三条测试消息，测试结果如下：

答案是：while (true) 只执行了一次，而且一直没有结束.。
这意味着服务端主线程一直在执行 while(message = r.rindLine() != null); 的语句。
现在把while 改成 if ，同时把socket的获取放在前面，否则会一直阻塞进程，测试效果如下:
Socket accept = serverSocket.accept();
while(true){
	//...
	if(message=r.rindLine())!=null){
		// ...
成功解决了服务端接受一个客户端的线程阻塞问题，接下来测试两个客户端，通过修改端口类的连接IP实现。
很明显，由于 服务端获取socket的代码必须放在外面，否则无法一直执行while(true) 的所有内容（线程阻塞），但是在主线程，服务端必须要随时等待客户端发来的消息，此时也有其他客户端连接的可能，所以这里需要引用多线程的机制，使用Java.lang包下的Thread类实现该过程。

2 多线程机制的应用
实现多线程的方法主要有两种
方式一：实现Runnable接口，重写Run方法
class RunnableImpl implements Runnable{
	@Override
	public void run(){
		// ...
// 使用通过 new Thread(new RunnableImpl()).start()
方式二：继承Thread类，重写Run方法
class myThread extends Thread{
	@Override
	public void run(){
		// ...
// 使用通过 new myThread().start();
它们的区别是：
实现接口方式，还可以继承其他的类，具有更高的扩展性，但只有多线程的run方法。
继承的方式，具有原生Thread的方法，更加全面，但扩展性低，无法再继承第二个类。
当有多个客户端连接服务端时，即多个用户需要管理员进行管理，对于每个用户，管理员需要进行不同的约束，当然也有共性，在程序实现中，给每个用户分配一个线程，这样管理员就不用一一的对用户进行管理，提高了并发性。
现对服务端添加两个线程类，一是负责随时接待连接的客户端，二是针对响应每个客户端的消息。
ServerReadThread.java
该类负责处理一个客户端的消息发送，其中的socket对象是与服务端连接时创建的socket，所以可以根据该对象进行数据通信。
package App;
import java.io.DataInputStream;
import java.io.IOException;
import java.net.Socket;
public class ServerReadThread extends Thread{
    private Socket socket;
    private DataInputStream in;
    public ServerReadThread(Socket socket){
        this.socket = socket;
        try {
            in = new DataInputStream(socket.getInputStream());
        } catch (IOException e) {
            System.out.println("获取套接字输入流对象失败");
    @Override
    public void run() {
        while (true) {
            String info;
            try {
                if ((info = in.readUTF()) != null)
                    System.out.println(info);
            } catch (IOException e) {
                e.printStackTrace();
ServerReadyThread.java
该类负责处理每个客户端的连接，其中的serverSocket对象是创建服务端时产生的套接字，通过该对象可以调用accept()方法接收到连接的客户端套接字。
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
public class ServerReadyThread extends Thread{
    private ServerSocket serverSocket;
    public ServerReadyThread(ServerSocket serverSocket){
        this.serverSocket = serverSocket;
    @Override
    public void run() {
        while (true){
            try {
                Socket accept = serverSocket.accept();
                new ServerReadThread(accept).start();
                Server.list_socket.add(accept);
            } catch (IOException e) {
                e.printStackTrace();
Server.java
该类是服务端的主要实现类，采用多线程过后，主线程可以不用while(true)循环，
其中的 list_socket 存储当前连接的所有客户端套接字，在客户端连接时会添加进来，这样方便主线程可以对客户端进行消息反馈。
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
public class Server {
    private final static int port = 6666;
    public final static ArrayList<Socket> list_socket = new ArrayList<>(5);
    public static void main(String[] args) throws IOException {
        System.out.println("服务端启动");
        int i = 0;
        ServerSocket serverSocket = new ServerSocket(port);
        // 启动负责连接的线程
        new ServerReadyThread(serverSocket).start();
3. 服务端的反馈机制
通过多线程机制，现在服务端的主线程已经可以继续执行其他的操作，比如再添加更多的多线程。
之前所有客户端套接字存储在了 list_sockets对象里，既然是相通的套接字，那么服务端同样可以发送消息给出去，只要客户端也做相应的接收即可。
再次使用多线程机制，这次在客户端类设计多线程负责接收来自服务端的消息，同时在服务端添加发送消息的代码。
Server.java
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketAddress;
import java.util.ArrayList;
import java.util.Scanner;
public class Server {
    private final static int port = 6666;
    public final static ArrayList<Socket> list_socket = new ArrayList<>(5);
    public static Scanner in = new Scanner(System.in);
    public static void main(String[] args) throws IOException {
        System.out.println("服务端启动");
        int i = 0;
        ServerSocket serverSocket = new ServerSocket(port);
        // 启动负责连接的线程
        new ServerReadyThread(serverSocket).start();
        tips();
        while (true) {
            String operation = in.nextLine();
            switch (operation){
                case "1":
                    sendMsgToClient();
                    break;
                default:
                    System.out.print(">> 不支持当前指令,请重新输入\n>> ");
            tips();
    public static void tips(){
        System.out.println("==========欢迎访问服务端========");
        System.out.println("|      现在可进行的操作如下     |");
        System.out.println("|   1. 向指定客户端发送消息     |");
        System.out.println("================================");
        System.out.printf(">> ");
    public static void sendMsgToClient(){
        showAllClient();
        System.out.print(">> 请选择要发送到的客户端(e可取消操作)\n>> ");
        boolean flag = true;
        while (flag) {
            String choice = in.nextLine();
            switch (choice) {
                case "e":
                    flag = false;
                    break;
                default:
                    int i = Integer.parseInt(choice) -1;
                    if(i < list_socket.size()){
                        System.out.print(">> 选择成功, 接下来请输入要发送的内容\n>> ");
                        try {
                            DataOutputStream out = new DataOutputStream(list_socket.get(i).getOutputStream());
                            out.writeUTF(in.nextLine());
                            System.out.println(">> 消息发送成功!");
                            flag = false;
                        } catch (IOException e) {
                            e.printStackTrace();
                    } else{
                        System.out.println("选择的客户端不存在, 当前客户端总数目为: " + list_socket.size());
    public static void showAllClient(){
        for (int i = 0; i < list_socket.size(); i++) {
            SocketAddress name = list_socket.get(i).getRemoteSocketAddress();
            System.out.printf("%d号客户端:%s\n", (i+1), name);
ClientReadServer.java

该类负责处理客户端接收套接字的消息
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;
public class ClientReadThread extends Thread{
    private Socket socket;
    private DataInputStream in;
    public ClientReadThread(Socket socket){
        this.socket = socket;
        try {
            in = new DataInputStream(socket.getInputStream());
        } catch (IOException e) {
            System.out.println("获取套接字输出流失败.");
    @Override
    public void run() {
        while(true){
            String info;
            try {
                if((info = in.readUTF())!=null)
                    System.out.println("服务端发送了:" + info);
            } catch (IOException e) {
                e.printStackTrace();
最后需要在 Client.java中添加 new ClientReadThread(socket).start();确保线程启动。
测试结果：

4. 实现注册登陆功能
通过上面的测试，可以发现在客户端发送消息时，并不知道自己的名称，这显然不符合用户的定义，聊天工具一般都有个人的账号系统，所以在服务端和客户端连接前，最好指定一个登陆状态对象，并且服务端可以通过该对象读取已连接客户端的信息，类似于对上线的用户进行的操作。
PersonInfo.java 用户信息实体类
存储管理员和用户两个身份的信息，主要包括登陆ID、登陆密码和身份
public class PersonInfo {
    private String id;
    private String pw;
    private String identity;
    private boolean isLogin = false;
    public PersonInfo() {};
    public PersonInfo(String id, String pw, String identity) {
        this.id = id;
        this.pw = pw;
        this.identity = identity;
    public String getId() {
        return id;
    public void setId(String id) {
        this.id = id;
    public String getPw() {
        return pw;
    public void setPw(String pw) {
        this.pw = pw;
    public String getIdentity() {
        return identity;
    public void setIdentity(String identity) {
        this.identity = identity;
    public void setLogin(boolean x){
        this.isLogin = x;
Login.java 登陆功能实现类
该类可以通过判断账号ID与密码是否匹配而实现登陆，若账号不存在则可以直接创建，若密码错误则提示重新输入，代码看起来比较简洁，因为大多是调用自定义的数据工具类DataUtils.java的里的静态方法
import java.io.*;
import java.util.ArrayList;
import java.util.Scanner;
public class Login {
    public static Scanner in = new Scanner(System.in);
    public static PersonInfo go() {
        System.out.println("========登陆系统=======");
        PersonInfo user = new PersonInfo(null, null, "admin");
        boolean needLogin = true;
        while (needLogin) {
            System.out.print("id>> ");  user.setId(in.nextLine()) ;
            System.out.print("pw>> ");  user.setPw(in.nextLine());
            if (DataUtils.checkPersonInfo(user) != null) {
                System.out.println(">> 登陆成功!");
                return user;
            } else if (DataUtils.checkId(user.getId()) == false) {
                System.out.println(">> 密码错误");
            } else {
                System.out.println(">> 该用户不存在，是否创建？(y/n)");
                switch (in.nextLine()) {
                    case "y": ;
                        DataUtils.writeRegister(user);
                        System.out.println(">> 已登陆.");
                        needLogin = false;
                        break;
                    default:
                        System.out.println(">> 请重新登陆");
                        break;
        return user;
DataUtils.java 数据工具类
该类存储了所有的登陆用户的信息、以及连接的所有套接字，并提供一些相关的操作，比如读取注册用户，写入用户，验证登陆等。
import java.io.*;
import java.net.Socket;
import java.net.SocketAddress;
import java.util.ArrayList;
public class DataUtils {
    // 变量: 存储所有的注册用户 (包括管理员下同)
    private final static ArrayList<PersonInfo> list_origin_info = new ArrayList<>();
    // 变量: 存储所有上线的用户
    private final static ArrayList<PersonInfo> list_online_info = new ArrayList<>();
    // 变量: 存储所有的客户端与服务端的套接字
    public final static ArrayList<Socket> list_socket = new ArrayList<>(5);
    // 功能: 从本地读取所有的注册用户
    public static void readRegister(){
        try {
            BufferedReader in = new BufferedReader(new FileReader("personInfo.txt"));
            String info;
            while ((info = in.readLine()) != null) {
                String[] split = info.split(",");
                if (split != null && split.length == 3)
                    list_origin_info.add(new PersonInfo(split[0], split[1], split[2]));
        } catch (IOException e) { e.printStackTrace();}
    // 功能: 返回所有注册用户
    public static ArrayList<PersonInfo> getOriginInfo() {return list_origin_info; }
    // 功能: 将新用户写入配置文件
    public static void writeRegister(PersonInfo p){
        try {
            BufferedWriter out = new BufferedWriter(new FileWriter("personInfo.txt", true));
            out.write(p.getId() + "," + p.getPw() + "," + p.getIdentity() + "\n");
            out.flush();
            p.setLogin(true);
            list_online_info.add(p);
            System.out.println(p.getId() + " 注册成功!");
        } catch (IOException e) {
            e.printStackTrace();
    // 功能: 返回所有线上用户
    public static ArrayList<PersonInfo> getOnlienInfo() {return list_online_info; }
    // 功能: 检查ID是否存在
    public static boolean checkId(String id){
        for (PersonInfo personInfo : list_origin_info) {
            if (id.equals(personInfo.getId()))
                return false;
        return true;
    // 功能: 显示所有客户端的名称
    public static void showAllClient(){
        for (int i = 0; i < list_socket.size(); i++) {
            SocketAddress name =list_socket.get(i).getRemoteSocketAddress();
            System.out.printf("%d号客户端:%s\n", (i+1), name);
    // 功能: 检查用户是否存在，即验证登陆正确性
    public static PersonInfo checkPersonInfo(PersonInfo user){
        readRegister();
        String id = user.getId();
        String pw = user.getPw();
        String identity = user.getIdentity();
        for (PersonInfo p : DataUtils.getOriginInfo()) {
            if (id.equals(p.getId()) && pw.equals(p.getPw()) &&
                    identity.equals(p.getIdentity())) {
                PersonInfo pi = new PersonInfo(id, pw, identity);
                pi.setLogin(true);
                return pi;
        return null;
Server.java 服务端类， 部分有修改
public class Server {
   //...
    private static PersonInfo admin = null;
    public static void main(String[] args) throws IOException {
        admin = Login.go();
        //...
        while (true) {
            //...
5. 总结 、所有实现代码
5.1 项目结构
项目结构：
各种类的作用描述表

5.2 存在的不足
IO流的选择问题，在上一篇中，笔者用到了 BufferedReader 字符缓冲输入流，适合字符数据的传输，另外，DataInputStream似乎更适合数据的传输，但是又有一个缺点，它必须遵循严格的读写类型，比如若在socket的一端是调用readInt() 那么另一端就必须是  writeInt()，否则会抛出异常，同时还有ObjectInputStream这类输入流存在，可以尝试一番。
项目结构层次比较混乱，没有接口，未体现出多态的特性。
未考虑到多线程机制的安全性问题，目前只是按需求创建线程，以便处理事件，还没有考虑到线程是否能够合理地使用系统资源。
5.3 所有实现代码
Client.java
import java.io.*;
import java.net.Socket;
import java.util.Scanner;
public class Client {
    private static PersonInfo user = null;
    private static Socket socket;
    public static void main(String[] args) throws IOException {
        System.out.println("客户端启动");
        user = Login.go();
        // 连接服务端
        socket = new Socket("localhost", 6666);
        DataOutputStream out = new DataOutputStream(socket.getOutputStream());
        // 启动接收服务端消息的线程
        new ClientReadThread(socket).start();
        Scanner in = new Scanner(System.in);
        out.writeUTF("\n>> " + user.getId() + " 已加入聊天室!");
        while(true){
            System.out.print(user.getId() + " >> ");
            String info = in.nextLine();
            out.writeUTF("\n>> 收到来自 [ " + user.getId() +" ] 的消息: " + info);
ClientReadThread.java
import java.io.*;
import java.net.Socket;
public class ClientReadThread extends Thread{
    private Socket socket;
    private DataInputStream in;
    public ClientReadThread(Socket socket){
        this.socket = socket;
        try {
            in = new DataInputStream(socket.getInputStream());
        } catch (IOException e) {
            System.out.println("获取套接字输出流失败.");
    @Override
    public void run() {
        while(true){
            String info;
            try {
                if((info = in.readUTF())!=null)
                    System.out.println("\n服务端发送了:" + info);
            } catch (IOException e) {
                e.printStackTrace();
DataUtils.java
import java.io.*;
import java.net.Socket;
import java.net.SocketAddress;
import java.util.ArrayList;
 * @author Uni
 * @create 2021/11/20 10:55
public class DataUtils {
    // 变量: 存储所有的注册用户 (包括管理员下同)
    private final static ArrayList<PersonInfo> list_origin_info = new ArrayList<>();
    // 变量: 存储所有上线的用户
    private final static ArrayList<PersonInfo> list_online_info = new ArrayList<>();
    // 变量: 存储所有的客户端与服务端的套接字
    public final static ArrayList<Socket> list_socket = new ArrayList<>(5);
    // 功能: 从本地读取所有的注册用户
    public static void readRegister(){
        try {
            BufferedReader in = new BufferedReader(new FileReader("personInfo.txt"));
            String info;
            while ((info = in.readLine()) != null) {
                String[] split = info.split(",");
                if (split != null && split.length == 3)
                    list_origin_info.add(new PersonInfo(split[0], split[1], split[2]));
            in.close();
        } catch (IOException e) { e.printStackTrace();}
    // 功能: 返回所有注册用户
    public static ArrayList<PersonInfo> getOriginInfo() {return list_origin_info; }
    // 功能: 将新用户写入配置文件
    public static void writeRegister(PersonInfo p){
        try {
            BufferedWriter out = new BufferedWriter(new FileWriter("personInfo.txt", true));
            out.write(p.getId() + "," + p.getPw() + "," + p.getIdentity() + "\n");
            out.flush();
            p.setLogin(true);
            list_online_info.add(p);
            System.out.println(p.getId() + " 注册成功!");
            out.close();
        } catch (IOException e) {
            e.printStackTrace();
    // 功能: 返回所有线上用户
    public static ArrayList<PersonInfo> getOnlienInfo() {return list_online_info; }
    // 功能: 检查ID是否存在
    public static boolean checkId(String id){
        for (PersonInfo personInfo : list_origin_info) {
            if (id.equals(personInfo.getId()))
                return false;
        return true;
    // 功能: 显示所有客户端的名称
    public static void showAllClient(){
        for (int i = 0; i < list_socket.size(); i++) {
            SocketAddress name =list_socket.get(i).getRemoteSocketAddress();
            System.out.printf("%d号客户端:%s\n", (i+1), name);
    // 功能: 检查用户是否存在，即验证登陆正确性
    public static PersonInfo checkPersonInfo(PersonInfo user){
        readRegister();
        String id = user.getId();
        String pw = user.getPw();
        String identity = user.getIdentity();
        for (PersonInfo p : DataUtils.getOriginInfo()) {
            if (id.equals(p.getId()) && pw.equals(p.getPw()) &&
                    identity.equals(p.getIdentity())) {
                PersonInfo pi = new PersonInfo(id, pw, identity);
                pi.setLogin(true);
                return pi;
        return null;
Login.java
import java.io.*;
import java.util.ArrayList;
import java.util.Scanner;
public class Login {
    public static Scanner in = new Scanner(System.in);
    public static PersonInfo go() {
        System.out.println("========登陆系统=======");
        PersonInfo user = new PersonInfo(null, null, "admin");
        boolean needLogin = true;
        while (needLogin) {
            System.out.print("id>> ");  user.setId(in.nextLine()) ;
            System.out.print("pw>> ");  user.setPw(in.nextLine());
            if (DataUtils.checkPersonInfo(user) != null) {
                System.out.println(">> 登陆成功!");
                return user;
            } else if (DataUtils.checkId(user.getId()) == false) {
                System.out.println(">> 密码错误");
            } else {
                System.out.println(">> 该用户不存在，是否创建？(y/n)");
                switch (in.nextLine()) {
                    case "y": ;
                        DataUtils.writeRegister(user);
                        System.out.println(">> 已登陆.");
                        needLogin = false;
                        break;
                    default:
                        System.out.println(">> 请重新登陆");
                        break;
        return user;
PersonInfo.java
public class PersonInfo {
    private String id;
    private String pw;
    private String identity;
    private boolean isLogin = false;
    public PersonInfo() {};
    public PersonInfo(String id, String pw, String identity) {
        this.id = id;
        this.pw = pw;
        this.identity = identity;
    public String getId() {
        return id;
    public void setId(String id) {
        this.id = id;
    public String getPw() {
        return pw;
    public void setPw(String pw) {
        this.pw = pw;
    public String getIdentity() {
        return identity;
    public void setIdentity(String identity) {
        this.identity = identity;
    public void setLogin(boolean x){
        this.isLogin = x;
Server.java
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketAddress;
import java.util.ArrayList;
import java.util.Scanner;
public class Server {
    private final static int port = 6666;
    private static PersonInfo admin = null;
    public static Scanner in = new Scanner(System.in);
    public static void main(String[] args) throws IOException {
        System.out.println("服务端启动");
        admin = Login.go();
        int i = 0;
        ServerSocket serverSocket = new ServerSocket(port);
        // 启动负责连接的线程
        new ServerReadyThread(serverSocket).start();
        tips();
        while (true) {
            String operation = in.nextLine();
            switch (operation) {
                case "1":
                    sendMsgToClient();
                    break;
                default:
                    System.out.print(">> 不支持当前指令,请重新输入\n>> ");
            tips();
    public static void tips() {
        System.out.println("==========欢迎访问服务端========");
        System.out.println("|      现在可进行的操作如下     |");
        System.out.println("|   1. 向指定客户端发送消息     |");
        System.out.println("================================");
        System.out.printf(">> ");
    public static void sendMsgToClient() {
        DataUtils.showAllClient();
        System.out.print(">> 请选择要发送到的客户端(e可取消操作)\n>> ");
        boolean flag = true;
        while (flag) {
            String choice = in.nextLine();
            switch (choice) {
                case "e":
                    flag = false;
                    break;
                default:
                    int i = Integer.parseInt(choice) - 1;
                    if (i < DataUtils.list_socket.size()) {
                        System.out.print(">> 选择成功, 接下来请输入要发送的内容\n>> ");
                        try {
                            DataOutputStream out = new DataOutputStream(DataUtils.list_socket.get(i).getOutputStream());
                            while (true){
                                String info = in.nextLine();
                                if(!info.equals("e")){
                                    out.writeUTF(info);
                                    System.out.print(">> 消息发送成功!\n>> ");
                                else break;
                            flag = false;
                        } catch (IOException e) {
                            e.printStackTrace();
                    } else {
                        System.out.println("选择的客户端不存在, 当前客户端总数目为: " + DataUtils.list_socket.size());
ServerReadThread.java
import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;
public class ServerReadThread extends Thread{
    private static Socket socket;
    private static DataInputStream in = null;
    public ServerReadThread(Socket socket){
        this.socket = socket;
        try {
            in = new DataInputStream(this.socket.getInputStream());
        } catch (IOException e) {
            System.out.println("获取套接字输入流对象失败");
    @Override
    public void run() {
        while (true) {
            try {
                String info;
                if (in != null && (info = in.readUTF()) != null)
                    System.out.println(info);
            } catch (IOException e) {
                e.printStackTrace();
ServerReadyThread.java
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
public class ServerReadyThread extends Thread{
    private static ServerSocket serverSocket;
    public ServerReadyThread(ServerSocket serverSocket){
        this.serverSocket = serverSocket;
    @Override
    public void run() {
        while (true){
            try {
                Socket accept = serverSocket.accept();
                new ServerReadThread(accept).start();
                DataUtils.list_socket.add(accept);
            } catch (IOException e) {
                e.printStackTrace();