1. Netty 网络编程 NIO编程 ByteBuffer的初步使用

最新推荐文章于 2024-06-04 14:30:24 发布
最新推荐文章于 2024-06-04 14:30:24 发布
阅读量64 收藏
点赞数
文章标签： nio java 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37488173/article/details/131729715
版权

1.netty整体知识结构

2.NIO编程

3.ByteBuffer 使用

       3.1 构建springboot项目,引入pom文件

        <dependency>
            <groupId>io.netty</groupId>
            <artifactId>netty-all</artifactId>
            <version>4.1.39.Final</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.18</version>
        </dependency>
        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.8.5</version>
        </dependency>
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>19.0</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>
        <dependency>
            <groupId>com.google.protobuf</groupId>
            <artifactId>protobuf-java</artifactId>
            <version>3.11.3</version>
        </dependency>

        3.2 logback的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<configuration
        xmlns="http://ch.qos.logback/xml/ns/logback"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://ch.qos.logback/xml/ns/logback logback.xsd">
    <!-- 输出控制，格式控制-->
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%date{HH:mm:ss} [%-5level] [%thread] %logger{17} - %m%n </pattern>
        </encoder>
    </appender>
    <!--<appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        &lt;!&ndash; 日志文件名称 &ndash;&gt;
        <file>logFile.log</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            &lt;!&ndash; 每天产生一个新的日志文件 &ndash;&gt;
            <fileNamePattern>logFile.%d{yyyy-MM-dd}.log</fileNamePattern>
            &lt;!&ndash; 保留 15 天的日志 &ndash;&gt;
            <maxHistory>15</maxHistory>
        </rollingPolicy>
        <encoder>
            <pattern>%date{HH:mm:ss} [%-5level] [%thread] %logger{17} - %m%n </pattern>
        </encoder>
    </appender>-->

    <!-- 用来控制查看那个类的日志内容（对mybatis name 代表命名空间） -->
    <logger name="cn.itcast" level="DEBUG" additivity="false">
        <appender-ref ref="STDOUT"/>
    </logger>

    <logger name="io.netty.handler.logging.LoggingHandler" level="DEBUG" additivity="false">
        <appender-ref ref="STDOUT"/>
    </logger>

    <root level="ERROR">
        <appender-ref ref="STDOUT"/>
    </root>
</configuration>

        3.3 创建data.txt文件,在项目目录下

123321上山 abc...z

        3.4 编写读取代码

package cn.itcast.netty.c1;

import lombok.extern.slf4j.Slf4j;

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

@Slf4j
public class TestByteBuffer  {
    public static void main(String[] args) {
        //1.FileChannel
        //1.输入输出流 2.RandomAccessFile
        try (FileChannel channel = new FileInputStream("data.txt").getChannel();) {
            //准备缓冲区
            ByteBuffer buffer = ByteBuffer.allocate(48);//通过静态方法获得,划分一块内存容量为48个字节

            while ( true){
                //从Channel读取文件,写到Buffer缓冲区
                int read = channel.read(buffer);
                if (read  == -1){
                    break;
                }
                //打印buffer内容
                buffer.flip();//将缓冲区转换为开放状态，以便可以将其“阅读”,将缓冲区转化为读模式
                while (buffer.hasRemaining()){//当Buffer有内容可用时
                    byte b = buffer.get();//从缓冲区中取出一个字节，并将其存储到数组中
                    log.info("读取到的字节:{}",(char)b);//从Buffer中取出1个字符

                }
                buffer.clear();//将缓冲区转换为可用状态，以便将其“阅读”
            }
        } catch (IOException e) {

        }
    }
}

        

  1. 向 buffer 写入数据，例如调用 channel.read(buffer)
  2. 调用 flip() 切换至读模式
  3. 从 buffer 读取数据，例如调用 buffer.get()
  4. 调用 clear() 或 compact() 切换至写模式
  5. 重复 1~4 步骤

      

  3.5 执行结果

        写模式下，position 是写入位置，limit 等于容量，下图表示写入了 4 个字节后的状态

 

        flip 动作发生后，position 切换为读取位置，limit 切换为读取限制 

        读取 4 个字节后，状态

 

        clear 动作发生后，状态

 

        compact 方法，是把未读完的部分向前压缩，然后切换至写模式

 

 5.ByteBuffer 读写模式切换

        调试工具类

