Netty学习笔记_6(Channel的基本使用)

最新推荐文章于 2021-10-19 14:06:52 发布
最新推荐文章于 2021-10-19 14:06:52 发布
阅读量1.8w 收藏
点赞数
分类专栏： Netty 笔记 文章标签： java netty
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/feiku_ysu/article/details/106916686
版权
Netty 同时被 2 个专栏收录
15 篇文章 0 订阅
订阅专栏
笔记
15 篇文章 0 订阅
订阅专栏

1、基本介绍

1、NIO通道类似于Java的输入输出流，有所区别：

      通道可以同时进行读写，流只能读或写；

      通道可以实现异步读写数据；

      通道可以从缓冲区读数据，也可以写数据到缓冲区。

2、BIO中stream是单向的，例如FileInputStream对象只能进行读取数据的操作，而NIO的 通道(Channel)是双向的可以读操作，也可以写操作。

3、Channnel在NIO中是一个接口：public interface Channel extends Closeable{}

4、常用的Channnel类有：FileChannel、DatagramChannel、ServerSocketChannel和SocketChannel。【ServerSocketChannel类似于ServerSocket，SocketChannel类似于Socket】

【注】在NIO模式下，当客户端向服务器请求连接时，客户端程序先访问服务器主线 程的ServerSocketChannel类，若服务器同意连接，则为客户端分配SocketChannel。

5、FileChannel用于文件数据读写，DatagramChannel用于UDP数据读写，ServerSocketChannel 和SocketChannel用于TCP数据读写。

2、FileChannel类：主要用于对本地文件进行IO操作

  1. Public int read(ByteBuffer dst); 从通道中读取数据到缓冲区中
  2. Public int write(ByteBuffer src); 把缓冲区中的数据写入到通道中
  3. Public long transferFrom(ReadableByteChannel src,long position,long count);从目标通道中复制数据到当前通道
  4. Public long transferTo(long position,long count,WriteableByteChannel target);把数据从当前通道复制给目标通道

2-1通道应用案例1 本地文件写数据

要求：1）使用ByteBuffer(缓冲)和FileChannel(通道)，将“你好，Netty”写入到file01.txt中

           2）若文件不存在则创建文件

设计思路：1）首先定义一个String类型的变量，赋值为“你好，Netty”

                  2）创建一个文件输出流FileOutputStream内置FileChannel

                  3）创建一个ByteBuffer缓冲区，将String变量按照字节形式存入缓冲区

                  4）将缓冲区中的数据通过channel输出到指定文件

                                     【注】使用FileChannel进行数据输入输出时，其底层使用的仍然是java.io中的输入输出流

 

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class NIOFileChannel01 {
    public static void main(String[] args) throws Exception {
        String str = "你好，Netty";

        //创建一个输出流包裹到Channel中
        FileOutputStream fileOutputStream = new FileOutputStream("d:\\file01.txt");

        //通过fileOutputStream获取对应的FileChannel
        //该FileChannel的真实类型是 FileChannelImpl
        FileChannel fileChannel = fileOutputStream.getChannel();

        //创建一个缓冲区 ByteBuffer
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

        //将str放入到ByteBuffer中
        byteBuffer.put(str.getBytes());

        //对byteBuffer进行反转
        byteBuffer.flip();

        //将byteBuffer中的数据写入到fileChannel中
        fileChannel.write(byteBuffer);
        fileOutputStream.close();
    }
}
  • 创建缓冲区ByteBuffer时，设置缓冲区大小为1024，此时缓冲区中无内容，底层数组各下标位置值为0
  • 将String类型的数据写入缓冲区时，按照中文字符占3个字节，英文字符占1个字节，给ByteBuffer的0~13位置赋值【3*3+5-1=13】；写入结束后，ByteBuffer的limit=1024，position=14
  • 将ByteBuffer反转（状态切换）flip()方法，此时limit=14，position=0，准备从0开始读取缓冲区数据，写入通道。
  • 调用FlieChannel的write()方法，将数据写入通道，再由输出流OutputStream输出到指定文件

