NIO：基本操作和学习

最新推荐文章于 2023-11-03 10:37:37 发布

yubin1285570923

最新推荐文章于 2023-11-03 10:37:37 发布

阅读量292

点赞数

分类专栏： NIO 文章标签： nio

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接：https://blog.csdn.net/yubin1285570923/article/details/107912924

版权

NIO 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

NIO的核心：缓冲区，通道，选择器

Table of Contents

一、缓冲区 Buffer ：存储数据

1 基本概念：

2 直接缓冲区和非直接缓冲区

3 种类：基本数据类型处理boolean外都有

二、管道channel ：传输数据

2 通道的主要实现类

3 获取的三种方式

例子：通过非直接缓冲区完成文件复制

通过直接缓冲区完成文件复制（内存映射文件）

4 通道之间传输 transferTo和 transferFrom

5 分散（scatter）和聚集（Gather）

6 字符集charset

三、阻塞io和非阻塞io

1 阻塞io，就是服务端一直等待客户端的请求，不能去做其他的事情

2 非阻塞io，服务端可以在选择器上监控已经准备就绪的事件处理，不用一直等待

四、管道：

一、缓冲区 Buffer ：存储数据

1 基本概念：

1 position :当前操作数据的位置，指针位置

2 limit：缓冲区中可以操作数据的大小，即limit后面的数据不能操作

3 capacity：缓冲区的存储大小

2 直接缓冲区和非直接缓冲区

非直接缓冲区（allocate（））方法分配的缓冲区，将缓冲区直接建立在jvm上面

直接缓冲区：allocateDirect（）方法分配的缓冲区，将缓冲区直接建立在磁盘内存中，可以提高效率，弊端是消耗大，不安全

ByteBuffer.allocateDirect(1024);
ByteBuffer allocate = ByteBuffer.allocate(1024);

3 种类：基本数据类型处理boolean外都有

ByteBuffer
CharBuffer

ShortBuffer

IntBuffer

LongBuffer

FloatBuffer
DoubleBuffer

4 常用方法

常用方法：
put  存储数据
get  获取数据
flip：转换为读取模式，将指针位置置于开始部位可以读或者写操作
clear 清空位子，数据还在

mark 标记此刻数据的位子
reset  回到mark标记的数据位子

 ByteBuffer byteBuffer = ByteBuffer.allocateDirect(1024);
        ByteBuffer allocate = ByteBuffer.allocate(1024);
        System.out.println(allocate.position());
        System.out.println(allocate.limit());
        System.out.println(allocate.capacity());


        //存数据
        String str = "abcde";
        allocate.put(str.getBytes());
        System.out.println("*************put***********");
        System.out.println(allocate.position());
        System.out.println(allocate.limit());
        System.out.println(allocate.capacity());


        System.out.println("******************flip************");
        allocate.flip();//切换为读数据模式

        System.out.println("*************put***********");
        System.out.println(allocate.position());
        System.out.println(allocate.limit());
        System.out.println(allocate.capacity());

        System.out.println("**********get***************");
        byte[] dest = new byte[allocate.limit()];
        allocate.get(dest);
        System.out.println(new String(dest,0,dest.length));

        System.out.println(allocate.position());
        System.out.println(allocate.limit());
        System.out.println(allocate.capacity());

        System.out.println("*************clear******");
        allocate.clear();

        System.out.println(allocate.position());
        System.out.println(allocate.limit());
        System.out.println(allocate.capacity());

        System.out.println("***********mark**********");

        allocate.mark();
        System.out.println(allocate.position());
        System.out.println(allocate.limit());
        System.out.println(allocate.capacity());

        allocate.reset();

二、管道channel ：传输数据

1 概念

表示IO源与目标打开的连接，类似于传统的流，只不过channel本身不存储数据，它只能与缓冲区交互。

用于源节点和目标节点的连接，在java NIO中负责缓冲区中数据的传输。

2 通道的主要实现类

java.nio.channels.Channel接口
    -- FileChannel
    -- SocketChannel
    -- ServerSocketChannel
    -- DatagramChannel

    -- Pipe.SourceChannel
    --Pipe.SinkChannel