package cn.itcast.netty.c1;

import io.netty.util.internal.StringUtil;

import java.nio.ByteBuffer;

import static io.netty.util.internal.MathUtil.isOutOfBounds;
import static io.netty.util.internal.StringUtil.NEWLINE;

public class ByteBufferUtil {
    private static final char[] BYTE2CHAR = new char[256];
    private static final char[] HEXDUMP_TABLE = new char[256 * 4];
    private static final String[] HEXPADDING = new String[16];
    private static final String[] HEXDUMP_ROWPREFIXES = new String[65536 >>> 4];
    private static final String[] BYTE2HEX = new String[256];
    private static final String[] BYTEPADDING = new String[16];

    static {
        final char[] DIGITS = "0123456789abcdef".toCharArray();
        for (int i = 0; i < 256; i++) {
            HEXDUMP_TABLE[i << 1] = DIGITS[i >>> 4 & 0x0F];
            HEXDUMP_TABLE[(i << 1) + 1] = DIGITS[i & 0x0F];
        }

        int i;

        // Generate the lookup table for hex dump paddings
        for (i = 0; i < HEXPADDING.length; i++) {
            int padding = HEXPADDING.length - i;
            StringBuilder buf = new StringBuilder(padding * 3);
            for (int j = 0; j < padding; j++) {
                buf.append("   ");
            }
            HEXPADDING[i] = buf.toString();
        }

        // Generate the lookup table for the start-offset header in each row (up to 64KiB).
        for (i = 0; i < HEXDUMP_ROWPREFIXES.length; i++) {
            StringBuilder buf = new StringBuilder(12);
            buf.append(NEWLINE);
            buf.append(Long.toHexString(i << 4 & 0xFFFFFFFFL | 0x100000000L));
            buf.setCharAt(buf.length() - 9, '|');
            buf.append('|');
            HEXDUMP_ROWPREFIXES[i] = buf.toString();
        }

        // Generate the lookup table for byte-to-hex-dump conversion
        for (i = 0; i < BYTE2HEX.length; i++) {
            BYTE2HEX[i] = ' ' + StringUtil.byteToHexStringPadded(i);
        }

        // Generate the lookup table for byte dump paddings
        for (i = 0; i < BYTEPADDING.length; i++) {
            int padding = BYTEPADDING.length - i;
            StringBuilder buf = new StringBuilder(padding);
            for (int j = 0; j < padding; j++) {
                buf.append(' ');
            }
            BYTEPADDING[i] = buf.toString();
        }

        // Generate the lookup table for byte-to-char conversion
        for (i = 0; i < BYTE2CHAR.length; i++) {
            if (i <= 0x1f || i >= 0x7f) {
                BYTE2CHAR[i] = '.';
            } else {
                BYTE2CHAR[i] = (char) i;
            }
        }
    }

    /**
     * 打印所有内容
     * @param buffer
     */
    public static void debugAll(ByteBuffer buffer) {
        int oldlimit = buffer.limit();
        buffer.limit(buffer.capacity());
        StringBuilder origin = new StringBuilder(256);
        appendPrettyHexDump(origin, buffer, 0, buffer.capacity());
        System.out.println("+--------+-------------------- all ------------------------+----------------+");
        System.out.printf("position: [%d], limit: [%d]\n", buffer.position(), oldlimit);
        System.out.println(origin);
        buffer.limit(oldlimit);
    }

    /**
     * 打印可读取内容
     * @param buffer
     */
    public static void debugRead(ByteBuffer buffer) {
        StringBuilder builder = new StringBuilder(256);
        appendPrettyHexDump(builder, buffer, buffer.position(), buffer.limit() - buffer.position());
        System.out.println("+--------+-------------------- read -----------------------+----------------+");
        System.out.printf("position: [%d], limit: [%d]\n", buffer.position(), buffer.limit());
        System.out.println(builder);
    }

