Java Socket 全雙工通信

最開始接觸TCP編程是想測試一下服務器的一些端口有沒有開，阿里雲的服務器，公司的服務器，我也不知道他開了那些端口，於是寫個小程序測試一下，反正就是能連上就是開了，

雖然曉得nmap這些東西，但服務器不監聽開放的端口，他也檢測不到開沒開

后來前幾天寫了個程序，接受TCP請求並解析字節流寫入數據庫，這其實不難，整個程序就是個半雙工模式，就是設備給我發一條消息，我給他回一條

然后就像寫個類似QQ這類聊天軟件的東西玩玩，百度了半天沒找到全雙工的例子，那就自己寫吧，兩天寫完了，好開心，有新玩具可以玩了

不解釋，直接放代碼，感覺注釋寫的很清楚了

這是服務器的代碼

補充一點，可能忘寫了，服務器可以主動斷開與客戶端的連接，例如連接的id是1號，那么輸入1:exit，就會斷開與id為1的連接

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Set;
import java.util.Map;
import java.util.HashMap;
import java.util.LinkedList;

/**
 * 服務器，全雙工，支持單播和廣播
 *
 * 注意是全雙工，全雙工，全雙工
 * 
 * 就是像QQ一樣
 */
public class Server{
    // 分配給socket連接的id，用於區分不同的socket連接
    private static int id = 0;
    // 存儲socket連接，發送消息的時候從這里取出對應的socket連接
    private HashMap<Integer,ServerThread> socketList = new HashMap<>();
    // 服務器對象，用於監聽TCP端口
    private ServerSocket server;

