java输入输出 -- Java NIO之套接字通道

一、简介

　　前面一篇文章讲了文件通道，本文继续来说说另一种类型的通道 – 套接字通道。在展开说明之前，咱们先来聊聊套接字的由来。套接字即 socket，最早由伯克利大学的研究人员开发，所以经常被称为Berkeley sockets。UNIX 4.2BSD 内核版本中加入了 socket 的实现，此后，很多操作系统都提供了自己的 socket 接口实现。通过 socket 接口，我们就可以与不同地址的计算机实现通信。

　　如果大家使用过 Unix/Linux 系统下的 socket 接口，那么对 socket 编程的过程应该有一些了解。

　　对于 TCP 服务端，接口调用的顺序为socket() -> bind() -> listen() -> accept() -> 其他操作 -> close()，客户端的顺序为socket() -> connect() -> 其他操作 -> close()。

　　如下图所示：

二、通道类型

　　Java 套接字通道包含三种类型，分别是：

　　　　1. SocketChannel：TCP 网络套接字通道

　　　　2. ServerSocketChannel：TCP 服务端套接字通道

　　　　3. DatagramChannel：UDP 网络套接字通道

Java 套接字通道类型对应于两种通信协议 TCP 和 UDP，这个大家应该都知道。本文将介绍 TCP 网络套接字通道的使用，并在最后实现一个简单的聊天功能。至于 UDP 类型的通道，大家可以自己看看。

三、基本操作

3.1 打开通道

　　SocketChannel 和 ServerSocketChannel 都是抽象类，所以不能直接通过构造方法创建通道。这两个类均是使用 open 方法创建通道，如下：

SocketChannel socketChannel = SocketChannel.open();
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();

3.2 关闭通道

　　SocketChannel 和 ServerSocketChannel 均提供了 close 方法，用于关闭通道。示例如下：

SocketChannel socketChannel = SocketChannel.open();
socketChannel.connect(new InetSocketAddress("www.coolblog.xyz", 80));
// do something...
socketChannel.close();

/*******************************************************************/

ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
serverSocketChannel.socket().bind(new InetSocketAddress(8080));
SocketChannel socketChannel = serverSocketChannel.accept();
// do something...
socketChannel.close();
serverSocketChannel.close();

3.3 读写操作

读操作

通过使用 SocketChannel 的 read 方法，并配合 ByteBuffer 字节缓冲区，即可以从 SocketChannel 中读取数据。示例如下：

ByteBuffer buffer = ByteBuffer.allocate(32);
int num = socketChannel.read(buffer);

写操作

读取数据使用的是 read 方法，那么写入自然也就是 write 方法了。NIO 通道是面向缓冲的，所以向管道中写入数据也需要和缓冲区配合才行。示例如下

String data = "Test data..."

ByteBuffer buffer = ByteBuffer.allocate(32);
buffer.clear();
buffer.put(data.getBytes());

bbuffer.flip();
channel.write(buffer);

3.4 非阻塞模式

　　与文件通道不同，套接字通道可以运行在非阻塞模式下。在此模式下，调用 connect()，read() 和 write() 等方法时，进程/线程会立即返回。

　　设置非阻塞模式的方法为configureBlocking，我们来看一下该方法的使用示例：

SocketChannel socketChannel = SocketChannel.open();
socketChannel.configureBlocking(false);
socketChannel.connect(new InetSocketAddress("www.coolblog.xyz", 80));

// 这里要循环检测是否已经连接上
while(!socketChannel.finishConnect()){
    // do something
}

// 连接建立起来后，才能进行读取或写入操作

　　由于在非阻塞模式下，调用 connect 方法会立即返回。如果在连接未建立起来的情况下，从管道中读取，或向管道写入数据，会触发 NotYetConnectedException 异常。

　　所以要进行循环检测，以保证连接完成建立。如果代码按照上面那样去写，会引发另外一个问题。非阻塞模式虽然不会阻塞线程，但是在方法返回后，还要进行循环检测，线程实际上还是被阻塞。出现这个问题的原因是和 Java NIO 套接字通道的 IO 模型有关，套接字通道采用的是“同步非阻塞”式 IO 模型，用户发起一个 IO 操作后，即可去做其他事情，不用等待 IO 完成。但是 IO 是否已完成，则需要用户自己时不时的去检测，这样实际上还是会浪费 CPU 资源。

3.5 实例演示

　　本节用一个简单的例子来演示套接字通道的使用，这个例子演示了一个客户端与服务端互相聊天的场景。首先服务端会监听某个端口，等待客户端来连接。客户端连接后，由客户端先向服务端发送消息，然后服务端再回复一条消息。这样，客户端和服务端就能你一句我一句的聊起来了。背景先介绍到这，我们来看看代码实现吧，首先看看服务端的代码：