    private static void appendPrettyHexDump(StringBuilder dump, ByteBuffer buf, int offset, int length) {
        if (isOutOfBounds(offset, length, buf.capacity())) {
            throw new IndexOutOfBoundsException(
                    "expected: " + "0 <= offset(" + offset + ") <= offset + length(" + length
                            + ") <= " + "buf.capacity(" + buf.capacity() + ')');
        }
        if (length == 0) {
            return;
        }
        dump.append(
                "         +-------------------------------------------------+" +
                        NEWLINE + "         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |" +
                        NEWLINE + "+--------+-------------------------------------------------+----------------+");

        final int startIndex = offset;
        final int fullRows = length >>> 4;
        final int remainder = length & 0xF;

        // Dump the rows which have 16 bytes.
        for (int row = 0; row < fullRows; row++) {
            int rowStartIndex = (row << 4) + startIndex;

            // Per-row prefix.
            appendHexDumpRowPrefix(dump, row, rowStartIndex);

            // Hex dump
            int rowEndIndex = rowStartIndex + 16;
            for (int j = rowStartIndex; j < rowEndIndex; j++) {
                dump.append(BYTE2HEX[getUnsignedByte(buf, j)]);
            }
            dump.append(" |");

            // ASCII dump
            for (int j = rowStartIndex; j < rowEndIndex; j++) {
                dump.append(BYTE2CHAR[getUnsignedByte(buf, j)]);
            }
            dump.append('|');
        }

        // Dump the last row which has less than 16 bytes.
        if (remainder != 0) {
            int rowStartIndex = (fullRows << 4) + startIndex;
            appendHexDumpRowPrefix(dump, fullRows, rowStartIndex);

            // Hex dump
            int rowEndIndex = rowStartIndex + remainder;
            for (int j = rowStartIndex; j < rowEndIndex; j++) {
                dump.append(BYTE2HEX[getUnsignedByte(buf, j)]);
            }
            dump.append(HEXPADDING[remainder]);
            dump.append(" |");

            // Ascii dump
            for (int j = rowStartIndex; j < rowEndIndex; j++) {
                dump.append(BYTE2CHAR[getUnsignedByte(buf, j)]);
            }
            dump.append(BYTEPADDING[remainder]);
            dump.append('|');
        }

        dump.append(NEWLINE +
                "+--------+-------------------------------------------------+----------------+");
    }

    private static void appendHexDumpRowPrefix(StringBuilder dump, int row, int rowStartIndex) {
        if (row < HEXDUMP_ROWPREFIXES.length) {
            dump.append(HEXDUMP_ROWPREFIXES[row]);
        } else {
            dump.append(NEWLINE);
            dump.append(Long.toHexString(rowStartIndex & 0xFFFFFFFFL | 0x100000000L));
            dump.setCharAt(dump.length() - 9, '|');
            dump.append('|');
        }
    }

    public static short getUnsignedByte(ByteBuffer buffer, int index) {
        return (short) (buffer.get(index) & 0xFF);
    }
}

        调试代码

package cn.itcast.netty.c1;

import java.nio.ByteBuffer;

import static cn.itcast.netty.c1.ByteBufferUtil.debugAll;

public class TestByteBufferReadWrite {
    public static void main(String[] args) {
        ByteBuffer buffer = ByteBuffer.allocate(10);
        buffer.put((byte)0x61);
        debugAll(buffer);
        buffer.put(new byte[]{(byte)0x62,(byte)0x63,(byte)0x64});
        debugAll(buffer);
        buffer.flip();
        System.out.println( buffer.get());
        debugAll(buffer);
        buffer.compact();
        debugAll(buffer);
        buffer.put(new byte[]{(byte)0x65,(byte)0x6f});
        debugAll(buffer);
    }
}

        打印结果

+--------+-------------------- all ------------------------+----------------+
position: [1], limit: [10]
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 61 00 00 00 00 00 00 00 00 00                   |a.........      |
+--------+-------------------------------------------------+----------------+
+--------+-------------------- all ------------------------+----------------+
position: [4], limit: [10]
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 61 62 63 64 00 00 00 00 00 00                   |abcd......      |
+--------+-------------------------------------------------+----------------+
97
+--------+-------------------- all ------------------------+----------------+
position: [1], limit: [4]
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 61 62 63 64 00 00 00 00 00 00                   |abcd......      |
+--------+-------------------------------------------------+----------------+
+--------+-------------------- all ------------------------+----------------+
position: [3], limit: [10]
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 62 63 64 64 00 00 00 00 00 00                   |bcdd......      |
+--------+-------------------------------------------------+----------------+
+--------+-------------------- all ------------------------+----------------+
position: [5], limit: [10]
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 62 63 64 65 6f 00 00 00 00 00                   |bcdeo.....      |
+--------+-------------------------------------------------+----------------+

