public boolean chessPeerTalk(String chessPeerTalk, String chessTalkMessage) {

        for (Enumeration enu = clientDataHash.keys(); enu.hasMoreElements();) {
            Socket userClient = (Socket) enu.nextElement();

            if (chessPeerTalk.equals((String) clientNameHash.get(userClient))
                    && !chessPeerTalk.equals((String) clientNameHash.get(clientSocket))) {
                synchronized (clientDataHash) {
                    DataOutputStream peerOutData = (DataOutputStream) clientDataHash.get(userClient);
                    try {
                        peerOutData.writeUTF(chessTalkMessage);
                    } catch (IOException es) {
                        es.printStackTrace();
                    }
                }
                return (false);
            }
        }
        return (true);
    }

    /**
     * 用于處理消息回饋的函數(shù)
     */
    public void Feedback(String feedbackString) {
        synchronized (clientDataHash) {
            //得到輸出流。。。
            DataOutputStream outData = (DataOutputStream) clientDataHash.get(clientSocket);
            try {
                //輸出信息。。。
                outData.writeUTF(feedbackString);
            } catch (Exception eb) {
                //打印堆棧軌跡，程序終止。。
                eb.printStackTrace();
            }
        }
    }

    /**
     * 獲取用戶列表的函數(shù)，此函數(shù)讀取clientNameHash獲取用戶列表， 然后將其保存在一個字符串userList中。
     */
    public String getUserList() {
        String userList = "/userlist";
        //遍歷hashtable中的values，以空格分割連接起來
        for (Enumeration enu = clientNameHash.elements(); enu.hasMoreElements();) {
            userList = userList + " " + (String) enu.nextElement();
        }
        return userList;
    }

    /**
     * 給出HashTable和值對象，獲取相對應得鍵值的函數(shù)。
     */
    public Object getHashKey(Hashtable targetHash, Object hashValue) {
        Object hashKey;
        for (Enumeration enu = targetHash.keys(); enu.hasMoreElements();) {
            hashKey = (Object) enu.nextElement();
            //如果鍵對應的值與hashValue相等,則返回這個key
            if (hashValue.equals((Object) targetHash.get(hashKey)))
                return (hashKey);
        }
        return (null);
    }

    public void firstCome() {
        //新用戶第一次加入、廣播用戶列表。。
        publicTalk(getUserList());
        //反饋給這個用戶，以修改相應顯示信息。。
        Feedback("/yourname " + (String) clientNameHash.get(clientSocket));
        Feedback("Java五子棋聊天客戶端");
        Feedback("/changename <你的名字> --更改名字");
        Feedback("/list --更新用戶列表");
        Feedback("/<用戶名> <要說的話> --私聊");
        Feedback("注意：用命令的時候，先把談話的對象定為所有人");
    }

    /**
     * 用于和客戶端斷開的函數(shù)。
     */
    public void clientClose() {
        server.messageBoard.append("用戶斷開:" + clientSocket + "\n");
        // 如果是游戲客戶端主機
        synchronized (chessPeerHash) {
            if (chessPeerHash.containsKey(clientNameHash.get(clientSocket))) {
                chessPeerHash.remove((String) clientNameHash.get(clientSocket));
            }
            if (chessPeerHash.containsValue(clientNameHash.get(clientSocket))) {
                chessPeerHash.put((String) getHashKey(chessPeerHash, (String) clientNameHash.get(clientSocket)),
                        "tobeclosed");
            }
        }
        // 將保留的HashTable里的數(shù)據(jù)清除
        synchronized (clientDataHash) {
            clientDataHash.remove(clientSocket);
        }
        synchronized (clientNameHash) {
            clientNameHash.remove(clientSocket);
        }
        //廣播更新用戶列表。。。
        publicTalk(getUserList());
        // 計算當前連接數(shù)，并顯示在狀態(tài)框中
        server.statusLabel.setText("當前連接數(shù):" + clientDataHash.size());
        try {
            clientSocket.close();
        } catch (IOException exx) {
        }
        isClientClosed = true;
    }

    public void run() {
        DataInputStream inData;
        synchronized (clientDataHash) {
            server.statusLabel.setText("當前連接數(shù):" + clientDataHash.size());
        }
        try {
            inData = new DataInputStream(clientSocket.getInputStream());
            firstCome();
            while (true) {
                String message = inData.readUTF();
                messageTransfer(message);
            }
        } catch (IOException esx) {
        } finally {
            if (!isClientClosed) {
                clientClose();
            }
        }
    }

}

