Netty中用于打印字节流(类似winhex)的工具类及其改进

最新推荐文章于 2024-10-03 11:24:27 发布
最新推荐文章于 2024-10-03 11:24:27 发布
阅读量2k 收藏 3
点赞数 2
分类专栏： netty 文章标签： netty winhex 打印字节数组中的内容
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/nmgrd/article/details/98094598
版权
本文介绍Netty中ByteBufUtil类的使用，该类能以十六进制形式打印ByteBuf对象。同时分享了一个自定义的BytesPrinter类，用于打印字节数组byte[]，并详细解释了其实现原理与代码细节。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Netty中类似winhex用于打印字节流的工具类

三年前，本人为了查看java类字节码，使用了一款叫做winhex的软件用于打开.class的二进制文件，当时最大的感觉就是如获至宝。winhex的界面截图如下所示：

在这里插入图片描述

时隔一年，本人在阅读Netty源码的时候，竟然发现netty中也存在一个类似winhex的工具类ByteBufUtil。 该类中的方法：*public static void appendPrettyHexDump(StringBuilder dump, ByteBuf buf)*可以将ByteBuf对象中的字节流以类似winhex的方式呈现。
然而遗憾的是，ByteBufUtil并不能直接打印字节数组byte[]中的内容，为了弥补这个缺陷，本人参考了ByteBufUtil的源码，并作了少量的修改，实现了打印byte[]数组得目的。 相关代码如下所示：核心代码就是BytesPrinter类的print方法。代码如下：
//import io.netty.buffer.ByteBufUtil;
//import io.netty.buffer.ByteBuf;
//import io.netty.buffer.PooledByteBufAllocator;

/**
 * <p>
 * 打印字节数组到日志的工具，便于排错使用，也可以当做hexdump工具使用
 * </p>
 *
 * @author lihong10 2019/6/12 19:26
 * @version v1.0
 * @modificationHistory=========================逻辑或功能性重大变更记录
 * @modify by user: {修改人} 2019/6/12 19:26
 * @modify by reason:{方法名}:{原因}
 */
public class BytesPrinter {

    public static final String NEWLINE = System.getProperty("line.separator", "\n");
    private static final char[] BYTE2CHAR = new char[256];
    private static final String[] HEXDUMP_ROWPREFIXES = new String[65536 >>> 4];
    private static final String[] HEXPADDING = new String[16];
    private static final String[] BYTE2HEX = new String[256];
    private static final String[] BYTEPADDING = new String[16];
    private static final String[] BYTE2HEX_PAD = new String[256];
    private static final String[] BYTE2HEX_NOPAD = new String[256];


