Java随笔记 - BIO Socket 编程实例

﹏ヽ暗。殇╰゛Y 2022-12-21 03:24 189阅读 0赞

###  Java随笔记 - BIO Socket 编程实例 ###

#### Review ####

*  在上上篇博客（[Java随笔记 - TCP通信的基本过程，三次握手，四次挥手][Java_ - TCP]）的最后，留下了三个经常被追问的问题，这里做一下个人的总结：
    
     *  为什么需要三次握手？两次行吗？会有什么问题？
        
         *  针对这个问题，从为什么两次握手不行来进行回答。我们假设就采用两次握手的策略来建立连接，也就是说，客户端向服务器发起一个连接请求，服务端收到这一连接请求后，返回一个确认包，连接就建立了。这看起来似乎没什么问题，也可以达到和三次握手同样的作用效果。但是，试设想，客户端向服务端发出的一个连接请求，在传输过程中并没有丢失，而是在某个网络节点滞留了较长时间，以至于客户端的连接释放后该报文才到达服务端。此时服务端收到的其实是一个已经失效的报文，但是服务端对此并不知情，而以为是客户端发起的一个新的连接请求，于是服务端在返回一个确认包后就进入连接状态，但是客户端收到他的确认包之后只会将其当作无效报文丢弃，最后导致服务端傻傻的等待着客户端发来数据，但其实他是等不到的，只是导致服务端资源的浪费。这就是使用两次握手会遇到的问题，所以使用两次握手是不行的，还需要最后客户端向服务端返回一个确认包，即第三次握手，才能正确的把连接建立起来。
     *  为什么需要四次挥手？
        
         *  TCP是使用全双工模式进行数据交流的，也就是说，当客户端向服务端发送一个FIN包，表明其想要断开连接，服务端给客户端返回一个ACK包进行确认，但这只是说明客户端已经没有数据要发送给服务端了，此时客户端还是可以接收来自服务端的信息的。所以在服务端发送完他的数据后，他再向客户端发送一个FIN包，表示其数据已经发送完毕，连接可以断开，客户端返回一个确认包后此次TCP连接就结束了。
     *  为什么最后客户端的TIME\_WAIT状态的时间为2MSL？
        
         *  最后客户端发送给服务端的ACK包可能出现丢失的情况，导致服务端收不到该确认包，所以客户端在最后不会马上关闭端口，而是会进入TIME\_WAIT状态，因为如果服务端没收到相应的ACK包，会向客户端发来重发请求，客户度啊需要再向服务端发送ACK包。至于为什么TIME\_WAIT的时间是2MSL，MSL指的是一个报文在网络中的最长生存时间，而2MSL就是一个发送和一个回复所需要的最长时间，如果直到2MSL客户端都没有收到服务端的FIN包，那么就可以推断服务端已经成功收到ACK包了，就可以关闭其端口了。

#### BIO Socket编程实例 ####

*  在上篇博客（[Java随笔记 - Java BIO，Socket通信][Java_ - Java BIO_Socket]）中，大致讲述了BIO Socket典型的编程模型，以及几个常用的API。这里就给出两个简单的编程实例，分别实现的是字节流传输和字符流传输

##### 1）Java Socket实现字节流传输 #####

