Java NIO学习使用

来源：互联网发布：mac搜索文件不好用编辑：程序博客网时间：2024/06/14 14:50

![Uploading 0_131088834611J5_092419.png . . .]###Java NIO学习使用

在Java1.4之前的I/O系统中，提供的都是面向流的I/O系统，系统一次一个字节地处理数据，一个输入流产生一个字节的数据，一个输出流消费一个字节的数据，面向流的I/O速度非常慢，而在Java 1.4中推出了NIO，这是一个面向块的I/O系统，系统以块的方式处理处理，每一个操作在一步中产生或者消费一个数据库，按块处理要比按字节处理数据快的多。
在NIO中有几个核心对象需要掌握：缓冲区（Buffer）、通道（Channel）、选择器（Selector）。
缓冲区Buffer
缓冲区实际上是一个容器对象，更直接的说，其实就是一个数组，在NIO库中，所有数据都是用缓冲区处理的。在读取数据时，它是直接读到缓冲区中的；在写入数据时，它也是写入到缓冲区中的；任何时候访问 NIO 中的数据，都是将它放到缓冲区中。而在面向流I/O系统中，所有数据都是直接写入或者直接将数据读取到Stream对象中。
在NIO中，所有的缓冲区类型都继承于抽象类Buffer，最常用的就是ByteBuffer，对于Java中的基本类型，基本都有一个具体Buffer类型与之相对应，它们之间的继承关系如下图所示：

Buffer.png

