java实现PBOC的TLV格式解析,超简单的解析(全互联网最简单)

本文涉及的产品
公共DNS(含HTTPDNS解析),每月1000万次HTTP解析
全局流量管理 GTM,标准版 1个月
云解析 DNS,旗舰版 1个月
简介: java实现PBOC的TLV格式解析,超简单的解析(全互联网最简单)

简介下TLV:


PBOC基本信息数据采用TLV(tag-length-value)的表示方式,即每项由tag标签(T),长度(L)和取值(V)构成。


标签:


 tag标签的属性为bit,由16进制表示,占1~2个字节长度。若tag标签的第一个字节(注:字节排序方向为从左往右数(b8~b0),第一个字节即为最左边的字节。bit排序规则同理。)的后四个bit为“1111”,则说明该tag占两个字节,例如“9F33”;否则占一个字节,例如“95”。b8和b7两位标识tag所属类别. 这个可以暂时不用理.  b6决定当前的TLV数据是一个单一的数据和复合结构的数据. 复合的TLV是指value域里也包含一个或多个TLV, 类似嵌套的编码格式. b5~b1如果全为1,则说明这个tag下面还有一个子字节. 占两个字节, 否则tag占一个字节。


长度:


 长度(即L本身)的属性也为bit,占1~3个字节长度。具体编码规则如下:


 a)当L字段最左边字节的最左bit位(即bit8)为0,表示该L字段占一个字节,它的后续7个bit位(即bit7~bit1)表示取值的长度,采用二进制数表示取值长度的十进制数。


 b)当L字段最左边字节的最左bit位(即bit8)为1,表示该L字段不止占一个字节,那么它到底占几个字节由该最左字节的后续7个bit位(即bit7~bit1)的十进制取值表示。例如,若最左字节为10000010,表示L字段除该字节外,后面还有两个字节。其后续字节的十进制取值表示取值的长度。


附: java版的TLV解析:



package com.example.yang.myapplication.ans8583;
import java.util.ArrayList;
import java.util.List;
import static com.example.yang.myapplication.ans8583.Easy8583Ans.bytesToHexString;
import static com.example.yang.myapplication.ans8583.Easy8583Ans.hexStringToBytes;
import static java.lang.System.arraycopy;
/**
 * Created by yangyongzhen on 2018/07/07
 * simple TLV format Analysis
 * qq:534117529
 */
