使用Java Socket模擬實現了一個聊天室，實現了基本的私聊以及群聊。分為伺服器端和客戶端，下面我來介紹一下實現的步驟。

伺服器端

        伺服器端是聊天室的核心所在，主要用來處理客戶端的請求，先來看一下伺服器端的主方法：

    public static void main(String[] args) {
        try {
            ExecutorService executorService = Executors.newFixedThreadPool(100);//最多容納100個客戶端聊天
            ServerSocket serverSocket = new ServerSocket(6655);//監聽6655號埠
            for (int i = 0; i < 100; i++) {
                Socket client = serverSocket.accept();
                System.out.println("有新的使用者連線 " + client.getInetAddress() +
                        client.getPort());
                executorService.execute(new ExecuteClientThread(client));
            }
            executorService.shutdown();
            serverSocket.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 

        首先我建立了一個固定大小為100的執行緒池，這個聊天室的實現是一個伺服器執行緒對應一個客戶端執行緒的，就是說執行緒池的大小就是最大的同時聊天的人數。伺服器的執行順序是這樣的：

        1：監聽埠，等待客戶端連線

        2：如果有客戶端連線到監聽的埠，那麼通過accept()方法返回該客戶端的Socket，並且線上程池中啟動一個新的伺服器執行緒用來與剛剛連線的客戶端"溝通"。

        3：把接收到的客戶端的Socket構造注入新啟動的伺服器執行緒中，這樣伺服器執行緒就可以獲取到客戶端對應的流。

        到這裡，伺服器已經和客戶端連線成功了，我們現在來看一下伺服器執行緒是如何處理客戶端的請求的，先上一段伺服器程式碼

    private static Map<String, Socket> clientMap = new ConcurrentHashMap<>();//儲存所有的使用者資訊

    static class ExecuteClientThread implements Runnable {
        private Socket client;//每一個伺服器執行緒對應一個客戶端執行緒
        ExecuteClientThread(Socket client) {
            this.client = client;
        }
......
 

        程式碼的第一行，建立了一個ConcurrentHashmap，這個map不是某個執行緒中的，而是伺服器的static屬性，用來儲存所有客戶端的資訊。因為客戶端是有姓名，有Socket的，所以採用K-value的模式來儲存，使用者名稱作為Key。考慮到執行緒安全的原因，採用了ConcurrentHashmap，保證了執行緒安全。

        接下來就是剛剛構造注入的、連線的客戶端的Socket了，我們可以通過這個Socket獲取到輸入和輸出流。

        然後就是伺服器的執行緒執行的run方法了，具體的就直接看程式碼把。都有註釋，就不一一解釋了，以下是所有伺服器端的程式碼

import java.io.IOException;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.regex.Matcher;
import java.util.regex.Pattern;



public class Main {


    private static Map<String, Socket> clientMap = new ConcurrentHashMap<>();//儲存所有的使用者資訊

    static class ExecuteClientThread implements Runnable {
        private Socket client;//每一個伺服器執行緒對應一個客戶端執行緒
        ExecuteClientThread(Socket client) {
            this.client = client;
        }

        @Override
        public void run() {
            boolean Flag = true;//防止一個客戶端多次註冊所做的標記位置
            try {
                PrintStream PrintToCilent = new PrintStream(client.getOutputStream());//伺服器向用戶輸出一些提示資訊


                Scanner scanner = new Scanner(client.getInputStream());
                String str = null;//使用者外部的輸入資訊
                while (true) {
                    if (scanner.hasNext()) {
                        str = scanner.next();//外部的使用者輸出

                        Pattern pattern = Pattern.compile("\r");//排除特殊符號
                        Matcher matcher = pattern.matcher(str);
                        str = matcher.replaceAll("");

                        if (str.startsWith("userName")) {
                            String userName = str.split(":")[1];
                            userRegist(userName, client, Flag);
                            Flag = false;
                        }
                        // 群聊流程
                        else if (str.startsWith("G:")) {
                            PrintToCilent.println("已進入群聊模式！");
                            groupChat(scanner,client);
                        }
                        // 私聊流程
                        else if (str.startsWith("P")) {//模式
                            String userName = str.split("-")[1];
                            PrintToCilent.println("已經進入與"+userName+"的私聊");

                            privateChat(scanner,userName);
                        }
                        // 使用者退出
                        else if (str.contains("byebye")) {
                            String userName = null;
                            for (String getKey:clientMap.keySet()) {
                                if (clientMap.get(getKey).equals(client)) {
                                    userName = getKey;
                                }
                            }

                            System.out.println("使用者"+userName+"下線了..");
                            clientMap.remove(userName);//將此例項從map中移除
                        }
                    }
                }

            } catch (IOException e) {
                e.printStackTrace();
            }
        }
       
        private void userRegist(String userName, Socket client, boolean Flag) throws IOException {
            PrintStream PrintToCilent = new PrintStream(client.getOutputStream());//伺服器向用戶輸出一些提示資訊
            if(Flag) {
                System.out.println("使用者" + userName + "上線了！");

                clientMap.put(userName, client);//把使用者加入儲存map
                System.out.println("當前群聊人數為" + (clientMap.size()) + "人");
                PrintToCilent.println("註冊成功！");
            }else {
                PrintToCilent.println("警告:一個客戶端只能註冊一個使用者！");
            }
        }
     
        private void groupChat(Scanner scanner,Socket client) throws IOException {
            // 取出clientMap中所有客戶端Socket，然後遍歷一遍
            // 分別取得每個Socket的輸出流向每個客戶端輸出
            PrintStream PrintToClient = new PrintStream(client.getOutputStream());//在群聊的時候伺服器向客戶端傳送資料
            boolean ExitFlag = false;

            Set<Map.Entry<String, Socket>> entrySet =
                    clientMap.entrySet();

            String userName = null;
            for (Map.Entry<String, Socket> socketEntry : entrySet) {//獲得:是哪個使用者說的話
                if (socketEntry.getValue() == client) {
                    userName = socketEntry.getKey();//發出資訊的使用者
                }
            }
            String msg = null;

            while (true) {
                if (scanner.hasNext()) {
                    msg = scanner.next();
                    if("exit".equals(msg)){//如果使用者退出了
                        for(Map.Entry<String,Socket> stringSocketEntry : entrySet){
                            new PrintStream(stringSocketEntry.getValue().getOutputStream(),true).println("使用者"+userName+"剛剛退出了群聊！！");//給所有人發退出群聊的訊息
                        }
                        return;
                    }


                    for (Map.Entry<String, Socket> stringSocketEntry : entrySet) {//遍歷使用者的map，獲取所有使用者的Socket
                        try {
                            Socket socket = stringSocketEntry.getValue();
                            PrintStream ps = new PrintStream(socket.getOutputStream(), true);

                            ps.println("群聊:使用者" + userName + "說: " + msg);//給每個使用者發訊息
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }

                }
            }

        }
        private void privateChat(Scanner scanner, String privatepeopleName) throws IOException {

            Socket privateUser = clientMap.get(privatepeopleName);
            PrintStream ps = new PrintStream(privateUser.getOutputStream());//拿到私聊物件的輸出流
            PrintStream PrintToClient = new PrintStream(client.getOutputStream());//拿到當前客戶端的輸出流
            String Message = null;
            String MyName = null;
            Set<Map.Entry<String,Socket>> set = clientMap.entrySet();
            for(Map.Entry<String,Socket> value : set){
                if(value.getValue() == client){
                    MyName = value.getKey();
                    break;
                }
            }

            while (true) {
                if(scanner.hasNext()) {
                    Message = scanner.next();
                    if ("exit".equals(Message)){//如果使用者輸入了退出
                        PrintToClient.println("已退出和"+privatepeopleName+"的私聊");
                        ps.println("對方已經退出了私聊");
                        break;
                    }
                    ps.println(MyName+"說"+Message);//如果使用者沒有退出，向私聊物件傳送訊息
                }
            }


        }


    }

    public static void main(String[] args) {
        try {
            ExecutorService executorService = Executors.newFixedThreadPool(100);//最多容納100個客戶端聊天
            ServerSocket serverSocket = new ServerSocket(6655);
            for (int i = 0; i < 100; i++) {
                Socket client = serverSocket.accept();
                System.out.println("有新的使用者連線 " + client.getInetAddress() +
                        client.getPort());
                executorService.execute(new ExecuteClientThread(client));
            }
            executorService.shutdown();
            serverSocket.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

        然後是客戶端的程式碼，客戶端的程式碼比較簡單：分為兩個執行緒，一個執行緒用於接收伺服器的資料，一個執行緒用於向伺服器傳送資料。我就直接上程式碼了，裡面有註釋的。

import java.io.IOException;
import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;


class ExcuteServerInPut implements Runnable{//接收伺服器的資料
    private Socket ToServer;

    ExcuteServerInPut(Socket ToServer){
        this.ToServer = ToServer;
    }

    @Override
    public void run() {
        try {
            Scanner scanner = new Scanner(ToServer.getInputStream());
               while (scanner.hasNext()){
                System.out.println(scanner.nextLine());
            }
            scanner.close();
            ToServer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

class ExcuteServerOutPut implements Runnable{//向伺服器傳送資料

    private Socket Socket;
    ExcuteServerOutPut(Socket Socket){
        this.Socket = Socket;
    }

    @Override
    public void run() {
        try {
            PrintStream printStream = new PrintStream(Socket.getOutputStream());
            Scanner scanner = new Scanner(System.in);
            scanner.useDelimiter("\n");
            System.out.println("*****************************************");
            System.out.println("***使用者註冊:useerName:同戶名(僅限一次)***");
            System.out.println("***進入群聊:G:           退出群聊:exit***");
            System.out.println("***私聊:P-使用者名稱         退出私聊:exit***");
            System.out.println("***********退出聊天室:byebye*************");
            while (true){
                if(scanner.hasNext()) {
                    String string = scanner.next();
                    printStream.println(string);
                    if ("byebye".equals(string)) {
                        System.out.println("退出！");
                        printStream.close();
                        scanner.close();
                        break;
                    }
                }

            }

            Socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}


public class Main {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("127.0.0.1", 6655);
        ExcuteServerInPut excuteServerInPut = new ExcuteServerInPut(socket);
        ExcuteServerOutPut excuteServerOutPut = new ExcuteServerOutPut(socket);
        new Thread(excuteServerInPut).start();
        new Thread(excuteServerOutPut).start();
        }
}