2-2通道应用案例2 本地文件读数据 

要求：1）使用ByteBuffer和FileChannel，将file01.txt中的数据读入到程序，并显示在控制台屏幕

           2）假定文件已经存在

设计思路：1）先创建文件的输入流FileInputStream获取对应的FileChannel

                   2）将file01.txt中的内容读入通道

                   3）创建一个字节缓冲区ByteBuffer，通过FileChannnel.read()方法将通道中的数据读入缓冲区

                   4）调用ByteBuffer底层的字节数组，将数组中的内容转换为字符串类型并定义变量接收

                   5）将字符串输出至控制台显示

【注】将数据读入缓冲区之后不能直接输出，因为此时缓冲区存放的并不是原始字符串，而是字符串对应的字节文件，必须将字节转换为字符串才符合要求

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class NIOFileChannel02 {
    public static void main(String[] args) throws IOException {
        //创建文件的输入流
        File file = new File("d:\\file01.txt");
        FileInputStream fileInputStream = new FileInputStream(file);

        //通过fileInputStream获取对应的FileChannel -> 实际类型：FileChannelImpl
        FileChannel fileChannel = fileInputStream.getChannel();

        //创建缓冲区
        ByteBuffer byteBuffer = ByteBuffer.allocate((int) file.length());
        
        //将通道数据读入缓冲区中
        fileChannel.read(byteBuffer);

        //将byteBuffer中的字节数据转换为字符串输出
        System.out.println(new String(byteBuffer.array()));

        fileInputStream.close();
    }
}

2-3通道应用案例3 使用一个buffer完成文件读取

要求：1）使用FileChannel(通道)和方法 read，write，完成文件拷贝

           2）拷贝一个文本文件1.txt，放在项目下即可

数据流动过程如图：

 

设计思路：1）创建文件输入流输出流对象，并获取对应的FileChannel

                   2）创建ByteBuffer缓冲区

                   3）调用输入流通道的read()方法，将1.txt的内容循环读入缓冲区

                   4）每次读入缓冲区后，将缓冲区数据通过输出流通道的write()方法写入到2.txt

import java.io.*;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class NIOFileChannel03 {
    public static void main(String[] args) throws IOException {
        //创建文件输入流对象
        File f1 = new File("1.txt");
        FileInputStream fileInputStream = new FileInputStream(f1);

        //获取对应的FileChannel
        FileChannel inputStreamChannel = fileInputStream.getChannel();

        //创建文件输出流对象以及对应的FileChannel
        FileOutputStream fileOutputStream = new FileOutputStream("2.txt");
        FileChannel outputStreamChannel = fileOutputStream.getChannel();

        //创建缓冲区ByteBuffer
        ByteBuffer byteBuffer = ByteBuffer.allocate((int) f1.length());

        while(true){
            //循环读取文件内容，输入到缓冲区
            byteBuffer.clear(); //清空buffer 重要
            int read = inputStreamChannel.read(byteBuffer);
            System.out.println("read = "+read);
            if (read == -1){ //表示读取完毕
                break;
            }

            //将buffer中的数据写入到outputStreamChannel中 -> 2.txt
            byteBuffer.flip();
            outputStreamChannel.write(byteBuffer);
        }

        //关闭流
        fileInputStream.close();
        fileOutputStream.close();

    }
}

【注】1）每次进行循环读入前，必须调用ByteBuffer.clear()方法，将所有标志位重置。否则，若待读取文件不能一次读入缓冲区时，第二                次开始，limit和position的值一直相等，会导致读取内容为0。

            2）将Buffer中的数据写入通道前，需要调用flip()方法将缓冲区反转。

2-4通道应用案例4 使用transferFrom方法拷贝文件