6. ByteBuffer 常见方法

        1.分配空间,可以使用 allocate 方法为 ByteBuffer 分配空间，其它 buffer 类也有该方法

Bytebuffer buf = ByteBuffer.allocate(16);

        2.向 buffer 写入数据

            调用channel的read方法

                

int readBytes = channel.read(buf);

             调用buffer的put方法

buf.put((byte)127);
        3.从buffer读取数据
                调用channel的write方法 
int writeBytes = channel.write(buf);
                调用buffer自己的get方法 
byte b = buf.get();

get 方法会让 position 读指针向后走，如果想重复读取数据

        可以调用 rewind 方法将 position 重新置为 0

        调用 get(int i) 方法获取索引 i 的内容，它不会移动读指针

        

7. ByteBuffer的 allocate和 allocateDirect 
package cn.itcast.nio.c2;

import java.nio.ByteBuffer;

public class TestByteBufferAllocate {
    public static void main(String[] args) {
        System.out.println(ByteBuffer.allocate(16).getClass());
        System.out.println(ByteBuffer.allocateDirect(16).getClass());
        /*
        class java.nio.HeapByteBuffer    - java 堆内存，读写效率较低，受到 GC 的影响
        class java.nio.DirectByteBuffer  - 直接内存，读写效率高（少一次拷贝），不会受 GC 影响，分配的效率低
         */
    }
}

8. mark和reset

        mark在读取时,做一个标记,即使position改变,只要调用reset就会回到mark地址     

        注意: rewind和flip都会清楚mark位置

9. 字符串和ByteBuffer相互转换

package cn.itcast.nio.c2;


import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;

import static cn.itcast.nio.c2.ByteBufferUtil.debugAll;

public class TestByteBufferString {
    public static void main(String[] args) {
        // 1. 字符串转为 ByteBuffer
        ByteBuffer buffer1 = ByteBuffer.allocate(16);
        buffer1.put("hello你好".getBytes());
        debugAll(buffer1);

        // 2. Charset
        ByteBuffer buffer2 = StandardCharsets.UTF_8.encode("hello你好");//输出结果自动转化为读模式
        debugAll(buffer2);

        // 3. wrap
        ByteBuffer buffer3 = ByteBuffer.wrap("hello你好".getBytes());//输出结果自动转化为读模式
        debugAll(buffer3);

        // 4. 转为字符串
        String str1 = StandardCharsets.UTF_8.decode(buffer2).toString();
        System.out.println(str1);

        buffer1.flip();
        String str2 = StandardCharsets.UTF_8.decode(buffer1).toString();
        System.out.println(str2);

    }
}

10. 分散读和集中写

words.txt

onetwothree
package cn.itcast.nio.c2;

import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

import static cn.itcast.nio.c2.ByteBufferUtil.debugAll;

public class TestScatteringReads {
    public static void main(String[] args) {
        try (FileChannel channel = new RandomAccessFile("words.txt", "r").getChannel()) {
            ByteBuffer b1 = ByteBuffer.allocate(3);
            ByteBuffer b2 = ByteBuffer.allocate(3);
            ByteBuffer b3 = ByteBuffer.allocate(5);
            channel.read(new ByteBuffer[]{b1, b2, b3});
            b1.flip();
            b2.flip();
            b3.flip();
            debugAll(b1);
            debugAll(b2);
            debugAll(b3);
        } catch (IOException e) {
        }
    }
}

package cn.itcast.nio.c2;

import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.charset.StandardCharsets;

public class TestGatheringWrites {
    public static void main(String[] args) {
        ByteBuffer b1 = StandardCharsets.UTF_8.encode("hello");
        ByteBuffer b2 = StandardCharsets.UTF_8.encode("world");
        ByteBuffer b3 = StandardCharsets.UTF_8.encode("你好");

        try (FileChannel channel = new RandomAccessFile("words2.txt", "rw").getChannel()) {
            channel.write(new ByteBuffer[]{b1, b2, b3});
        } catch (IOException e) {
        }
    }
}

11. 黏包和半包

package cn.itcast.nio.c2;

import java.nio.ByteBuffer;

import static cn.itcast.nio.c2.ByteBufferUtil.debugAll;

