NIO入门

最新推荐文章于 2022-10-13 08:57:20 发布
最新推荐文章于 2022-10-13 08:57:20 发布
阅读量288 收藏
点赞数 1
分类专栏： Java基础 文章标签： java

java.nio包是Java在1.4之后增加的，用来提高I/O操作的效率。在nio包中主要包括以下几个类或接口:

  • Buffer：缓冲区，用来临时存放输入或输出数据。

  • Charset：用来把Unicode字符编码和其它字符编码互转。

  • Channel：数据传输通道，用来把Buffer中的数据写入到数据源，或者把数据源中的数据读入到Buffer。

  • Selector：用来支持异步I/O操作，也叫非阻塞I/O操作。

nio包中主要通过下面两个方面来提高I/O操作效率:

  • 通过Buffer和Channel来提高I/O操作的速度。

  • 通过Selector来支持非阻塞I/O操作。

下面来看一下程序中是怎么通过这些类库实现Socket功能。

首先介绍一下几个辅助类

辅助类SerializableUtil，这个类用来把java对象序列化成字节数组，或者把字节数组反序列化成java对象。

[java] view plain copy
print?

package com.googlecode.garbagecan.test.socket;  

import java.io.ByteArrayInputStream;  
import java.io.ByteArrayOutputStream;  
import java.io.IOException;  
import java.io.ObjectInputStream;  
import java.io.ObjectOutputStream;  

public class SerializableUtil {  

    public static byte[] toBytes(Object object) {  
        ByteArrayOutputStream baos = new ByteArrayOutputStream();  
        ObjectOutputStream oos = null;  
        try {  
            oos = new ObjectOutputStream(baos);  
            oos.writeObject(object);  
            byte[] bytes = baos.toByteArray();  
            return bytes;  
        } catch(IOException ex) {  
            throw new RuntimeException(ex.getMessage(), ex);  
        } finally {  
            try {  
                oos.close();  
            } catch (Exception e) {}  
        }  
    }  

    public static Object toObject(byte[] bytes) {  
        ByteArrayInputStream bais = new ByteArrayInputStream(bytes);  
        ObjectInputStream ois = null;  
        try {  
            ois = new ObjectInputStream(bais);  
            Object object = ois.readObject();  
            return object;  
        } catch(IOException ex) {  
            throw new RuntimeException(ex.getMessage(), ex);  
        } catch(ClassNotFoundException ex) {  
            throw new RuntimeException(ex.getMessage(), ex);  
        } finally {  
            try {  
                ois.close();  
            } catch (Exception e) {}  
        }  
    }  
}

辅助类MyRequestObject和MyResponseObject，这两个类是普通的java对象，实现了Serializable接口。MyRequestObject类是Client发出的请求，MyResponseObject是Server端作出的响应。

[java] view plain copy
print?

package com.googlecode.garbagecan.test.socket.nio;  

import java.io.Serializable;  

public class MyRequestObject implements Serializable {  

    private static final long serialVersionUID = 1L;  

    private String name;  

    private String value;  

    private byte[] bytes;  

    public MyRequestObject(String name, String value) {  
        this.name = name;  
        this.value = value;  
        this.bytes = new byte[1024];  
    }  

    public String getName() {  
        return name;  
    }  

    public void setName(String name) {  
        this.name = name;  
    }  

    public String getValue() {  
        return value;  
    }  

    public void setValue(String value) {  
        this.value = value;  
    }  

    @Override  
    public String toString() {  
        StringBuffer sb = new StringBuffer();  
        sb.append("Request [name: " + name  + ", value: " + value + ", bytes: " + bytes.length+ "]");  
        return sb.toString();  
    }  
}  

package com.googlecode.garbagecan.test.socket.nio;  

import java.io.Serializable;  

public class MyResponseObject implements Serializable {  

    private static final long serialVersionUID = 1L;  

    private String name;  

    private String value;  

    private byte[] bytes;  

