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

本文涉及的产品
全局流量管理 GTM,标准版 1个月
云解析 DNS,旗舰版 1个月
公共DNS(含HTTPDNS解析),每月1000万次HTTP解析
简介: 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'}


相关文章
|
5天前
|
监控 Java 应用服务中间件
高级java面试---spring.factories文件的解析源码API机制
【11月更文挑战第20天】Spring Boot是一个用于快速构建基于Spring框架的应用程序的开源框架。它通过自动配置、起步依赖和内嵌服务器等特性,极大地简化了Spring应用的开发和部署过程。本文将深入探讨Spring Boot的背景历史、业务场景、功能点以及底层原理,并通过Java代码手写模拟Spring Boot的启动过程,特别是spring.factories文件的解析源码API机制。
18 2
|
9天前
|
Java
轻松上手Java字节码编辑:IDEA插件VisualClassBytes全方位解析
本插件VisualClassBytes可修改class字节码,包括class信息、字段信息、内部类,常量池和方法等。
58 6
|
7天前
|
存储 算法 Java
Java Set深度解析:为何它能成为“无重复”的代名词?
Java的集合框架中,Set接口以其“无重复”特性著称。本文解析了Set的实现原理,包括HashSet和TreeSet的不同数据结构和算法,以及如何通过示例代码实现最佳实践。选择合适的Set实现类和正确实现自定义对象的hashCode()和equals()方法是关键。
19 4
|
10天前
|
Java 编译器 数据库连接
Java中的异常处理机制深度解析####
本文深入探讨了Java编程语言中异常处理机制的核心原理、类型及其最佳实践,旨在帮助开发者更好地理解和应用这一关键特性。通过实例分析,揭示了try-catch-finally结构的重要性,以及如何利用自定义异常提升代码的健壮性和可读性。文章还讨论了异常处理在大型项目中的最佳实践,为提高软件质量提供指导。 ####
|
13天前
|
存储 Java 开发者
Java中的集合框架深入解析
【10月更文挑战第32天】本文旨在为读者揭开Java集合框架的神秘面纱,通过深入浅出的方式介绍其内部结构与运作机制。我们将从集合框架的设计哲学出发,探讨其如何影响我们的编程实践,并配以代码示例,展示如何在真实场景中应用这些知识。无论你是Java新手还是资深开发者,这篇文章都将为你提供新的视角和实用技巧。
12 0
|
10天前
|
安全 Java 测试技术
Java并行流陷阱:为什么指定线程池可能是个坏主意
本文探讨了Java并行流的使用陷阱,尤其是指定线程池的问题。文章分析了并行流的设计思想,指出了指定线程池的弊端,并提供了使用CompletableFuture等替代方案。同时,介绍了Parallel Collector库在处理阻塞任务时的优势和特点。
|
19天前
|
安全 Java
java 中 i++ 到底是否线程安全?
本文通过实例探讨了 `i++` 在多线程环境下的线程安全性问题。首先,使用 100 个线程分别执行 10000 次 `i++` 操作,发现最终结果小于预期的 1000000,证明 `i++` 是线程不安全的。接着,介绍了两种解决方法:使用 `synchronized` 关键字加锁和使用 `AtomicInteger` 类。其中,`AtomicInteger` 通过 `CAS` 操作实现了高效的线程安全。最后,通过分析字节码和源码,解释了 `i++` 为何线程不安全以及 `AtomicInteger` 如何保证线程安全。
java 中 i++ 到底是否线程安全?
|
7天前
|
安全 Java 开发者
深入解读JAVA多线程:wait()、notify()、notifyAll()的奥秘
在Java多线程编程中,`wait()`、`notify()`和`notifyAll()`方法是实现线程间通信和同步的关键机制。这些方法定义在`java.lang.Object`类中,每个Java对象都可以作为线程间通信的媒介。本文将详细解析这三个方法的使用方法和最佳实践,帮助开发者更高效地进行多线程编程。 示例代码展示了如何在同步方法中使用这些方法,确保线程安全和高效的通信。
27 9
|
10天前
|
存储 安全 Java
Java多线程编程的艺术:从基础到实践####
本文深入探讨了Java多线程编程的核心概念、应用场景及其实现方式,旨在帮助开发者理解并掌握多线程编程的基本技能。文章首先概述了多线程的重要性和常见挑战,随后详细介绍了Java中创建和管理线程的两种主要方式:继承Thread类与实现Runnable接口。通过实例代码,本文展示了如何正确启动、运行及同步线程,以及如何处理线程间的通信与协作问题。最后,文章总结了多线程编程的最佳实践,为读者在实际项目中应用多线程技术提供了宝贵的参考。 ####
|
6天前
|
监控 安全 Java
Java中的多线程编程:从入门到实践####
本文将深入浅出地探讨Java多线程编程的核心概念、应用场景及实践技巧。不同于传统的摘要形式,本文将以一个简短的代码示例作为开篇,直接展示多线程的魅力,随后再详细解析其背后的原理与实现方式,旨在帮助读者快速理解并掌握Java多线程编程的基本技能。 ```java // 简单的多线程示例:创建两个线程,分别打印不同的消息 public class SimpleMultithreading { public static void main(String[] args) { Thread thread1 = new Thread(() -> System.out.prin

推荐镜像

更多