    static {
        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 that converts a byte into a 2-digit hexadecimal integer.
        for (i = 0; i < BYTE2HEX_PAD.length; i++) {
            String str = Integer.toHexString(i);
            BYTE2HEX_PAD[i] = i > 0xf ? str : ('0' + str);
            BYTE2HEX_NOPAD[i] = str;
        }

        // Generate the lookup table for byte-to-hex-dump conversion
        for (i = 0; i < BYTE2HEX.length; i ++) {
            BYTE2HEX[i] = ' ' + 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;
            }
        }
    }


    /**
     * Determine if the requested {@code index} and {@code length} will fit within {@code capacity}.
     * @param index The starting index.
     * @param length The length which will be utilized (starting from {@code index}).
     * @param capacity The capacity that {@code index + length} is allowed to be within.
     * @return {@code true} if the requested {@code index} and {@code length} will fit within {@code capacity}.
     * {@code false} if this would result in an index out of bounds exception.
     */
    public static boolean isOutOfBounds(int index, int length, int capacity) {
        return (index | length | (index + length) | (capacity - (index + length))) < 0;
    }



    /**
     * 打印字节数组的关键方法
     * @param dump 打印的内容会被追加到dump中
     * @param buf 字节数组，被打印的对象
     * @param offset 偏移或起始位置
     * @param length 打印的字节长度
     * @return
     * @modificationHistory=========================逻辑或功能性重大变更记录
     * @modify by user: {修改人} 2019/8/1 19:11
     * @modify by reason:{原因}
     */
    public static void print(StringBuilder dump, byte[] buf, int offset, int length) {
        if (isOutOfBounds(offset, length, buf.length)) {
            throw new IndexOutOfBoundsException(
                    "expected: " + "0 <= offset(" + offset + ") <= offset + length(" + length
                            + ") <= " + "buf.length(" + buf.length + ')');
        }
        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('|');
        }
    }

    private static String byteToHexStringPadded(int value) {
        return BYTE2HEX_PAD[value & 0xff];
    }


    /**
     * 字节转换成无符号数
     * @param b
     * @return
     * @modificationHistory=========================逻辑或功能性重大变更记录
     * @modify by user: {修改人} 2019/8/1 19:13
     * @modify by reason:{原因}
     */
    private static short getUnsignedByte(byte b) {
        return (short)(b & 0xFF);
    }



    private static String testPrint(String a) {
        byte[] bytes = a.getBytes();
        StringBuilder builder = new StringBuilder();
        print(builder, bytes, 0, bytes.length);
        System.out.println(builder);
        return builder.toString();

    }

    /*private static String testPrint2(String b) {
        byte[] bytes = b.getBytes();
        PooledByteBufAllocator pooledByteBufAllocator = new PooledByteBufAllocator(false);
        //这里：  byteBuf的实际类型是：PooledUnsafeHeapByteBuf
        ByteBuf byteBuf = pooledByteBufAllocator.heapBuffer(bytes.length);

        byteBuf.writeBytes(bytes);

        StringBuilder builder = new StringBuilder();
        ByteBufUtil.appendPrettyHexDump(builder, byteBuf);
        System.out.println(builder);
        return builder.toString();
    }*/




    public static void main(String... args) {

        System.out.println("\n\r");
        System.out.println(Long.toHexString(0 & 0xFFFFFFFFL | 0x100000000L));
        System.out.println(Long.toHexString(1 & 0xFFFFFFFFL | 0x100000000L));

        System.out.println("\n\r");
        System.out.println(1 << 4);
        System.out.println(Long.toHexString(16 & 0xFFFFFFFFL | 0x100000000L));

        testPrint("abcd123!@#$%^&");


       /* String str1 = "abcdefghijklmnopqrstuvwxyz1234567890";
        System.out.println("equals: "  + testPrint(str1).equals(testPrint2(str1)));

        String str2 = "我是中国人";
        System.out.println("equals: "  + testPrint(str2).equals(testPrint2(str2)));*/
    }






}
上述代码中用到得辅助类Int2BinaryStringUtil代码如下:

/**
 * 该类是一个将int型整数转成32位二进制字符串形式的工具类
 * Created by lihong10 on 2017/4/28.
 */
public class Int2BinaryStringUtil {


    private final static char[] digits = {'0', '1'};


    /**
     * 将int型整数转成32位的2进制形式
     * @param num
     * @return String
     */
    public static String toFullBinaryString(int num, boolean indent)
    {
        char[] buf = new char[32];
        int pos = 32;
        int mask = 1;
        do
        {
            buf[--pos] = digits[num & mask];
            num >>>= 1;
        }
        while (pos > 0);
        if (indent) {
            return formatString(buf);
        }

        return new String(buf, pos, 32);
    }

    public static String toFullBinaryString(int num)
    {
        char[] buf = new char[32];
        int pos = 32;
        int mask = 1;
        do
        {
            buf[--pos] = digits[num & mask];
            num >>>= 1;
        }
        while (pos > 0);

        return new String(buf, pos, 32);
    }


    public static String toFullBinaryString(long num)
    {
        char[] buf = new char[64];
        int pos = 64;
        int mask = 1;
        do
        {
            buf[--pos] = digits[(int)(num & mask)];
            num >>>= 1;
        }
        while (pos > 0);

        return new String(buf, pos, 64);
    }

    public static String toFullBinaryString(long num, boolean indent)
    {
        char[] buf = new char[64];
        int pos = 64;
        int mask = 1;
        do
        {
            buf[--pos] = digits[(int)(num & mask)];
            num >>>= 1;
        }
        while (pos > 0);

        if (indent) {
            return  formatString(buf);
        }

        return new String(buf, pos, 64);
    }


    public static String formatString(char[] buf) {

        //从后往前，每相隔8个元素就插入一个空格，一共插入8个空格
        char[] formatBuf = new char[buf.length + (buf.length / 8)];
        int k = formatBuf.length;
        for(int i = buf.length; i > 0; i--) {
            formatBuf[--k] = buf[i - 1];
            if ((i - 1) % 8 == 0) {
                //插入空格
                formatBuf[--k] = (char) 0;
            }
        }
        return new String(formatBuf, 1, formatBuf.length - 1);

    }



