1. import java.io.*;
    2. import java.net.Socket;
    4. //聊天室客户机：发送消息、接收别人发送的消息
    5. public class Client {
    7.     public static void clientRequest() throws IOException {
    8.         //建立客户机，与服务器建立连接
    9.         Socket client = new Socket("localhost", 8888);
    10.         //创建一个线程用于接收消息
    11.         new Thread(new Receive(client)).start();
    12.         //本线程专用于送发消息
    13.         send.clientSend(client);
    14.     }
    17.     //封装内部类：发送消息
    18.     private static class send{
    20.         private static void clientSend(Socket client) throws IOException {
    21.             boolean isRunning = true;
    22.             String msg;
    23.             System.out.println("已连接服务");
    24.             //利用IO流进行数据传输
    25.             //从键盘获取输入
    26.             BufferedReader is = new BufferedReader(new InputStreamReader(System.in));
    27.             //并将获取到的内容发送出去
    28.             DataOutputStream os = new DataOutputStream(client.getOutputStream());
    29.             while (isRunning) {
    30.                 try {
    31.                     msg = is.readLine();
    32.                     os.writeUTF(msg);
    33.                 } catch (IOException e) {
    34.                     isRunning = false;
    35.                     System.out.println("服务被停止，发送失败！");
    36.                     is.close();
    37.                     os.close();
    38.                     client.close();
    39.                 }
    40.             }
    41.         }
    42.     }
    45.     //封装内部类：接收消息
    46.     private static class Receive implements Runnable{
    47.         Socket client;
    48.         DataInputStream dis;
    49.         boolean isRunning = true;
    51.         //构造器
    52.         private Receive(Socket client) {
    53.             this.client = client;
    54.         }
    56.         //run方法：具体操作
    57.         @Override
    58.         public void run() {
    59.             //具体操作：接收消息
    60.             String result;
    61.             while(isRunning){
    62.                 try {
    63.                     dis = new DataInputStream(client.getInputStream());
    64.                     result = dis.readUTF();
    65.                     System.out.println(result);
    66.                 } catch (IOException e) {
    67.                     isRunning = false;
    68.                 }
    69.             }
    70.             try {
    71.                 dis.close();
    72.             } catch (IOException e) {
    73.                 e.printStackTrace();
    74.             }
    75.         }
    77.     }
    78. }
    1. import java.net.Socket;
    2. //用户类：保存一个客户机的用户名和Socket
    3. public class User{
    4.     String userName;
    5.     Socket userSocket;
    6.     public User(String name, Socket client){
    7.         this.userName = name;
    8.         this.userSocket = client;
    9.     }
    10. }
    1. import java.io.*;
    2. import java.net.ServerSocket;
    3. import java.net.Socket;
    4. import java.util.concurrent.CopyOnWriteArrayList;
    6. //聊天室服务器：转发客户机发送的消息
    7. public class Server {
    9.     //群聊容器
    10.     private static CopyOnWriteArrayList<User> all = new CopyOnWriteArrayList<User>();
    12.     public static void serverResponse() throws IOException {
    13.         boolean isRunning = true;
    14.         //建立服务器
    15.         ServerSocket server = new ServerSocket(8888);
    16.         System.out.println("服务启动");
    17.         //监听端口，随时等待客户机连接，当一个客户机连接后，建立一条线程为其服务，随后继续监听端口
    18.         while(isRunning){
    19.             try{
    20.                 Socket client = server.accept();
    21.                 new Thread(new Channel(client)).start();//为这个客户机建立单独的消息转发服务
    22.                 System.out.println("一个客户机进行了连接");
    23.             } catch (IOException e) {
    24.                 isRunning = false;
    25.                 System.out.println("服务停止！");
    26.                 server.close();
    27.             }
    28.         }
    29.     }
    32.     //封装内部类：转发器 提供消息转发服务：将客户机发送的消息转发给其他客户机
    33.     private static class Channel implements Runnable{
    34.         DataInputStream sis;
    35.         DataOutputStream sos;
    36.         Socket client;
    37.         String name;
    39.         //构造器
    40.         private Channel(Socket client){
    41.             try {
    42.                 //利用IO流进行数据传输
    43.                 this.client = client;
    44.                 sis = new DataInputStream(client.getInputStream());
    45.             } catch (IOException e) {
    46.                 e.printStackTrace();
    47.             }
    48.         }
    50.         //群聊
    51.         private void group(String msg) throws IOException {
    52.             for (User c : all) {//一个客户机发送消息后，遍历容器将该条消息转发给其他客户机
    53.                 if (c.userSocket != this.client) {
    54.                     sos = new DataOutputStream(c.userSocket.getOutputStream());
    55.                     sos.writeUTF(msg);
    56.                 }
    57.             }
    58.         }
    60.         //run方法：具体操作
    61.         @Override
    62.         public void run() {
    63.             //具体操作：获取用户名，并将用户类存入群聊容器
    64.             try {
    65.                 boolean flag = true;
    66.                 while(flag){
    67.                     sos = new DataOutputStream(client.getOutputStream());
    68.                     sos.writeUTF("请输入您的用户名：");
    69.                     name = sis.readUTF();
    70.                     int i = 1;
    71.                     for (User c : all) {//遍历容器验证用户名是否存在
    72.                         if (c.userName.equals(name)) {
    73.                             sos.writeUTF("用户名已存在！");
    74.                             break;
    75.                         }else{
    76.                             i++;
    77.                         }
    78.                     }
    79.                     if(i > all.size())
    80.                         flag = false;
    81.                 }
    82.                 User user = new User(name, client);
    83.                 all.add(user);
    84.                 group("欢迎"+name+"加入聊天！");
    85.             } catch (IOException e) {
    86.                 e.printStackTrace();
    87.             }
    88.             String msg;
    89.             boolean isRunning = true;
    90.             //具体操作：转发消息
    91.             while(isRunning) {
    92.                 try {
    93.                     msg = sis.readUTF();
    94.                     //转发私聊消息：@xxx:msg
    95.                     if(msg.startsWith("@")) {
    96.                         int idx = msg.indexOf(":");
    97.                         String targetName = msg.substring(1, idx);//获取该条消息所@的用户的用户名
    98.                         msg = "来自"+name+"的私聊:"+msg.substring(idx+1);
    99.                         for (User c : all) {//遍历容器找到该条消息所@的用户后转发消息
    100.                             if (c.userName.equals(targetName)) {
    101.                                 sos = new DataOutputStream(c.userSocket.getOutputStream());
    102.                                 sos.writeUTF(msg);
    103.                                 break;
    104.                             }
    105.                         }
    106.                     //转发公共群聊消息
    107.                     }else{
    108.                         msg = (name + ":" + msg);
    109.                         group(msg);
    110.                     }
    111.                 } catch (IOException e) {//客户机断开连接以后会进行以下操作
    112.                         isRunning = false;//停止对该客户机的转发服务
    113.                         all.removeIf(c -> c.userSocket == client);//将该客户机从容器中移除
    114.                         System.out.println("一个客户机断开了连接");
    115.                     }
    116.             }
    117.             try {
    118.                 //释放资源，随后该线程结束
    119.                 sis.close();
    120.             } catch (IOException e) {
    121.                 e.printStackTrace();
    122.             }
    123.         }
    124.     }
    125. }