要求：1）使用FileChannel和方法transferFrom，完成文件拷贝

           2）拷贝一张图片

设计思路：1）新建输入流和输出流，并分别获取对应的通道

                  2）调用通道的transferFrom()方法，将输入通道中的数据复制到输出通道中

import java.io.*;
import java.nio.channels.FileChannel;

public class NIOFlieChannel04 {
    public static void main(String[] args) throws IOException {
        File f1 = new File("1.jpg");
        FileInputStream fileInputStream = new FileInputStream(f1);
        FileChannel inputStreamChannel = fileInputStream.getChannel();

        FileOutputStream fileOutputStream = new FileOutputStream("2.jpg");
        FileChannel outputStreamChannel = fileOutputStream.getChannel();

        outputStreamChannel.transferFrom(inputStreamChannel,0,f1.length());

        fileInputStream.close();
        fileOutputStream.close();


    }
}

3、关于Buffer和Channel的注意事项和细节

  1. ByteBuffer支持类型化的put和get，put放入什么数据类型，get就应该使用相应的数据类型来取出，否则可能会产生ByteUnderflowException异常。
  2. 可以将一个普通的Buffer转换为只读的Buffer：asReadOnlyBuffer()方法。 
    import java.nio.ByteBuffer;

public class ReadOnlyBuffer {
    public static void main(String[] args) {
        ByteBuffer buffer = ByteBuffer.allocate(64);

        for (int i = 0; i < 64; i++){
            buffer.put((byte) i);
        }

        buffer.flip();

        //得到一个只读的buffer
        ByteBuffer readOnlyBuffer = buffer.asReadOnlyBuffer();
        System.out.println(readOnlyBuffer.getClass());

        while (readOnlyBuffer.hasRemaining()){
            System.out.println(readOnlyBuffer.get());
        }

        readOnlyBuffer.put((byte) 122);
    }
}
    【注】此时，向只读buffer中放入数据会产生异常。
  3. NIO提供了MapperByteBuffer，可以让文件直接在内存（堆外内存）中进行修改，而如何同步到文件由NIO来完成。 
    import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;

/*
* 说明
* 1、MappedByteBuffer可以直接让文件在内存（堆外内存）中修改，操作系统不需要拷贝一次
*
* */
public class MappedByteBufferTest {
    public static void main(String[] args) throws IOException {
        RandomAccessFile randomAccessFile = new RandomAccessFile("1.txt", "rw");

        //获取对应的文件通道
        FileChannel channel = randomAccessFile.getChannel();

        MappedByteBuffer mappedByteBuffer = channel.map(FileChannel.MapMode.READ_WRITE, 0, 5);
        /**
         * 参数1：FileChannel.MapMode.READ_WRITE 使用的是读写模式
         * 参数2：0 可以直接修改的起始位置
         * 参数3：5 映射到内存的大小(不是索引位置)，即将文件的多少个字节映射到内存中
         *                          可以直接修改的范围是0~5
         * 实际类型是 DirectByteBuffer
         * */


        mappedByteBuffer.put(0, (byte) 'H');
        mappedByteBuffer.put(3, (byte) '9');
        mappedByteBuffer.put(5, (byte) 'D');

        randomAccessFile.close();


    }
}

     

  4. NIO还支持通过多个Buffer(即Buffer数组)完成读写操作，即Scattering（分散）和Gathering（聚集）。

     Scattering(分散)：在向缓冲区写入数据时，可以使用buffer数组依次写入，一个buffer数组写满后，继续写入下一个buffer数组。

     Gathering(聚集)：从缓冲区读取数据时，可以依次读取，读完一个buffer再按顺序读取下一个。

import java.io.IOException;
import java.lang.reflect.Array;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Arrays;

/**
 * scattering[分散]:将数据写入到buffer时，可以采用buffer数组，依次写入
 *                 一个buffer满了，写入下一个buffer
 * gathering[聚集]:从buffer中读数据时，可以采用buffer数组，依次读取
 * */