    /**
     * 構造函數，必須輸入端口號
     */
    public Server(int port) {
        try {
            this.server = new ServerSocket(port);
            System.out.println("服務器啟動完成 使用端口: "+port);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 啟動服務器，先讓Writer對象啟動等待鍵盤輸入，然后不斷等待客戶端接入
     * 如果有客戶端接入就開一個服務線程，並把這個線程放到Map中管理
     */
    public void start() {
        new Writer().start();
        try {
            while (true) {
                Socket socket = server.accept();
                System.out.println(++id + ":客戶端接入:"+socket.getInetAddress() + ":" + socket.getPort());
                ServerThread thread = new ServerThread(id,socket);
                socketList.put(id,thread);
                thread.run();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 回收資源啦，雖然不廣播關閉也沒問題，但總覺得通知一下客戶端比較好
     */
    public void close(){
        sendAll("exit");
        try{
            if(server!=null){
                server.close();
            }
        }catch(IOException e){
            e.printStackTrace();
        }
        System.exit(0);
    }

    /**
     * 遍歷存放連接的Map，把他們的id全部取出來，注意這里不能直接遍歷Map，不然可能報錯
     * 報錯的情況是，當試圖發送 `*:exit` 時，這段代碼會遍歷Map中所有的連接對象，關閉並從Map中移除
     * java的集合類在遍歷的過程中進行修改會拋出異常
     */
    public void sendAll(String data){ 
        LinkedList<Integer> list = new LinkedList<>();
        Set<Map.Entry<Integer,ServerThread>> set = socketList.entrySet();
        for(Map.Entry<Integer,ServerThread> entry : set){
            list.add(entry.getKey());
        }
        for(Integer id : list){
            send(id,data);
        }
    }

    /**
     * 單播
     */
    public void send(int id,String data){
        ServerThread thread = socketList.get(id);
        thread.send(data);
        if("exit".equals(data)){
            thread.close();
        }
    }

    // 服務線程，當收到一個TCP連接請求時新建一個服務線程
    private class ServerThread implements Runnable {
        private int id;
        private Socket socket;
        private InputStream in;
        private OutputStream out;
        private PrintWriter writer;

        /**
         * 構造函數
         * @param id 分配給該連接對象的id
         * @param socket 將socket連接交給該服務線程
        */
        ServerThread(int id,Socket socket) {
            try{
                this.id = id;
                this.socket = socket;
                this.in = socket.getInputStream();
                this.out = socket.getOutputStream();
                this.writer = new PrintWriter(out);
            }catch(IOException e){
                e.printStackTrace();
            }
        }

        /**
         * 因為設計為全雙工模式，所以讀寫不能阻塞，新開線程進行讀操作
        */
        @Override
        public void run() {
            new Reader().start();
        }

        /**
         * 因為同時只能有一個鍵盤輸入，所以輸入交給服務器管理而不是服務線程
         * 服務器負責選擇socket連接和發送的消息內容，然后調用服務線程的write方法發送數據
         */
        public void send(String data){
            if(!socket.isClosed() && data!=null && !"exit".equals(data)){
                writer.println(data);
                writer.flush();
            }
        }

        /**
         * 關閉所有資源
         */
        public void close(){
            try{
                if(writer!=null){
                    writer.close();
                }
                if(in!=null){
                    in.close();
                }
                if(out!=null){
                    out.close();
                }
                if(socket!=null){
                    socket.close();
                }
                socketList.remove(id);
            }catch(IOException e){
                e.printStackTrace();
            }
        }

        /**
         * 因為全雙工模式所以將讀操作單獨設計為一個類，然后開個線程執行
         */
        private class Reader extends Thread{
            private InputStreamReader streamReader = new InputStreamReader(in);
            private BufferedReader reader = new BufferedReader(streamReader);

            @Override
            public void run(){
                try{
                    String line = "";
                    // 只要連接沒有關閉，而且讀到的行不為空，為空說明連接異常斷開，而且客戶端發送的不是exit，那么就一直從連接中讀
                    while(!socket.isClosed() && line!=null && !"exit".equals(line)){
                        line=reader.readLine();
                        if(line!=null){
                            System.out.println(id+":client: "+line);
                        }
                    }
                    // 如果循環中斷說明連接已斷開
                    System.out.println(id+":客戶端主動斷開連接");
                    close();
                }catch(IOException e) {
                    System.out.println(id+":連接已斷開");
                }finally{
                    try{
                        if(streamReader!=null){
                            streamReader.close();
                        }
                        if(reader!=null){
                            reader.close();
                        }
                        close();
                    }catch(IOException e){
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    /**
     * 因為發送的時候必須指明發送目的地，所以不能交給服務線程管理寫操作，不然就無法選擇向哪個連接發送消息
     * 如果交給服務線程管理的話，Writer對象的會爭奪鍵盤這一資源，誰搶到是誰的，就無法控制消息的發送對象了
     */
    private class Writer extends Thread{
        // 我們要從鍵盤獲取發送的消息
        private BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        
        @Override
        public void run(){
            String line = "";
            // 先來個死循環，除非主動輸入exit關閉服務器，否則一直等待鍵盤寫入
            while(true){
                try{
                    line = reader.readLine();
                    if("exit".equals(line)){
                        break;
                    }
                }catch(IOException e){
                    e.printStackTrace();
                }
                // 輸入是有規則的 [連接id]:[要發送的內容]
                // 連接id可以為*，代表所有的連接對象，也就是廣播
                // 要發送的內容不能為空，發空內容沒意義，而且浪費流量
                // 連接id和要發送的消息之間用分號分割，注意是半角的分號
                // 例如： 1:你好    ==>客戶端看到的是 server:你好
                //       *:吃飯了  ==>所有客戶端都能看到 server:吃飯了
                if(line!=null){
                    try{
                        String[] data = line.split(":");
                        if("*".equals(data[0])){
                            // 這里是廣播
                            sendAll(data[1]);
                        }else{
                            // 這里是單播
                            send(Integer.parseInt(data[0]),data[1]);
                        }
                        // 有可能發生的異常
                    }catch(NumberFormatException e){
                        System.out.print("必須輸入連接id號");
                    }catch(ArrayIndexOutOfBoundsException e){
                        System.out.print("發送的消息不能為空");
                    }catch(NullPointerException e){
                        System.out.print("連接不存在或已經斷開");
                    }
                }
            }
            // 循環中斷說明服務器退出運行
            System.out.println("服務器退出");
            close();
        }
    }

    public static void main(String[] args) {
        int port = Integer.parseInt(args[0]);
        new Server(port).start();
    }
}

這是客戶端的代碼

import java.io.*;
import java.net.Socket;
import java.net.UnknownHostException;

/**
 * 客戶端 全雙工 但同時只能連接一台服務器
 */
public class Client {
    private Socket socket;
    private InputStream in;
    private OutputStream out;

    /**
     * 啟動客戶端需要指定地址和端口號
     */
    private Client(String address, int port) {
        try {
            socket = new Socket(address, port);
            this.in = socket.getInputStream();
            this.out = socket.getOutputStream();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("客戶端啟動成功");
    }

    public void start(){
        // 和服務器不一樣，客戶端只有一條連接，能省很多事
        Reader reader = new Reader();
        Writer writer = new Writer();
        reader.start();
        writer.start();
    }

    public void close(){
        try{
            if(in!=null){
                in.close();
            }
            if(out!=null){
                out.close();
            }
            if(socket!=null){
                socket.close();
            }
            System.exit(0);
        }catch(IOException e){
            e.printStackTrace();
        }
    }

    private class Reader extends Thread{
        private InputStreamReader streamReader = new InputStreamReader(in);
        private BufferedReader reader = new BufferedReader(streamReader);

        @Override
        public void run(){
            try{
                String line="";
                while(!socket.isClosed() && line!=null && !"exit".equals(line)){
                    line=reader.readLine();
                    if(line!=null){
                        System.out.println("Server: "+line);
                    }
                }
                System.out.println("服務器主動斷開連接");
                close();
            }catch(IOException e){
                System.out.println("連接已斷開");
            }finally{
                try{
                    if(streamReader!=null){
                        streamReader.close();
                    }
                    if(reader!=null){
                        reader.close();
                    }
                    close();
                }catch(IOException e){
                    e.printStackTrace();
                }
            }
        }
    }

    private class Writer extends Thread{
        private PrintWriter writer = new PrintWriter(out);
        private BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        @Override
        public void run(){
            try{
                String line = "";
                while(!socket.isClosed() && line!=null && !"exit".equals(line)){
                    line = reader.readLine();
                    if("".equals(line)){
                        System.out.print("發送的消息不能為空");
                    }else{
                        writer.println(line);
                        writer.flush();
                    }
                }
                System.out.println("客戶端退出");
                close();
            }catch(IOException e){
                System.out.println("error:連接已關閉");
            }finally{
                try{
                    if(writer!=null){
                        writer.close();
                    }
                    if(reader!=null){
                        reader.close();
                    }
                    close();
                }catch(IOException e){
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
       String address = args[0];
       int port = Integer.parseInt(args[1]);
       new Client(address, port).start();
    }
}

無聊的時候就自己和自己聊天吧

感覺在這基礎上可以搭個http服務器什么的了

 

然后就可以輸入要返回的信息了，輸入完斷開客戶端連接就好了，就是 2:exit，然后瀏覽器就能看到返回的信息了，不過貌似沒有響應頭，只有響應正文

/*

這里什么都沒寫

還有服務器或者客戶端添加個執行遠程命令什么的方法。。。。。。

別老想壞事，沒開SSH的服務器遠程執行個運維腳本什么的也不錯啊，尤其是Win的服務器

其實我一直想弄個遠程部署Tomcat項目的東西，最好是熱部署，不然每次都要用FTP上傳war

但是Windows服務器不會玩

*/

目前已知Bug:

當一方（不論是客戶端還是服務器）輸入消息后但沒有發出，但此時接受到另一方發來的消息，顯示會出現問題

因為輸入的字符還在緩沖區中，所以會看到自己正在寫的字符和發來的字符拼到了一行

左邊是服務器，右邊是客戶端

客戶端輸入了 `測試一下` 但沒有發出，服務器此時發送一條消息 `這里是服務器` 於是就發生了右圖的情況

然后客戶端發送消息，服務器收到 `測試一下`，發送前再輸入字符不會影響到服務器接受到的消息，

例如在上述情況下，客戶端收到服務器的消息后，在輸入`我還沒說完` 然后再發送，服務器會收到 `測試一下我還沒說完`

也就是說只是客戶端要發送的消息，顯示上會與服務器發來的消息顯示在一行，而且再輸入字符會折行

如果誰知道怎么弄請告訴我一下