局域网聊天室 -ChatServer

package com.chat.server;

import java.io.IOException;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
import java.util.HashMap;
import java.util.Vector;


/**
* 服务器类, 无限循环等待客户端的连接, 并创建线程响应客户端
* @author 刘优
*
*/
public class ChatServer implements Runnable {

    private ServerSocket server;                                              // serversocket
    private int port;                                                                // 端口
    private static Vector<Socket> clients;                                 // 客户端socket集合
    private static HashMap<String,PrintWriter> clientWriterMap;        // 客户,字符流输出流MAP(可以根据用户名直接定位到writer)
    private static HashMap<Socket,String> socketClientMap;            // SOCKET,客户MAP
    private static Vector<String []> blackUsers;                           // 用户黑名单对应关系 String[1] 是 String[0]的黑名单中的用户
    private static HashMap<String,Boolean> clientTypeMap;            // 客户,客户端类型MAP 客户端的类型有Window和telnet用户
    private static Vector<ServerResponseThread> allThreads;            // 所有的线程集合
    private static HashMap<String,ServerResponseThread> threadMap;  // 用户名,线程Map
    private boolean serverRunning;                                                    // 服务器运行标志
    private boolean started;                                                                // 服务器启动标志

    public ChatServer(int port) throws IOException {
        this.port = port;
        started = false;                                            // 运行标志
    }

    /**
     * 修改服务器端口号, 会导致服务重起
     * @param port
     */
    public void setPort(int port) {
        this.port = port;
        if (started) {
            stop();
        }
        try {
            start();                                                // 启动服务器
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 初始化服务器
     *
     */
    private void init() {
        clients = new Vector<Socket>();
        clientWriterMap = new HashMap<String,PrintWriter>();
        socketClientMap = new HashMap<Socket,String>();
        blackUsers = new Vector<String []>();
        clientTypeMap = new HashMap<String,Boolean>();
        serverRunning = true;
        allThreads = new Vector<ServerResponseThread>();
        threadMap = new HashMap<String,ServerResponseThread>();
    }

    /**
     * 启动服务器线程
     * @throws IOException
     */
    public void start() throws IOException {
        init();
        Thread serverThread = new Thread(this);                    // 新建一个线程来运行服务器
        serverThread.start();
        started = true;
    }
    /**
     * 重起服务器
     * @throws IOException
     */
    public void restart() throws IOException {
        if (started) {
            stop();                                                // 如果已经启动, 则关闭后再重起
        }
        start();
    }

    /**
     * 停止服务器, 清空所有集合
     *
     */
    public void stop() {
        serverRunning = false;
        if (allThreads != null) {
            for (int i = 0; i < allThreads.size(); ++i) {
                allThreads.get(i).stopService();
            }
            allThreads.clear();
            allThreads = null;
        }
        if (server != null) {
            try {
                server.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if (clients != null) {
            clients.clear();
            clients = null;
        }
        if (clientWriterMap != null) {
            clientWriterMap.clear();
            clientWriterMap = null;
        }
        if (socketClientMap != null) {
            socketClientMap.clear();
            socketClientMap = null;
        }
        if (blackUsers != null) {
            blackUsers.clear();
            blackUsers = null;
        }
        if (clientTypeMap != null) {
            clientTypeMap.clear();
            clientTypeMap = null;
        }
        started = false;
    }

    /**
     * 启动服务器RUN方法
     */
    public void run() {
        try {
            server = new ServerSocket(port);                        // 创建SERVERSOCKET 服务器主对象
        } catch (IOException e) {
            e.printStackTrace();
        }
        while (serverRunning) {
            System.out.println("server is running at port : " + port);
            Socket socket;
            try {
                if (server == null) {
                    System.out.println("server is null");
                    break;
                }
                socket = server.accept();                            // 监听客户端连接请求
                clients.add(socket);
                System.out.println("client : " + socket.getInetAddress() + " attempt to enter the chat room"); // 打印客房信息...
                // 启动一个服务器端应答线程响应客户端. 并把服务器的各种集合共享,使之能访问其他线程
                ServerResponseThread response = new ServerResponseThread(socket,clientWriterMap,socketClientMap,blackUsers,clientTypeMap,threadMap);
                allThreads.add(response);
                response.setAllClientsThreadVector(allThreads);
                response.setClientSocketVector(clients);
                response.start();                                    // 启动响应线程
            }
            catch (SocketException ee) {
                System.out.println("server is down");                // 关闭服务器的提示
            }
            catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public void kickOff(String user) {
        ServerResponseThread thread = threadMap.get(user);
        //System.out.println("thread " + thread);
        if (thread != null) {
            thread.kickOff();
            System.out.println("user " + user + " has been kicked...");
        }
        else {
            System.out.println("user " + user + " not on line!");
        }
    }
}