Netty笔记-NIO基础[三大组件,文件以及网络编程]

已于 2022-08-16 10:36:13 修改
阅读量199 收藏
点赞数
分类专栏： netty 文章标签： 网络 nio udp
于 2022-08-10 02:33:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_49194578/article/details/126258800
版权

三大组件

Chinnel

  • FileChannel
    一般就是文件的数据传输通道
  • DatageamChannel
    UDP网络编程时用到的数据传输通道
  • SocketChannel
    TCP时的数据传输通道(客户端服务器都可用)
  • ServerSocketChannel
    TCP时的数据传输通道（服务器专用）

Buffer

Selector


**改进后**

必须等一个socket任务执行完成才能执行别的sokcket任务
我们来看看 **Selector** 是怎么解决的

selector会监听channel中客户端的需求，一旦客户端有需求，selector就会把需求分发给Thread执行

ByteBuffer

使用Channle和FileBuffer读取文件

public static void main(String[] args) {
    // FileChannel
    // 输入输出流
    try(FileChannel channel = new FileInputStream("./NIOBasic/data.txt").getChannel()) {
        // 准备缓冲区
        ByteBuffer buffer = ByteBuffer.allocate(8196);
        // 读取数据写入缓冲区
        int len=0;
        while (true){
            int read = channel.read(buffer);
            if (read==-1){
                break;
            }
            // 打印buffer的内容
            buffer.flip(); // 切换至读模式（将读取位置设置为0）
            // 获取数据
            while (buffer.hasRemaining()){  // hasRemaining是否还有剩余
                byte b = buffer.get(); // 一次读一个
                System.out.println((char)b);
            }
            // 清空缓冲区,进入写模式,否则buffer再次执行读取的时候将读不到数据，永远读的前几个
             buffer.clear();
        }
    } catch (IOException e) {
        e.printStackTrace();
    }

ByteBuffer结构

图片太长直接上连接

ByteBuffer常见方法

分配空间方法

 ByteBuffer allocate = ByteBuffer.allocate(16);  //  -java堆内存
 ByteBuffer byteBuffer = ByteBuffer.allocateDirect(16); //  -直接内存

堆内存：
读写效率低，java内部内存，会收到gc影响
直接内存：
读写效率高，少一次拷贝,不会受到gc影响，分配速度慢因为需要调用系统函数，而且使用不当容易造成内存泄漏

向buffer写入数据

int read = channel.read(buffer); // 从channel读取数据存入buffer
buffer.put(byte[]) // 直接向buffer写入数据

从buffer读取数据

byte b = buffer.get();  // 从buffer读取
channel.write(buffer); // 向channel输出时传入buffer

读写之前记得调用
image.png
image.png
image.png
buffer.get_(1);// 按照索引读取，并且不改变position指针_

字符串和buffer互转

image.png

Scattering Read(分散读)

image.png

GetherubgWrites(集中写入)

将buffer进行组合，进行集中写入，减少拷贝次数
image.png

粘包和半包的问题

粘包

因为数据传输时为了提升效率，经常将数据组合发送，所以产生了粘包

半包

因为服务器缓冲区大小限制，导致在某一些数据传输中必须分批发送数据，导致出现半包问题

文件编程

基本APi

image.png
image.png
image.png
image.png

两个Channel进行传输

把数据从Channel传输到另一个Channel

public  void toChannel() {
    try (
            FileChannel from = new FileInputStream("NIOBasic\\data.txt").getChannel();
            FileChannel to = new FileOutputStream("NIOBasic\\toData.txt").getChannel()
    ){
        // 效率高，经过了0拷贝优化
        from.transferTo(0,from.size(),to);  // 从from发起传输,从0开始,结束位置是from的最大长度也是就全部,到传输到to的channel去
    } catch (IOException e) {
        e.printStackTrace();
    }
}

// 传输大于2gb的文件
public  void toChannel2() {
    try (
            FileChannel from = new FileInputStream("NIOBasic\\data.txt").getChannel();
            FileChannel to = new FileOutputStream("NIOBasic\\toData.txt").getChannel()
    ){
        // 这里有一点需要注意，这个传输方法一次最大传输2gb的文件，多出的文件将会消失，
        // 我们可以分批传递
        long size = from.size();
        // left代表channel中还有多少
        long left = size;
        while (left>0){
            long numberOfBytes = from.transferTo(size-left, left, to); // 返回的是实际传输了多少
            left = size-numberOfBytes;
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Path

image.png
image.png

Files

image.png
image.png
image.png
需要手动删除所有文件以后才能删除文件夹

遍历文件夹案例

public static void main(String[] args) throws IOException {
    Path start = Paths.get("D:\\Project\\TestProject\\Netty");
    // 必须用这两个进行计数
    // 因为匿名类里和外部变量不再一个工作空间，所以不能使用基本类型，
    // 因为基本类型数据是保存在栈里的，就得用地址不可变的引用类型
    // 即使Integer也不行因为值变了地址也变了，简而言之，匿名类如果要使用外部变量，则该变量地址不能发生改变；
    final AtomicInteger dirCount = new AtomicInteger();
    final AtomicInteger fileCount = new AtomicInteger();
    SimpleFileVisitor<Path> fileVisitor = new SimpleFileVisitor<Path>() {
        // 访问到目录时执行的方法
        @Override
        public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOExcept
            // 重写时我们加入自己的方法就可以了,不要去改动他的返回
            System.out.println("进入文件夹:" + dir.getFileName());
            dirCount.incrementAndGet();
            return super.preVisitDirectory(dir, attrs);
        }
        // 访问到文件时执行的方法
        @Override
        public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
            System.out.println("找到文件:" + file.getFileName());
            fileCount.incrementAndGet();
            return super.visitFile(file, attrs);
        }
    };
    // 遍历文件树
    Files.walkFileTree(start,fileVisitor);
    System.out.println("文件夹共计："+dirCount+"个");
    System.out.println("文件共计："+fileCount+"个");
}

遍历删除

遍历删除中就是在遍历到文件的时候直接删除文件，然后删除文件夹

public static void main(String[] args) throws IOException {
        Path start = Paths.get("D:\\Project\\TestProject\\Netty\\NIOBasic\\src\\main\\java\\cn\\netty");
        SimpleFileVisitor<Path> fileVisitor = new SimpleFileVisitor<Path>() {
            // 进入文件夹时
            @Override
            public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
                System.out.println("进入："+dir.getFileName());
                return super.preVisitDirectory(dir, attrs);
            }
            // 进入文件时
            @Override
            public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
                System.out.println("找到文件："+file.getFileName());
                return super.visitFile(file, attrs);
            }
            // 退出文件夹时
            @Override
            public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
                System.out.println("退出："+dir.getFileName());
                return super.postVisitDirectory(dir, exc);
            }
        };
        Files.walkFileTree(start,fileVisitor);
    }

