nio-Netty-字节的工具封装

最新推荐文章于 2023-02-24 17:10:59 发布
最新推荐文章于 2023-02-24 17:10:59 发布
阅读量246 收藏 1
点赞数
分类专栏： 工具 java springboot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wlwork66/article/details/106479279
版权
工具 同时被 3 个专栏收录
36 篇文章 1 订阅
订阅专栏
java
31 篇文章 0 订阅
订阅专栏
springboot
24 篇文章 0 订阅
订阅专栏 
 /**
     * 字符串转数组，需要传入数组的位数
     *
     * @param n   byte数组位数
     * @param str 待转字符串
     * @return byte[]
     */
    public static byte[] str2bytes(int n, String str) {
        byte[] temp = new byte[n];

        byte[] strByte = str.getBytes(Charset.forName("GBK"));

        int length = n >= strByte.length ? strByte.length : n;

        System.arraycopy(strByte, 0, temp, 0, length);

        return temp;
    }


package com.common.util;

import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;

public class ByteUtil {
	private static  int  INT8_MASK  = 0xFF;
	private static  int  INT16_MASK = 0xFFFF;
	private static  long INT32_MASK = 0xFFFFFFFFL;
	
	public static  long[] DECIMALISM = { 1000000000000000000L,
        100000000000000000L, 10000000000000000L, 1000000000000000L,
        100000000000000L, 10000000000000L, 1000000000000L, 100000000000L,
        10000000000L, 1000000000L, 100000000L, 10000000L, 1000000L,
        100000L, 10000L, 1000L, 100L, 10L, 1L };
	 /**
	  * 取ByteBuffer中一个字节,转换成带符号的int
	  * @param buf 
	  * @return int
	  * @throws Exception
	  */


    public static  int int8(ByteBuffer buf) {
        return buf.get();
    }

    /**
     * 取ByteBuffer中一个字节,转换成无符号的int
     * @param buf
     * @return int
     * @throws Exception
     */
    public static  int uint8(ByteBuffer buf) {
        return buf.get() & INT8_MASK;
    }

    /**
     * 取ByteBuffer中两个字节,转换成int
     * @param buf
     * @return int
     * @throws Exception
     */
    public static  int int16(ByteBuffer buf) {
        return buf.getShort();
    }

    /**
     * 取ByteBuffer中两个字节,转换成无符号的int
     * @param buf
     * @return int
     * @throws Exception
     */
    public static  int uint16(ByteBuffer buf) {
        return buf.getShort() & INT16_MASK;
    }

    /**
     * 取ByteBuffer中四个字节,转换成int
     * @param buf
     * @return int
     * @throws Exception
     */
    public static  long int32(ByteBuffer buf) {
        return buf.getInt();
    }
    /**
     * 取ByteBuffer中四个字节,转换成无符号的int
     * @param buf
     * @return int
     * @throws Exception
     */
    public static  long uint32(ByteBuffer buf) {
        return buf.getInt() & INT32_MASK;
    }

   /**
    * 取ByteBuffer中八个字节,转换成long
    * @param buf
    * @return long
    * @throws Exception
    */
    public static  long int64(ByteBuffer buf) {
        return buf.getLong();
    }

    /**
     * 将ByteBuffer转换成String，utf8编码<br>
     * 如果读取到0,则不会继续读取
     * @param buf
     * @return
     * @throws Exception
     */
    public static  String string(ByteBuffer buf) {
        List<Byte> list = new ArrayList<Byte>(10);
        byte b = -1;
        while ((b = buf.get()) != 0) {
            list.add(b);
        }
        byte[] bs = new byte[list.size()];
        for (int i = 0; i < bs.length; i++) {
            bs[i] = list.get(i);
        }
        return new String(bs);
    }

    /**
     * 取length长度的ByteBuffer转换成String,utf8编码
     * @param buf 
     * @param length 
     * @return
     * @throws Exception
     */
    public static  String string(ByteBuffer buf, int length) {
        byte[] bs = new byte[length];
        buf.get(bs);
        return new String(bs);
    }

