JAVA基礎知識之網絡編程——-基於TCP通信的簡單聊天室

下面將基於TCP協議用JAVA寫一個非常簡單的聊天室程序， 聊天室具有以下功能，

• 在服務器端，可以接受客戶端注冊（用戶名），可以顯示注冊成功的賬戶
• 在客戶端，可以注冊一個賬號，並用這個賬號發送信息
• 發送信息有兩種模式，一種是群聊，所有在線用戶都可以看到消息，另一種是私聊，只針對指定賬戶發送消息

下面是主要的實現思路，

1. 首先是服務器端， 需要使用多線程實現。 主線程用來循環監聽客戶端的連接請求， 一旦接收到一個請求，就為這個客戶端創建一個專用通信線程。
2. 服務器端依靠一個經過重寫的map保存在線的客戶端賬戶以及建立連接后的通信句柄（inputStream/outputStream)
3. 服務器端和客戶端通信使用約定好的自定義協議，將在雙方發送的消息中添加固定消息頭和消息尾。 通信雙發都使用socket的inputStream和outStream讀和寫消息，與本地IO區別不大。
4. 當服務器端接收到客戶端的請求的時候，先解析出消息頭和尾，根據約定的通信協議來判斷消息類型，是注冊賬戶，還是群發消息，還是私聊消息
5. 對於群發消息，服務器端將遍歷在線的所有用戶（線程），然后將消息廣播出去
6. 對於私聊消息，服務器端根據客戶端發來的目的地址（收信賬戶），去map中查找到通信線程句柄（outputStream)，然后將信息發送給指定賬戶
7. 對於每個客戶端，都創建兩個線程。 主線程用來做鍵盤輸入， 輔線程用來接收服務器發回的消息
8. 客戶端的主線程中，所有消息都是先發送到服務器端，再由服務器端決定分發策略。
9. 包括注冊賬戶在內，服務器和客戶端雙方所有消息都是經過約定協議包裝過的，這樣服務器才能讀取消息的屬性，進行指定操作。

服務器端實現如下，

首先我們要自定義一個通信協議，服務器端和客戶端需要使用同一種協議，用來描述消息的屬性，

package chat;

public interface ChatProtocol {
    int PROTOCOL_LEN = 2;
    
    //協議字符串，會加入數據包中
    String MSG_ROND = "##";
    String USER_ROND = "@@";
    String LOGIN_SUCCESS = "1";
    String NAME_REP = "-1";
    String PRIVATE_ROND = "%%";
    String SPLIT_SIGN = "}";
    
}

服務器端的監聽線程（主線程）

package chat;