public class TestByteBufferExam {
    public static void main(String[] args) {
         /*
         网络上有多条数据发送给服务端，数据之间使用 \n 进行分隔
         但由于某种原因这些数据在接收时，被进行了重新组合，例如原始数据有3条为
             Hello,world\n
             I'm zhangsan\n
             How are you?\n
         变成了下面的两个 byteBuffer (黏包，半包)
             Hello,world\nI'm zhangsan\nHo
             w are you?\n
         现在要求你编写程序，将错乱的数据恢复成原始的按 \n 分隔的数据
         */
        ByteBuffer source = ByteBuffer.allocate(32);
        source.put("Hello,world\nI'm zhangsan\nHo".getBytes());
        split(source);
        source.put("w are you?\n".getBytes());
        split(source);
    }

    private static void split(ByteBuffer source) {
        source.flip();
        for (int i = 0; i < source.limit(); i++) {
            // 找到一条完整消息
            if (source.get(i) == '\n') {
                int length = i + 1 - source.position();
                // 把这条完整消息存入新的 ByteBuffer
                ByteBuffer target = ByteBuffer.allocate(length);
                // 从 source 读，向 target 写
                for (int j = 0; j < length; j++) {
                    target.put(source.get());
                }
                debugAll(target);
            }
        }
        source.compact();
    }
}