    /**
     * 取length长度的ByteBuffer转换成String,gbk编码
     * @param buf
     * @param length
     * @return
     * @throws Exception
     */
    public static  String gbk(ByteBuffer buf, int length) throws Exception{
        byte[] bs = new byte[length];
        buf.get(bs);
        int real = 0;
        for (real = 0; real < bs.length && bs[real] != 0; real++);
        return new String(bs, 0, real, "GBK");
    }

    /**
     * 将ByteBuffer转换成String,gbk编码<br>
     * 如果读取到0,则不会继续读取
     * @param buf
     * @return
     * @throws Exception
     */
    public static  String gbk(ByteBuffer buf) throws Exception{
        byte[] bs = new byte[1024];
        int index = 0;
        while (buf.hasRemaining()) {
            byte b = buf.get();
            if (b == 0) {
                break;
            }
            bs[index++] = b;
        }
        return new String(bs, 0, index, "GBK");
    }

    /**
     * 从ByteBuffer取出length长度的字节<br>
     * 如果ByteBuffer中剩余字节不够,全部取出
     * @param buf
     * @param length
     * @return
     * @throws Exception
     */
    public static  byte[] bytes(ByteBuffer buf, int length) {
        byte[] bs = new byte[length];
        buf.get(bs);
        return bs;
    }

    /**
     * ByteBuffer向后移动length个字节<br>
     * 如果ByteBuffer剩余字节小于length,不做处理
     * @param buf
     * @param length
     * @throws Exception
     */
    public static  void skip(ByteBuffer buf, int length){
        if (buf.remaining() >= length) {
            buf.position(buf.position() + length);
        }
    }
    /**
     * 从ByteBuffer中取出length长度的字节<br>
     * 字节不够全部取出,然后转换成GBK编码字符串,同时去掉空格
     * @param buf
     * @param lenght
     * @return
     * @throws Exception
     */
    public static  String removeSpace(ByteBuffer buf, int lenght) throws Exception{
        byte space = 0x20;
        byte[] bs = new byte[lenght];
        buf.get(bs);
        int real = 0;
        for (; real < bs.length && bs[real] != space; real++);      
        return new String(bs, 0, real, "GBK");
    }
   
    /**
     * 
     * 从ByteBuffer中取出length长度的字节<br>
     * 字节不够全部取出,然后转换成asc码拼接成的字符串
     * @param buf
     * @param lenght
     * @return
     * @throws Exception
     */
    public static  String ascii(ByteBuffer buf, int lenght) {
        byte[] bs = new byte[lenght];
        buf.get(bs);
        StringBuffer buffer = new StringBuffer();
        for (int i = 0; i < bs.length; i++) {
            buffer.append((char)bs[i]);
        }
        return buffer.toString();
    }
    
    /**
     * 从ByteBuffer中取出length长度的字节<br>
     * 字节不够全部取出,然后转换成长整型,如取出的字节为0x17,则返回17而不是23
     * @param buf
     * @param len
     * @return
     * @throws Exception
     */
    public static  long bcd(ByteBuffer buf, int len) {
        byte[] bs = new byte[len];
        buf.get(bs);
        long result = 0;
        for (int i = 0; i < len; i++) {
            result += DECIMALISM[DECIMALISM.length - len * 2 + i * 2 + 1]
                    * (bs[i] & 0x0F);
            result += DECIMALISM[DECIMALISM.length - len * 2 + i * 2]
                    * ((bs[i] >> 4) & 0x0F);
        }
        return result;
    }
    
    /**
     * 从ByteBuffer中取出length长度的字节<br>
     * 字节不够全部取出,然后转换成bcd码的字符串,如取出的字节为0x17,则返回17而不是23
     * @param buf
     * @param len
     * @return
     * @throws Exception
     */
    public static  String bcdString(ByteBuffer buf, int len) {
        byte[] bs = new byte[len];
        buf.get(bs);
        String str = "";
        for (int i = 0; i < bs.length; i++) {
            byte e = bs[i];
            str += Integer.toHexString((e >> 4) & 0x0f);
            str += Integer.toHexString(e & 0x0f);
        }
        return str;
    }