    public MyResponseObject(String name, String value) {  
        this.name = name;  
        this.value = value;  
        this.bytes = new byte[1024];  
    }  

    public String getName() {  
        return name;  
    }  

    public void setName(String name) {  
        this.name = name;  
    }  

    public String getValue() {  
        return value;  
    }  

    public void setValue(String value) {  
        this.value = value;  
    }  

    @Override  
    public String toString() {  
        StringBuffer sb = new StringBuffer();  
        sb.append("Response [name: " + name  + ", value: " + value + ", bytes: " + bytes.length+ "]");  
        return sb.toString();  
    }  
}

下面主要看一下Server端的代码，其中有一些英文注释对理解代码很有帮助，注释主要是来源jdk的文档和例子，这里就没有再翻译

[java] view plain copy
print?

package com.googlecode.garbagecan.test.socket.nio;  

import java.io.ByteArrayOutputStream;  
import java.io.IOException;  
import java.net.InetSocketAddress;  
import java.nio.ByteBuffer;  
import java.nio.channels.ClosedChannelException;  
import java.nio.channels.SelectionKey;  
import java.nio.channels.Selector;  
import java.nio.channels.ServerSocketChannel;  
import java.nio.channels.SocketChannel;  
import java.util.Iterator;  
import java.util.logging.Level;  
import java.util.logging.Logger;  

import com.googlecode.garbagecan.test.socket.SerializableUtil;  

public class MyServer3 {  

    private final static Logger logger = Logger.getLogger(MyServer3.class.getName());  

    public static void main(String[] args) {  
        Selector selector = null;  
        ServerSocketChannel serverSocketChannel = null;  

        try {  
            // Selector for incoming time requests  
            selector = Selector.open();  

            // Create a new server socket and set to non blocking mode  
            serverSocketChannel = ServerSocketChannel.open();  
            serverSocketChannel.configureBlocking(false);  

            // Bind the server socket to the local host and port  
            serverSocketChannel.socket().setReuseAddress(true);  
            serverSocketChannel.socket().bind(new InetSocketAddress(10000));  

            // Register accepts on the server socket with the selector. This  
            // step tells the selector that the socket wants to be put on the  
            // ready list when accept operations occur, so allowing multiplexed  
            // non-blocking I/O to take place.  
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);  

            // Here's where everything happens. The select method will  
            // return when any operations registered above have occurred, the  
            // thread has been interrupted, etc.  
            while (selector.select() > 0) {  
                // Someone is ready for I/O, get the ready keys  
                Iterator<SelectionKey> it = selector.selectedKeys().iterator();  

                // Walk through the ready keys collection and process date requests.  
                while (it.hasNext()) {  
                    SelectionKey readyKey = it.next();  
                    it.remove();  

                    // The key indexes into the selector so you  
                    // can retrieve the socket that's ready for I/O  
                    execute((ServerSocketChannel) readyKey.channel());  
                }  
            }  
        } catch (ClosedChannelException ex) {  
            logger.log(Level.SEVERE, null, ex);  
        } catch (IOException ex) {  
            logger.log(Level.SEVERE, null, ex);  
        } finally {  
            try {  
                selector.close();  
            } catch(Exception ex) {}  
            try {  
                serverSocketChannel.close();  
            } catch(Exception ex) {}  
        }  
    }  

    private static void execute(ServerSocketChannel serverSocketChannel) throws IOException {  
        SocketChannel socketChannel = null;  
        try {  
            socketChannel = serverSocketChannel.accept();  
            MyRequestObject myRequestObject = receiveData(socketChannel);  
            logger.log(Level.INFO, myRequestObject.toString());  

            MyResponseObject myResponseObject = new MyResponseObject(  
                    "response for " + myRequestObject.getName(),   
                    "response for " + myRequestObject.getValue());  
            sendData(socketChannel, myResponseObject);  
            logger.log(Level.INFO, myResponseObject.toString());  
        } finally {  
            try {  
                socketChannel.close();  
            } catch(Exception ex) {}  
        }  
    }  

    private static MyRequestObject receiveData(SocketChannel socketChannel) throws IOException {  
        MyRequestObject myRequestObject = null;  
        ByteArrayOutputStream baos = new ByteArrayOutputStream();  
        ByteBuffer buffer = ByteBuffer.allocate(1024);  

        try {  
            byte[] bytes;  
            int size = 0;  
            while ((size = socketChannel.read(buffer)) >= 0) {  
                buffer.flip();  
                bytes = new byte[size];  
                buffer.get(bytes);  
                baos.write(bytes);  
                buffer.clear();  
            }  
            bytes = baos.toByteArray();  
            Object obj = SerializableUtil.toObject(bytes);  
            myRequestObject = (MyRequestObject)obj;  
        } finally {  
            try {  
                baos.close();  
            } catch(Exception ex) {}  
        }  
        return myRequestObject;  
    }  

    private static void sendData(SocketChannel socketChannel, MyResponseObject myResponseObject) throws IOException {  
        byte[] bytes = SerializableUtil.toBytes(myResponseObject);  
        ByteBuffer buffer = ByteBuffer.wrap(bytes);  
        socketChannel.write(buffer);  
    }  
}