import java.io.IOException;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {
    private static final int SERVER_PORT = 33000;
    public static ChatMap<String, PrintStream> clients = new ChatMap();
    public void init() {
        try {
            ServerSocket ss = new ServerSocket(SERVER_PORT) ;
            while(true) {
                Socket socket = ss.accept();
                new ServerThread(socket).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        Server server = new Server();
        server.init();
    }
}

服務器端需要使用一個重寫的map來存放用戶名和對應的通信句柄， 這樣才能實現私聊功能，

package chat;

import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

//用map來保存用戶和socket輸出流的對應關系,
//K將會是String類型的用戶名，不允許重復
//V是從socket返回的outputStream對象，也不允許重復
public class ChatMap<K,V> {
    public Map<K,V> map = Collections.synchronizedMap(new HashMap<K,V>());
    
    //根據outputStream對象刪除制定項
    public synchronized void removeByValue(Object value) {
        for (Object key : map.keySet()) {
            if(map.get(key) == value) {
                map.remove(key);
                break;
            }
        }
    }
    
    //獲取outputStream對象組成的Set
    public synchronized Set<V> valueSet() {
        Set<V> result = new HashSet<V>();
        //遍歷map，將map的value存入Set
        for(K key :  map.keySet()) {
            result.add(map.get(key));
        }
        /*
         for (Map.Entry<K, V> entry : map.entrySet()) {
             result.add(entry.getValue());
         }
         */
         return result;
    }
    
    //根據ouputStream對象查找用戶名
    public synchronized K getKeyByValue(V val) {
        for(K key : map.keySet()) {
            if (map.get(key) == val || map.get(key).equals(val)) {
                return key;
            }
        }
        return null;
    }
    
    //實現put,key和value都不允許重復
    public synchronized V put(K key, V value) {
        for (V val : valueSet() ) {
                if (val.equals(value) && val.hashCode() == value.hashCode()) {
                    throw new RuntimeException("此輸入流已經被使用");
            }
        }
        return map.put(key, value);
    }
}

對每一個客戶端請求創建一個通信子線程

package chat;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.Socket;

public class ServerThread extends Thread{
    private Socket socket;
    BufferedReader br = null;
    PrintStream ps = null;
    
    public ServerThread(Socket socket) {
        this.socket = socket;
    }

    public void run() {
        try {
            br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            //一個客戶端的輸出流對象
            ps = new PrintStream(socket.getOutputStream());
            String line = null;
            while((line = br.readLine()) != null) {
                //如果消息以ChatProtocol.USER_ROND開始，並以其結束
                //則可以確定讀到的是用戶登錄的用戶名
                if(line.startsWith(ChatProtocol.USER_ROND) &&
                        line.endsWith(ChatProtocol.USER_ROND)) {
                    String userName = getRealMsg(line);
                    //用戶名不允許重復
                    if(Server.clients.map.containsKey(userName)) {
                        System.out.println("用戶名重復");
                        ps.println(ChatProtocol.NAME_REP);
                    } else {
                        System.out.println("["+userName+"] 注冊成功，你可以開始聊天了！");
                        ps.println(ChatProtocol.LOGIN_SUCCESS);
                        //將用戶名和輸出流對象組成的鍵值關聯對存入前面經過改造的map
                        Server.clients.map.put(userName, ps);
                    }
                } //如果消息以ChatProtocol.PRIVATE_ROND開頭並以ChatProtocol.PRIVATE_ROND結尾
                //則可以確定是私聊信息
                else if (line.startsWith(ChatProtocol.PRIVATE_ROND ) && 
                        line.endsWith(ChatProtocol.PRIVATE_ROND)) {
                    String userAndMsg = getRealMsg(line);
                    
                    //以SPILT_SIGN分割字符串，前半是用戶名，后半是聊天信息
                    String user = userAndMsg.split(ChatProtocol.SPLIT_SIGN)[0];
                    String msg = userAndMsg.split(ChatProtocol.SPLIT_SIGN)[1];
                    //根據用戶名在map中找出輸出流對象，進行私聊信息發送
                    Server.clients.map.get(user).println("[私聊信息] [來自 "+Server.clients.getKeyByValue(ps)+"] : " + msg);
                    
                }
                // 群聊信息，廣播消息
                else {
                    String msg = getRealMsg(line);
                    for(PrintStream clientPs :  Server.clients.valueSet()) {
                        clientPs.println("[群發信息] [來自 "+Server.clients.getKeyByValue(ps)+"] : " + msg);
                    }
                }
            }
        } catch (IOException e) {
            //e.printStackTrace();
            Server.clients.removeByValue(ps);
            System.out.println(Server.clients.map.size());
            try {
                if (br != null) {
                    br.close();
                } 
                
                if (ps != null) {
                    ps.close();
                }
                
                if (socket != null) {
                    socket.close();
                }
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }

    private String getRealMsg(String line) {
        return line.substring(ChatProtocol.PROTOCOL_LEN, line.length() - ChatProtocol.PROTOCOL_LEN);
    }


}

 

下面開始寫客戶端， 客戶端和服務器端是兩個完全獨立的應用， 可以新建工程寫一個客戶端，

為了簡單起見，我將服務器端和客戶端放在了同一個工程的同一個包下， 這樣可以共享一下協議接口 ChatProtocol.java

首先是客戶端主程序，用來完成鍵盤輸入操作， 其中注冊用戶名的地方調用了一點點java的gui編程接口swi，彈出對話框輸入用戶名，

package chat;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.Socket;

import javax.swing.JOptionPane;

public class Client {
    private static final int SERVER_PORT = 33000;
    private Socket socket;
    private PrintStream ps;
    private BufferedReader brServer;
    private BufferedReader keyIn;
    
    public void init() {
        try {
            keyIn = new BufferedReader(new InputStreamReader(System.in));
            socket = new Socket("127.0.0.1", SERVER_PORT);
            ps = new PrintStream(socket.getOutputStream());
            brServer = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            String tip = "";
            while(true) {
                String userName = JOptionPane.showInputDialog(tip + "輸入用戶名");
                ps.println(ChatProtocol.USER_ROND + userName + ChatProtocol.USER_ROND);
                
                //服務器端響應
                String result = brServer.readLine();
                if(result.equals(ChatProtocol.NAME_REP)) {
                    tip = "用戶名重復，請重新輸入";
                    continue;
                }
                //登錄成功
                if(result.equals(ChatProtocol.LOGIN_SUCCESS)) {
                    System.out.println("登錄成功，賬號： ["+ userName +"]");
                    break;
                }
            }
        } catch (IOException ex) {
            ex.printStackTrace();
        }
        
        new ClientThread(brServer).start();
    }
    
    private void readAndSend() {
        try {
            String line = null;
            while((line = keyIn.readLine()) != null) {
                //如果發送的消息中帶有冒號，且以//開頭，則認為是私聊信息
                if(line.indexOf(":") > 0 && line.startsWith("//")) {
                    line = line.substring(2);
                    ps.println(ChatProtocol.PRIVATE_ROND 
                            + line.split(":")[0] 
                            + ChatProtocol.SPLIT_SIGN 
                            + line.split(":")[1]
                            + ChatProtocol.PRIVATE_ROND);
                } else {
                    ps.println(ChatProtocol.MSG_ROND + line + ChatProtocol.MSG_ROND);
                }
            }
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }

    private void closeRs() {
        try {
            if (keyIn != null) {
                keyIn.close();
            }
            
            if (brServer != null) {
                brServer.close();
            }
            
            if (ps != null) {
                ps.close();
            }
            
            if (socket != null) {
                socket.close();
            }
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }
    
    public static void main(String[] args) {
        Client client = new Client();
        client.init();
        client.readAndSend();
    }
}

 

鍵盤操作中，區分群發消息和私聊消息是看消息以什么開頭，以//開頭就是私聊，否則是群發，

私聊時，用冒號隔開收信人和消息內容， 一條私聊消息格式是這樣的    //b:hi, i'm a

下面是客戶端的子線程，專門用來回顯服務器端發回來的消息，

package chat;

import java.io.BufferedReader;
import java.io.IOException;

public class ClientThread extends Thread {

    BufferedReader br = null;
    
    public ClientThread(BufferedReader brServer) {
        this.br = brServer;
    }
    
    public void run() {
        try {
            String line = null;
            while((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException ex) {
            ex.printStackTrace();
        } finally {
            try {
                if (br != null) {
                    br.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

 

下面是執行結果， 先啟動一個Server端的進程，可以看到啟動之后Server端處於監聽阻塞狀態，

接着分別啟動兩個Client端進程，每次啟動Client進程的時候都會要求輸入用戶名，要保證用戶名不能重復，

接着就可以發送消息了，普通消息將會發送給所有人，即群發， 指定格式的消息將是私聊，例如 //bbb:hi I'm aaa     (這是發給賬戶bbb)的私人消息。