Socket io聊天室模拟

Server

package com.bobo.org.mvc.test;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;




/**
 * Created by Bobo on 2015/11/19.
 */
public class Server {
    // 服务器端口
    private static final int SERVERPORT = 8888;
    // 客户端连接
    private static List<Socket> mClientList = new ArrayList<Socket>();
    // 线程池
    private ExecutorService mExecutorService;
    // serverSocket对象
    private ServerSocket mServerSocket;

    public static void main(String[] args) {
        new Server();
    }

    public Server() {
        try {
            // 设置服务器端口
            mServerSocket = new ServerSocket(SERVERPORT);
            // 创建一个线程池
            mExecutorService = Executors.newCachedThreadPool();
            System.out.println("start...");
            // 用来临时保存客户端连接的Socket对象
            Socket client = null;
            while(true) {
                // 接受客户度连接并添加到List中
                client = mServerSocket.accept();
                mClientList.add(client);
                mExecutorService.execute(new ThreadServer(client));
            }
        }
        catch(Exception e) {
            e.printStackTrace();
        }
    }

    // 每个客户端单独开启一个线程
    static class ThreadServer implements Runnable {
        private Socket mSocket;
        private BufferedReader mBufferedReader;
        private PrintWriter mPrintWriter;
        private String mStrMSG;

        public ThreadServer(Socket socket) throws IOException {
            this.mSocket = socket;
            // 设置读取套接字客户端发送流的编码格式
            mBufferedReader = new BufferedReader(new InputStreamReader(
                    socket.getInputStream(), "GB2312"));
            mStrMSG = "user:" + this.mSocket.getInetAddress() + " come total:"
                    + mClientList.size();
            sendMessage();
        }

        private void sendMessage() throws IOException {
            System.out.println(mStrMSG);
            for(Socket client : mClientList) {
                // 设置向套接字客户端写入流的编码格式
                mPrintWriter = new PrintWriter(new OutputStreamWriter(
                        client.getOutputStream(), "GB2312"), true);
                mPrintWriter.println(mStrMSG);
            }
        }

        public void run() {
            try {
                while((mStrMSG = mBufferedReader.readLine()) != null) {
                    if(mStrMSG.trim().equals("exit")) {
                        // 当一个客户端退出时
                        mClientList.remove(mSocket);
                        mBufferedReader.close();
                        mPrintWriter.close();
                        mStrMSG = "user:" + this.mSocket.getInetAddress()
                                + " exit tatal:" + mClientList.size();
                        mSocket.close();
                        sendMessage();
                        break;
                    }
                    else {
                        mStrMSG = mSocket.getInetAddress() + ":" + mStrMSG;
                        sendMessage();
                    }
                }
            }
            catch(Exception e) {
                e.printStackTrace();
            }
        }

    }
}

Client

package com.bobo.org.mvc.test;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * Created by Bobo on 2015/11/19.
 */


public class Client {
    private static final int PORT = 8888;
    // 线程池
    private static ExecutorService exec = Executors.newCachedThreadPool();

    public static void main(String[] args) throws Exception {
        new Client();
    }

    public Client() {
        try {
            Socket socket = new Socket("127.0.0.1", PORT);
            exec.execute(new Sender(socket));
            // 设置读取套接字服务器返回流的编码格式
            BufferedReader br = new BufferedReader(new InputStreamReader(
                    socket.getInputStream(), "GB2312"));
            String msg;
            while((msg = br.readLine()) != null) {
                System.out.println(msg);
            }
        }
        catch(Exception e) {
            System.out.println(e.getMessage());
        }
    }

    // 客户端线程获取控制台输入消息
    static class Sender implements Runnable {
        private Socket socket;

        public Sender(Socket socket) {
            this.socket = socket;
        }

        public void run() {
            try {
                BufferedReader br = new BufferedReader(new InputStreamReader(
                        System.in));
                // 设置向套接字服务器写入流的编码格式
                PrintWriter pw = new PrintWriter(new OutputStreamWriter(
                        socket.getOutputStream(), "GB2312"), true);
                String msg;

                while(true) {
                    msg = br.readLine();
                    pw.println(msg);

                    if(msg.trim().equals("exit")) {
                        pw.close();
                        br.close();
                        exec.shutdownNow();
                        break;
                    }
                }
            }
            catch(Exception e) {
                e.printStackTrace();
            }
        }
    }
}