Java网络编程：以一个基于BIO模型的多线程网络聊天室为例

网络编程的目的在于远程发送数据，发送接收数据就涉及到I/O的操作，这里因为涉及到比较底层字节和字符的操作，所以不可以使用java.nio.file.Files 操作文件。那就先说说I/O吧，I/O流分为字节流和字符流。字节即Byte，包含8位二进制数，一个二进制数就是1bit，中文名称叫位。字符即一个字母或者一个汉字。一个字母由一个字节组成，而汉字根据编码多字节个组成。

 Java I/O类的实现原理是装饰者设计模式：

FileInputStream fileInputStream = new FileInputStream(filePath);
BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);

优点：装饰类和被装饰类可以独立发展，不会相互耦合，装饰模式是继承的一个替代模式，装饰模式可以动态扩展一个实现类的功能。

使用场景： 1、扩展一个类的功能。 2、动态增加功能，动态撤销。

 

Java BIO：同步阻塞

Java NIO：同步非阻塞

多个的进程的IO可以注册到一个复用器（select）上，然后用一个进程调用该select， select会监听所有注册进来的IO。如果select监听的IO在内核缓冲区都没有可读数据，select调用进程会被阻塞；而当任一IO在内核缓冲区中有可数据时，select调用就会返回。而后select调用进程可以自己或通知另外的进程（注册进程）来再次发起读取IO，读取内核中准备好的数据。可以看到，多个进程注册IO后，只有另一个select调用进程被阻塞。

Java AIO：异步非阻塞

BIO通信模型

所谓BIO，就是Block IO，阻塞式的IO。这个阻塞主要发生在：ServerSocket接收请求时、InputStream、OutputStream（输入输出流的读和写）都是阻塞的。

服务端ChatServer类：

package top.rqfreefly.chatroom.bio;

/**
 * 功能实现：服务器端，这个类有两个关键的全局变量，一个就是存储在线用户信息的Map，一个就是线程池
 * 这个类会监听端口，接收客户端的请求，然后为客户端分配工作线程
 * 还会提供一些常用的工具方法给每个工作线程调用，比如：添加和移除用户，发送消息。
 */

import java.io.*;
import java.net.*;
import java.util.Map;
import java.util.concurrent.*;

public class ChatServer {

    private int SEVER_PORT = 8888;
    /**
     * 创建一个Map存储在线用户的信息。这个userMap可以统计在线用户、针对这些用户可以转发其他用户发送的消息
     * 因为会有多个线程操作这个userMap，所以为了安全起见用ConcurrentHashMap
     * 在这里key就是客户端的端口号，但在实际中肯定不会用端口号区分用户，如果是web的话一般用session
     * value是用户的IO的Writer，用以给客户端发送消息
     */
    private Map<Integer, Writer> userMap = new ConcurrentHashMap<>();
    /**
     * 创建线程池，线程上限为40个，如果第41个客户端请求进来，服务器会接收但是不会去分配线程处理它。
     */
    private ExecutorService executorService = Executors.newFixedThreadPool(40);

    //客户端连接时往map添加客户端
    public void addClient(Socket socket) throws IOException {
        if (socket != null) {
            BufferedWriter writer = new BufferedWriter(
                    new OutputStreamWriter(socket.getOutputStream())
            );
            userMap.put(socket.getPort(), writer);
            System.out.println("Client["+socket.getPort()+"]:Online");
        }
    }

    //断开连接时map里移除客户端
    public void removeClient(Socket socket) throws Exception {
        if (socket != null) {
            if (userMap.containsKey(socket.getPort())) {
                userMap.get(socket.getPort()).close();
                userMap.remove(socket.getPort());
            }
            System.out.println("Client [" + socket.getPort() + "] Offline");
        }
    }

    //转发客户端消息，这个方法就是把消息发送给在线的其他的所有客户端
    public void sendMessage(Socket socket, String msg) throws IOException {
        //遍历在线客户端
        for (Integer port : userMap.keySet()) {
            //发送给在线的其他客户端
            if (port != socket.getPort()) {
                Writer writer = userMap.get(port);
                writer.write(msg);
                writer.flush();
            }
        }
    }