public class TlvAns {
    class Tag{
        String tag;
        String length;
        String value;
        @Override
        public String toString() {
            return "Tag{" +
                    "tag='" + tag + '\'' +
                    ", length='" + length + '\'' +
                    ", value='" + value + '\'' +
                    '}';
        }
    }
    Tag tag;
    List<Tag> tags;
    public TlvAns(){
        tags = new ArrayList<>();
    }
    void printTags(List<Tag> tags){
        for(Tag tag : tags){
            System.out.println(tag.toString());
        }
    }
    int pbocTlvAns( byte[] rxbuf, int rxsize )
    {
        int cout=0,n=0,num=0;
        //===========================================TLV解析
        while( cout < rxsize ) {
            if( ( ( (rxbuf[cout]&0xff) & 0x1F ) == 0x1F ) ) {
                //2字节Tag
                if( ( (rxbuf[cout]&0xff) == 0xBF ) && ( (rxbuf[cout+1]&0xff) == 0x0C ) ) {
                    //=================================//模板
                    //模板里的数据还需要进一步解析
                    num = 0;
                }
                else {
                    //=================================//标签
                    num = 1;
                }
                tag = new Tag();
                tag.tag = String .format("%02x%02x",(rxbuf[cout]&0xff),(rxbuf[cout+1]&0xff));
                cout += 2;
                if( ( (rxbuf[cout]&0xff) & 0x80 ) == 0x80 ) {
                    //=============================//长度为非1字节
                    switch( (rxbuf[cout]&0xff) & 0x7F ) {
                        //目前只处理最多2字节
                        case 1:
                            n = (rxbuf[cout+1]&0xff);
                            tag.length = String.format("%02x%02x",(rxbuf[cout]&0xff),(rxbuf[cout+1]&0xff));
                            cout += 2;
                            break;
                        case 2:
                            n = ( ( (rxbuf[cout+1]&0xff) << 8 ) & 0xFF00 ) | (rxbuf[cout+2]&0xff);
                            tag.length = String.format("%02x%02x%02x",rxbuf[cout]&0xff,rxbuf[cout+1]&0xff,rxbuf[cout+2]&0xff);
                            cout += 3;
                            break;
                        // case 3:
                        //n = ( ( rxbuf[cout+1] << 16 ) & 0xFF0000 ) | ( ( rxbuf[cout+2] << 8 ) & 0xFF00 ) | rxbuf[cout+3];
                        //cout += 4;
                        //break;
                        default:
                            //ErrMsg((U08*)"L解析错误\r\n",strlen("L解析错误\r\n") );
                            return 40;
                    }
                }
                else {
                    //=============================//长度为1字节
                    n = (rxbuf[cout]&0xff);
                    tag.length = String.format("%02x",n);
                    cout += 1;
                }
                byte[] buffer = new byte[n];
                arraycopy(rxbuf,cout,buffer,0,n);
                tag.value = bytesToHexString(buffer);
                tags.add(tag);
                if( num == 0 ) {
                    //=================================//模板
                    //模板里的数据还需要进一步解析
                }
                else {
                    //=================================//标签
                    cout += n;
                }
            }
            else {
                //1字节T
                if( ( (rxbuf[cout]&0xff) >= 0x61 ) && ( (rxbuf[cout]&0xff) <= 0x7F ) )
                {//=================================//模板
                    //模板里的数据还需要进一步解析
                    num = 0;
                }
                else if( ( (rxbuf[cout]&0xff) == 0x80 ) || ( (rxbuf[cout]&0xff) == 0xA5 ) ) {
                    //=================================//模板
                    //模板里的数据还需要进一步解析
                    num = 0;
                }
                else {
                    //=================================//标签
                    num = 1;
                }
                tag = new Tag();
                tag.tag = String .format("%02x",(rxbuf[cout]&0xff));
                cout++;
                if( ( (rxbuf[cout]&0xff) & 0x80 ) == 0x80 ) {
                    //=============================//长度为非1字节
                    switch( (rxbuf[cout]&0xff) & 0x7F ) {
                        //目前只处理最多2字节
                        case 1:
                            n = (rxbuf[cout+1]&0xff);
                            tag.length = String.format("%02x%02x",(rxbuf[cout]&0xff),(rxbuf[cout+1]&0xff));
                            cout += 2;
                            break;
                        case 2:
                            n = ( ( rxbuf[cout+1] << 8 ) & 0xFF00 ) | rxbuf[cout+2];
                            tag.length = String.format("%02x%02x%02x",(rxbuf[cout]&0xff),(rxbuf[cout+1]&0xff),(rxbuf[cout+2]&0xff));
                            cout += 3;
                            break;
                        // case 3:
                        //n = ( ( rxbuf[cout+1] << 16 ) & 0xFF0000 ) | ( ( rxbuf[cout+2] << 8 ) & 0xFF00 ) | rxbuf[cout+3];
                        //cout += 4;
                        //break;
                        default:
                            //ErrMsg((U08*)"L解析错误\r\n",strlen("L解析错误\r\n") );
                            return 40;
                    }
                }
                else {
                    //=============================//长度为1字节
                    n = (rxbuf[cout]&0xff);
                    tag.length = String.format("%02x",n);
                    cout += 1;
                }
                byte[] buffer = new byte[n];
                arraycopy(rxbuf,cout,buffer,0,n);
                tag.value = bytesToHexString(buffer);
                tags.add(tag);
                if( num == 0 ) {
                    //=================================//模板
                    //模板里的数据还需要进一步解析
                }
                else {
                    //=================================//标签
                    cout += n;
                }
            }
        }
        return 0;
    }
    public static void main(String[] args) {
        String hexstr = "776882027C009F3602004E57136212264200008234827D25062204329991635F9F101307010103A00000010A01000000000079B281999F2608DE242036EBF1B10B5F3401019F6C0220009F5D060000000000005F20142020202020202020202020202020202020202020";
        byte[] hexdata = hexStringToBytes(hexstr);
        TlvAns tlvAns = new TlvAns();
        //开始解析:
        tlvAns.pbocTlvAns(hexdata,hexdata.length);
        //打印出解析结果:
        tlvAns.printTags(tlvAns.tags);
    }
}


