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)的私人消息。