public class ScatteringANDGathering {
    public static void main(String[] args) throws IOException {

        //使用ServerSocketChannel和SocketChannel 网络
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        InetSocketAddress inetSocketAddress = new InetSocketAddress(7000);

        //绑定端口到socket并启动
        serverSocketChannel.socket().bind(inetSocketAddress);

        //创建buffer数组
        ByteBuffer[] byteBuffers = new ByteBuffer[2];
        byteBuffers[0] = ByteBuffer.allocate(5);
        byteBuffers[1] = ByteBuffer.allocate(3);

        //等待客户端连接（telnet）
        SocketChannel socketChannel = serverSocketChannel.accept();
        int messageLength = 8; //假定从客户端接收8个字节

        //循环读取
        while (true){
            int byteRead = 0;

            while (byteRead < messageLength ){
                long l = socketChannel.read(byteBuffers);
                byteRead += l; //累计读取到在字节数
                System.out.println("byte = "+byteRead);
                //使用流打印，输出当前buffer的position和limit
                Arrays.asList(byteBuffers).stream().map(buffer ->
                        "position="+buffer.position()+",limit="+buffer.limit()).forEach(System.out::println);
            }

            //将所有的buffer进行一次反转
            Arrays.asList(byteBuffers).forEach(buffer -> buffer.flip());

            //将数据读出显示到客户端
            long byteWrite = 0;
            while (byteWrite < messageLength){
                long l = socketChannel.write(byteBuffers);//
                byteWrite += l;
            }

            //将所有的buffer进行复位（clear）
            Arrays.asList(byteBuffers).forEach(buffer -> {
                buffer.clear();
            });

            System.out.println("byteRead = "+ byteRead + " byteWrite = "+ byteWrite + "messageLength = "
            + messageLength);
        }

    }
}

 