    /**
     * 从ByteBuffer取6个字节,每个字节为无符号的整形<br>
     * 转成年月日时分秒的转成date,数组中格式为yymmddhhmmss
     * @param buf
     * @return
     * @throws Exception
     */
    public static Date date(ByteBuffer buf) {
        int year = uint8(buf) + 2000;
        int month = uint8(buf);
        int date = uint8(buf);
        int hour = uint8(buf);
        int minute = uint8(buf);
        int second = uint8(buf);

        Calendar calendar = Calendar.getInstance();
        calendar.set(year, month - 1, date, hour, minute, second);
        calendar.set(Calendar.MILLISECOND, 0);
        return calendar.getTime();
    }

    /**
     * 从ByteBuffer取6个字节,每个字节为bcd码<br>
     * 转成年月日时分秒的date,年份2017为17
     * @param buf
     * @return
     * @throws Exception
     */
    public static  Date bcdDate(ByteBuffer buf) {
        int year = (int) (bcd(buf, 1) + 2000);
        int month = (int) bcd(buf, 1);
        int date = (int) bcd(buf, 1);
        int hour = (int) bcd(buf, 1);
        int minute = (int) bcd(buf, 1);
        int second = (int) bcd(buf, 1);

        Calendar calendar = Calendar.getInstance();
        calendar.set(year, month - 1, date, hour, minute, second);
        calendar.set(Calendar.MILLISECOND, 0);
        return calendar.getTime();
    }

    /**
     * 从ByteBuffer取7个字节,每个字节为bcd码<br>
     * 转成年月日时分秒的date,年份2017为2017
     * @param buf
     * @return
     * @throws Exception
     */
    public static  Date bcdDateFullYear(ByteBuffer buf) {
        int year = (int) bcd(buf, 2);
        int month = (int) bcd(buf, 1);
        int date = (int) bcd(buf, 1);
        int hour = (int) bcd(buf, 1);
        int minute = (int) bcd(buf, 1);

        Calendar calendar = Calendar.getInstance();
        calendar.set(year, month - 1, date, hour, minute);
        calendar.set(Calendar.MILLISECOND, 0);
        return calendar.getTime();
    }
    /**
     * 从ByteBuffer取3个字节(时分秒都为0),每个字节为bcd码<br>
     * 转成年月日时分秒的date,年份2017为17
     * @param buf
     * @return
     * @throws Exception
     */
    public static  Date bcdDateNoHMS(ByteBuffer buf) {
    	int year = (int) (bcd(buf, 1) + 2000);
        int month = (int) bcd(buf, 1);
        int date = (int) bcd(buf, 1);

        Calendar calendar = Calendar.getInstance();
        calendar.set(year, month - 1, date);
        calendar.set(Calendar.MILLISECOND, 0);
        return calendar.getTime();
    }
    
    /**
     * 从ByteBuffer取4个字节(时分秒都为0),每个字节为bcd码<br>
     * 转成年月日时分秒的date,年份2017为2017
     * @param buf
     * @return
     * @throws Exception
     */
    public static  Date bcdDateFullYearNoMS(ByteBuffer buf) {
        int year = (int) bcd(buf, 2);
        int month = (int) bcd(buf, 1);
        int date = (int) bcd(buf, 1);
        int hour = (int) bcd(buf, 1);

        Calendar calendar = Calendar.getInstance();
        calendar.set(year, month - 1, date, hour, 0);
        calendar.set(Calendar.MILLISECOND, 0);
        return calendar.getTime();
    }
    
