学习笔记4：JavaSE & API（网络编程 & 多线程）

public class Client {
    private Socket socket;
    public static void main(String[] args) {
        Client client = new Client();
        client.start();
    }
    public Client(){
        try {
            System.out.println("正在连接服务端...");
            socket = new Socket("localhost",8088);
            System.out.println("与服务端建立连接了!");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public void start(){
        try {
            //启动用于读取服务端发送过来消息的线程：避免处理消息，卡住当前线程的执行
            ServerHandler handler = new ServerHandler();
            Thread t = new Thread(handler);
            t.start();
            //通过socket获取的字节输出流，写出的字节会通过网络发送给远端计算机
            OutputStream out = socket.getOutputStream();
            //转换流，字符转字节
            OutputStreamWriter osw = new OutputStreamWriter(out, StandardCharsets.UTF_8);
            //缓冲流
            BufferedWriter bw = new BufferedWriter(osw);
            //自动行刷新-字符缓冲输出流
            PrintWriter pw = new PrintWriter(bw,true);
            Scanner scanner = new Scanner(System.in);
            while(true) {
                String line = scanner.nextLine();
                if("exit".equalsIgnoreCase(line)){
                    break;
                }
                pw.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    //该线程任务负责处理服务端发送过来的消息
    private class ServerHandler implements Runnable{
        public void run(){
            try{
                //通过socket获取输入流读，取服务端发送过来的消息
                InputStream in = socket.getInputStream();
                InputStreamReader isr = new InputStreamReader(in, StandardCharsets.UTF_8);
                BufferedReader br = new BufferedReader(isr);
                String line;
                //循环读取服务端发送过来的每一行字符串
                while((line = br.readLine())!=null){//readLine方法是阻塞方法，返回如果是null，表示对方close了。
                    System.out.println(line);
                }
            }catch(IOException e){
                e.printStackTrace();
            }
        }
    }
}

public class Server {
    private ServerSocket serverSocket;
    private Collection<PrintWriter> allOut = new ArrayList<>();
    public static void main(String[] args) {
        Server server = new Server();
        server.start();
    }
    public Server(){
        try {
            System.out.println("正在启动服务端...");
            serverSocket = new ServerSocket(8088);//可能抛出java.net.BindException:address already in use
            System.out.println("服务端启动完毕!");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public void start(){
        try {
            while(true) {
                System.out.println("等待客户端连接");
                Socket socket = serverSocket.accept();
                System.out.println("一个客户端连接了!");
                //启动一个线程来处理该客户端的交互
                ClientHandler clientHandler = new ClientHandler(socket);
                Thread thread = new Thread(clientHandler);
                thread.start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    // 该线程任务是用一个线程来处理一个客户端的交互工作
    private class ClientHandler implements Runnable{
        private Socket socket;
        private String host;//记录远端计算机的地址信息
        public ClientHandler(Socket socket){
            this.socket = socket;
            host = socket.getInetAddress().getHostAddress();
        }
        public void run(){
            PrintWriter pw = null;
            try {
                //通过socket获取输入流读取对方发送过来的消息
                InputStream in = socket.getInputStream();
                InputStreamReader isr = new InputStreamReader(in, StandardCharsets.UTF_8);
                BufferedReader br = new BufferedReader(isr);

                //通过socket获取输出流用于给对方发送消息
                OutputStream out = socket.getOutputStream();
                OutputStreamWriter osw = new OutputStreamWriter(out, StandardCharsets.UTF_8);
                BufferedWriter bw = new BufferedWriter(osw);
                pw = new PrintWriter(bw,true);

                //将该输出流存入共享数组allOut中
                synchronized (Server.this) {//加锁，并且使用外部类对象加锁
                    allOut.add(pw);
                }

                //通知所有客户端，该用户上线了!
                sendMessage(host+"上线了，当前在线人数:"+allOut.size());
                String line;
                /*
                    这里的BufferedReader读取时，底下连接的流是通过Socket获取的输入流，当远端计算机还处于连接状态，
                    但是暂时没有发送内容时，readLine方法会处于阻塞状态，直到对方发送过来一行字符串为止。
                    如果返回值为null，则表示对方断开了连接(对方调用了socket.close())。
                    对于windows的客户端而言(Mac不会)，如果是强行杀死的进程，服务端这里readLine方法
                    会抛出下面异常: java.net.SocketException: connection reset
                    服务端无法避免这个异常。
                 */
                while ((line = br.readLine()) != null) {
                    //将读取到的内容，广播给所有客户端
                    sendMessage(host+"说:" + line);
                }
            }catch(IOException e){
                e.printStackTrace();
            }finally {
                //处理客户端断开连接后的操作
                synchronized (Server.this) {
                    allOut.remove(pw);
                }
                //通知所有客户端，该用户下线了!
                sendMessage(host+"下线了，当前在线人数:"+allOut.size());
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        //将消息群发给所有客户端(广播)
        private void sendMessage(String line){
            synchronized (Server.this) {
                System.out.println(line);
                //遍历allOut数组，将消息发送给所有客户端
                for (PrintWriter pw : allOut) {
                    pw.println(line);
                }
            }
        }
    }
}