feiku_ysu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Netty学习笔记_Springboot实现自定义协议.docx
12-27
Netty学习笔记_Springboot实现自定义协议.docx Netty学习笔记_Springboot实现自定义协议.docx Netty学习笔记_Springboot实现自定义协议.docx
Netty学习笔记_9(Netty概述)
feiku_ysu的博客
07-25 166
一、原生NIO存在的问题 NIO的类库与API繁杂，需要熟练掌握Selector、ServerSocketChannel、SocketChannel、Bytebuffer等 要求熟悉Java多线程编程和网络编程 开发工作量和难度大，例如客户端面临断连重连、网络闪断、半包读写、失败缓存、网络拥塞和异常流的处理等 JDK NIO的BUG：例如Epoll Bug，它会导致Selector空轮询，最终导致CPU占用100%，到JDK1.7还未被有效解决 二、Netty说明 Netty是由JBOS.
Netty学习笔记_day01 IO模型
风归去.
10-19 191
前言 Netty是一个非阻塞I/O客户端-服务器框架，主要用于开发Java网络应用程序，如协议服务器和客户端。异步事件驱动的网络应用程序框架和工具用于简化网络编程，例如TCP和UDP套接字服务器。Netty包括了反应器编程模式的实现。Netty最初由JBoss开发，现在由Netty项目社区开发和维护。 除了作为异步网络应用程序框架，Netty还包括了对HTTP、HTTP2、DNS及其他协议的支持，涵盖了在Servlet容器内运行的能力、对WebSockets的支持、与Google Protocol Buf
Netty学习笔记_11(Netty群聊系统)
feiku_ysu的博客
08-05 260
一、Netty群聊系统开发要求 编写一个Netty群聊系统，实现服务器端和客户端之间的数据简单通信（非阻塞） 实现多人群聊 服务器端：检测用户上线、离线、转发客户端消息 客户端：通过channel可以无阻塞发送消息给其他客户，同时可以接收其他客户端发送的消息（服务器转发得到） 二、设计与开发 2-1、服务器端 首先要设置监听端口，服务器将通过该端口与客户端交换信息，发送和接收数据； 初始化事件循环组EventLoopGroup，这里初始化两个事件循环组bossGroup和workerGroup
Netty学习笔记五Netty参数
SunYang的博客
08-26 382
Netty学习笔记五 五. 优化与参数 1. 优化 1.1 扩展序列化算法 序列化，反序列化主要用在消息正文的转换上 序列化时，需要将 Java 对象变为要传输的数据（可以是 byte[]，或 json 等，最终都需要变成 byte[]） 反序列化时，需要将传入的正文数据还原成 Java 对象，便于处理 package com.sunyang.netty.study.protocol; import com.google.gson.*; import java.io.*; import java
Netty学习笔记
01-20
Netty解决JDK空轮询BUG 1、创建一个新的Selector ...Netty如何确定要使用那些编码器和解码器 很简单，去看API文档 Netty自带的编码器可以解决99%的业务需求 1%自己编码 Netty中大文件上传的那个handler是怎么
netty-4.1_javaNetty_netty_服务器_
10-02
高性能的网络服务器，Java 开发学习进阶
Netty_In_Action中文版.pdf
01-31
NettyInAction中文版(高清+目录)，非常适合NIO入门和深度学习
netty-netty-4.1.19.Final.zip_netty_netty学习_rocketmq
09-15
学习netty源码，为后续rocketmq等学习打下基础
Netty学习笔记_14(Netty编解码器和handler调用机制)
feiku_ysu的博客
08-14 768
1、Netty的主要组件有：Channel、EventLoop、ChannelFuture、ChannelHandler、ChannelPipeline等。 ChannelHandler充当了处理入站和出站数据的应用程序逻辑的容器。例如：实现ChannelInboundHandler接口（或ChannelInboundHandlerAdapter），可以接收入站事件和数据，这些数据将被业务逻辑处理；当给客户端回送响应时，也可以通过ChannelInboundHandler冲刷数据。业务逻辑通常写在一个或多
Netty学习笔记_12(WebSocket与长连接)
feiku_ysu的博客
08-07 663
Http短连接和长连接 Http短连接即TCP短连接，即客户端和服务器通过“三次握手”建立连接后，进行一次Http操作以后，便断开连接。因此，浏览器每打开一个web资源，便创建了一个新的http会话； Http长连接即TCP长连接，即客户端和服务器建立连接后保持一定的时间，即使用户在进行某次操作后将浏览器（或客户端）关闭，但只要在保持时间内又一次访问该服务器，则默认使用已经创建好的连接； Http1.0默认支持短连接，Http1.1默认支持长连接。 Http连接无状态 Http协议无状态是指协议对于
Netty学习笔记_7(Selector的基本使用及NIO小案例)
feiku_ysu的博客
07-09 497
1、Selector（选择器） 1.1、基本介绍 Java的NIO使用了非阻塞的io方式->一个线程处理若干个客户端连接，使用到了selector(选择器)。 Selector能够检测到多个注册通道上是否有事件发生(多个Channel以事件的形式注册到同一个selector)，如果有事件发生，便获取事件然后针对每个事件进行相应的处理。 只有在连接/通道真正有读写事件发生时，才会进行读写，减少了系统开销，并且不必为每个连接都创建一个线程，不用去维护多个线程。 避免了多线程之间上下文切换导致的开
Netty学习笔记_5 (Buffer的基本使用)
feiku_ysu的博客
06-18 388
基本介绍： 本质——可以读写数据的内存块【一个容器对象(含数组)】； 一组方法——可以轻松使用内存块； 一些机制——跟踪或记录缓冲区的状态变化情况。 Buffer类及其子类：NIO中Buffer是一个顶级父类，抽象类 常用的Buffer子类：1）ByteBuffer——存储字节数据到缓冲区 ShortBuffer——存储字符串数据到缓冲区 CharBuffer——存储字符数据到缓冲区 IntBuffer——存储整型数据到缓冲区 LongBuffer——存储长整型数据到缓冲区 ...
Netty学习笔记_10(Netty核心模块组件)
feiku_ysu的博客
07-28 297
1、BootStrap,ServerBootStrap 一个Netty应用通常由一个BootStrap开始，主要作用是配置整个Netty程序，串联各个组件，Netty中的BootStrap类是客户端程序的启动引导类，ServerBootStrap是服务端启动引导类 常见方法： public ServerBootstrapgroup (EventLoopGroup parentGroup, EventLoopGroup childGroup) 作用于服..
Netty学习笔记_13(ProtoBuf在Netty中的简单应用)
feiku_ysu的博客
08-09 288
1、Netty编解码器 ​ 数据在网络中是以二进制字节码的形式流动，而我们在端接收或发送的数据形式则各种各样（文本、图片、音视频等），因此需要在发送端对数据进行编码，在接收端对收到的数据解码； codeC(编解码器)的组成部分——Encoder(编码器)负责将业务数据转换为二进制字节码；Decoder(解码器)负责将二进制字节码转换为业务数据； Netty编码机制——StringEncoder / StringDecoder负责字符串数据对象的编解码；ObjectEncoder / Objec.
Netty学习笔记_8(NIO与零拷贝)
feiku_ysu的博客
07-21 216
1、零拷贝基本介绍 传统IO是基于数据拷贝操作的，即让数据在操作系统内核地址空间的缓冲区和用户程序地址空间定义的缓冲区进行传输【PS：减少了磁盘IO，但增加了CPU开销( CPU会进行多次冗余拷贝，且在数据拷贝过程中有极大的系统资源浪费 )】 零拷贝是一种避免CPU将数据从一个存储块拷贝到另一块存储的技术【避免数据拷贝+多种操作结合】(所谓“零拷贝”，是没有CPU拷贝) 1.2、传统IO（本地文件数据上传）【4次拷贝，3次切换】 应用程序调用read()方法，先将数据从磁盘读取到OS内核缓冲区，采用D
Netty学习笔记_3（BIO基本介绍和简单使用）
feiku_ysu的博客
06-13 189
Java BIO，即blocking IO，是传统的Java IO编程，在JDK1.版本之前，只有这一种IO编程，BIO 相关的类和接口被封装在java.io包及其子包中。 BIO——同步阻塞型IO，每有一个客户端想要连接服务器时（即发出请求），服务器就启动一个线程专门处理该请求。一个连接对应一个线程，则有多少客户端连接服务器，就会产生多少线程。当有海量客户发出请求时，必然给服务器巨大的压力；除此之外，客户端对于服务器的访问并不是永久持续的，服务器在启动一个线程管理某客户端的请求后，客户端如果不再发...
Netty学习笔记_1（基本介绍）
feiku_ysu的博客
06-07 185
Netty学习笔记_1（基本介绍） Netty是异步的，基于事件驱动的网络应用框架。 异步：区别于过去的BS模型，当浏览器向服务器发送某请求以后，可以不等待服务器对该请求做出响应，而是设置一回调函数专门处理此服务器响应。浏览器可以在此期间发出其他事件请求。 基于事件驱动：例如在网页上点击某按钮，即产生一事件，随后程序会按照此事件发出请求，服务器相应地做出回馈，最后将结果呈现给用户。实际使用时，网页连接、网页断开、表单提交等都可以看做是一个事件。而这一个一个的事件，是Netty框架功能运行的触发者。 Nett
java.lang.UnsatisfiedLinkError: no com_alibaba_nacos_shaded_io_grpc_netty_shaded_netty_transport_native_epoll_x86_64 in java.library.path
最新发布
07-27
这通常发生在使用了需要本机库的 Java 应用程序中。 要解决这个问题，你可以尝试以下几个步骤： 1. 检查本机库是否存在：确保 `...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值