    /**
     * 把data转成byte数组,放入byteBuffer中
     * @param buf
     * @param date
     * @throws Exception
     */
    public static  void putDate(ByteBuffer buf, Date date) {
        Calendar c = Calendar.getInstance();
        int year = c.get(Calendar.YEAR) - 2000;
        int month = c.get(Calendar.MONTH) + 1;
        int day = c.get(Calendar.DAY_OF_MONTH);
        int hour = c.get(Calendar.HOUR_OF_DAY);
        int minute = c.get(Calendar.MINUTE);
        int second = c.get(Calendar.SECOND);
        byte[] bs = new byte[] { (byte) year, (byte) month, (byte) day,
                (byte) hour, (byte) minute, (byte) second };
        buf.put(bs);
    }

    /**
     * 把GBK编码的String转成byte数组,放入ByteBuffer中
     * @param buf
     * @param str
     * @throws Exception
     */
    public static  void putString(ByteBuffer buf, String str)
            throws Exception {
        byte[] bs = str.getBytes("GBK");
        buf.put(bs);
        buf.put((byte) 0);
    }

    /**
     * 把gbk编码字符串转成byte数组放入ByteBuffer中
     * @param buf
     * @param str
     * @throws Exception
     */
    public static  void putGbkString(ByteBuffer buf, String str) throws Exception{
		byte[] bs = null;
		bs = str.getBytes("GBK");
		buf.put(bs);
    }

   /**
    * 将一个long转成bcd放入bytebuffer中<br>
    * len表示bcd的长度
    * @param buf
    * @param l
    * @param len
    * @throws Exception
    */
    public static  void putBcd(ByteBuffer buf, long l, int len) {
        for (int i = DECIMALISM.length - len * 2; i < DECIMALISM.length; i += 2) {
            byte b = 0;
            b = (byte) ((l / DECIMALISM[i] % 10) << 4);
            b |= (l / DECIMALISM[i + 1] % 10);
            buf.put(b);
        }
    }
    /**
     * 把date转成bcd,放入bytebuffer中<br>
     * bcd的格式为yymmddhhmmss
     * @param buf
     * @param date
     * @throws Exception
     */
    public static  void putBcdDate(ByteBuffer buf, Date date){
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        putBcd(buf, c.get(Calendar.YEAR) - 2000, 1);
        putBcd(buf, c.get(Calendar.MONTH) + 1, 1);
        putBcd(buf, c.get(Calendar.DAY_OF_MONTH), 1);
        putBcd(buf, c.get(Calendar.HOUR_OF_DAY), 1);
        putBcd(buf, c.get(Calendar.MINUTE), 1);
        putBcd(buf, c.get(Calendar.SECOND), 1);
    }
    
    /**
     * 把字节数组按16进制转字符串
     * @param buf
     * @return
     * @throws Exception
     */
    public static String hex(byte[] buf){
    	StringBuilder sb = new StringBuilder();
    	 String table = "0123456789ABCDEF";
    	for (int i = 0; i < buf.length; i++) {
    		sb.append(table.charAt(buf[i] >> 4 & 0x0f));
    		sb.append(table.charAt(buf[i] & 0x0f));
    	}
    	return sb.toString();
    }
	/**
	 * byte[]转二进制字符串
	 * @param buf
	 * @return
	 */
	public static String bytes2Hex(byte[] buf) {
        if (null == buf) {
            return "";
        }
        
        StringBuilder s = new StringBuilder();
        for (int i = 0; i < buf.length; ++i) {
            s.append(String.format("%02X ", buf[i]));
        }
        s.deleteCharAt(s.length()-1);
        
        return s.toString().replaceAll(" ", "");
    }
    /**
     * convert hex string to byte array
     * @param msg
     * @return
     */
    public static byte[] hex2Byte(String msg) {
 	   
 	   if (msg == null || msg.isEmpty()){
 		   return null;
 	   }
 	   String data = msg.toUpperCase();
 	   if ((data.length() % 2) != 0){
 		   data = msg + "0";
 	   }
 	   int len = data.length() / 2;
 	   
 	   ByteBuffer buf = ByteBuffer.allocate(len);
 	   for (int i = 0; i < data.length(); i += 2){
 		   int cl = hexChar2Int(data.codePointAt(i));
 		   int cr = hexChar2Int(data.codePointAt(i + 1));
 		   byte b = (byte) ((cl << 4 & 0xF0) | (cr & 0x0F));
 		   buf.put(b);
 	   }
 	   
 	   return buf.array();
    }
    