*  本实例将实现一个基于短连接的二进制字节流文件传输，在连接建立后，客户端向服务端传输一个文件，并在文件传输完成后通过调用socket.shutdownOutput( )方法告知服务端其数据已经发送完成。之后，客户端则是等待服务端完成逻辑处理后，返回标识（“ok”），然后结束连接。而服务端则是循环调用socket.isInputShutDown( )来判断客户端是否已经完成了数据的传输，一旦返回的是true，说明客户端的数据传输完成，服务端就会退出读取数据的循环。具体实现代码如下：
    
        // 客户端代码 Client.java
        
        public class Client { 
        
            public static final Logger logger = LoggerFactory.getLogger(Client.class);
        
            public static void main(String[] args) { 
                BufferedReader socketReader = null;
                BufferedInputStream fileInputStream = null;
                BufferedOutputStream socketOutputStream = null;
                Socket socket = null;
                byte[] buffer = new byte[16];
                try { 
                    socket = new Socket("127.0.0.1", 8080);
                    fileInputStream = new BufferedInputStream(new FileInputStream(new File("tempClient.txt")));
                    socketOutputStream = new BufferedOutputStream(socket.getOutputStream());
                    int readByte;
                    while ((readByte = fileInputStream.read(buffer)) > 0) { 
                        logger.info("read {} bytes from the file.", readByte);
                        socketOutputStream.write(buffer, 0, readByte);
                        socketOutputStream.flush();
                    }
                    socket.shutdownOutput();
                    logger.info("finish writing data to server.");
                    socketReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                    String response = socketReader.readLine();
                    if ("ok".equalsIgnoreCase(response)) { 
                        logger.info("transport the data to server successfully.");
                    }
                } catch (Exception e) { 
                    logger.error("error in client", e);
                } finally { 
                    StreamUtil.close(socketReader);
                    StreamUtil.close(fileInputStream);
                    StreamUtil.close(socketOutputStream);
                    StreamUtil.close(socket);
                }
            }
        
        }
    
        // 服务端代码 Processor.java 实现了Runnable接口
        // Server每接收到一个客户端的请求，就会实例化一个Processor对象，开启一个线程进行处理
        
        public class Processor implements Runnable { 
        
            public static final Logger logger = LoggerFactory.getLogger(Processor.class);
        
            private Socket socket = null;
        
            public Processor(Socket socket) { 
                this.socket = socket;
            }
        
            @Override
            public void run() { 
                BufferedInputStream socketInputStream = null;
                BufferedOutputStream fileOutputStream = null;
                PrintWriter socketWriter = null;
                byte[] buffer = new byte[16];
                try { 
                    fileOutputStream = new BufferedOutputStream(new FileOutputStream(new File("tempServer.txt")));
                    socketInputStream = new BufferedInputStream(socket.getInputStream());
                    int readByte;
                    while (!socket.isInputShutdown() && (readByte = socketInputStream.read(buffer)) > 0) { 
                        logger.info("receive {} bytes from client.", readByte);
                        fileOutputStream.write(buffer, 0, readByte);
                        fileOutputStream.flush();
                    }
                    logger.info("finish reading data from client.");
                    socketWriter = new PrintWriter(socket.getOutputStream(), true);
                    socketWriter.println("ok");
                } catch (Exception e) { 
                    logger.error("error in processor", e);
                } finally { 
                    StreamUtil.close(socketInputStream);
                    StreamUtil.close(fileOutputStream);
                    StreamUtil.close(socketWriter);
                    StreamUtil.close(this.socket);
                }
            }
        }
    
        // 服务端代码 Server.java
        // 主要就是负责监听来自客户端的连接请求
        
        public class Server implements Runnable { 
        
            public static final Logger logger = LoggerFactory.getLogger(Server.class);
        
            private final ExecutorService threadPool = Executors.newCachedThreadPool();
            private ServerSocket serverSocket = null;
        
            public void start() throws IOException { 
                serverSocket = new ServerSocket(8080);
                threadPool.execute(this);
            }
        
            @Override
            public void run() { 
                Socket socket = null;
                try { 
                    while ((socket = serverSocket.accept()) != null) { 
                        logger.info("client {} connected.", socket.getRemoteSocketAddress());
                        threadPool.execute(new Processor(socket));
                    }
                } catch (Exception e) { 
                    e.printStackTrace();
                }
            }
        
            public void close() { 
                if (serverSocket != null && !serverSocket.isClosed()) { 
                    try { 
                        serverSocket.close();
                    } catch (IOException e) { 
                        logger.error("error on close.", e);
                    }
                }
                threadPool.shutdown();
            }
        
        
        
            public static void main(String[] args) { 
                Server server = new Server();
                BufferedReader keyboardReader = null;
                try { 
                    server.start();
        
                    System.out.println("type 'exit' to end.");
        
                    keyboardReader = new BufferedReader(new InputStreamReader(System.in));
                    String cmd = null;
                    while ((cmd = keyboardReader.readLine()) != null) { 
                        if ("exit".equalsIgnoreCase(cmd)) { 
                            break;
                        }
                    }
                } catch (Exception e) { 
                    e.printStackTrace();
                } finally { 
                    StreamUtil.close(keyboardReader);
                    server.close();
                }
            }
        
        }
    
        // 工具类
        
        public class StreamUtil { 
        
            public static final Logger logger = LoggerFactory.getLogger(StreamUtil.class);
        
            public static void close(Closeable stream) { 
                if (stream == null) { 
                    return ;
                }
                try { 
                    stream.close();
                } catch (Exception e) { 
                    logger.error("errors on close {}", stream.getClass().getName(), e);
                }
            }
        
        }

