chessserver.java

实现了一个网络五子棋的对弈程序

    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);
    }

    /**
     * 用于处理消息回馈的函数
     */
    public void Feedback(String feedbackString) {
        synchronized (clientDataHash) {
            //得到输出流。。。
            DataOutputStream outData = (DataOutputStream) clientDataHash.get(clientSocket);
            try {
                //输出信息。。。
                outData.writeUTF(feedbackString);
            } catch (Exception eb) {
                //打印堆栈轨迹，程序终止。。
                eb.printStackTrace();
            }
        }
    }

    /**
     * 获取用户列表的函数，此函数读取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和值对象，获取相对应得键值的函数。
     */
    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("注意：用命令的时候，先把谈话的对象定为所有人");
    }

    /**
     * 用于和客户端断开的函数。
     */
    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里的数据清除
        synchronized (clientDataHash) {
            clientDataHash.remove(clientSocket);
        }
        synchronized (clientNameHash) {
            clientNameHash.remove(clientSocket);
        }
        //广播更新用户列表。。。
        publicTalk(getUserList());
        // 计算当前连接数，并显示在状态框中
        server.statusLabel.setText("当前连接数:" + clientDataHash.size());
        try {
            clientSocket.close();
        } catch (IOException exx) {
        }
        isClientClosed = true;
    }

    public void run() {
        DataInputStream inData;
        synchronized (clientDataHash) {
            server.statusLabel.setText("当前连接数:" + 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("服务器状态");

    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);

    /**
     * 框架类的构造函数
     */
    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);
        // 退出窗口的监听器
        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++));

                //每连接一个用户，创建一个线程，监听服务。。
                ServerThread thread = new ServerThread(clientSocket, clientDataHash, clientNameHash, chessPeerHash,
                        server);
                thread.start();
            }
        } catch (IOException ex) {
            System.out.println("已经有服务器在运行. \n");
        }
    }

    /**
     * 按钮的事件监听器，响应按钮点击事件
     */
    public void actionPerformed(ActionEvent e) {
        if (e.getSource() == messageClearButton) {
            server.messageBoard.setText("");
        }
        // 当“服务器状态”按钮点击时，显示服务器状态
        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[]) {//主函数，启动服务器。。。
        chessServer chessServer = new chessServer();
    }
}