使用示例：

    public static void start() {                /**         * 分配新的int缓冲区，参数为缓冲区容量         * 新缓冲区当前位置为零，其界限(限制位置)将为其容量         * 它将具有一个底层实现数组，其数组偏移量将为零。         */        IntBuffer buffer = IntBuffer.allocate(8);        // buffer.capacity()获取buffer的缓冲区长度        for(int i = 0; i < buffer.capacity(); i++){            int j = 2 * (i + 1);            // 将给定整数写入此缓冲区的当前位置，当前位置递增            buffer.put(j);        }                // 重设此缓冲区， 将限制设置为当前位置，然后将当前位置设置为0        buffer.flip();                // 查看在当前位置和限制位置之间是否有元素        while(buffer.hasRemaining()){            // 读取此缓冲区当前位置的整数，然后当前位置递增            int j = buffer.get();            System.out.println(j);        }            }

打印结果：

246810121416

通道Channel
通道是一个对象，通过它可以读取和写入数据，当然了所有数据都通过Buffer对象来处理。我们永远不会将字节直接写入通道中，相反是将数据写入包含一个或者多个字节的缓冲区。同样不会直接从通道中读取字节，而是将数据从通道读入缓冲区，再从缓冲区获取这个字节。
在NIO中，提供了多种通道对象，而所有的通道对象都实现了Channel接口。它们之间的继承关系如下：

0_1310888420STkI.png

使用NIO读取数据
在前面我们说过，任何时候读取数据，都不是直接从通道读取，而是从通道读取到缓冲区。所以使用NIO读取数据可以分为下面三个步骤：

从FileInputStream获取Channel
创建Buffer
将数据从Channel读取到Buffer中
下面是一个简单的使用NIO从文件中读取数据的例子：

    public static void readFile() throws IOException {        // 创建文件输入流        FileInputStream fis = new FileInputStream("E:\\test.txt");        // 获取通道        FileChannel fc = fis.getChannel();        // 创建缓冲区        ByteBuffer buffer = ByteBuffer.allocate(1024);        // 读取到缓冲区        fc.read(buffer);        buffer.flip();                byte[] bytes = new byte[1024];        int i = 0;        while(buffer.remaining() > 0){            byte b = buffer.get();            bytes[i++] = b;        }        System.out.println(new String(bytes,"UTF-8"));        fis.close();    }

打印结果：

?在前面我们说过，任何时候读取数据，都不是直接从通道读取，而是从通道读取到缓冲区。所以使用NIO读取数据可以分为下面三个步骤：从FileInputStream获取Channel创建Buffer将数据从Channel读取到Buffer中

使用NIO写入数据
使用NIO写入数据与读取数据的过程类似，同样数据不是直接写入通道，而是写入缓冲区，可以分为下面三个步骤：

从FileInputStream获取Channel
创建Buffer
将数据从Channel写入到Buffer中

下面是一个简单的使用NIO向文件中写入数据的例子：

    public static void writeFile() throws IOException {        // 要写入的数据        final byte message[] = { 83, 111, 109, 101, 32,                  98, 121, 116, 101, 115, 46 };         // 创建输出流        FileOutputStream fos = new FileOutputStream("E:\\test1.txt");        // 获取通道        FileChannel fc = fos.getChannel();        // 创建缓冲区        ByteBuffer buffer = ByteBuffer.allocate(1024);                for(int i = 0; i < message.length; i++){            buffer.put(message[i]);        }                buffer.flip();                fc.write(buffer);                fos.close();            }

写入结果:

test1.png

NIO中非阻塞I/O编写服务器处理程序
使用NIO中非阻塞I/O编写服务器处理程序，大体上可以分为下面三个步骤：

向Selector对象注册感兴趣的事件
从Selector中获取感兴趣的事件
根据不同的事件进行相应的处理

Server端：

public class NioServer {    /**     * 监听的端口     */    private static final int PORT = 8001;    /**     * 1. 注册事件      * 创建了ServerSocketChannel对象，并调用configureBlocking()方法，配置为非阻塞模式，     * 接下来的三行代码把该通道绑定到指定端口，最后向Selector中注册事件，此处指定的是参数是OP_ACCEPT，     * 即指定我们想要监听accept事件，也就是新的连接发 生时所产生的事件，对于ServerSocketChannel通道     * 来说，我们唯一可以指定的参数就是OP_ACCEPT。     * @throws IOException      */    public Selector getSelector() throws IOException {        // 创建Selector        Selector selector = Selector.open();                // 创建可选择通道，并配置为非阻塞模式        ServerSocketChannel server = ServerSocketChannel.open();        server.configureBlocking(false);                // 绑定通道到指定的端口        ServerSocket socket = server.socket();        InetSocketAddress address = new InetSocketAddress(PORT);        socket.bind(address);                // 向Selector中注册感兴趣的事件        server.register(selector, SelectionKey.OP_ACCEPT);                return selector;    }        /**     * 2. 开始监听     * 在非阻塞I/O中，内部循环模式基本都是遵循这种方式。首先调用select()方法，该方法会阻塞，     * 直到至少有一个事件发生，然后再使用selectedKeys()方法获取发生事件的SelectionKey，     * 再使用迭代器进行循环。     */    public void listener(Selector selector) {        try{        while(true){            // 该调用会阻塞，知道至少有一个事件发生            selector.select();            // 当有事件可用的时候            Set<SelectionKey> keys = selector.selectedKeys();            // 遍历结合键            Iterator<SelectionKey> iterator = keys.iterator();            while (iterator.hasNext()) {                SelectionKey key = iterator.next();                iterator.remove();                process(selector,key);            }                   }        }catch (Exception e) {            e.printStackTrace();        }            }    /**     * 3. 根据不同的事件做处理     * @param selector      * @param key     * @throws IOException      */    private void process(Selector selector, SelectionKey key) throws IOException {        // 接受请求        if (key.isAcceptable()) {            ServerSocketChannel server = (ServerSocketChannel) key.channel();            SocketChannel channel = server.accept();            channel.configureBlocking(false);            channel.register(selector, SelectionKey.OP_READ);        }        // 读信息        else if (key.isReadable()) {            System.out.println("读信息");            SocketChannel channel = (SocketChannel) key.channel();            ByteBuffer buffer = ByteBuffer.allocate(1024);            int count = channel.read(buffer);            if (count > 0) {                buffer.flip();                System.out.println(count);                byte[] bytes = new byte[1024];                int i = 0;                while(buffer.remaining() > 0){                    byte b = buffer.get();                    bytes[i++] = b;                }                System.out.println(new String(bytes,"UTF-8"));            }else {                channel.close();            }            buffer.flip();            buffer.clear();        }        // 写数据        else if (key.isWritable()) {            System.out.println("写数据");            SocketChannel channel = (SocketChannel) key.channel();//          String name = (String) key.attachment();            byte[] bytes = "hello".getBytes("UTF-8");            ByteBuffer buffer = ByteBuffer.allocate(1024);            System.out.println(bytes.length);            for(int i = 0;i < bytes.length;i++){                buffer.put(bytes[i]);            }            buffer.flip();            channel.write(buffer);        }            }        public static void main(String[] args) throws IOException {        NioServer nioServer = new NioServer();        Selector selector = nioServer.getSelector();        nioServer.listener(selector);    }    }

Client端：

public class NioClient {        /**     * 连接的端口     */    private static final int PORT = 8001;    /**     * 1. 注册事件      * @throws IOException      */    public void start() throws IOException {        // // 创建可选择通道，并配置为非阻塞模式        SocketChannel socketChannel = SocketChannel.open();                     socketChannel.configureBlocking(false);                // 连接指定的端口        InetSocketAddress address = new InetSocketAddress(PORT);        socketChannel.connect(address);                Selector selector = Selector.open();                // 向Selector中注册感兴趣的事件        socketChannel.register(selector, SelectionKey.OP_CONNECT);                Scanner scanner = new Scanner(System.in);        while(true){            selector.select();// 连接            Set<SelectionKey> selectedKeys = selector.selectedKeys();//获取连接            System.out.println("selectedKeys.size:"+selectedKeys.size());            Iterator<SelectionKey> iterator = selectedKeys.iterator();            while (iterator.hasNext()) {                SelectionKey key = iterator.next();                iterator.remove();                                if (key.isConnectable()) {                    socketChannel.finishConnect();                    socketChannel.register(selector, SelectionKey.OP_WRITE);                    System.out.println("server connected...");                    break;                }                else if(key.isWritable()){                    System.out.println("please input message:");                    String message = scanner.nextLine();                    ByteBuffer byteBuffer = ByteBuffer.wrap(message.getBytes("UTF-8"));                    socketChannel.write(byteBuffer);                }            }                   }    }        public static void main(String[] args) throws IOException {        new NioClient().start();    }       }

本文示例代码下载
更多示例请参考这里

阅读全文

0 0