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

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

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

    模块拆解

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

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

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

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

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

    项目的目录结构如下所示

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

    项目代码

    服务器端

    监听线程

    1. package Server;
    2.  
    3. import java.io.IOException;
    4. import java.net.InetAddress;
    5. import java.net.ServerSocket;
    6. import java.net.Socket;
    7. import java.util.ArrayList;
    8. import java.util.List;
    9.  
    10. public class MultiServer {
    11.     public static void main(String[] args) {
    12.         ServerSocket ss = null;
    13.         Socket s = null;
    14.  
    15.         // 定义一个List列表来保存每个客户端，每新建一个客户端连接，就添加到List列表里。
    16.         List listSocket = new ArrayList<>();
    17.         try {
    18.             // 1. 创建ServerSocket类型的对象并提供端口号
    19.             ss = new ServerSocket(9999);
    20.             // 2. 等待客户端的连接请求，调用accept方法
    21.             // 采用多线程的方式，允许多个用户请求连接。
    22.             int i = 0;
    23.             while (true) {
    24.                 System.out.println("等待客户端的连接请求...");
    25.                 s = ss.accept();
    26.                 listSocket.add(s);
    27.                 //sArr[i] = s;
    28.                 i++;
    29.                 System.out.printf("欢迎用户%d加入群聊!\n", i);
    30.                 System.out.printf("目前群聊中共有%d人\n", listSocket.size());
    31.                 InetAddress inetAddress = s.getInetAddress();
    32.                 System.out.println("客户端" + inetAddress + "连接成功!");
    33.                 // 调用多线程方法，每一个连上的客户端，服务器都有一个线程为之服务
    34.                 new MultiServerThread(s, inetAddress, listSocket).start();
    35.             }
    36.  
    37.         } catch (IOException e) {
    38.             e.printStackTrace();
    39.         } finally {
    40.             // 关闭流
    41.             try {
    42.                 ss.close();
    43.             } catch (IOException e) {
    44.                 e.printStackTrace();
    45.             }
    46.             try {
    47.                 s.close();
    48.             } catch (IOException e) {
    49.                 e.printStackTrace();
    50.             }
    51.         }
    52.  
    53.  
    54.     }
    55. }
    56.  
    57. 复制代码

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

    处理收发信的线程

    1. package Server;
    2.  
    3. import java.io.BufferedInputStream;
    4. import java.io.BufferedOutputStream;
    5. import java.io.IOException;
    6. import java.net.InetAddress;
    7. import java.net.Socket;
    8. import java.util.Arrays;
    9. import java.util.List;
    10.  
    11. public class MultiServerThread extends Thread {
    12.     private Socket s;
    13.     private InetAddress inetAddress;
    14.     private List listSockets;
    15.  
    16.     public MultiServerThread(Socket s, InetAddress inetAddress, List listSockets) {
    17.         this.s = s;
    18.         this.inetAddress = inetAddress;
    19.         this.listSockets = listSockets;
    20.     }
    21.  
    22.     public void BroadCast(Socket s, byte[] by, int res)
    23.     {
    24.         // 将服务器接收到的消息发送给除了发送方以外的其他客户端
    25.         int i = 0;
    26.         for (Socket socket: listSockets)
    27.         {
    28.             if (s!=socket)  // 判断不是当前发送的客户端
    29.             {
    30.                 System.out.println("发送给用户: " + listSockets.indexOf(socket));
    31.                 BufferedOutputStream ps = null;
    32.                 try {
    33.                     ps = new BufferedOutputStream(socket.getOutputStream());
    34.                     ps.write(by, 0, res);   // 写入输出流，将内容发送给客户端的输入流
    35.                     ps.flush();
    36.  
    37.                 } catch (IOException e) {
    38.                     e.printStackTrace();
    39.                 }
    40.             }
    41.         }
    42.     }
    43.  
    44.     // 服务器与客户端的交互线程
    45.     @Override
    46.     public void run() {
    47.         BufferedInputStream ois = null;
    48.         BufferedOutputStream oos = null;
    49.         try {
    50.             ois = new BufferedInputStream(s.getInputStream());
    51.  
    52.             oos = new BufferedOutputStream(s.getOutputStream());
    53.  
    54.             int i = 0;
    55.             while (true) {
    56.                 //System.out.println("进入MultiChatServerThread");
    57.                 byte[] by = new byte[1024+2];
    58.                 //System.out.println("by.length: " + by.length);
    59.                 int res = 0;
    60.                 res = ois.read(by);
    61.                 // 对读取到的字节数组第一位位置进行修改，标识该数据流是由哪个用户发送来的
    62.                 by[0] = (byte)listSockets.indexOf(s);
    63.  
    64.                 if (by[1] == 2){
    65.                     // 因为前两个位置是标志位，所以length的大小为读取的字节数-2,同时offset也从第三个位置(下标是2)开始读
    66.                     String receive = new String(by, 2, res-2);
    67.  
    68.                     if (receive.equalsIgnoreCase("bye"))
    69.                     {
    70.                         // 如果客户端发送的是bye, 说明其下线，则从listSockets里删除对应的socket.
    71.                         oos.write(receive.getBytes());  // 把bye给客户端的读取线程，从而可以关闭掉读取线程
    72.                         oos.flush();
    73.                         System.out.printf("用户%d下线, ", listSockets.indexOf(s));
    74.                         listSockets.remove(s);
    75.                         System.out.printf("目前聊天室仍有%d人\n", listSockets.size());
    76.                     }
    77.                 }
    78.                 System.out.println("i" + i + "res = " + res);
    79.                 System.out.println("by.length: " + by.length);
    80.                 System.out.println("Socket[]: " + Arrays.toString(listSockets.toArray()));
    81.                 // 调用函数，将接受到的消息发送给所有客户端
    82.                 BroadCast(s, by, res);
    83.  
    84.             }
    85.         } catch (IOException e) {
    86.             e.printStackTrace();
    87.         } finally {
    88.             try {
    89.                 if (oos != null) {
    90.                     oos.close();
    91.                 }
    92.             } catch (IOException e) {
    93.                 e.printStackTrace();
    94.             }
    95.             try {
    96.                 if (ois != null) {
    97.                     ois.close();
    98.                 }
    99.             } catch (IOException e) {
    100.                 e.printStackTrace();
    101.             }
    102.         }
    103.  
    104.     }
    105. }
    106.  
    107. 复制代码

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

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

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

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

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

    客户端

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

    客户端1

    1. package Client;
    2.  
    3. import java.io.*;
    4. import java.net.Socket;
    5. import java.text.SimpleDateFormat;
    6. import java.util.Date;
    7. import java.util.Scanner;
    8.  
    9. public class MultiClient extends Thread {
    10.     private Socket ss;
    11.  
    12.     public MultiClient() {
    13.     }
    14.  
    15.     public MultiClient(Socket ss) {
    16.         this.ss = ss;
    17.     }
    18. 	
    19.     public byte[] reviseArr(byte[] by, int res) {
    20.         byte[] newByteArr = new byte[by.length + 2];
    21.         // 将by字节数组的内容都往后移动两位，即头部的两个位置空出来作为标志位
    22.         for (int i = 0; i < by.length; i++)
    23.         {
    24.             newByteArr[i+2] = by[i];
    25.         }
    26.         return newByteArr;
    27.     }
    28. 	
    29.     // 子线程执行读操作，读取服务端发回的数据
    30.     @Override
    31.     public void run() {
    32.         BufferedInputStream bis = null;
    33.         BufferedOutputStream bosFile = null;    // 与输出文件流相关联
    34.         try {
    35.             bis = new BufferedInputStream(ss.getInputStream());
    36.             //bosFile = new BufferedOutputStream(new FileOutputStream("./directoryTest/src/用户1 IO流的框架图.png"));
    37.             // 等待接收服务器发送回来的消息
    38.             while(true) {
    39.                 byte[] by = new byte[1024+2];
    40.                 int res = bis.read(by);
    41.                 int sendUser = by[0];
    42.                 Date date = new Date();
    43.                 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-mm-dd HH:mm:ss");
    44.                 String format = sdf.format(date);
    45.                 if (by[1] == 1) // 说明传的是文件
    46.                 {
    47.                     //String filePath = String.format("./directoryTest/src/用户%d传送来的IO流的框架图.png", sendUser);
    48.                     bosFile = new BufferedOutputStream(new FileOutputStream("./directoryTest/用户" + sendUser + "-传输的文件.png", true));
    49.                     bosFile.write(by, 2, res-2);
    50.                     bosFile.flush();
    51.                     if (res<1026)   // 说明是最后一次在传送文件，所以传送的字节数才会小于字节数组by的大小
    52.                     {
    53.                         System.out.println("用户" + sendUser + "\t" + format + ":");
    54.                         System.out.printf("用户%d发送的文件传输完成\n", sendUser);
    55.                     }
    56.                 }
    57.                 else    // 说明传输的是聊天内容，则按字符串的形式进行解析
    58.                 {
    59.                     // 利用String构造方法的形式，将字节数组转化成字符串打印出来
    60.                     String receive = new String(by, 2, res);
    61.                     System.out.println("用户" + sendUser + "\t" + format + ":");
    62.                     System.out.println(receive);
    63.                 }
    64.             }
    65.         } catch (IOException e) {
    66.             e.printStackTrace();
    67.         }finally{
    68.             try {
    69.                 bis.close();
    70.             } catch (IOException e) {
    71.                 e.printStackTrace();
    72.             }
    73.         }
    74.     }
    75.  
    76.     public static void main(String[] args) {
    77.         // 主线程执行写操作，发送消息到服务器
    78.         Socket ss = null;
    79.         BufferedOutputStream bos = null;
    80.         BufferedInputStream bis = null;     // 与文件关联的流
    81.         MultiClient mcc = null;
    82.         try {
    83.             ss = new Socket("127.0.0.1", 9999);
    84.             System.out.println("服务器连接成功");
    85.             System.out.println("-----------聊天室-----------");
    86.             bos = new BufferedOutputStream(ss.getOutputStream());
    87.             Scanner sc = new Scanner(System.in);
    88.             mcc = new MultiClient(ss);
    89.             mcc.start();
    90.             byte[] by = new byte[1024];
    91.             int res = 0;
    92.             int i = 0;
    93.             while(true) {
    94.                 // 由用户输入选择执行不同的传输任务
    95.                 // 若用户输入传输文件，则传输指定文件，否则，则正常聊天任务
    96.                 String str = sc.nextLine();
    97.                 if (str.equals("传输文件")) {
    98.                     bis = new BufferedInputStream(new FileInputStream("./directoryTest/壁纸1.png"));
    99.  
    100.                     while ((res = bis.read(by)) != -1) {
    101.                         //System.out.println("i" + i + " res: " + res);
    102.                         byte[] newByteArr = mcc.reviseArr(by, res);;
    103.                         newByteArr[1] = 1;  // 表示第二个位置上的值为1时表示传输的是文件
    104.                         bos.write(newByteArr, 0, res+2);
    105.                         bos.flush();
    106.  
    107.                     }
    108.                 }
    109.                 else{
    110.                     byte[] sb = str.getBytes(); // 转化为字节数组
    111.                     byte[] newByteArr = mcc.reviseArr(sb, sb.length);
    112.                     newByteArr[1] = 2;      // 表示第二个位置上的值为2时表示传输的是聊天内容
    113.                     bos.write(newByteArr);  // 把内容发给服务器
    114.                     bos.flush();
    115.                     if (str.equalsIgnoreCase("bye"))
    116.                     {
    117.                         System.out.println("用户下线!");
    118.                         break;
    119.                     }
    120.                 }
    121.  
    122.             }
    123.         }catch (IOException e) {
    124.             e.printStackTrace();
    125.         }finally {
    126.             try {
    127.                 bos.close();
    128.             } catch (IOException e) {
    129.                 e.printStackTrace();
    130.             }
    131.             try {
    132.                 mcc.stop();
    133.                 ss.close();
    134.             } catch (IOException e) {
    135.                 e.printStackTrace();
    136.             }
    137.         }
    138.     }
    139. }
    140.  
    141. 复制代码

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

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

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

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

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

    客户端2

    1. package Client;
    2.  
    3. import java.io.*;
    4. import java.net.Socket;
    5. import java.text.SimpleDateFormat;
    6. import java.util.Date;
    7. import java.util.Scanner;
    8.  
    9. public class MultiClient2 extends Thread {
    10.     private Socket ss;
    11.  
    12.     public MultiClient2() {
    13.     }
    14.  
    15.     public MultiClient2(Socket ss) {
    16.         this.ss = ss;
    17.     }
    18.  
    19.     public byte[] reviseArr(byte[] by, int res) {
    20.         byte[] newByteArr = new byte[by.length + 2];
    21.         // 将by字节数组的内容都往后移动两位，即头部的两个位置空出来作为标志位
    22.         for (int i = 0; i < by.length; i++)
    23.         {
    24.             newByteArr[i+2] = by[i];
    25.         }
    26.         return newByteArr;
    27.     }
    28.  
    29.     @Override
    30.     public void run() {
    31.         BufferedInputStream bis = null;
    32.         BufferedOutputStream bosFile = null;    // 与输出文件流相关联
    33.         try {
    34.             bis = new BufferedInputStream(ss.getInputStream());
    35.  
    36.             // 等待接收服务器发送回来的消息
    37.  
    38.             while(true) {
    39.                 byte[] by = new byte[1024+2];
    40.                 int res = bis.read(by);
    41.                 int sendUser = by[0];
    42.                 Date date = new Date();
    43.                 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-mm-dd HH:mm:ss");
    44.                 String format = sdf.format(date);
    45.                 if (by[1] == 1) // 说明传的是文件
    46.                 {
    47.                     //String filePath = String.format("./directoryTest/src/用户%d传送来的IO流的框架图.png", sendUser);
    48.                     bosFile = new BufferedOutputStream(new FileOutputStream("./directoryTest/用户" + sendUser + "-传输的文件.png", true));
    49.                     bosFile.write(by, 2, res-2);
    50.                     bosFile.flush();
    51.                     if (res<1026)   // 说明是最后一次在传送文件，所以传送的字节数才会小于字节数组by的大小
    52.                     {
    53.                         System.out.println("用户" + sendUser + "\t" + format + ":");
    54.                         System.out.printf("用户%d发送的文件传输完成\n", sendUser);
    55.                     }
    56.                 }
    57.                 else    // 说明传输的是聊天内容，则按字符串的形式进行解析
    58.                 {
    59.                     // 利用String构造方法的形式，将字节数组转化成字符串打印出来
    60.                     String receive = new String(by,2, res);
    61.                     System.out.println("用户" + sendUser + "\t" + format + ":");
    62.                     System.out.println(receive);
    63.                 }
    64.  
    65.             }
    66.         } catch (IOException e) {
    67.             e.printStackTrace();
    68.         }finally{
    69.             try {
    70.                 bis.close();
    71.             } catch (IOException e) {
    72.                 e.printStackTrace();
    73.             }
    74.         }
    75.     }
    76.  
    77.     public static void main(String[] args) {
    78.         // 主线程写操作
    79.  
    80.         Socket ss = null;
    81.         BufferedOutputStream bos = null;
    82.         BufferedInputStream bis = null;     // 与文件关联的流
    83.         MultiClient2 mcc = null;
    84.         try {
    85.             ss = new Socket("127.0.0.1", 9999);
    86.             System.out.println("服务器连接成功");
    87.             System.out.println("-----------聊天室-----------");
    88.             bos = new BufferedOutputStream(ss.getOutputStream());
    89.             Scanner sc = new Scanner(System.in);
    90.             mcc = new MultiClient2(ss);
    91.             mcc.start();
    92.             byte[] by = new byte[1024];
    93.             int res = 0;
    94.             int i = 0;
    95.             while(true) {
    96.                 String str = sc.nextLine();
    97.                 if (str.equals("传输文件")) {
    98.                     bis = new BufferedInputStream(new FileInputStream("./directoryTest/壁纸1.png"));
    99.                     while ((res = bis.read(by)) != -1) {
    100.                         i += 1;
    101.                         //System.out.println("i" + i + " res: " + res);
    102.                         byte[] newByteArr = mcc.reviseArr(by, res);;
    103.                         newByteArr[1] = 1;  // 表示第二个位置上的值为1时表示传输的是文件
    104.                         bos.write(newByteArr, 0, res+2);
    105.                         bos.flush();
    106.  
    107.                     }
    108.                 }
    109.                 else{
    110.                     byte[] sb = str.getBytes(); // 转化为字节数组
    111.                     byte[] newByteArr = mcc.reviseArr(sb, sb.length);
    112.                     //System.out.println("newByteArr: " + Arrays.toString(newByteArr));
    113.                     newByteArr[1] = 2;      // 表示第二个位置上的值为2时表示传输的是聊天内容
    114.                     bos.write(newByteArr);  // 把内容发给服务器
    115.                     bos.flush();
    116.                     if (str.equalsIgnoreCase("bye"))
    117.                     {
    118.                         System.out.println("用户下线!");
    119.                         break;
    120.                     }
    121.                 }
    122.  
    123.             }
    124.         }catch (IOException e) {
    125.             e.printStackTrace();
    126.         }finally {
    127.             try {
    128.                 bos.close();
    129.             } catch (IOException e) {
    130.                 e.printStackTrace();
    131.             }
    132.             try {
    133.                 mcc.stop();
    134.                 ss.close();
    135.             } catch (IOException e) {
    136.                 e.printStackTrace();
    137.             }
    138.         }
    139.     }
    140. }
    141.  
    142. 复制代码

    客户端3

    1. package Client;
    2.  
    3. import java.io.*;
    4. import java.net.Socket;
    5. import java.text.SimpleDateFormat;
    6. import java.util.Date;
    7. import java.util.Scanner;
    8.  
    9. public class MultiClient3 extends Thread {
    10.     private Socket ss;
    11.  
    12.     public MultiClient3() {
    13.     }
    14.  
    15.     public MultiClient3(Socket ss) {
    16.         this.ss = ss;
    17.     }
    18.  
    19.     public byte[] reviseArr(byte[] by, int res) {
    20.         byte[] newByteArr = new byte[by.length + 2];
    21.         // 将by字节数组的内容都往后移动两位，即头部的两个位置空出来作为标志位
    22.         for (int i = 0; i < by.length; i++)
    23.         {
    24.             newByteArr[i+2] = by[i];
    25.         }
    26.         return newByteArr;
    27.     }
    28.  
    29.     @Override
    30.     public void run() {
    31.         BufferedInputStream bis = null;
    32.         BufferedOutputStream bosFile = null;    // 与输出文件流相关联
    33.         try {
    34.             bis = new BufferedInputStream(ss.getInputStream());
    35.             // 等待接收服务器发送回来的消息
    36.             while(true) {
    37.                 byte[] by = new byte[1024+2];
    38.                 int res = bis.read(by);
    39.                 int sendUser = by[0];
    40.                 Date date = new Date();
    41.                 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-mm-dd HH:mm:ss");
    42.                 String format = sdf.format(date);
    43.                 if (by[1] == 1) // 说明传的是文件
    44.                 {
    45.                     bosFile = new BufferedOutputStream(new FileOutputStream("./directoryTest/用户" + sendUser + "-传输的文件.png", true));
    46.                     bosFile.write(by, 2, res-2);
    47.                     bosFile.flush();
    48.                     if (res<1026)   // 说明是最后一次在传送文件，所以传送的字节数才会小于字节数组by的大小
    49.                     {
    50.                         //System.out.println("客户端接收到的信息" + receive);
    51.                         System.out.println("用户" + sendUser + "\t" + format + ":");
    52.                         System.out.printf("用户%d发送的文件传输完成\n", sendUser);
    53.                     }
    54.                 }
    55.                 else    // 说明传输的是聊天内容，则按字符串的形式进行解析
    56.                 {
    57.                     // 利用String构造方法的形式，将字节数组转化成字符串打印出来
    58.                     String receive = new String(by, 2, res);
    59.                     System.out.println("用户" + sendUser + "\t" + format + ":");
    60.                     System.out.println(receive);
    61.                 }
    62.             }
    63.         } catch (IOException e) {
    64.             e.printStackTrace();
    65.         }finally{
    66.             try {
    67.                 bis.close();
    68.             } catch (IOException e) {
    69.                 e.printStackTrace();
    70.             }
    71.         }
    72.     }
    73.  
    74.     public static void main(String[] args) {
    75.         // 主线程写操作
    76.         //MultiClient mc = new MultiClient();
    77.         Socket ss = null;
    78.         BufferedOutputStream bos = null;
    79.         BufferedInputStream bis = null;     // 与文件关联的流
    80.         MultiClient3 mcc = null;
    81.         try {
    82.             ss = new Socket("127.0.0.1", 9999);
    83.             System.out.println("服务器连接成功");
    84.             System.out.println("-----------聊天室-----------");
    85.             bos = new BufferedOutputStream(ss.getOutputStream());
    86.             Scanner sc = new Scanner(System.in);
    87.             mcc = new MultiClient3(ss);
    88.             mcc.start();
    89.             byte[] by = new byte[1024];
    90.             int res = 0;
    91.             int i = 0;
    92.             while(true) {
    93.                 String str = sc.nextLine();
    94.                 if (str.equals("传输文件")) {
    95.                     bis = new BufferedInputStream(new FileInputStream("./directoryTest/壁纸1.png"));
    96.                     while ((res = bis.read(by)) != -1) {
    97.                         byte[] newByteArr = mcc.reviseArr(by, res);;
    98.                         newByteArr[1] = 1;  // 表示第二个位置上的值为1时表示传输的是文件
    99.                         bos.write(newByteArr, 0, res+2);
    100.                         bos.flush();
    101.  
    102.                     }
    103.                 }
    104.                 else{
    105.                     byte[] sb = str.getBytes(); // 转化为字节数组
    106.                     byte[] newByteArr = mcc.reviseArr(sb, sb.length);
    107.                     newByteArr[1] = 2;      // 表示第二个位置上的值为2时表示传输的是聊天内容
    108.                     bos.write(newByteArr);  // 把内容发给服务器
    109.                     bos.flush();
    110.                     // 如果用户输入bye则表示用户下线
    111.                     if (str.equalsIgnoreCase("bye"))
    112.                     {
    113.                         System.out.println("用户下线!");
    114.                         break;
    115.                     }
    116.                 }
    117.  
    118.             }
    119.         }catch (IOException e) {
    120.             e.printStackTrace();
    121.         }finally {
    122.             try {
    123.                 bos.close();
    124.             } catch (IOException e) {
    125.                 e.printStackTrace();
    126.             }
    127.             try {
    128.                 mcc.stop();
    129.                 ss.close();
    130.             } catch (IOException e) {
    131.                 e.printStackTrace();
    132.             }
    133.         }
    134.     }
    135. }
    136.  
    137. 复制代码

    功能展示

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

    聊天室

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

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

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

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

    传输文件

    在客户端1输入传输文件

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

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


  • 相关阅读:
    物联网iot全称
    使用zdppy_api+onlyoffice word文档在线共同编辑，附完整的vue3前端代码和python后端代码
    Spring5 框架学习笔记
    ts的接口和对象类型
    Redis_01_Redis安装与使用
    海康设备、LiveNVR等通过GB35114国密协议对接到LiveGBS GB28181/GB35114平台的详细操作说明
    redis的原理和源码-客户端结构体的介绍和源码解析
    解决gif导出后显示异常的现象
    代码工程化问题
    【蜂鸟E203的FPGA验证】Chap.6 基于Iverilog的指令功能与流水线仿真
  • 原文地址：https://blog.csdn.net/m0_71777195/article/details/126157763