Java Socket实现简易多人聊天室传输聊天内容或文件

向右看齐 2023-10-01 23:16 21阅读 0赞

## Java Socket实现简易多人聊天室传输聊天内容或文件 ##

**Java小练手项目：用Java Socket实现多人聊天室，聊天室功能包括传输聊天内容或者文件**。相比于其它的聊天室，增加了传输文件的功能供参考。

### 模块拆解 ###

分成服务端和客户端两部分来写

服务端包括监听线程和处理收发信线程：

1.  创建监听线程，监听客户端的连接。将每个连接的客户端加入维护的列表，并为每个连接的客户端开启一个处理收发信的线程。
2.  在每个客户端的收发信线程中，接收每个客户端发回的消息，并对其进行转发到相应接收的客户端上，以此实现多人聊天室。
3.  添加处理传输文件的判断，通过在传输的字节数组中添加标志位来区分传输的是文本消息，还是文件。

客户端包括发送消息线程和接收消息线程：

1.  发送消息线程，用来处理用户的输入信息，判断输入的是文本信息还是文件，并修改传输的字节数组标志位进行区分。最后将信息传输给服务器。
2.  接收消息线程，用来处理服务器发回的信息，根据标志位判断输入的是文本信息还是文件，并做相应处理。如果是文本信息，则显示在控制台，如果是文件，则保存在指定目录下。

项目的目录结构如下所示

![format_png][]

接下来，给出实际的代码进行分析

### 项目代码 ###

#### 服务器端 ####

监听线程