输出结果:


Tag{tag='77',length='68', value='82027c009f3602004e57136212264200008234827d25062204329991635f9f101307010103a00000010a01000000000079b281999f2608de242036ebf1b10b5f3401019f6c0220009f5d060000000000005f20142020202020202020202020202020202020202020'}
Tag{tag='82', length='02', value='7c00'}
Tag{tag='9f36', length='02', value='004e'}
Tag{tag='57', length='13', value='6212264200008234827d25062204329991635f'}
Tag{tag='9f10', length='13', value='07010103a00000010a01000000000079b28199'}
Tag{tag='9f26', length='08', value='de242036ebf1b10b'}
Tag{tag='5f34', length='01', value='01'}
Tag{tag='9f6c', length='02', value='2000'}
Tag{tag='9f5d', length='06', value='000000000000'}
Tag{tag='5f20', length='14', value='2020202020202020202020202020202020202020'}


相关文章
|
3天前
|
人工智能 搜索推荐 API
Cobalt:开源的流媒体下载工具,支持解析和下载全平台的视频、音频和图片,支持多种视频质量和格式,自动提取视频字幕
cobalt 是一款开源的流媒体下载工具,支持全平台视频、音频和图片下载,提供纯净、简洁无广告的体验
73 9
Cobalt:开源的流媒体下载工具,支持解析和下载全平台的视频、音频和图片,支持多种视频质量和格式,自动提取视频字幕
|
3天前
|
人工智能 自然语言处理 Java
FastExcel:开源的 JAVA 解析 Excel 工具,集成 AI 通过自然语言处理 Excel 文件,完全兼容 EasyExcel
FastExcel 是一款基于 Java 的高性能 Excel 处理工具,专注于优化大规模数据处理,提供简洁易用的 API 和流式操作能力,支持从 EasyExcel 无缝迁移。
46 9
FastExcel:开源的 JAVA 解析 Excel 工具,集成 AI 通过自然语言处理 Excel 文件,完全兼容 EasyExcel
|
10天前
|
存储 缓存 Java
Java 并发编程——volatile 关键字解析
本文介绍了Java线程中的`volatile`关键字及其与`synchronized`锁的区别。`volatile`保证了变量的可见性和一定的有序性,但不能保证原子性。它通过内存屏障实现,避免指令重排序,确保线程间数据一致。相比`synchronized`,`volatile`性能更优,适用于简单状态标记和某些特定场景,如单例模式中的双重检查锁定。文中还解释了Java内存模型的基本概念,包括主内存、工作内存及并发编程中的原子性、可见性和有序性。
Java 并发编程——volatile 关键字解析
|
4天前
|
缓存 边缘计算 网络协议
深入解析CDN技术:加速互联网内容分发的幕后英雄
内容分发网络(CDN)是现代互联网架构的重要组成部分,通过全球分布的服务器节点,加速网站、应用和多媒体内容的传递。它不仅提升了访问速度和用户体验,还减轻了源站服务器的负担。CDN的核心技术包括缓存机制、动态加速、流媒体加速和安全防护,广泛应用于静态资源、动态内容、视频直播及大文件下载等场景,具有低延迟、高带宽、稳定性强等优势,有效降低成本并保障安全。
25 3
|
8天前
|
Java 数据库连接 Spring
反射-----浅解析(Java)
在java中,我们可以通过反射机制,知道任何一个类的成员变量(成员属性)和成员方法,也可以堆任何一个对象,调用这个对象的任何属性和方法,更进一步我们还可以修改部分信息和。
|
1月前
|
存储 算法 Java
Java内存管理深度解析####
本文深入探讨了Java虚拟机(JVM)中的内存分配与垃圾回收机制,揭示了其高效管理内存的奥秘。文章首先概述了JVM内存模型,随后详细阐述了堆、栈、方法区等关键区域的作用及管理策略。在垃圾回收部分,重点介绍了标记-清除、复制算法、标记-整理等多种回收算法的工作原理及其适用场景,并通过实际案例分析了不同GC策略对应用性能的影响。对于开发者而言,理解这些原理有助于编写出更加高效、稳定的Java应用程序。 ####
|
1月前
|
存储 监控 算法
Java虚拟机(JVM)垃圾回收机制深度解析与优化策略####
本文旨在深入探讨Java虚拟机(JVM)的垃圾回收机制,揭示其工作原理、常见算法及参数调优方法。通过剖析垃圾回收的生命周期、内存区域划分以及GC日志分析,为开发者提供一套实用的JVM垃圾回收优化指南,助力提升Java应用的性能与稳定性。 ####
|
2月前
|
监控 Java 应用服务中间件
高级java面试---spring.factories文件的解析源码API机制
【11月更文挑战第20天】Spring Boot是一个用于快速构建基于Spring框架的应用程序的开源框架。它通过自动配置、起步依赖和内嵌服务器等特性,极大地简化了Spring应用的开发和部署过程。本文将深入探讨Spring Boot的背景历史、业务场景、功能点以及底层原理,并通过Java代码手写模拟Spring Boot的启动过程,特别是spring.factories文件的解析源码API机制。
87 2
|
10天前
|
存储 设计模式 算法
【23种设计模式·全精解析 | 行为型模式篇】11种行为型模式的结构概述、案例实现、优缺点、扩展对比、使用场景、源码解析
行为型模式用于描述程序在运行时复杂的流程控制,即描述多个类或对象之间怎样相互协作共同完成单个对象都无法单独完成的任务,它涉及算法与对象间职责的分配。行为型模式分为类行为模式和对象行为模式,前者采用继承机制来在类间分派行为,后者采用组合或聚合在对象间分配行为。由于组合关系或聚合关系比继承关系耦合度低,满足“合成复用原则”,所以对象行为模式比类行为模式具有更大的灵活性。 行为型模式分为: • 模板方法模式 • 策略模式 • 命令模式 • 职责链模式 • 状态模式 • 观察者模式 • 中介者模式 • 迭代器模式 • 访问者模式 • 备忘录模式 • 解释器模式
【23种设计模式·全精解析 | 行为型模式篇】11种行为型模式的结构概述、案例实现、优缺点、扩展对比、使用场景、源码解析
|
10天前
|
设计模式 存储 安全
【23种设计模式·全精解析 | 创建型模式篇】5种创建型模式的结构概述、实现、优缺点、扩展、使用场景、源码解析
结构型模式描述如何将类或对象按某种布局组成更大的结构。它分为类结构型模式和对象结构型模式,前者采用继承机制来组织接口和类,后者釆用组合或聚合来组合对象。由于组合关系或聚合关系比继承关系耦合度低,满足“合成复用原则”,所以对象结构型模式比类结构型模式具有更大的灵活性。 结构型模式分为以下 7 种: • 代理模式 • 适配器模式 • 装饰者模式 • 桥接模式 • 外观模式 • 组合模式 • 享元模式
【23种设计模式·全精解析 | 创建型模式篇】5种创建型模式的结构概述、实现、优缺点、扩展、使用场景、源码解析

推荐镜像

更多