云淡风轻12345
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
1.Netty介绍及NIO三大组件
qq_36352889的博客
03-29 739
用来暂存从channel中读取的数据，也可以将channel中的数据写入Buffer。
Netty中ByteBuf 和 java.nio.ByteBuffer的区别
weixin_45690229的博客
11-04 296
ByteBuf 和 ByteBuffer的区别ByteBuf 和 ByteBuffer的区别ByteBuffer相关apiByteBuf ByteBuf 和 ByteBuffer的区别 ByteBuffer 对于ByteBuffer，其主要有五个属性：mark，position，limit，capacity和array。 这五个属性的作用如下： mark：记录了当前所标记的索引下标； position：表示当前位置； limit：对于写入模式，表示当前可以写入的数组大小，默认为数组的最大长度，对于读取模式
Netty ByteBuf与NIO ByteBuffer
qq_42411214的博客
08-13 390
Netty中引入了ByteBuf，相较于NIO中的ByteBuffer有了一下改进，使得网络编程更加简便。 ByteBuffer的缺点        在NIO的Buffer中，我们已经知道Buffer有七种，最常用的是ByteBuffer，而ByteBuffer也有一些局限性： ByteBuf...
基于IO、NIO、Netty的Java网络程序简单示例
weixin_45654230的博客
12-17 221
一、基于IO的java网络程序 1.循环输出多条数据 创建服务器端和客户端 2.服务器代码 import java.io.IOException; import java.io.InputStream; import java.net.ServerSocket; import java.net.Socket; public class IOServer { public static void main(String[] args) throws Exception { ..
Netty ByteBuf和Nio ByteBuffer
热门推荐
刘剑峰的博客
04-05 1万+
一、简介Netty中引入了ByteBuf，它相对于ByteBuffer来说，带来了很多便捷性和创新的地方，使得程序员更简单得进行网络编程二、ByteBuffer的缺点和ByteBuf的改进下面我们从几个点来分别讲解：1. 扩容ByteBuffer：ByteBuffer缓冲区的长度固定，分多了会浪费内存，分少了存放大的数据时会索引越界，所以使用ByteBuffer时，为了解决这个问题，我们一般每次pu
java-nio-缓冲区ByteBuffer、Netty的ByteBuf和MappedByteBuffer的使用
2010yhh
03-18 1141
java-nio-缓冲区ByteBuffer、Netty的ByteBuf和MappedByteBuffer的使用 文章目录java-nio-缓冲区ByteBuffer、Netty的ByteBuf和MappedByteBuffer的使用1.ByteBuffer2.MappedByteBuffer3 Netty的ByteBuf4.测试 环境 idea2018，jdk1.8 记录一下缓冲区ByteB...
Netty基础必备知识，ByteBuffer和ByteBuf底层原理
叶新东老师的博客
10-24 1834
前言 本文章只讨论ByteBuffer和ByteBuf的底层结构的区别，如果想要了解堆内内存和堆外内存的区别，请看我的另一篇文章：java堆外内存详解（又名直接内存）和ByteBuffer 什么是Buffer 中文称为缓冲区，指的是从网络或者文件读写数据的时候，在他们中间多了个缓冲区，应用程序只需要对着缓冲区 进行读写即可；然后缓冲区在将数据复制到内核或者从内核读取数据；这种方式加快读写速度，减少了IO次数；小文件的读写用不用缓冲区速度都没有多大区别，但是当我们进行大文件进行读写的时候一般都会使用到缓冲区；
Netty之NIO基础-ByteBuffer
KevinJee_
07-19 98
ByteBuffer 创建一个普通的Maven项目 package com.kevin.netty; import java.io.FileInputStream; import java.io.IOException; import java.nio.ByteBuffer; import java.nio.channels.FileChannel; public class TestBuffer { public static void main(String[] args) {
Netty网络编程框架的核心概念以及入门案例
终生学习践行者
09-17 1931
详细介绍了Netty网络编程框架的核心概念以及入门案例。
netty系列之:NIO和netty详解
程序那些事
03-09 5635
文章目录简介NIO常用用法NIO和EventLoopGroupNioEventLoopGroupSelectorProviderSelectStrategyFactoryRejectedExecutionHandlerEventLoopTaskQueueFactoryNioEventLoop总结 简介 netty为什么快呢？这是因为netty底层使用了JAVA的NIO技术，并在其基础上进行了性能的优化，虽然netty不是单纯的JAVA nio，但是netty的底层还是基于的是nio技术。 nio是JDK1.
网络编程及Netty使用Java代码示例.zip
12-27
网络编程及Netty使用Java代码示例
Netty网络编程视频教程
08-10
近百节视频详细讲解，...4. 网络编程 5. NIO vs BIO 二. Netty 入门 1. 概述 2. Hello World 3. 组件 4. 双向通信 三. Netty 进阶 1. 粘包与半包 2. 协议设计与解析 3. 聊天室案例 四. 优化与源码 1. 优化 2. 源码分析
基于Netty网络编程项目实战笔记.pdf
03-24
基于Netty网络编程项目实战笔记.pdf
基于Netty网络编程项目实战笔记.rar
03-20
基于Netty网络编程项目实战笔记
Java I/O 与 NIO：深入文件和网络编程
Programming Talk
06-03 507
在本篇文章中，我们详细探讨了Java的I/O系统，包括传统的I/O（java.io包）和新I/O（java.nio包）。通过学习文件读写、使用Buffer和Channel、以及非阻塞I/O操作，你可以编写高效的文件操作和网络通信程序。掌握这些技术将使你能够应对各种I/O需求，提高程序的性能和可靠性。在接下来的文章中，我们将继续深入探索Java的其他高级特性和实际应用，希望你能继续关注并享受学习的过程！如果你有任何问题或需要进一步的解释，请在评论区留言。我们将尽快回复。
深入理解IO与NIO：Java中的IO模型
请 端正你的态度的博客
06-02 410
Java的传统IO和NIO在处理数据输入/输出时提供了不同的方法和模型。传统IO基于流和块，是阻塞式的，适用于简单的数据传输场景。而NIO则提供了更高效的非阻塞IO模型，通过通道、缓冲区和选择器等组件，能够处理大量并发连接，并提高了系统的性能和可扩展性。在选择使用哪种IO模型时，需要根据具体的应用场景和需求进行权衡。
Mysql基础教程（14）：UNION
最新发布
WwLK123的博客
06-04 1129
UNION 操作符是一个集合操作符，它用于合并 2 个结果集中的所有的行。
java环境部署
JiuMeilove的博客
06-04 413
如果你电脑已经下载了 jdk ，那你可以跳过这一步了我这里下载的是java21 你们可以选择自己需要下载的游览进去的页面是这样子的（相比以前这个页面发生很大变化了），可以看见目前 jdk 已经发行到 17 了，jdk 它又分了三个个操作系统，一个是 Linux、一个是 macOS、以及 windows，如果你是在 windows 操作系统上，那当然就下载 windows 对应的 jdk，其次的话就是还会区分你操作系统的处理器是 32 位的还是 64 位的，可以点击 我的电脑 - 属性 查看。
java代码读取本地图片转成io.netty.buffer.ByteBuf类型代码怎么写
01-10
ByteBuffer byteBuffer = ByteBuffer.allocate((int) file.length()); // 将图片内容读入字节缓冲区 channel.read(byteBuffer); // 将字节缓冲区内容转换为ByteBuf ByteBuf buf = Unpooled.wrappedBuffer...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值