    public static String toFullBinaryString(byte num)
    {
        num &= 0xFF;
        char[] buf = new char[8];
        int pos = 8;
        int mask = 1;
        do
        {
            buf[--pos] = digits[num & mask];
            num >>>= 1;
        }
        while (pos > 0);

        return new String(buf, pos, 8);
    }

    public static String toFullBinaryString(char num)
    {
        num &= 0xFFFF;
        char[] buf = new char[16];
        int pos = 16;
        int mask = 1;
        do
        {
            buf[--pos] = digits[num & mask];
            num >>>= 1;
        }
        while (pos > 0);

        return new String(buf, pos, 16);
    }


    /**
     * 将int型整数转成32位的2进制形式
     * @param num
     * @return String
     */
    public static String toFullBinaryString2(int num)
    {
        char[] chs = new char[Integer.SIZE];
        for (int i = 0; i < Integer.SIZE; i++)
        {
            chs[Integer.SIZE - 1 - i] = (char) ((num >> i & 1) + '0');
        }
        return new String(chs);
    }

    public static void printComplementCode(int a)
    {
        for (int i = 0; i < 32; i++)
        {
            // 0x80000000 是一个首位为1，其余位数为0的整数
            int t = (a & 0x80000000 >>> i) >>> (31 - i);
            System.out.print(t);
        }
        System.out.println();
    }




