1. 使用 Socket 和 ServerSocket 进行 BIO 模型的演示，ServerSocket 代表的是**在服务器端的Socket**，而 Socket 代表的是**客户端的Socket**<br />![](https://cdn.nlark.com/yuque/0/2022/png/21405095/1641461703843-c8d31e4c-2481-459a-9015-bafdbffb92cf.png#clientId=u06a70c8a-6300-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=359&id=u4c46567b&margin=%5Bobject%20Object%5D&originHeight=543&originWidth=764&originalType=url&ratio=1&rotation=0&showTitle=false&status=done&style=stroke&taskId=uc147f772-0804-4a38-a84c-53fb80b4e58&title=&width=505)<br />**BIO模型演示**

BIO步骤：

服务器创建 ServerSocket 对象的时候需要提供端口进行绑定（bind），实现绑定之后，ServerSocket 可以作为其他客户端与服务器进行通信时使用的端点，服务器端会一直监听的绑定端口，任何客户端应用只要把想要发送的服务器的消息发送服务器到绑定的端口，服务器就可以收到并进行处理
服务器完成绑定之后，会调用 accept 函数，该函数是一个阻塞式的调用，在没有客户端建立连接的时候，accept 函数会一直阻塞当前线程，直到客户端创建了 Socket 对象与服务器进程进行连接（ 在生成客户端 Socket 时需要传入服务器所在的主机、监听端口，有这些信息才能实现与服务器 ServerSocket 的连接）；一旦服务器的 accept 函数接收了客户端发起的连接将会返回一个 Socket 对象，该Socket对象可以和客户端的 Socket 进行通信
完成连接后，通过两边的端点使用 IO流 进行信息传输，两边信息交换完成后可以使用 close 函数关闭客户端的 Socket 对象与服务器端的 ServerSocket 对象

代码演示：

源码下载：

  1. https://gitee.com/dmbjzorg/Netty

服务器端：

  1. package study;
  3. import java.io.*;
  4. import java.net.ServerSocket;
  5. import java.net.Socket;
  7. /* 服务器端 */
  8. public class MyServer {
  10.     private static final int port = 8888;
  11.     private static final String exit = "exit";
  13.     public static void main(String[] args) {
  15.         /* 创建ServerSocket对象并绑定端口 */
  16.         ServerSocket serverSocket = null;
  17.         try {
  18.             serverSocket = new ServerSocket(port);
  19.             System.out.println("服务器端创建serverSocket对象,开始监听"+port+"端口");
  21.             while (true){
  23.                 Socket socket = serverSocket.accept();      //等待客户端连接，获取到连接后与客户端的Socket进行通信
  24.                 System.out.println("服务器端收到端口为"+socket.getPort()+"客户端的Socket请求");
  26.                 /* 从客户端Socket读取数据*/
  27.                 InputStreamReader inputStream = new InputStreamReader(socket.getInputStream());
  28.                 BufferedReader reader = new BufferedReader(inputStream);
  30.                 OutputStreamWriter outputStream = new OutputStreamWriter(socket.getOutputStream());
  31.                 BufferedWriter writer = new BufferedWriter(outputStream);
  33.                 /* 修改收到的数据返还给服务器端 */
  34.                 String lineMsg = null;
  35.                 while ( (lineMsg = reader.readLine())!=null ) {
  36.                     System.out.println("服务器端收到端口为"+socket.getPort()+"客户端的消息:"+lineMsg);
  37.                     writer.write("服务器:"+lineMsg+"\n");
  38.                     writer.flush();
  39.                     /* 退出服务器端 */
  40.                     if(exit.equals(lineMsg)){
  41.                         System.out.println("端口为"+socket.getPort()+"的客户端断开连接");
  42.                         break;
  43.                     }
  44.                 }
  46.             }
  48.         } catch (IOException e) {
  49.             e.printStackTrace();
  50.         }finally {
  52.             if(serverSocket!=null){
  53.                 try {
  54.                     serverSocket.close();
  55.                 } catch (IOException e) {
  56.                     e.printStackTrace();
  57.                 }
  58.                 System.out.println("服务端ServerSocket已关闭");
  59.             }
  61.         }
  63.     }
  66. }

客户端：

  1. package study;
  3. import java.io.*;
  4. import java.net.Socket;
  7. /* 客户端请求 */
  8. public class Browser {
  10.     private static final String address = "127.0.0.1";
  11.     private static final int port = 8888;
  13.     private static final String exit = "exit";
  15.     public static void main(String[] args) {
  17.         Socket socket = null;
  18.         BufferedWriter writer = null;
  19.         try {
  21.             socket = new Socket(address,port);
  23.             /* 创建IO流 */
  24.             BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
  25.             writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
  27.             /* 控制台输入信息 */
  28.             BufferedReader consoleReader = new BufferedReader(new InputStreamReader(System.in));
  30.             while (true){
  32.                 String lineStr = consoleReader.readLine();
  34.                 /* 发送消息给服务器 */
  35.                 writer.write(lineStr+"\n");
  36.                 writer.flush();
  38.                 /* 读取服务器返回的消息 */
  39.                 String msg = reader.readLine();
  40.                 System.out.println("服务器返回的消息: "+msg);
  42.                 /* 查看用户是否退出 */
  43.                 if(exit.equals(lineStr)){
  44.                     break;
  45.                 }
  47.             }
  50.         } catch (IOException e) {
  51.             e.printStackTrace();
  52.         }finally {
  54.             /* 关闭 writer的时候会自动清空内部缓存区且关闭 Socket */
  55.             if(writer!=null){
  56.                 try {
  57.                     writer.close();
  58.                 } catch (IOException e) {
  59.                     e.printStackTrace();
  60.                 }
  61.                 System.out.println("客户端Socket已关闭");
  62.             }
  64.         }
  67.     }
  71. }

测试：

运行 MyServer 先创建出 ServerSocket 对象，再运行 Browser 后 MyServer 获取到连接请求，使用IO流传输消息后收到指定信息进行退出操作
image.png
测试案例

聊天室案例：

用户加入到聊天室后可以看到后续每个成员的发言
绘图1.png
BIO聊天室案例时序图

聊天室服务器端：

使用线程池对资源进行限制，由于核心数为10，因此包括服务器在内最多有9个用户可以在聊天室中进行正常交流，9位在线用户不会收到未加入到聊天室用户发送的消息

  1. package chatroom;
  3. import java.io.BufferedWriter;
  4. import java.io.IOException;
  5. import java.io.OutputStreamWriter;
  6. import java.io.Writer;
  7. import java.net.ServerSocket;
  8. import java.net.Socket;
  9. import java.util.HashMap;
  10. import java.util.Map;
  11. import java.util.concurrent.ArrayBlockingQueue;
  12. import java.util.concurrent.ThreadPoolExecutor;
  13. import java.util.concurrent.TimeUnit;
  16. /* 聊天室服务器端 */
  17. public class ChatServer {
  19.     private static int DEFAULT_PORT = 8888;            //监听端口号
  20.     private static final String QUIT = "quit";         //用户输入quit时退出聊天
  22.     private ServerSocket serverSocket;                 //接收客户端的Socket
  23.     private ThreadPoolExecutor executorService;        //线程池
  24.     private Map<Integer, Writer> connectedClients;     //保存目前为止所有客户发送的消息,key:客户端的端口号 value:服务端向对应的客户端发送信息时的 writer
  26.     /* 初始化参数 */
  27.     public ChatServer() {
  28.         executorService = new ThreadPoolExecutor(5,10,200, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<>(10));
  29.         connectedClients = new HashMap<>();
  30.     }
  33.     /* 新客户端用户加入到聊天室服务器 */
  34.     public synchronized void addClient(Socket socket) throws IOException {
  36.         if (socket!=null){
  37.             int port = socket.getPort();
  38.             BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
  39.             connectedClients.put(port,writer);
  40.             System.out.println("客户端["+port+"]已经连接到服务器");
  41.         }
  43.     }
  46.     /* 客户端用户退出聊天室服务器 */
  47.     public synchronized void removeClient(Socket socket) throws IOException {
  49.         if (socket!=null){
  50.             int port = socket.getPort();
  51.             //先判断当前客户端有没有在map中(之前有没有与客户端建立连接)
  52.             if (connectedClients.containsKey(port)){
  53.                 //如果在,直接将writer流关闭
  54.                 connectedClients.get(port).close();
  55.             }
  56.             connectedClients.remove(port);           //将对应的值从map中去除
  57.             System.out.println("客户端["+port+"]断开连接");
  58.         }
  60.     }
  63.     /* 接收到某一客户发送的消息后将其发送给其他用户
  64.     *    @param socket 发送消息的用户
  65.     *    @param fwdMsg 客户端需要转发的消息
  66.     * */
  67.     public synchronized void forwardMessage(Socket socket,String fwdMsg){
  69.         connectedClients.forEach((k,v)->{
  70.             /* 如果该端口与发送消息的用户端口号不一致,则转发消息 */
  71.             if (!k.equals(socket.getPort())){
  72.                 Writer writer = connectedClients.get(k);
  73.                 //将消息转发给客户
  74.                 try {
  75.                     writer.write(fwdMsg);
  76.                     writer.flush();
  77.                 } catch (IOException e) {
  78.                     e.printStackTrace();
  79.                 }
  80.             }
  81.         });
  83.     }
  86.     /* 启动服务器端 */
  87.     public void start(){
  89.         try {
  90.             serverSocket = new ServerSocket(DEFAULT_PORT);     //绑定监听端口
  91.             System.out.println("服务器已启动,监听端口:"+DEFAULT_PORT+"......");
  92.             while (true){
  93.                 //等待是否有客户端需要尝试建立连接
  94.                 Socket socket = serverSocket.accept();
  95.                 //创建ChatHandler线程
  96.                 executorService.execute(new ChatHandler(this,socket));
  97.             }
  98.         } catch (IOException e) {
  99.             e.printStackTrace();
  100.         } finally {
  101.             if (serverSocket!=null){
  102.                 try {
  103.                     serverSocket.close();
  104.                     System.out.println("关闭ServerSocket");
  105.                 } catch (IOException e) {
  106.                     e.printStackTrace();
  107.                 }
  108.             }
  109.         }
  111.     }
  114.     /* 检查用户是否退出 */
  115.     public boolean readyToQuit(String msg){
  116.         return QUIT.equals(msg)?true:false;
  117.     }
  119.     public static void main(String[] args) {
  120.         ChatServer server = new ChatServer();
  121.         server.start();
  122.     }
  125. }

聊天室建立对应关系方法：

  1. package chatroom;
  4. import java.io.BufferedReader;
  5. import java.io.IOException;
  6. import java.io.InputStreamReader;
  7. import java.net.Socket;
  9. /* 用于建立客户端与用户一对一的交换(一个用户对应一个线程) */
  10. public class ChatHandler implements Runnable{
  12.     private ChatServer server;      //用操作存放在服务器端的map集合
  13.     private Socket socket;          //建立连接的客户端socket
  15.     public ChatHandler(ChatServer server, Socket socket) {
  16.         this.server = server;
  17.         this.socket = socket;
  18.     }
  21.     @Override
  22.     public void run() {
  24.         try {
  25.             server.addClient(socket);      //添加新上线用户
  26.             BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));               //读取用户发送来的消息
  27.             String msg = null;
  28.             while ( (msg = reader.readLine())!=null  ){
  29.                 String forMsg = "客户端["+socket.getPort()+"]"+msg+"\n";
  30.                 System.out.println(forMsg);
  32.                 /*
  33.                  *将收到的消息转发给聊天室里在线的其他用户
  34.                  *由于该方法读取的消息也是由readLine读取,而该方法要读取到\n才可以接受读取
  35.                  *因此需要在msg后面加上\n,用于使读取接受
  36.                  */
  37.                 server.forwardMessage(socket,forMsg);
  39.                 /* 检查用户是否准备退出 */
  40.                 if (server.readyToQuit(msg)){
  41.                     break;
  42.                 }
  44.             }
  46.         }catch (IOException e) {
  47.             e.printStackTrace();
  48.         }finally {
  49.             try {
  50.                 //如果该用户退出聊天,也要将该用户的key、value从map中删除
  51.                 server.removeClient(socket);
  52.             } catch (IOException e) {
  53.                 e.printStackTrace();
  54.             }
  55.         }
  58.     }
  61. }