##### 2）Java Socket实现字符流传输 #####

*  TCP协议是基于二进制字节流的，字符流则是在字节流的基础上增加了字符编解码的过程，从而实现字节和字符之间的转换。Java提供了面向字符的流处理API，通过这些API我们可以很方便的以字符流的形式读写Socket。
 *  本实例将实现一个基于字符流和长连接的Socket通信。在代码中，使用BufferedReader的readLine()方法和PrintWriter的println()方法分别进行读写操作，这其实已经约定了基于字符流的传输协议，也就是每次传输一串字符，并以换行符表示一行结束。具体代码如下，其中Server.java以及StreamUtil.java同上，不再赘述：
    
        // 客户端代码 Client.java
        
        public class Client { 
        
            public static final Logger logger = LoggerFactory.getLogger(Client.class);
        
            public static void main(String[] args) { 
                BufferedReader socketReader = null;
                BufferedReader keyboardReader = null;
                PrintWriter socketWriter = null;
                Socket socket = null;
                String cmd = null;
                try { 
                    socket = new Socket("127.0.0.1", 8080);
                    socketReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                    socketWriter = new PrintWriter(socket.getOutputStream(), true);
        
                    System.out.println("Type 'bye' to exit.");
        
                    keyboardReader = new BufferedReader(new InputStreamReader(System.in));
                    while ((cmd = keyboardReader.readLine()) != null) { 
                        socketWriter.println(cmd);
                        String s = socketReader.readLine();
                        System.out.println(s);
                        if ("bye".equalsIgnoreCase(cmd)) { 
                            break;
                        }
                    }
                    System.out.println("bye.");
                } catch (Exception e) { 
                    logger.error("errors on connection: ", e);
                } finally { 
                    StreamUtil.close(socketReader);
                    StreamUtil.close(keyboardReader);
                    StreamUtil.close(socketWriter);
                    StreamUtil.close(socket);
                }
            }
        }
    
        // 服务端代码 Processor.java
        
        public class Processor implements Runnable { 
        
            public static final Logger logger = LoggerFactory.getLogger(Processor.class);
        
            private Socket socket;
        
            public Processor(Socket socket) { 
                this.socket = socket;
            }
        
            @Override
            public void run() { 
                BufferedReader socketReader = null;
                PrintWriter socketWriter = null;
                try { 
                    socketReader = new BufferedReader(new InputStreamReader(this.socket.getInputStream()));
                    socketWriter = new PrintWriter(this.socket.getOutputStream(), true);
                    while (!Thread.interrupted()) { 
                        String s = socketReader.readLine();
                        socketWriter.println(String.format("%s says %s.", this.socket.getRemoteSocketAddress(), s));
                        System.out.println(Thread.currentThread().getName() + " - " + s);
                        if ("bye".equalsIgnoreCase(s)) { 
                            break;
                        }
                    }
                } catch (Exception e) { 
                    logger.error("error on processor.", e);
                } finally { 
                    StreamUtil.close(socketReader);
                    StreamUtil.close(socketWriter);
                }
            }
        }

[Java_ - TCP]: https://blog.csdn.net/J__Max/article/details/109641701
[Java_ - Java BIO_Socket]: https://blog.csdn.net/J__Max/article/details/109656687