package Server;
    
    import java.io.IOException;
    import java.net.InetAddress;
    import java.net.ServerSocket;
    import java.net.Socket;
    import java.util.ArrayList;
    import java.util.List;
    
    public class MultiServer {
        public static void main(String[] args) {
            ServerSocket ss = null;
            Socket s = null;
    
            // 定义一个List列表来保存每个客户端，每新建一个客户端连接，就添加到List列表里。
            List<Socket> listSocket = new ArrayList<>();
            try {
                // 1. 创建ServerSocket类型的对象并提供端口号
                ss = new ServerSocket(9999);
                // 2. 等待客户端的连接请求，调用accept方法
                // 采用多线程的方式，允许多个用户请求连接。
                int i = 0;
                while (true) {
                    System.out.println("等待客户端的连接请求...");
                    s = ss.accept();
                    listSocket.add(s);
                    //sArr[i] = s;
                    i++;
                    System.out.printf("欢迎用户%d加入群聊!\n", i);
                    System.out.printf("目前群聊中共有%d人\n", listSocket.size());
                    InetAddress inetAddress = s.getInetAddress();
                    System.out.println("客户端" + inetAddress + "连接成功!");
                    // 调用多线程方法，每一个连上的客户端，服务器都有一个线程为之服务
                    new MultiServerThread(s, inetAddress, listSocket).start();
                }
    
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                // 关闭流
                try {
                    ss.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                try {
                    s.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
    
    
        }
    }
    
    复制代码

上述代码实现服务器监听客户端连接，利用`accept`方法，每加入一个客户端，服务器都创建一个线程为之服务，同时将其加入一个List集合中，用来保存已加入聊天室的所有客户端。

处理收发信的线程

package Server;
    
    import java.io.BufferedInputStream;
    import java.io.BufferedOutputStream;
    import java.io.IOException;
    import java.net.InetAddress;
    import java.net.Socket;
    import java.util.Arrays;
    import java.util.List;
    
    public class MultiServerThread extends Thread {
        private Socket s;
        private InetAddress inetAddress;
        private List<Socket> listSockets;
    
        public MultiServerThread(Socket s, InetAddress inetAddress, List<Socket> listSockets) {
            this.s = s;
            this.inetAddress = inetAddress;
            this.listSockets = listSockets;
        }
    
        public void BroadCast(Socket s, byte[] by, int res)
        {
            // 将服务器接收到的消息发送给除了发送方以外的其他客户端
            int i = 0;
            for (Socket socket: listSockets)
            {
                if (s!=socket)  // 判断不是当前发送的客户端
                {
                    System.out.println("发送给用户: " + listSockets.indexOf(socket));
                    BufferedOutputStream ps = null;
                    try {
                        ps = new BufferedOutputStream(socket.getOutputStream());
                        ps.write(by, 0, res);   // 写入输出流，将内容发送给客户端的输入流
                        ps.flush();
    
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    
        // 服务器与客户端的交互线程
        @Override
        public void run() {
            BufferedInputStream ois = null;
            BufferedOutputStream oos = null;
            try {
                ois = new BufferedInputStream(s.getInputStream());
    
                oos = new BufferedOutputStream(s.getOutputStream());
    
                int i = 0;
                while (true) {
                    //System.out.println("进入MultiChatServerThread");
                    byte[] by = new byte[1024+2];
                    //System.out.println("by.length: " + by.length);
                    int res = 0;
                    res = ois.read(by);
                    // 对读取到的字节数组第一位位置进行修改，标识该数据流是由哪个用户发送来的
                    by[0] = (byte)listSockets.indexOf(s);
    
                    if (by[1] == 2){
                        // 因为前两个位置是标志位，所以length的大小为读取的字节数-2,同时offset也从第三个位置(下标是2)开始读
                        String receive = new String(by, 2, res-2);
    
                        if (receive.equalsIgnoreCase("bye"))
                        {
                            // 如果客户端发送的是bye, 说明其下线，则从listSockets里删除对应的socket.
                            oos.write(receive.getBytes());  // 把bye给客户端的读取线程，从而可以关闭掉读取线程
                            oos.flush();
                            System.out.printf("用户%d下线, ", listSockets.indexOf(s));
                            listSockets.remove(s);
                            System.out.printf("目前聊天室仍有%d人\n", listSockets.size());
                        }
                    }
                    System.out.println("i" + i + "res = " + res);
                    System.out.println("by.length: " + by.length);
                    System.out.println("Socket[]: " + Arrays.toString(listSockets.toArray()));
                    // 调用函数，将接受到的消息发送给所有客户端
                    BroadCast(s, by, res);
    
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    if (oos != null) {
                        oos.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
                try {
                    if (ois != null) {
                        ois.close();
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
    
        }
    }
    
    复制代码

在处理收发信的线程中，利用`BroadCast()`方法将服务器接收到的消息发送给除了发送方以外的其他客户端。

在`run()`方法中，创建字节数组来接收客户端发送的数据流。定义字节数组时，`byte[] by = new byte[1024+2];`**这里+2的原因是，为了区分发送的用户以及传输的数据类型是消息文本还是文件。其中，第一位标志位用来表示用户的id，第二位标志位用1，2来表示发送的是消息还是文件，1表示发送的是消息，2表示发送的是文件。** 下面客户端代码时可以更好理解。

判断用户下线的标志是用户发送`bye`，说明其下线，则服务端从listSockets里删除对应的socket。同时，将把`bye`发送给客户端的读取线程，提示其可以关闭掉读取线程。

**以上就是服务端的实现逻辑。整体思路就是：**

1.  首先创建监听线程，接收每个客户端的连接请求，并创建一个List集合保存。
2.  创建一个处理收发信的线程，即每个客户端发送的聊天内容，都先统一发回给服务器端，再由服务器端进行集中转发给每个客户端。

#### 客户端 ####

客户端的两个线程包括发送消息给服务器和读取服务器发送的消息，用主线程和子线程来分别实现。

客户端1

package Client;
    
    import java.io.*;
    import java.net.Socket;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.Scanner;
    
    public class MultiClient extends Thread {
        private Socket ss;
    
        public MultiClient() {
        }
    
        public MultiClient(Socket ss) {
            this.ss = ss;
        }
    	
        public byte[] reviseArr(byte[] by, int res) {
            byte[] newByteArr = new byte[by.length + 2];
            // 将by字节数组的内容都往后移动两位，即头部的两个位置空出来作为标志位
            for (int i = 0; i < by.length; i++)
            {
                newByteArr[i+2] = by[i];
            }
            return newByteArr;
        }
    	
        // 子线程执行读操作，读取服务端发回的数据
        @Override
        public void run() {
            BufferedInputStream bis = null;
            BufferedOutputStream bosFile = null;    // 与输出文件流相关联
            try {
                bis = new BufferedInputStream(ss.getInputStream());
                //bosFile = new BufferedOutputStream(new FileOutputStream("./directoryTest/src/用户1 IO流的框架图.png"));
                // 等待接收服务器发送回来的消息
                while(true) {
                    byte[] by = new byte[1024+2];
                    int res = bis.read(by);
                    int sendUser = by[0];
                    Date date = new Date();
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-mm-dd HH:mm:ss");
                    String format = sdf.format(date);
                    if (by[1] == 1) // 说明传的是文件
                    {
                        //String filePath = String.format("./directoryTest/src/用户%d传送来的IO流的框架图.png", sendUser);
                        bosFile = new BufferedOutputStream(new FileOutputStream("./directoryTest/用户" + sendUser + "-传输的文件.png", true));
                        bosFile.write(by, 2, res-2);
                        bosFile.flush();
                        if (res<1026)   // 说明是最后一次在传送文件，所以传送的字节数才会小于字节数组by的大小
                        {
                            System.out.println("用户" + sendUser + "\t" + format + ":");
                            System.out.printf("用户%d发送的文件传输完成\n", sendUser);
                        }
                    }
                    else    // 说明传输的是聊天内容，则按字符串的形式进行解析
                    {
                        // 利用String构造方法的形式，将字节数组转化成字符串打印出来
                        String receive = new String(by, 2, res);
                        System.out.println("用户" + sendUser + "\t" + format + ":");
                        System.out.println(receive);
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            }finally{
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    
        public static void main(String[] args) {
            // 主线程执行写操作，发送消息到服务器
            Socket ss = null;
            BufferedOutputStream bos = null;
            BufferedInputStream bis = null;     // 与文件关联的流
            MultiClient mcc = null;
            try {
                ss = new Socket("127.0.0.1", 9999);
                System.out.println("服务器连接成功");
                System.out.println("-----------聊天室-----------");
                bos = new BufferedOutputStream(ss.getOutputStream());
                Scanner sc = new Scanner(System.in);
                mcc = new MultiClient(ss);
                mcc.start();
                byte[] by = new byte[1024];
                int res = 0;
                int i = 0;
                while(true) {
                    // 由用户输入选择执行不同的传输任务
                    // 若用户输入传输文件，则传输指定文件，否则，则正常聊天任务
                    String str = sc.nextLine();
                    if (str.equals("传输文件")) {
                        bis = new BufferedInputStream(new FileInputStream("./directoryTest/壁纸1.png"));
    
                        while ((res = bis.read(by)) != -1) {
                            //System.out.println("i" + i + " res: " + res);
                            byte[] newByteArr = mcc.reviseArr(by, res);;
                            newByteArr[1] = 1;  // 表示第二个位置上的值为1时表示传输的是文件
                            bos.write(newByteArr, 0, res+2);
                            bos.flush();
    
                        }
                    }
                    else{
                        byte[] sb = str.getBytes(); // 转化为字节数组
                        byte[] newByteArr = mcc.reviseArr(sb, sb.length);
                        newByteArr[1] = 2;      // 表示第二个位置上的值为2时表示传输的是聊天内容
                        bos.write(newByteArr);  // 把内容发给服务器
                        bos.flush();
                        if (str.equalsIgnoreCase("bye"))
                        {
                            System.out.println("用户下线!");
                            break;
                        }
                    }
    
                }
            }catch (IOException e) {
                e.printStackTrace();
            }finally {
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                try {
                    mcc.stop();
                    ss.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    复制代码

在客户端实现中，主线程执行写操作，发送消息到服务器，接收键盘的标准输入。在主线程发送消息时，判断用户的输入，如果输入的文本内容是传输文件，则会去读取指定路径下的文件，并利用`BufferedOutputStream`方法将文件转化为字节缓冲输出流发送。

这里`reviseArr`方法，是将读入文件输入流的102大小的字节数组往后移动两位，实现前两位作为标志位，区分用户id和传输数据类型的目的。如果传输的是文件，会在第二个标志位赋1，如果传输的是消息文本，则第二个标志位赋2。

若用户发送的消息是"bye"，则表示用户下线，利用`break`跳出主线程循环，并在`finally`中调用`mcc.stop()`关闭子线程，从而关闭该客户端。

在子线程中，若用户发送的是文件，则利用字节缓冲输入流`BufferedInputStream`将文件写入到指定路径中，并在文件名中简易标识发送用户。若接收的字节数组长度小于设定的1026，说明是最后一次在传送文件，在将最后一次文件的输入流写入后，在控制台打印文件传输完成的提示信息。

以上是客户端1的实现代码，其它客户端的实现代码类似

客户端2

package Client;
    
    import java.io.*;
    import java.net.Socket;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.Scanner;
    
    public class MultiClient2 extends Thread {
        private Socket ss;
    
        public MultiClient2() {
        }
    
        public MultiClient2(Socket ss) {
            this.ss = ss;
        }
    
        public byte[] reviseArr(byte[] by, int res) {
            byte[] newByteArr = new byte[by.length + 2];
            // 将by字节数组的内容都往后移动两位，即头部的两个位置空出来作为标志位
            for (int i = 0; i < by.length; i++)
            {
                newByteArr[i+2] = by[i];
            }
            return newByteArr;
        }
    
        @Override
        public void run() {
            BufferedInputStream bis = null;
            BufferedOutputStream bosFile = null;    // 与输出文件流相关联
            try {
                bis = new BufferedInputStream(ss.getInputStream());
    
                // 等待接收服务器发送回来的消息
    
                while(true) {
                    byte[] by = new byte[1024+2];
                    int res = bis.read(by);
                    int sendUser = by[0];
                    Date date = new Date();
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-mm-dd HH:mm:ss");
                    String format = sdf.format(date);
                    if (by[1] == 1) // 说明传的是文件
                    {
                        //String filePath = String.format("./directoryTest/src/用户%d传送来的IO流的框架图.png", sendUser);
                        bosFile = new BufferedOutputStream(new FileOutputStream("./directoryTest/用户" + sendUser + "-传输的文件.png", true));
                        bosFile.write(by, 2, res-2);
                        bosFile.flush();
                        if (res<1026)   // 说明是最后一次在传送文件，所以传送的字节数才会小于字节数组by的大小
                        {
                            System.out.println("用户" + sendUser + "\t" + format + ":");
                            System.out.printf("用户%d发送的文件传输完成\n", sendUser);
                        }
                    }
                    else    // 说明传输的是聊天内容，则按字符串的形式进行解析
                    {
                        // 利用String构造方法的形式，将字节数组转化成字符串打印出来
                        String receive = new String(by,2, res);
                        System.out.println("用户" + sendUser + "\t" + format + ":");
                        System.out.println(receive);
                    }
    
                }
            } catch (IOException e) {
                e.printStackTrace();
            }finally{
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    
        public static void main(String[] args) {
            // 主线程写操作
    
            Socket ss = null;
            BufferedOutputStream bos = null;
            BufferedInputStream bis = null;     // 与文件关联的流
            MultiClient2 mcc = null;
            try {
                ss = new Socket("127.0.0.1", 9999);
                System.out.println("服务器连接成功");
                System.out.println("-----------聊天室-----------");
                bos = new BufferedOutputStream(ss.getOutputStream());
                Scanner sc = new Scanner(System.in);
                mcc = new MultiClient2(ss);
                mcc.start();
                byte[] by = new byte[1024];
                int res = 0;
                int i = 0;
                while(true) {
                    String str = sc.nextLine();
                    if (str.equals("传输文件")) {
                        bis = new BufferedInputStream(new FileInputStream("./directoryTest/壁纸1.png"));
                        while ((res = bis.read(by)) != -1) {
                            i += 1;
                            //System.out.println("i" + i + " res: " + res);
                            byte[] newByteArr = mcc.reviseArr(by, res);;
                            newByteArr[1] = 1;  // 表示第二个位置上的值为1时表示传输的是文件
                            bos.write(newByteArr, 0, res+2);
                            bos.flush();
    
                        }
                    }
                    else{
                        byte[] sb = str.getBytes(); // 转化为字节数组
                        byte[] newByteArr = mcc.reviseArr(sb, sb.length);
                        //System.out.println("newByteArr: " + Arrays.toString(newByteArr));
                        newByteArr[1] = 2;      // 表示第二个位置上的值为2时表示传输的是聊天内容
                        bos.write(newByteArr);  // 把内容发给服务器
                        bos.flush();
                        if (str.equalsIgnoreCase("bye"))
                        {
                            System.out.println("用户下线!");
                            break;
                        }
                    }
    
                }
            }catch (IOException e) {
                e.printStackTrace();
            }finally {
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                try {
                    mcc.stop();
                    ss.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    复制代码

客户端3

package Client;
    
    import java.io.*;
    import java.net.Socket;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.Scanner;
    
    public class MultiClient3 extends Thread {
        private Socket ss;
    
        public MultiClient3() {
        }
    
        public MultiClient3(Socket ss) {
            this.ss = ss;
        }
    
        public byte[] reviseArr(byte[] by, int res) {
            byte[] newByteArr = new byte[by.length + 2];
            // 将by字节数组的内容都往后移动两位，即头部的两个位置空出来作为标志位
            for (int i = 0; i < by.length; i++)
            {
                newByteArr[i+2] = by[i];
            }
            return newByteArr;
        }
    
        @Override
        public void run() {
            BufferedInputStream bis = null;
            BufferedOutputStream bosFile = null;    // 与输出文件流相关联
            try {
                bis = new BufferedInputStream(ss.getInputStream());
                // 等待接收服务器发送回来的消息
                while(true) {
                    byte[] by = new byte[1024+2];
                    int res = bis.read(by);
                    int sendUser = by[0];
                    Date date = new Date();
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-mm-dd HH:mm:ss");
                    String format = sdf.format(date);
                    if (by[1] == 1) // 说明传的是文件
                    {
                        bosFile = new BufferedOutputStream(new FileOutputStream("./directoryTest/用户" + sendUser + "-传输的文件.png", true));
                        bosFile.write(by, 2, res-2);
                        bosFile.flush();
                        if (res<1026)   // 说明是最后一次在传送文件，所以传送的字节数才会小于字节数组by的大小
                        {
                            //System.out.println("客户端接收到的信息" + receive);
                            System.out.println("用户" + sendUser + "\t" + format + ":");
                            System.out.printf("用户%d发送的文件传输完成\n", sendUser);
                        }
                    }
                    else    // 说明传输的是聊天内容，则按字符串的形式进行解析
                    {
                        // 利用String构造方法的形式，将字节数组转化成字符串打印出来
                        String receive = new String(by, 2, res);
                        System.out.println("用户" + sendUser + "\t" + format + ":");
                        System.out.println(receive);
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            }finally{
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    
        public static void main(String[] args) {
            // 主线程写操作
            //MultiClient mc = new MultiClient();
            Socket ss = null;
            BufferedOutputStream bos = null;
            BufferedInputStream bis = null;     // 与文件关联的流
            MultiClient3 mcc = null;
            try {
                ss = new Socket("127.0.0.1", 9999);
                System.out.println("服务器连接成功");
                System.out.println("-----------聊天室-----------");
                bos = new BufferedOutputStream(ss.getOutputStream());
                Scanner sc = new Scanner(System.in);
                mcc = new MultiClient3(ss);
                mcc.start();
                byte[] by = new byte[1024];
                int res = 0;
                int i = 0;
                while(true) {
                    String str = sc.nextLine();
                    if (str.equals("传输文件")) {
                        bis = new BufferedInputStream(new FileInputStream("./directoryTest/壁纸1.png"));
                        while ((res = bis.read(by)) != -1) {
                            byte[] newByteArr = mcc.reviseArr(by, res);;
                            newByteArr[1] = 1;  // 表示第二个位置上的值为1时表示传输的是文件
                            bos.write(newByteArr, 0, res+2);
                            bos.flush();
    
                        }
                    }
                    else{
                        byte[] sb = str.getBytes(); // 转化为字节数组
                        byte[] newByteArr = mcc.reviseArr(sb, sb.length);
                        newByteArr[1] = 2;      // 表示第二个位置上的值为2时表示传输的是聊天内容
                        bos.write(newByteArr);  // 把内容发给服务器
                        bos.flush();
                        // 如果用户输入bye则表示用户下线
                        if (str.equalsIgnoreCase("bye"))
                        {
                            System.out.println("用户下线!");
                            break;
                        }
                    }
    
                }
            }catch (IOException e) {
                e.printStackTrace();
            }finally {
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                try {
                    mcc.stop();
                    ss.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    复制代码

### 功能展示 ###

开启服务器和3个客户端，初始状态

聊天室

每有一个客户端连接，会打印相应的提示信息

![format_png 1][]

三个客户端连接成功，打印提示信息

![format_png 2][]

接下来，进行聊天功能的展示

![format_png 3][]

可以看到，聊天室里标识出每个用户以及发送的时间和消息，可以实现基本的聊天功能。

传输文件

在客户端1输入传输文件

![format_png 4][]

进入到写入的目录下，存在相应的文件：

![format_png 5][]

即实现了聊天室和传输文件的功能，最后客户端1发送`bye`，该客户端断开连接

![format_png 6][]

![709b1d557c844c53b09ceb556d1f6b49.jpeg][]

[format_png]: https://img-blog.csdnimg.cn/img_convert/44416826827a43a936b01f903bbadb49.webp?x-oss-process=image/format,png
[format_png 1]: https://img-blog.csdnimg.cn/img_convert/2eaf7c65cc427685ceeccf91a23a8378.webp?x-oss-process=image/format,png
[format_png 2]: https://img-blog.csdnimg.cn/img_convert/2f4798a774dd49c900770b961fd8cf94.webp?x-oss-process=image/format,png
[format_png 3]: https://img-blog.csdnimg.cn/img_convert/14f070f946f8dde9176e6cf924f3e84a.webp?x-oss-process=image/format,png
[format_png 4]: https://img-blog.csdnimg.cn/img_convert/8677c61da0420a9a91df958d271d1318.webp?x-oss-process=image/format,png
[format_png 5]: https://img-blog.csdnimg.cn/img_convert/1751399629e3e9cfc7e7f65fe69e23ed.webp?x-oss-process=image/format,png
[format_png 6]: https://img-blog.csdnimg.cn/img_convert/5200f08bce1f66f3c92ae09368072613.webp?x-oss-process=image/format,png
[709b1d557c844c53b09ceb556d1f6b49.jpeg]: https://img-blog.csdnimg.cn/709b1d557c844c53b09ceb556d1f6b49.jpeg