    /**
     * 测试
     * @param args
     */
    public static void main(String[] args)
    {
       /* System.out.println("方法一：" + toFullBinaryString(6053));
        System.out.println("JDK自带： " + Integer.toBinaryString(6053));

        System.out.println("方法一：" + toFullBinaryString(-2));
        System.out.println("JDK自带： " + Integer.toBinaryString(-2));

        System.out.println("------------------------------------------");

        System.out.println("方法二：" + toFullBinaryString2(6053));
        System.out.println("JDK自带： " + Integer.toBinaryString(6053));

        System.out.println("方法二：" + toFullBinaryString2(-2));
        System.out.println("JDK自带： " + Integer.toBinaryString(-2));*/

        System.out.println("方法一：" + toFullBinaryString(255));
//        System.out.println("JDK自带： " + Integer.toBinaryString(6053));


        System.out.println(toFullBinaryString('\uffff'));
        System.out.println(toFullBinaryString(0xFFFF));
        System.out.println(toFullBinaryString(0x80000000 ));

        printComplementCode(-10); // 11111111 11111111 11111111 11110110
        printComplementCode(10); // 11111111 11111111 11111111 11110110


        System.out.println(toFullBinaryString(10));
        System.out.println(toFullBinaryString(Integer.reverseBytes(10)));


        System.out.println(toFullBinaryString(1));
        System.out.println(toFullBinaryString(Integer.reverse(1)));
        System.out.println(Integer.reverse(1));


    }

}
Packet字节流解析工具说明_Packet字节流解析工具说明_
10-04
Packet字节流解析工具是网络编程中的重要辅助工具，主要用于分析和理解网络数据包的结构和内容。本文将深入探讨JAVA语言中Packet字节流解析工具的相关知识。 1. **字节流基础** 在JAVA中，字节流是处理二进制数据...
Netty：利用ByteBufUtil将ByteBuf数据转换为美化过的十六进制表示
听海边涛声
08-15 1244
Netty：利用ByteBufUtil将ByteBuf数据转换为美化过的十六进制表示
Netty学习笔记（一）
Xiaoweidumpb
08-06 355
netty学习
Netty使用
qq_45072503的博客
03-28 1125
Netty使用
中间件系列「三」netty之NIO基础
qq_35789269的博客
03-31 441
123
Netty之ByteBuf介绍（一）
weixin_38598961的博客
04-19 626
Netty之ByteBuf介绍（一）
Netty 源码分析系列（七）字节缓冲区 ByteBuf（下）
java_dazhuzhu的博客
08-11 600
前言 在了解了 ByteBuffer 的原理之后，再来理解Netty 的 ByteBuf 就比较简单了。 ByteBuf 是 Netty 框架封装的数据缓冲区，区别于 position、limit、flip等属性和操作来控制 ByteBuffer 的读写，ByteBuf 通过两个位置指针来协助缓冲区的读写操作，分别是readIndex和writeIndex。 readIndex、writeIndex和capacity变量存在以下关系： 0 <= readIndex <= writeIn
基于 Java Netty实现的可用于内网穿透的代理工具.zip
12-22
基于 Java Netty实现的可用于内网穿透的代理工具.zip基于 Java Netty实现的可用于内网穿透的代理工具.zip基于 Java Netty实现的可用于内网穿透的代理工具.zip基于 Java Netty实现的可用于内网穿透的代理工具.zip基于...
Springboot+netty实现的流媒体服务（可用于直播点播）
04-28
介绍：Springboot、netty实现的http-flv、websocket-flv流媒体服务（可用于直播点播），支持rtsp、h264、h265等、rtmp等多种源，h5纯js播放（不依赖flash），不需要依赖nginx等第三方，低延迟（支持识别h264、aac...
java实现基于netty 的udp字节数据接收服务
08-14
在Java编程环境中，Netty是一个高性能、异步事件驱动的网络应用程序框架，常用于构建可伸缩、高并发的服务器。本示例关注的是如何利用Netty实现一个基于UDP（User Datagram Protocol）的数据接收服务，这在需要进行...
基于netty4 的udp字节数据接收服务
11-08
Netty 是一个高性能、异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。在本文中，我们将深入探讨如何利用 Netty 4 构建基于 UDP（用户数据报协议）的数据接收服务，以及如何实现...
NIO知识总结二
木子Teng的博客
09-25 279
NIO知识总结二
Netty：ByteBuf写入数据、读出数据
听海边涛声
08-03 6689
Netty：ByteBuf写入数据、读出数据
java用16进制的方式打印byte数组
web15687102624的博客
08-18 2405
代码】java用16进制的方式打印byte数组。
二进制文件 查看工具 类似winhex 十六进制 显示 并 拷贝
热门推荐
abc
06-22 3万+
成功导出变化了的dump文件。然后我们用hexeditor（这个会自动变成正常阅读顺序，当然某些数据不懂时我们可以尝试使用hexdump，这个是反端的顺序，可能会有新的发现）。打开分析。通过对比文件变化，我们发现有一部分内容变化了。 命令行形式的 工具，可以拷贝打印出的文字，用于分析 或者 写文档 https://www.di-mgt.com.au/hexdump-for-windows.ht...
软件修改工具----盘点那些免费的windows系统下的16进制编辑器 软件修改好帮手
最新发布
小马哥的专栏
10-03 3987
我们在修改软件或者有些分区文件时。不可避免的要使用一些进制修改工具。网络很多工具有的是收费的。另外有的功能不太全面。今天将详细解析下那些在windows下使用的免费进制修改工具HxD编辑器中文版是一款专业高效的十六进制编辑器和磁盘数据编辑器。HxD编辑器中文版功能全面，绿色小巧，支持对主存储器(RAM)的原始磁盘编辑和修改，还能够对任意文件进行16进制编辑。除了主存储器（RAM）的原始磁盘编辑和修改外，还可以处理任何大小的文件。界面提供了搜索和替换，导出，校验和/摘要，插入字节模式，文件碎纸机，连接或分割文
Netty入门——ByteBuf
小志的博客
11-07 877
Netty入门——ByteBuf
白帽黑客最常用的十款工具，你知道几款？
msb_114的博客
05-26 615
白帽黑客最常用的十款工具，你知道几款？建议收藏！
五款专业文本编辑器比较（转贴）
仓
06-27 2601
    分享一篇来自“华军软件园”郭华的文章，就常用的几款文本编辑器做了一些性能等方面的比较，希望给大家有所帮助。文章版权属于“华军软件园”和作者郭华所有，如有侵权，请联系linqiang0816@163.com，我将尽快处理文章信息。    {    今天我们将为大家评测几款能够“代替记事本”的软件。它们包括UltraEdit、
Netty中的Unpooled工具类与ByteBuf分配
`ByteBufUtil`是另一个重要的工具类，它包含了一组通用的ByteBuf操作静态方法，如比较、复制、检查、打印和哈希计算等。由于这些方法对池化与否不敏感，它们可以在任何需要处理ByteBuf的场合使用。 在非联网项目中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值