3 获取的三种方式

1 java针对支持通道的类提供了getChannel(）方法
本地IO
  FileInputStream/FileOutputStream
  RandomAccessFile

 网络IO
  socket
  ServerSocket
  DatagramSocket

比如：
RandomAccessFile raf2 = new RandomAccessFile("2.jpg", "rw"); FileChannel outChannel = raf2.getChannel();

2 在jdk1.7 中NIO2针对各个通道提供了静态方法open（）：

比如：

FileChannel.open(Paths.get("G:\\360Downloads\\photos\\0.jpg"),StandardOpenOption.READ);
3 在jdk1.7 中NIO2的Files 工具类的newByteChannel()

例子：通过非直接缓冲区完成文件复制

 /**
     * 利用通道完成数据复制
     */
    @Test
    public void test01(){

        FileInputStream inputStream =  null;
        FileOutputStream outputStream = null;
        FileChannel inChannel = null;
        FileChannel outChannel = null;

        try {
            inputStream = new FileInputStream("src/1.jpg");
            outputStream = new FileOutputStream("2.jpg");

            //1 获取通道
            inChannel = inputStream.getChannel();
            outChannel = outputStream.getChannel();

            //2 分配指定大小的缓冲区
            ByteBuffer buff = ByteBuffer.allocate(1024);

            //3 将通道的数据读入缓冲区

            while(inChannel.read(buff) != -1){
                buff.flip();
                //4 将缓冲区的数据写入通道
                outChannel.write(buff);

                buff.clear();
            }

            //5 关闭流和通道
        } catch (IOException e) {
            e.printStackTrace();
        } finally {

            if(inChannel != null) {
                try {
                    inChannel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if(outChannel!=null){
                try {
                    outChannel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if(outputStream != null) {
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if(inputStream!=null){
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }



        }




    }

通过直接缓冲区完成文件复制（内存映射文件）

  /**
     * 使用直接缓冲区完成文件复制（内存映射文件）
     */
    @Test
    public void test02() throws Exception {
        FileChannel inChannel = FileChannel.open(Paths.get("G:\\360Downloads\\photos\\0.jpg"),StandardOpenOption.READ);

        FileChannel outChannel = FileChannel.open(Paths.get("G:\\360Downloads\\photos\\00.jpg"), StandardOpenOption.READ, StandardOpenOption.WRITE,StandardOpenOption.CREATE);

        //内存映射文件
        MappedByteBuffer inBuffer =  inChannel.map(FileChannel.MapMode.READ_ONLY, 0, inChannel.size());

        MappedByteBuffer outBuffer = outChannel.map(FileChannel.MapMode.READ_WRITE, 0, inChannel.size());

        //直接对缓冲区进行数据读写操作
        byte[] dst = new byte[inBuffer.limit()];
        inBuffer.get(dst);
        outBuffer.put(dst);


        outChannel.close();
        inChannel.close();


    }

4 通道之间传输 transferTo和 transferFrom

 /*
     * 通道之间传输数据
     * transferTo
     * transferFrom
     */
    @Test
    public void test03() throws IOException {
        FileChannel inChannel = FileChannel.open(Paths.get("G:\\360Downloads\\photos\\0.jpg"),StandardOpenOption.READ);

        FileChannel outChannel = FileChannel.open(Paths.get("G:\\360Downloads\\photos\\00.jpg"), StandardOpenOption.READ, StandardOpenOption.WRITE,StandardOpenOption.CREATE);

        //transferTo
//        inChannel.transferTo(0,inChannel.size(),outChannel);

        //transferFrom
        outChannel.transferFrom(inChannel,0,inChannel.size());

        inChannel.close();
        outChannel.close();


    }

5 分散（scatter）和聚集（Gather）

/**
     * 分散和聚集
     */
    @Test
    public void test04() throws Exception {

        //1 获取通道
        RandomAccessFile raf1 = new RandomAccessFile("1.jpg", "rw");

        FileChannel inChannel = raf1.getChannel();

        //2 分配指定缓冲区

        ByteBuffer buffer1 = ByteBuffer.allocate(100);
        ByteBuffer buffer2 = ByteBuffer.allocate(102400);
        ByteBuffer buffer3 = ByteBuffer.allocate(102400);
        ByteBuffer buffer4 = ByteBuffer.allocate(102400);


        //3 分散du读1取
        ByteBuffer[] dst = {
                buffer1,buffer2,buffer3,buffer4
        };
        inChannel.read(dst);

        for (ByteBuffer b : dst){
            b.flip();
        }

        // 4 聚集写出
        RandomAccessFile raf2 = new RandomAccessFile("2.jpg", "rw");
        FileChannel outChannel = raf2.getChannel();

        outChannel.write(dst);

        outChannel.close();
        inChannel.close();
    }

6 字符集charset

 @Test
    public void test07() throws CharacterCodingException {

        Charset charset = Charset.forName("GBK");

        //获取编码器和解解码器

        CharsetEncoder encoder = charset.newEncoder();
        CharsetDecoder decoder = charset.newDecoder();


        CharBuffer buffer = CharBuffer.allocate(1024);
        buffer.put("研发费分为非") ;
        buffer.flip();

        //编码
        ByteBuffer byteBuffer = encoder.encode(buffer);
        //解码
        CharBuffer charBuffer = decoder.decode(byteBuffer);
        //读取

        System.out.println(charBuffer.toString());


    }

三、阻塞io和非阻塞io

1 阻塞io，就是服务端一直等待客户端的请求，不能去做其他的事情

2 示例

实例一

 @Test
    public void client() throws IOException {

        //1 获取通道
        SocketChannel skChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1",9898));

        FileChannel fileChannel = FileChannel.open(Paths.get("1.jpg"), StandardOpenOption.READ);
        //2 获取缓冲区
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        //3 通道传输出去数据
        while(fileChannel.read(buffer) != -1){
            buffer.flip();
            skChannel.write(buffer);
            buffer.clear();
        }

        //4 关闭流
        fileChannel.close();
        skChannel.close();


    }
    @Test
    public void server() throws IOException {

        // 获取通道
        ServerSocketChannel sskChannel = ServerSocketChannel.open();
        // 绑定连接
        sskChannel.bind(new InetSocketAddress(9898));
        //获取客户端连接通道
        SocketChannel skChannel = sskChannel.accept();

        //获取缓冲区
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        //接收客户端数据并存入本地
        FileChannel outChannel = FileChannel.open(Paths.get("2.jpg"), StandardOpenOption.WRITE, StandardOpenOption.CREATE);

        while(skChannel.read(buffer) != -1){
            buffer.flip();
            outChannel.write(buffer);
            buffer.clear();
        }

        outChannel.close();
        skChannel.close();
        sskChannel.close();


    }

示例二

@Test
    public void client() throws IOException {

        //1 获取通道
        SocketChannel skChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1",9898));

        FileChannel fileChannel = FileChannel.open(Paths.get("1.jpg"), StandardOpenOption.READ);
        //2 获取缓冲区
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        //3 通道传输出去数据
        while(fileChannel.read(buffer) != -1){
            buffer.flip();
            skChannel.write(buffer);
            buffer.clear();
        }

        System.out.println("发送图片完成");
        //阻塞式必须告诉服务端发送完成服务端才可以接收到数据
        skChannel.shutdownOutput();
        //接收服务端反馈
        int len = 0;
        while((len = skChannel.read(buffer)) != -1){
            buffer.flip();
            System.out.println(new String(buffer.array(),0,len));
            buffer.clear();
        }

        //4 关闭流
        fileChannel.close();
        skChannel.close();


    }
    @Test
    public void server() throws IOException {

        // 获取通道
        ServerSocketChannel sskChannel = ServerSocketChannel.open();
        // 绑定连接
        sskChannel.bind(new InetSocketAddress(9898));
        //获取客户端连接通道
        SocketChannel skChannel = sskChannel.accept();

        //获取缓冲区
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        //接收客户端数据并存入本地
        FileChannel outChannel = FileChannel.open(Paths.get("2.jpg"), StandardOpenOption.WRITE, StandardOpenOption.CREATE);

        while(skChannel.read(buffer) != -1){
            buffer.flip();
            outChannel.write(buffer);
            buffer.clear();
        }

        System.out.println("接收图片完成");

        byte[] src = "获取客户端图片成功".getBytes();
        buffer.put(src);

        buffer.flip();
        skChannel.write(buffer);

        outChannel.close();
        skChannel.close();
        sskChannel.close();


    }

2 非阻塞io，服务端可以在选择器上监控已经准备就绪的事件处理，不用一直等待

示例一

 public static void main(String[] args) throws IOException {
        //1 获取通道
        SocketChannel skChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9898));

        //切换 为非阻塞式
        skChannel.configureBlocking(false);

        // 2 获取缓冲区
        ByteBuffer buffer = ByteBuffer.allocate(1024);

        Scanner scan = new Scanner(System.in);

        while(scan.hasNext()) {
            String str = scan.next();
            System.out.println(str);
            //3 缓冲区存储数据
            buffer.put((new Date()+"\n"+str).getBytes());
            //4 通道传输数据
            buffer.flip();
            skChannel.write(buffer);
            buffer.clear();

        }

        // 关闭通道
        skChannel.close();
    }
    @Test
    public  void client() throws IOException {

        //1 获取通道
        SocketChannel skChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9898));

        //切换 为非阻塞式
        skChannel.configureBlocking(false);

        // 2 获取缓冲区
        ByteBuffer buffer = ByteBuffer.allocate(1024);



        //3 缓冲区存储数据
        buffer.put(new Date().toString().getBytes());
        //4 通道传输数据
        buffer.flip();
        skChannel.write(buffer);
        buffer.clear();

        // 关闭通道
        skChannel.close();

    }

    @Test
    public void server() throws IOException {
        //获取通道
        ServerSocketChannel sskChannel = ServerSocketChannel.open();
        // 切换为非阻塞式
        sskChannel.configureBlocking(false);

        //绑定客户端连接
        sskChannel.bind(new InetSocketAddress(9898));

        //获取选择器
        Selector selector = Selector.open();

        // 将通道注册到选择器
        SelectionKey selectionKey = sskChannel.register(selector, SelectionKey.OP_ACCEPT);
//        System.out.println("tongdao 注册选择器");
        //轮询式的获取选择器上已经准备就绪的事件

        while(selector.select()>0){

            // 获取当前选择器中所有的选择键（已经准备就绪的事件）
            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();

            while(iterator.hasNext()){
                //获取准备就绪的事件
                SelectionKey next = iterator.next();
//                System.out.println("获取选择器"+next.isReadable()+"||"+next.isAcceptable());
                if (next.isAcceptable()) {
                    //接收事件
                    //获取客户端连接的通道，并注册选择器
                    SocketChannel sChannel = sskChannel.accept();
                    //切换为非阻塞
                    sChannel.configureBlocking(false);
                    //注册到选择器
                    sChannel.register(selector,SelectionKey.OP_READ);

                }else if(next.isReadable()){
                    //读事件
                    //获取选择器上(读状态就绪)状态的通道
                    SocketChannel socketChannel = (SocketChannel) next.channel();
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    int len = 0;
                    while((len=socketChannel.read(buffer)) !=-1){
                        buffer.flip();
                        System.out.println(new String(buffer.array(),0,len));
                        buffer.clear();
                    }

                }
            }
            //需要将这个从选择器中取消掉，不然下次循环还会获取准备就绪的这个事件，重复获取了 Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            iterator.remove();
        }
    }

示例二

  @Test
    public void client() throws IOException {

        DatagramChannel dc = DatagramChannel.open();
        dc.configureBlocking(false);

        ByteBuffer buffer = ByteBuffer.allocate(1024);

        buffer.put("ceshi DatagramChannel".getBytes());

        buffer.flip();

        dc.send(buffer,new InetSocketAddress("127.0.0.1",9898));

        buffer.clear();

        dc.close();
    }


    @Test
    public void server() throws IOException {
        DatagramChannel dc = DatagramChannel.open();
        dc.configureBlocking(false);

        dc.bind(new InetSocketAddress(9898));

        Selector selector = Selector.open();

        dc.register(selector, SelectionKey.OP_READ);

        while (selector.select() > 0) {
            //遍历获取准备好的事件

            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while (iterator.hasNext()) {
                SelectionKey next = iterator.next();
                //只需要监控读事件
                if (next.isReadable()) {
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    dc.receive(buffer);

                    buffer.flip();
                    System.out.println(new String(buffer.array(), 0, buffer.limit()));
                    buffer.clear();

                }
                iterator.remove();

            }
        }
    }

四、管道：

javanio两个线程之间单向的数据传输：管道Pipe有个Source和Sink通道，数据会被写入Sink通道，从Source读取

 @Test
    public void test() throws IOException {

        //获取管道
        Pipe open = Pipe.open();

        //将缓冲区的数据写入管道
        Pipe.SinkChannel sink = open.sink();
        Pipe.SourceChannel source = open.source();

        ByteBuffer buffer = ByteBuffer.allocate(1024);
        buffer.put("测试sink通道".getBytes());
        System.out.println(buffer.position());
        System.out.println(buffer.limit());
        buffer.flip();
        System.out.println(buffer.position());
        System.out.println(buffer.limit());
        sink.write(buffer);

        System.out.println(buffer.position());
        System.out.println(buffer.limit());

        // 读取缓冲区的数据
        //切换操作模式，将位置置为初始位置，才可以读取
        buffer.flip();
        System.out.println(buffer.position());
        System.out.println(buffer.limit());

        source.read(buffer);
        System.out.println(new String(buffer.array(),0,buffer.limit()));


        //关闭通道
        sink.close();
        source.close();

    }

yubin1285570923

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
NIO：基本操作和学习

NIO的核心：缓冲区，通道，选择器一、缓冲区 Buffer ：存储数据1 基本概念： 1 position :当前操作数据的位置，指针位置 2 limit：缓冲区中可以操作数据的大小，即limit后面的数据不能操作 3 capacity：缓冲区的存储大小2 直接缓冲区和非直接缓冲区非直接缓冲区（allocate（））方法分配的缓冲区，将缓冲区直接建立在jvm上面直接缓冲区：allocateDirect（）方法分配的缓冲区，将缓冲区直接建立在...
复制链接

扫一扫

专栏目录

yubin1285570923 CSDN认证博客专家 CSDN认证企业博客

码龄6年

220: 原创

3万+: 周排名

8707: 总排名

40万+: 访问

: 等级

4277: 积分

157: 粉丝

350: 获赞

98: 评论

845: 收藏

私信

关注

分类专栏

最新评论

springboot配置多数据源以及事务问题
wangxj_1992: 有工程源码链接吗？
java8：创建Stream及常用API和Optional类
CSDN-Ada助手: 哇, 你的文章质量真不错，值得学习！不过这么高质量的文章, 还值得进一步提升, 以下的改进点你可以参考下: (1)提升标题与正文的相关性；(2)使用更多的站内链接。
Linux:组管理和权限管理
CSDN-Ada助手: 哇, 你的文章质量真不错，值得学习！不过这么高质量的文章, 还值得进一步提升, 以下的改进点你可以参考下: (1)使用更多的站内链接；(2)提升标题与正文的相关性；(3)增加条理清晰的目录。
Linux 服务管理： service| systemctl，top,netstat
CSDN-Ada助手: 如何在 Linux 上安装并配置 Nginx Web 服务器？
mybatis：逆向工程
CSDN-Ada助手: SpringBoot项目里的@Autowired 也会产生循环依赖，这个时候怎么解决呢？

最新文章

目录

评论

被折叠的条评论为什么被折叠?

到【灌水乐园】发言

查看更多评论

添加红包

成就一亿技术人!

hope_wisdom

发出的红包

实付元

使用余额支付

点击重新获取

扫码支付

钱包余额 0

抵扣说明：

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