    //接收客户端请求，并分配Handler去处理请求
    public void start() {
        try (ServerSocket serverSocket = new ServerSocket(SEVER_PORT)) {
            System.out.println("Server Start,The Port is:" + SEVER_PORT);
            while (true) {
                //等待客户端连接
                Socket socket = serverSocket.accept();
                //为客户端分配一个ChatHandler线程
                executorService.execute(new ChatHandler(this, socket));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        ChatServer server = new ChatServer();
        server.start();
    }

}

 服务端的ChatHandler类：

package top.rqfreefly.chatroom.bio;

/**
 * 功能实现：这个类就是工作线程类，把接收到的消息转发给其他客户端，还可以添加和移除用户。
 */

import java.io.*;
import java.net.*;

public class ChatHandler implements Runnable {
    private ChatServer server;
    private Socket socket;
    BufferedReader reader;

    //构造函数，ChatServer通过这个分配Handler线程
    public ChatHandler(ChatServer server, Socket socket) {
        this.server = server;
        this.socket = socket;
    }

    @Override
    public void run() {
        try {
            //往map里添加这个客户端
            server.addClient(socket);
            //读取这个客户端发送的消息
            reader = new BufferedReader(
                    new InputStreamReader(socket.getInputStream())
            );
            String msg = null;
            while ((msg = reader.readLine()) != null) {
                //这样拼接是为了让其他客户端也能看清是谁发送的消息
                String sendmsg = "Client [" + socket.getPort() + "]: " + msg;
                //服务器打印这个消息
                System.out.println(sendmsg);
                //将收到的消息转发给其他在线客户端
                server.sendMessage(socket, sendmsg + "\n");
                if (msg.equals("exit")) {
                    break;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //如果用户退出或者发生异常，就在map中移除该客户端
            try {
                server.removeClient(socket);
            } catch (Exception e) {
                e.printStackTrace();
            }
            try {
                if(reader != null) {
                    reader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

客户端ChatClient类：

package top.rqfreefly.chatroom.bio;

/**
 * 功能实现：客户端，会通过Socket和服务器连接。提供了两个工具方法：发送消息和接收消息。
 */

import java.io.*;
import java.net.*;

public class ChatClient {

    private BufferedReader reader;
    private BufferedWriter writer;
    private Socket socket;

    //发送消息给服务器
    public void sendToServer(String msg) throws IOException {
        //发送之前，判断socket的输出流是否关闭
        if (!socket.isOutputShutdown()) {
            //如果没有关闭就把用户键入的消息放到writer里面
            writer.write(msg + "\n");
            writer.flush();
        }
    }

    //从服务器接收消息
    public String receive() throws IOException {
        String msg = null;
        //判断socket的输入流是否关闭
        if (!socket.isInputShutdown()) {
            //没有关闭的话就可以通过reader读取服务器发送来的消息。注意：如果没有读取到消息线程会阻塞在这里
            msg = reader.readLine();
        }
        return msg;
    }

    public void start() {
        //和服务创建连接
        try {
            socket = new Socket("127.0.0.1", 8888);
            reader = new BufferedReader(
                    new InputStreamReader(socket.getInputStream())
            );
            writer = new BufferedWriter(
                    new OutputStreamWriter(socket.getOutputStream())
            );
            //新建一个线程去监听用户输入的消息
            new Thread(new UserInputHandler(this)).start();

            //不停的读取服务器转发的其他客户端的信息
            String msg=null;
            while ((msg=receive())!=null){
                System.out.println(msg);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if(writer != null) {
                    writer.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(reader != null) {
                    reader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        ChatClient chatClient = new ChatClient();
        chatClient.start();
    }

}

客户端UserInputHandler类：

package top.rqfreefly.chatroom.bio;

/**
 * 功能实现：专门负责监听用户输入信息，一旦有信息键入，就马上发送给服务器。
 */

import java.io.*;

public class UserInputHandler implements Runnable {

    private ChatClient client;

    public UserInputHandler(ChatClient client) {
        this.client = client;
    }

    @Override
    public void run() {
        try {
            //接收用户输入的消息
            BufferedReader reader = new BufferedReader(
                    new InputStreamReader(System.in)
            );
            //不停的获取reader中的System.in，实现了等待用户输入的效果
            while (true) {
                String input = reader.readLine();
                //向服务器发送消息
                client.sendToServer(input);
                if (input.equals("exit"))
                    break;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}