客户端：

  1. package chatroom;
  3. import java.io.*;
  4. import java.net.Socket;
  6. /* 用户端 */
  7. public class ChatClient {
  9.     private final String DEFAULT_SERVER_HOST = "127.0.0.1";
  10.     private final int DEFAULT_SERVER_PORT = 8888;
  11.     private final String QUIT = "quit";
  13.     private Socket socket;
  14.     private BufferedReader reader;
  15.     private BufferedWriter writer;
  18.     /* 发送消息给服务器 */
  19.     public void send(String msg) throws IOException {
  20.         //判断该socket的输出流是否为开放的状态
  21.         if (!socket.isOutputShutdown()){
  22.             writer.write(msg+"\n");
  23.             writer.flush();
  24.         }
  25.     }
  28.     /* 从服务器接收消息 */
  29.     public String receive() throws IOException {
  30.         String msg = null;
  31.         if (!socket.isInputShutdown()){
  32.             msg = reader.readLine();
  33.         }
  34.         return msg;
  35.     }
  38.     /* 检查用户是否准备退出 */
  39.     public  boolean readyToQuit(String msg){
  40.         return QUIT.equals(msg);
  41.     }
  44.     public void start(){
  45.         try {
  46.             //创建socket
  47.             socket = new Socket(DEFAULT_SERVER_HOST,DEFAULT_SERVER_PORT);
  48.             //创建用来发送和接收信息的io流
  49.             reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
  50.             writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
  51.             //处理用户的输入
  52.             new Thread(new UserInputHander(this)).start();
  53.             //读取服务器转发的各种信息
  54.             String msg = null;
  55.             while ((msg=receive())!=null){
  56.                 System.out.println(msg);
  57.             }
  58.         } catch (IOException e) {
  59.             e.printStackTrace();
  60.         } finally {
  61.             if (writer!=null){
  62.                 try {
  63.                     System.out.println("关闭socket");
  64.                     writer.close();
  65.                 } catch (IOException e) {
  66.                     e.printStackTrace();
  67.                 }
  68.             }
  69.         }
  70.     }
  73.     public static void main(String[] args) {
  74.         ChatClient chatClient = new ChatClient();
  75.         chatClient.start();
  76.     }
  79. }

客户端用户输入方法：

  1. package chatroom;
  3. import java.io.BufferedReader;
  4. import java.io.IOException;
  5. import java.io.InputStreamReader;
  8. /* 处理用户在控制台上的输入 */
  9. public class UserInputHander implements Runnable{
  11.     private ChatClient chatClient;
  13.     public UserInputHander(ChatClient chatClient) {
  14.         this.chatClient = chatClient;
  15.     }
  17.     @Override
  18.     public void run() {
  20.         try {
  21.             BufferedReader consoleReader = new BufferedReader(new InputStreamReader(System.in));  //等待用户输入信息
  22.             while (true){
  23.                 String input = consoleReader.readLine();
  24.                 chatClient.send(input);    //向服务器发送消息
  25.                 /* 检查用户是否准备退出 */
  26.                 if (chatClient.readyToQuit(input)){
  27.                     break;
  28.                 }
  29.             }
  30.         } catch (IOException e) {
  31.             e.printStackTrace();
  32.         }
  34.     }
  36. }

测试：

启动 ChatServer 后启动多个 ChatClient 实例，在不同的 ChatClient 实例窗口中模拟消息发送，每个窗口都可以收到其他用户的消息
image.pngimage.pngimage.png
聊天室测试图示