Java随笔记 - BIO Socket 编程实例

最新推荐文章于 2024-07-27 12:08:03 发布

JiangNanMax

最新推荐文章于 2024-07-27 12:08:03 发布

阅读量4.6k

点赞数 2

分类专栏： Java 文章标签： java bio socket 编程实例

本文链接：https://blog.csdn.net/J__Max/article/details/109690397

版权

Java 专栏收录该内容

38 篇文章 0 订阅

订阅专栏

Java随笔记 - BIO Socket 编程实例

Review

在上上篇博客（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通信）中，大致讲述了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);
        }
    }
}