image.png
所以我们只需要在找到文件时删除所有文件，在退出文件夹时删除文件夹即可

public static void main(String[] args) throws IOException {
    Path start = Paths.get("C:\\Users\\1\\Desktop\\tempa");
    SimpleFileVisitor<Path> fileVisitor = new SimpleFileVisitor<Path>() {
        // 进入文件时
        @Override
        public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
            System.out.println("删除文件："+file.getFileName());
            Files.delete(file);
            return super.visitFile(file, attrs);
        }
        // 退出文件夹时
        @Override
        public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
            System.out.println("删除文件夹："+dir.getFileName());
            Files.delete(dir);
            return super.postVisitDirectory(dir, exc);
        }
    };
    Files.walkFileTree(start,fileVisitor);
}

image.png

文件夹对拷

public static void main(String[] args) throws IOException {
    Path resource = Paths.get("C:\\Users\\1\\Desktop\\webSocketTest");
    Path target = Paths.get("C:\\Users\\1\\Desktop\\channelTest");
    // 使用返回Stream流的方法
    Files.walk(resource).forEach(
            path -> {
                if (Files.isDirectory(path)) {
                    // 如果是文件夹就创建目录
                    // 生成路径
                    String targetPah = target.toString() + path.toString().replace(resource.toString(), "");
                    try {
                        Files.createDirectories(Paths.get(targetPah));
                    } catch (IOException ioException) {
                        ioException.printStackTrace();
                        System.out.println("文件夹创建错误");
                    }
                }
                if (Files.isRegularFile(path)) {
                    // 如果是文件就传输
                    // 路径
                    String targetPah = target.toString() + path.toString().replace(resource.toString(), "");
                    try {
                        // FileChannel in = new FileInputStream(path.toString()).getChannel();
                        // FileChannel out = new FileOutputStream(targetPah).getChannel();
                        // in.transferTo(0, in.size(), out);
                        // 或者使用
                        Files.copy(path,Paths.get(targetPah));
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
    );
}

网络编程

阻塞和非阻塞

image.png

阻塞

public class Server {
    // 用于存放连接
    public static LinkedList<SocketChannel> CHANNELS = new LinkedList<>();
    public static ByteBuffer buf =ByteBuffer.allocate(8196);
    public static void main(String[] args) throws IOException {
        // 创建服务器
        ServerSocketChannel ssc = ServerSocketChannel.open();
        // 绑定监听的端口
        ssc.bind(new InetSocketAddress(8080));
        // 建立连接
        while (true){
            // 建立与客户端的连接，channel用来与客户端建立通讯
            System.out.println("服务器启动完成..");
            SocketChannel channel = ssc.accept(); // 阻塞方法,等待连接
            System.out.println("请求到达..");
            CHANNELS.add(channel);
            for (SocketChannel c : CHANNELS) {
                // 读取
                c.read(buf);// 连接建立以后阻塞,客户端如果不发送数据则会阻塞，等待客户端发送数据
                buf.flip();
                while (buf.hasRemaining()){
                    byte b = buf.get();
                    System.out.println((char)b);
                }
                buf.clear();
            }
        }
    }
}

/**
 * 创建网络客户端
 */
public class Client {

    public static void main(String[] args) throws IOException {
        SocketChannel clientSc = SocketChannel.open();
        clientSc.connect(new InetSocketAddress("localhost",8080));
        System.out.println("waiting....");
    }
}

非阻塞

public class Server {
    // 用于存放连接
    public static LinkedList<SocketChannel> CHANNELS = new LinkedList<>();
    public static ByteBuffer buf =ByteBuffer.allocate(8196);
    public static void main(String[] args) throws IOException {
        ServerSocketChannel ssc = ServerSocketChannel.open();
        // 服务器通道设置非阻塞模式。影响下方{ssc.accept()},服务器通道建立时非阻塞
        ssc.configureBlocking(false);
        ssc.bind(new InetSocketAddress(8080));
        while (true){
            System.out.println("服务器启动完成..");
            // 设置非阻塞以后到这不会等待,会继续向下执行,如果没有连接则SocketChannel为null
            SocketChannel socketChannel = ssc.accept();
            // 连接通道设置非阻塞，影响下方{channel.read(buf);},网络连接建立时非阻塞
            socketChannel.configureBlocking(false);
            System.out.println("请求到达..");
            CHANNELS.add(socketChannel);
            // 轮流遍历客户端，读取客户端发送的数据
            for (SocketChannel channel : CHANNELS) {
                channel.read(buf);
                buf.flip();
                while (buf.hasRemaining()){
                    byte b = buf.get();
                    System.out.println((char)b);
                }
                buf.clear();
            }
        }
    }
}

调试部分演示视频
https://www.bilibili.com/video/BV1py4y1E7oA?p=26&spm_id_from=pageDriver&vd_source=b81354d9e69632c870d2dc0db3f3174c

Selector

事件类型

  • accept : ServerSocket连接请求建立时触发
  • connect : 客户端连接建立后触发的事件
  • read : 客户端发送数据，数据到达时触发的事件
  • write : 可写事件

示例代码

public class AddSelector {
    public static void main(String[] args) throws IOException {
        // 1.创建selector
        Selector selector = Selector.open();
        ServerSocketChannel ssc = ServerSocketChannel.open();
        ssc.configureBlocking(false);
        // 2.把Channel注册到Select;;SelectionKey 事件发生时通过它可以知道是哪个channle发生的事件
        SelectionKey sscKey = ssc.register(selector, 0, null);
        // 3.设置专注类型,这里我们就关注连接建立事件,
        // 由于SelectionKey不但serverSocketChannel可以使用，socketChannel也可以使用，所以这里也有他们的事件
        sscKey.interestOps(SelectionKey.OP_ACCEPT); // 也可以在上面ssc.register时指定
        ssc.bind(new InetSocketAddress(8080)); // 启动端口
        System.out.println("服务器启动完成....");
        System.out.println("key:"+sscKey);
        while (true){
            // 执行select方法，虽然select依然是阻塞的，但是只要有上面的事件发生就会让线程恢复执行
            selector.select();
            // 处理事件,拿到所有发生的可用事件
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
            // 然后遍历处理，由于我们需要在执行后删除事件，所以我们需要用迭代器遍历，不能使用增强for
            Iterator<SelectionKey> iter = selectionKeys.iterator();
            while (iter.hasNext()){
                SelectionKey key = iter.next(); // 通过它就知道是哪个channle发生的事件
                System.out.println(key);
                ServerSocketChannel channel = (ServerSocketChannel)key.channel(); // 强转拿到ServerChannel
                SocketChannel socketChannel = channel.accept(); // 建立连接，建立连接以后就会消除事件
            }
        }
    }
}

NIO vs BIO

写代码要喊出来
关注
专栏目录
基于Netty网络编程项目实战笔记.rar
03-20
这个项目实战笔记主要涵盖了Netty的核心概念、设计模式以及如何在实际项目中运用Netty进行网络编程。 首先，Netty的核心概念包括通道（Channel）和处理器（Handler）。通道是Netty中的基本I/O抽象，它代表一个连接...
文件操作、网络编程、多线程
zheng199902的博客
09-27 590
文件操作、网络编程、多线程
java实现遍历磁盘文件中递归调用和非递归调用性能比较和使用SimpleFileVisitor性能比较
hongfei568718926的博客
11-20 738
1.说明一下,我的电脑中的磁盘目录是一个文件夹,并且是个隐藏的文件夹. 每一个磁盘中都有隐藏的文件夹,通过 File.listFiles()方法,返回的文件或者文件夹其中存在电脑上看不到但是实际存在的隐藏的文件夹,当对这个隐藏的文件使用new File的时候会出现空指针,因为这些文件夹不可以访问,备注:在C盘中不仅存在隐藏的文件夹,还存在一种其他类型的文件夹,也是电脑上看不到但是实际存在的系统文...
linux应用编程和网络编程——文件IO（1）
chao-@的博客
03-19 705
linux中的文件IO应用编程框架介绍什么是应用编程课程规划 应用编程框架介绍 什么是应用编程 整个嵌入式linux核心课程包括5点：裸机，c高级，uboot和系统移植，linux应用编程和网络编程，驱动。 典型的嵌入式产品就是基于嵌入式linux操作系统来工作的。典型的嵌入式产品的研发过程是：第一步让linux系统在硬件上跑起来（系统移植工作），第二步基于linux系统开发应用程序实现产品功能...
Java SimpleFileVisitor遍历文件夹与File遍历文件夹的速度对比
huyouyixia001的博客
12-13 3391
测试对比File类递归与SimpleFileVisitor类遍历文件夹的耗时： package other; import java.io.File; import java.io.IOException; import java.nio.file.FileVisitResult; import java.nio.file.Files; import java.nio.file.Path; i
使用FileVisitor遍历文件和目录
转身未来的博客
04-29 7470
在早期的Java版本中，如果需要对指定目录下的文件进行遍历，则需要用递归的方法来实现，这种方法有点复杂，而且灵活性也不高。而使用Java7中Files工具类中的walkFileTree()方法可以很容易的实现对目录下的所有文件进行遍历。这个方法需要一个Path和一个FileVisitor参数。其中Path是要遍历的路径，而FileVisitor则可以看成的一个文件访问器，它主要提供的四个方法，这在程
基于Netty网络编程项目实战笔记.7z
03-09
《基于Netty网络编程项目实战笔记》是一份深入探讨Netty框架在实际网络编程中的应用文档。Netty，作为一款高性能、异步事件驱动的网络应用程序框架，广泛应用于各种网络应用开发，包括服务器和客户端的实现。这份...
tqk-learn-nio:netty学习
04-16
2. **文档**：教程、笔记或者指导，解释了 NIO 和 Netty 的基本概念，以及如何将它们应用于实际项目。 3. **测试**：单元测试或集成测试，演示了 Netty 组件的正确使用方式。 4. **配置文件**：例如 pom.xml（Maven...
NIO+Netty5视频教程与Netty源码剖析视频教程
11-20
《NIO+Netty5视频教程与Netty源码剖析视频教程》是一份全面解析网络编程框架Netty的教育资源，旨在帮助学习者深入理解和应用NIO（非阻塞I/O）以及Netty5的核心技术。该教程分为两个主要部分，分别针对理论分析和实战...
Netty4.0学习笔记系列之三：构建简单的http服务
06-10
Netty4.0学习笔记系列之三是关于构建简单的HTTP服务的教程，这主要涉及网络编程、服务器开发以及Java NIO（非阻塞I/O）的相关知识。Netty是一个高性能、异步事件驱动的网络应用程序框架，它使得开发可伸缩且稳定的...
[NIO.2] 第三十二篇 SimpleFileVisitor 类
Terry Zhang 的技术博客
04-12 722
要实现 FileVisitor 接口就要实现接口上的所有方法，但是你有可能只需要实现其中的一两个方法，因此这对于你来说会显得很麻烦。在这种情况下，你可以继承 SimpleFileVisitor 类，它是 FileVisitor 接口的一个实现。这样，你就仅仅只需要覆盖你需要的方法即可。 例如，你可能需要遍历目录树并打印所有目录的名字。要实现这个目标，只需要覆盖 postVisitDirec...
Java-网络
2301_81543552的博客
09-14 792
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
4.网络编程
weixin_45476535的博客
09-14 583
程序注册端口：1024-49151。单个协议下，端口号不能冲突。公有端口0-1023。
使用堡垒机登录ftp服务报网络不可达错误
ajax_beijing_java的博客
09-14 286
解决方法：由于不想安装额外的服务在服务器上，于是想到使用sftp服务代替ftp服务，发现是可以使用的。22端口默认就是启动的，在堡垒机上加了sftp服务，再次连接服务器并使用filezila传输文件 ，文件可以正常传输。至此，问题得到解决。场景：开发同事想使用ftp传输服务，连接服务器时报网络不可达错误。排查发现，如果想使用ftp服务，需要在服务器上部署ftp服务，21端口才会存在，才可以访问该服务。
嵌入式流媒体SRT协议：send buffer和窗口延迟机制
Dada_ping的博客
09-16 661
Handshake Packets：握手控制包（“包类型”位 = 1）用于在点对点的 SRT 会话中建立两个对等体之间的连接。早期版本的 SRT 依赖于握手扩展来在连接建立后立即交换某些参数，但自 1.3 版本起，集成机制确保所有参数作为握手的一部分进行交换。有关详细信息，请参阅本文档后面的握手部分。KM Error Response Packets(key message 错误响应包):密钥消息...
网络工程师学习笔记——网络互连与互联网
2301_77279557的博客
09-14 901
网络互连相关技术
linux-网络相关概念
zdd56789的博客
09-17 611
linux-网络相关概念
USB 的工作原理：枚举和配置（第 3 部分）
最新发布
qq_37255138的博客
09-18 945
在上一个教程中，我们了解了 USB 设备如何与主机控制器通信。现在，我们将在本教程中了解 USB 描述符的妙处及其在枚举和配置过程中的作用，这使得 USB 设备可热插拔，因此事不宜迟，让我们深入研究它。要理解 USB 描述符，首先我们需要很好地理解什么是 USB 请求！它们本质上只是主机发送到 USB 设备以与其通信的数据包。下面提到的是协议支持的 USB 请求类型。这里要注意的关键点是所有请求的结构都保持不变。
【计算机网络 - 基础问题】每日 3 题（七）
Newin2020的博客
09-16 1226
✍个人博客：Pandaconda-CSDN博客📣专栏地址：http://t.csdnimg.cn/fYaBd📚专栏简介：在这个专栏中，我将会分享 C++ 面试中常见的面试题给大家~📝推荐参考地址：https://www.xiaolincoding.com/（这个大佬的专栏非常有用！
java nio空轮循_Netty笔记-JavaNIO的空轮询Bug及Netty应对
06-08
好的，关于 Java NIO 空轮询问题，其实是在 NIO 的 Selector 中存在的一个 Bug。当 Selector 中没有任何待处理的事件时，Selector.select() 方法会一直阻塞，导致 CPU 资源的浪费。这个问题也被称为“空轮询”。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值