下面是Client的代码，代码比较简单就是启动了100个线程来访问Server

[java] view plain copy
print?

package com.googlecode.garbagecan.test.socket.nio;  

import java.io.ByteArrayOutputStream;  
import java.io.IOException;  
import java.net.InetSocketAddress;  
import java.net.SocketAddress;  
import java.nio.ByteBuffer;  
import java.nio.channels.SocketChannel;  
import java.util.logging.Level;  
import java.util.logging.Logger;  

import com.googlecode.garbagecan.test.socket.SerializableUtil;  

public class MyClient3 {  

    private final static Logger logger = Logger.getLogger(MyClient3.class.getName());  

    public static void main(String[] args) throws Exception {  
        for (int i = 0; i < 100; i++) {  
            final int idx = i;  
            new Thread(new MyRunnable(idx)).start();  
        }  
    }  

    private static final class MyRunnable implements Runnable {  

        private final int idx;  

        private MyRunnable(int idx) {  
            this.idx = idx;  
        }  

        public void run() {  
            SocketChannel socketChannel = null;  
            try {  
                socketChannel = SocketChannel.open();  
                SocketAddress socketAddress = new InetSocketAddress("localhost", 10000);  
                socketChannel.connect(socketAddress);  

                MyRequestObject myRequestObject = new MyRequestObject("request_" + idx, "request_" + idx);  
                logger.log(Level.INFO, myRequestObject.toString());  
                sendData(socketChannel, myRequestObject);  

                MyResponseObject myResponseObject = receiveData(socketChannel);  
                logger.log(Level.INFO, myResponseObject.toString());  
            } catch (Exception ex) {  
                logger.log(Level.SEVERE, null, ex);  
            } finally {  
                try {  
                    socketChannel.close();  
                } catch(Exception ex) {}  
            }  
        }  

        private void sendData(SocketChannel socketChannel, MyRequestObject myRequestObject) throws IOException {  
            byte[] bytes = SerializableUtil.toBytes(myRequestObject);  
            ByteBuffer buffer = ByteBuffer.wrap(bytes);  
            socketChannel.write(buffer);  
            socketChannel.socket().shutdownOutput();  
        }  

        private MyResponseObject receiveData(SocketChannel socketChannel) throws IOException {  
            MyResponseObject myResponseObject = null;  
            ByteArrayOutputStream baos = new ByteArrayOutputStream();  

            try {  
                ByteBuffer buffer = ByteBuffer.allocateDirect(1024);  
                byte[] bytes;  
                int count = 0;  
                while ((count = socketChannel.read(buffer)) >= 0) {  
                    buffer.flip();  
                    bytes = new byte[count];  
                    buffer.get(bytes);  
                    baos.write(bytes);  
                    buffer.clear();  
                }  
                bytes = baos.toByteArray();  
                Object obj = SerializableUtil.toObject(bytes);  
                myResponseObject = (MyResponseObject) obj;  
                socketChannel.socket().shutdownInput();  
            } finally {  
                try {  
                    baos.close();  
                } catch(Exception ex) {}  
            }  
            return myResponseObject;  
        }  
    }  
}