服务端

package com.nio.wetalk;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Scanner;
import static com.nio.wetalk.WeTalkUtils.recvMsg;
import static com.nio.wetalk.WeTalkUtils.sendMsg;

public class WeTalkServer {
    private static final String EXIT_MARK = "exit";

    private int port;

    WeTalkServer(int port) {
        this.port = port;
    }
    public void start() throws IOException {
        ServerSocketChannel ssc = ServerSocketChannel.open();
        ssc.socket().bind(new InetSocketAddress(port));
        System.out.println("服务端已启动，正在监听 " + port + " 端口......");
        SocketChannel channel = ssc.accept();
        System.out.println("接受来自" + channel.getRemoteAddress().toString().replace("/", "") + " 请求");
        Scanner sc = new Scanner(System.in);
        while (true) {
            // 等待并接收客户端发送的消息
            String msg = recvMsg(channel);
            System.out.println("\n客户端：");
            System.out.println(msg + "\n");

            // 输入信息
            System.out.println("请输入：");
            msg = sc.nextLine();
            if (EXIT_MARK.equals(msg)) {
                sendMsg(channel, "bye~");
                break;
            }

            // 回复客户端消息
            sendMsg(channel, msg);
        }

        // 关闭通道
        channel.close();
        ssc.close();
    }

    public static void main(String[] args) throws IOException {
        new WeTalkServer(8080).start();
    }
}

客户端

package com.nio.wetalk;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.channels.SocketChannel;
import java.util.Scanner;
import static com.nio.wetalk.WeTalkUtils.recvMsg;
import static com.nio.wetalk.WeTalkUtils.sendMsg;

//客户端
public class WeTalkClient {
    private static final String EXIT_MARK = "exit";

    private String hostname;

    private int port;

    WeTalkClient(String hostname, int port) {
        this.hostname = hostname;
        this.port = port;
    }
    public void start() throws IOException {
        // 打开一个套接字通道，并向服务端发起连接
        SocketChannel channel = SocketChannel.open();
        channel.connect(new InetSocketAddress(hostname, port));

        Scanner sc = new Scanner(System.in);
        while (true) {
            // 输入信息
            System.out.println("请输入：");
            String msg = sc.nextLine();
            if (EXIT_MARK.equals(msg)) {
                sendMsg(channel, "bye~");
                break;
            }

            // 向服务端发送消息
            sendMsg(channel, msg);

            // 接受服务端返回的消息
            msg = recvMsg(channel);
            System.out.println("\n服务端：");
            System.out.println(msg + "\n");
        }

        // 关闭通道
        channel.close();
    }
    public static void main(String[] args) throws IOException {
        new WeTalkClient("localhost", 8080).start();
    }
}

工具类

package com.nio.wetalk;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
//工具类
public class WeTalkUtils {
    private static final int BUFFER_SIZE = 128;

    public static void sendMsg(SocketChannel channel, String msg) throws IOException {
        ByteBuffer byteBuffer = ByteBuffer.allocate(BUFFER_SIZE);
        byteBuffer.put(msg.getBytes());
        byteBuffer.flip();
        channel.write(byteBuffer);
    }

    public static String recvMsg(SocketChannel channel) throws IOException {
        ByteBuffer byteBuffer = ByteBuffer.allocate(BUFFER_SIZE);
        channel.read(byteBuffer);

        byteBuffer.flip();
        byte[] bytes = new byte[byteBuffer.limit()];
        byteBuffer.get(bytes);
        return new String(bytes);
    }
}

客户端做的事情也比较简单，首先是打开通道，然后连接服务单。紧接着进入 while 循环，然后就可以和服务端愉快的聊天了。

上面的代码和叙述都没啥意思，最后我们还是来看看上面代码的运行效果，一图胜前言。

四、总结

　　到这里，关于套接字通道的相关内容就讲完了，不知道大家有没有看懂。本文仅从使用的角度分析了套接字通道的用法，至于套接字通道的实现，这并不是本文关注的重点。实际上，我在上一篇文章中就说过，Java 所提供的很多类实际上是对操作系统层面上一些系统调用做了一层包装。所以大家在学习 Java 的同时，还应该去了解底层的一些东西，这样才算是知其然，又知其所以然。

感谢：http://www.tianxiaobo.com/2018/03/25/Java-NIO%E4%B9%8B%E5%A5%97%E6%8E%A5%E5%AD%97%E9%80%9A%E9%81%93/

原文地址：https://www.cnblogs.com/FondWang/p/11943697.html