/**
 * @author wufenghanren 服務器端框架類
 */
public class chessServer extends Frame implements ActionListener {

    Button messageClearButton = new Button("清除顯示");

    Button serverStatusButton = new Button("服務器狀態(tài)");

    Button serverOffButton = new Button("關閉服務器");

    Panel buttonPanel = new Panel();

    MessageServerPanel server = new MessageServerPanel();

    ServerSocket serverSocket;

    Hashtable clientDataHash = new Hashtable(50);

    Hashtable clientNameHash = new Hashtable(50);

    Hashtable chessPeerHash = new Hashtable(50);

    /**
     * 框架類的構造函數(shù)
     */
    chessServer() {
        super("Java五子棋服務器");
        setBackground(new Color(204, 204, 204));

        buttonPanel.setLayout(new FlowLayout());
        messageClearButton.setSize(60, 25);
        buttonPanel.add(messageClearButton);
        messageClearButton.addActionListener(this);
        serverStatusButton.setSize(75, 25);
        buttonPanel.add(serverStatusButton);
        serverStatusButton.addActionListener(this);
        serverOffButton.setSize(75, 25);
        buttonPanel.add(serverOffButton);
        serverOffButton.addActionListener(this);

        add(server, BorderLayout.CENTER);
        add(buttonPanel, BorderLayout.SOUTH);
        // 退出窗口的監(jiān)聽器
        addWindowListener(new WindowAdapter() {
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
        setVisible(true);
        setSize(400, 450);
        setResizable(false);
        validate();
        try {
            makeMessageServer(4331, server);
        } catch (Exception e) {
            System.out.println("e");
        }
    }

    /**
     * 初始化消息服務器的類
     */
    public void makeMessageServer(int port, MessageServerPanel server) throws IOException {
        Socket clientSocket;
        long clientAccessNumber = 1;
        this.server = server;

        try {
            // 輸出服務器的啟動信息
            serverSocket = new ServerSocket(port);
            server.messageBoard.setText("服務器開始于:" + serverSocket.getInetAddress().getLocalHost() + ":"
                    + serverSocket.getLocalPort() + "\n");

            while (true) {
                clientSocket = serverSocket.accept();
                server.messageBoard.append("用戶連接:" + clientSocket + "\n");
                DataOutputStream outData = new DataOutputStream(clientSocket.getOutputStream());
                //在這里填充這兩個Hashtable，在對應線程里用到。。
                clientDataHash.put(clientSocket, outData);
                clientNameHash.put(clientSocket, ("玩家" + clientAccessNumber++));

                //每連接一個用戶，創(chuàng)建一個線程，監(jiān)聽服務。。
                ServerThread thread = new ServerThread(clientSocket, clientDataHash, clientNameHash, chessPeerHash,
                        server);
                thread.start();
            }
        } catch (IOException ex) {
            System.out.println("已經(jīng)有服務器在運行. \n");
        }
    }

    /**
     * 按鈕的事件監(jiān)聽器，響應按鈕點擊事件
     */
    public void actionPerformed(ActionEvent e) {
        if (e.getSource() == messageClearButton) {
            server.messageBoard.setText("");
        }
        // 當“服務器狀態(tài)”按鈕點擊時，顯示服務器狀態(tài)
        if (e.getSource() == serverStatusButton) {
            try {//顯示服務器信息
                server.messageBoard.append("服務器信息:" + serverSocket.getInetAddress().getLocalHost() + ":"
                        + serverSocket.getLocalPort() + "\n");
            } catch (Exception ee) {
                System.out.println("serverSocket.getInetAddress().getLocalHost() error \n");
            }
        }
        if (e.getSource() == serverOffButton) {//關閉服務。。
            System.exit(0);
        }
    }

    public static void main(String args[]) {//主函數(shù)，啟動服務器。。。
        chessServer chessServer = new chessServer();
    }
}