最后测试上面的代码，首先运行Server类，然后运行Client类，就可以分别在Server端和Client端控制台看到发送或接收到的MyRequestObject或MyResponseObject对象了。

关于NIO和IO的比较，下面的两篇文章对理解很有帮助，可以参考一下。

http://tutorials.jenkov.com/java-nio/nio-vs-io.html

https://blogs.Oracle.com/slc/entry/javanio_vs_javaio

周世文_围城
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
NIO入门详解，深入浅出
yehongzhi1994的博客
06-26 1048
NIO入门看完这篇文章就够了
java nio入门
weixin_44504392的博客
11-25 475
NIO概述 JDK 1.4 java.nio 同步非阻塞 面向缓冲区（块编程） BIO\NIO和AIO BIO java.io 传统的同步阻塞式IO，线程在网络连接时会等待响应，期间不会做其他动作。 NIO java.nio from JDK1.4 同步非阻塞式io，一个线程下有一个多路选择器，他会维护多个连接。 AIO from JDK1.7 异步非阻塞IO，目前还没有什么应用 NIO三大组件 Channel 通道 Buffer 缓冲区 Selector 选择器 一个选择器对应多个通道 一个通
Java NIO入门与详解
u014624659的博客
01-23 285
http://www.yangyong.me/java-nio%E5%85%A5%E9%97%A8%E4%B8%8E%E8%AF%A6%E8%A7%A3/   Java NIO介绍 nio 是 New I/O 的简称，属于当时 jdk1.4 提供的新 api。如今 jdk 版本已经到 1.8 了，新 IO 这个称谓有点不合适了，nio 还有一个更合适的叫法——非阻塞(non-blockin...
Java NIO教程
最佳 Java 编程
06-10 219
1.简介 Java NIO是从Java 1.4引入的库。 自从Java NIO推出以来，它提供了另一种方法来处理I / O和网络事务。 它被认为是Java网络和Java IO库的替代方法。 开发Java NIO的目的是使输入和输出的事务异步和非阻塞。 阻塞和非阻塞IO的概念将在后面的部分中介绍。 目录 1.简介 2. IO中的术语 2.1阻止输入和输出 2.2无阻塞...
java NIO
weixin_34199335的博客
09-29 295
接上次写的《java IO整理》http://www.cnblogs.com/rollenholt/archive/2011/09/11/2173787.html 这次是关于java nio,有一些重复的发的地方。本文中的源代码可以在此处下载，下载链接为：http://115.com/file/cltlj10i#nio-src.zip 本文简介：  JDK 1.4 中引入的新输入输出 (NIO...
NIO入门 （一）
dengjili的专栏
03-06 274
IO概念 同步，调用方发起请求，且一直等着被调用方回复信息 异步，调用方发起请求后，不用等着被调用方回复信息，立即结束，等被调用方准备好以后，再一个合适的时机由被调用方主要发起反馈通知 阻塞，阻塞一般是指线程在处理数据的时候，一般是由于硬盘速度或者网络等原因，导致数据读取的速度远远低于内存的处理速度，导致了线程一致等待着数据加载完毕。 非阻塞，阻塞一般是指线程在处理数据的时候，当数据没有处...
NIO入门pdf分享
03-18
《NIO入门》一书是理解Java NIO（New Input/Output）的重要参考资料，NIO在Java编程中扮演着至关重要的角色，特别是在处理高并发、大数据传输等场景下。本PDF文档将引领读者深入理解这一核心概念。 NIO，全称New ...
Java NIO入门
03-20
IBM的NIO入门教程通常会涵盖这些基础概念，并通过实例演示如何使用NIO进行实际的I/O操作。教程可能还会深入讲解NIO的高级特性，如scatter/gather（分散/聚集）读写，以及如何使用`Selector`进行多路复用。通过学习这...
NIO - 入门
大雄送你走的博客
02-14 622
NIO - 入门 目录 为什么我们需要 NIO 传统 IO 的缺点 - 阻塞 NIO 的优点 - 非阻塞 NIO 的核心组成部分 NIO 的工作原理 代码实例 - 单个服务端线程，处理多个客户端连接 引导 参考 为什么我们需要 NIO 传统 IO 的缺点 - 阻塞 传统的 IO 流都是阻塞式的。也就是说，当一个线程调用 read() 或 write() 时，该线程被阻塞，直到有一些数据被读取或写入，该线程在此期间不能执行其他任务。 因此，在完成网络通信进行 IO 操作时，由于线程会阻塞，所
NIO编程入门
weixin_61557810的博客
05-19 274
NIO编程
Nio快速入门
最新发布
追寻心的步伐
10-13 574
NIO 模型中的 N 一般指 Non-blocking ，即非阻塞的意思，NIO 即非阻塞 IO 的意思。Java NIO 中的 N 是指 New ，即新的意思， Java NIO 即新的 IO ，是相对于BIO(Blocking IO) 来说的。在讲 NIO 之前先来了解一下这样几个概念：同步与异步，阻塞与非阻塞。同步与异步同步就是发起一个调用后，被调用者未处理完请求之前，调用不返回。
Nio入门学习
Pmithie的博客
07-31 192
1. Nio入门学习 Nio概述 JDK 1.4中的java.nio.*包中引入新的Java I/O库，其目的是提高速度。实际上，“旧”的I/O包已经使用NIO重新实现过，即使我们不显式的使用NIO编程，也能从中受益。 可以认为传统IO是面向字节流的，Nio是面向块的 Nio四个核心组件 [外链图片转存失败(img-nhe35745-1564585670321)(C:\Users\...
NIO快速入门
清欢
07-15 251
简介 在当今这个数据大爆炸时代，I/O 问题尤其突出，很容易成为一个性能瓶颈。正因如此，所以 Java 在 I/O 上也一直在做持续的优化，如从 1.4 开始引入了 NIO，提升了 I/O 的性能。 在了解NIO之前，关于IO的五种模型可以参考这篇文章：https://blog.csdn.net/qq_42191317/article/details/95937475 Java在JDK1.4...
Java NIO（一）入门篇
帅性而为1号的博客
03-31 1599
概念 java.nio（java new IO），是jdk1.4 里提供的新api ，为所有的原始类型提供缓存支持。Sun 官方标榜的特性如下： 为所有的原始类型提供(Buffer)缓存支持。字符集编码解码解决方案。 Channel ：一个新的原始I/O 抽象。 支持锁和内存映射文件的文件访问接口。 提供多路(non-bloking) 非阻塞式的高伸缩性网络I/O。 NIO和IO的主要
NIO入门和使用
1024
03-13 296
NIO入门和使用 阻塞和非阻塞，同步和异步 阻塞和非阻塞：程序在访问数据的时候，阻塞往往需要等待缓冲区中数据准备好才能继续处理，否则等待；非阻塞则是不论数据是否准备好都会返回。 同步和异步：同步应用程序直接参与IO读写操作，同步IO方式必须阻塞在某个方法上（阻塞IO或非阻塞轮询IO的方式）；而异步的IO操作交给了操作系统去处理，当IO完成后给应用程序一个通知即可。 Java IO模型 B...
Java NIO 入门教程
"java_NIO_入门" Java NIO（New Input/Output）是自JDK 1.4版本引入的一个新特性，它为Java应用程序提供了更高效的数据传输方式，特别是对于大块数据处理和并发操作。传统的Java I/O基于流（Stream）模型，而NIO则...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值