    /**
     * ASCII code to hex index 'A' -> 10, 'B' -> 11...
     * @param c
     * @return
     */
     public static int hexChar2Int(int c){
  	   if (c >= 0x30 && c <= 0x39){
  		   return c - 0x30;
  	   }
  	   if (c >= 0x41 && c <= 0x46){
  		   return c - 0x37;
  	   }
  	   return 0;
     }
    
}
吧啦蹦吧
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java开源包3
06-28
提供了一个基于对象模型的 ActionScript 字节码，并提供了 ActionScript 字节码统计工具。 Java类重加载工具 JReloader JReloader 是一个用来重新加载class文件而无需重启JVM的工具。 PHPJava Bridge php调用java...
Netty 的内存管理
嘻哈熊的专栏
05-11 275
原文地址 mp.weixin.qq.com 说明 在学习 Netty 的时候，ByteBuf 随处可见，但是如何高效分配 ByteBuf 还是很复杂的，Netty 的池化内存分配这块还是比较难的，很多人学习过，看过但是还是云里雾里的，本篇文章就是主要来讲解：**Netty 分配池化的堆外内存的细节，**期待可以让你明白！！！ 由于为了更好的表达，文章中的图我最少画了 6 小时，画的不熟悉，并且也强调一些细节上。 由于该源码中涉及到大量的二进制操作，建议看看我之前写的 2 篇二进制文章：java 二进制.
Netty写刷数据源码解析
我神级欧文的博客
07-07 659
Netty写刷数据源码解析
netty——数据传输载体ByteBuf 中的getbyte()、getshort()、getint()
愚者
04-26 5830
问题： 目前自学Netty中，正好学到数据传输载体ByteBuf的使用，对于其中的get方法获取到的值不理解。 先输入byte类型的1、2、3、4，再输入int类型的12，最后输入byte类型的5、6。 输出buffer.getByte(3)=4，这个很容易理解，接下来我就懵逼了。 输出buffer.getShort(3)=1024，why？ 输出buffer.getInt(3)=671...
Netty源码解析-ByteBuf基本API
恐龙弟旺仔的博客
12-23 1078
前言： Netty提供了自己的ByteBuffer操作类，名字叫做ByteBuf。相比较而言，ByteBuf的操作相对简单些，也提供了更多的方法来操作字节数组。 1.ByteBuf的基本参数 ByteBuf是一个基本接口，只提供方法，关于其基本参数我们可以参考其最重要的抽象实现类AbstractByteBuf public abstract class AbstractByteBuf extends ByteBuf { // 读索引（该值之前的数据都是已读过的，可读值范...
一句话技巧之: String 快速封装为 ByteBuffer ( Java )
_17708668的专栏
03-16 5201
String str ="内容";ByteBuffer bb = ByteBuffer.wrap( str.getBytes() );/*这语句简单，今后地球人都知道。在哪里最有用？-----当你通过 nio 与 SocketChannel 编写网络服务器，你可能经常需要将字符串发往客户端，然而 SocketChannel.write 方法却需要一个 ByteBuffer 作为参数。*/
java 进阶之路.zip
最新发布
03-14
面试高频算法、akka、多线程、NIO、Netty、SpringBoot、Spark&&Flink 等 Java是一种广泛使用的面向对象的编程语言，由Sun Microsystems公司于1995年5月正式发布。它的设计目标是“一次编写，到处运行...
java开源包1
06-28
提供了一个基于对象模型的 ActionScript 字节码，并提供了 ActionScript 字节码统计工具。 Java类重加载工具 JReloader JReloader 是一个用来重新加载class文件而无需重启JVM的工具。 PHPJava Bridge php调用java...
java开源包10
06-28
提供了一个基于对象模型的 ActionScript 字节码，并提供了 ActionScript 字节码统计工具。 Java类重加载工具 JReloader JReloader 是一个用来重新加载class文件而无需重启JVM的工具。 PHPJava Bridge php调用java...
java开源包11
06-28
提供了一个基于对象模型的 ActionScript 字节码，并提供了 ActionScript 字节码统计工具。 Java类重加载工具 JReloader JReloader 是一个用来重新加载class文件而无需重启JVM的工具。 PHPJava Bridge php调用java...
Netty实现长连接通讯-连接协议为了简单json封装
09-27
Netty实现长连接通讯,连接协议为了简单json封装,如果需要协议变化可以自己封装，有问题可以联系邮箱：[email protected]
netty-tools:netty工具包
05-02
netty-tools netty工具包
InputStream 封装 ByteBuffer
u013628117的博客
04-04 1041
最近，在查阅大文件切分算法时，其中一种算法是：采用nio的内存映射技术，即使用到了nio提供的MappedByteBuffer类，具体就不细讲了；网上资料很多。 当初，自己做的时候，不希望生成多个临时的小文件，而是直接将这个大文件分块上传到文件存储服务器；于是，就有了下面的这个类：ByteBufferInputStream，这个类使用MappedByteBuffer类对象映射到大文件的...
Java字节数组处理工具类-Mina的IoBuffer封装
带着键盘走江湖。。。
05-30 5514
Java字节数组处理工具类-Mina的IoBuffer封装处理网络数据的项目中经常需要处理字节数据，Java的ByteBuffer很强大，但是Mina和Netty两个常用的网络通信框架都拥有自己的数据读取Buffer，分别是IoBuffer和ByteBuff，IoBuffer基于Java原生ByteBuffer封装而成，ByteBuff则是Netty自己独有的字节数据Buffer，可以实现零拷贝。封
Netty Client的简单封装
研究员的自我修养
09-06 2527
Netty Client的简单封装 Netty 基于java NIO 网络通信框架，具有高效、简单、快速的应用特点。 Netty Client NettyClient NettyClientManager public class NettyClient { public static final int Port = 8888; public static final String IP = "192.168.0.100"; private NioEventLoopGrou
netty自定义封包实现
幻神舞的专栏
02-24 881
netty自定义封包
Java NIO学习篇之缓冲区ByteBuffer详解
qq_40837310的博客
05-20 1538
定义： ByteBuffer是Buffer的实现类之一，是一个通用的缓冲区，功能要比其他缓冲区子类多。支持直接内存。是一个抽象类。子类实现是HeapByteBuffer（非直接缓冲区子类），DirectByteBuffer（直接缓冲区子类）。 看此文前建议看看： 关于Buffer可以查看 Java NIO学习篇之缓冲区Buffer详解 直接缓冲区： 以上是书《深入理解Java虚拟机》对直接内存的描述。简单来说直接内存不是JVM内存，而是计算机真正的物理内存。 我们IO中有个步骤是： 读：把内核缓冲
【netty客户端】通过netty实现封装websocket客户端
iaoyou1的博客
12-31 6739
现在网上有很多netty实现的websocket服务端，但是客户端实现的不多，或者说是写的比较散，现写下。
基于 netty 封装的超简单通俗易用 服务端客户端交互框架 《net-framework》原理，源码和使用说明,开箱即用，只需要开发业务逻辑，完全自定义无限扩充 [结尾附github源码]
峡谷电光马仔的博客
11-11 580
基于 netty 封装的超简单通俗易用 服务端客户端交互框架 《net-framework》原理，源码和使用说明,开箱即用，只需要开发业务逻辑，完全自定义无限扩充 [结尾附github源码] 1.聊天室 2.远程控制 3.分布式计算 4.文件传输 5.其他交互场景
netty-nio-client找不到
07-15
如果您无法找到`netty-nio-client`包，可能是因为您没有正确添加Netty NIO客户端的依赖项。请确保您的项目的pom.xml文件中已添加正确的依赖项。 请尝试将以下依赖项添加到您的pom.xml文件中： ```xml ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值