Java版ISO8583 报文解析解组包工具(Java版)

最新推荐文章于 2024-08-02 07:04:21 发布
最新推荐文章于 2024-08-02 07:04:21 发布
阅读量5.5k 收藏 18
点赞数 5
分类专栏： Java类库 文章标签： ISO8583 8583 报文协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010979642/article/details/88779101
版权

文章目录

maven引入

<dependency>
    <groupId>io.gitee.jaemon</groupId>
    <artifactId>commons-toolkit</artifactId>
    <version>1.0.0</version>
</dependency>

说明： 项目中引入jar包依赖后，直接执行下面的测试演示测试方法即可， 部分代码展示 部分只用来做展示， jar包中已经包含了完整的代码。

 

部分代码展示

1. ISO8583字段域注解类

/**
 * ISO8583字段域注解类
 */
@Target({ElementType.FIELD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface ISO8583Annotation {

    /**
     * 域索引  MUST
     * */
    int fldIndex();

    /**
     * 数据域长度    MUST
     * */
    int dataFldLength();

    /**
     * 域编码规则(ASCII/BCD/HEX/BINARY)   MUST
     * */
    String encodeRule();

    /**
     * 域字段标识(0: 不用 1: 长度固定 2: 2位变长 3: 3位变长)  MUST
     * */
    String fldFlag();

    /**
     * 域长度编码规则(ASCII/BCD[默认]/HEX/BINARY)
     * */
    String lenEncodeRule() default "BCD";

    /**
     * 域填充规则(NONE(默认)/AFTER/BEFORE)
     * */
    String fillRule() default "NONE";

    /**
     * 域填充字符,十六进制ASSIC码(0:30, 空格:20)
     * */
    String fillChar() default "";

    /**
     * 域默认值
     * */
    String defalutValue() default "";
}

 

2. 报文交互 DTO

/**
 * 报文交互 DTO
 */
 @Data
public class ISO8583 {

    /** 2域 */
    @ISO8583Annotation(
            fldIndex = 2, dataFldLength = 19, encodeRule = "BCD", fldFlag = "2"
    )
    private String cardNo02;

    /** 3域 */
    @ISO8583Annotation(
            fldIndex = 3, dataFldLength = 6, encodeRule = "BCD", fldFlag = "1",
            fillRule = "BEFORE", fillChar = "30"
    )
    private String transProcCode03;

    /** 4域 */
    @ISO8583Annotation(
            fldIndex = 4, dataFldLength = 12, encodeRule = "BCD", fldFlag = "1",
            fillRule = "BEFORE", fillChar = "30"
    )
    private String transAmt04;

    /** 11域 */
    @ISO8583Annotation(
            fldIndex = 11, dataFldLength = 6, encodeRule = "BCD", fldFlag = "1",
            fillRule = "BEFORE", fillChar = "30"
    )
    private String sysTrackNo11;

    /** 12域 */
    @ISO8583Annotation(
            fldIndex = 12, dataFldLength = 6, encodeRule = "BCD", fldFlag = "1",
            fillRule = "BEFORE", fillChar = "30"
    )
    private String locTime12;

    /** 13域 */
    @ISO8583Annotation(
            fldIndex = 13, dataFldLength = 4, encodeRule = "BCD", fldFlag = "1",
            fillRule = "BEFORE", fillChar = "30"
    )
    private String locDate13;

    /** 14域 */
    @ISO8583Annotation(
            fldIndex = 14, dataFldLength = 4, encodeRule = "BCD", fldFlag = "1",
            fillRule = "BEFORE", fillChar = "30"
    )
    private String expireDate14;

    /** 15域 */
    @ISO8583Annotation(
            fldIndex = 15, dataFldLength = 4, encodeRule = "BCD", fldFlag = "1",
            fillRule = "BEFORE", fillChar = "30"
    )
    private String liquidatimeDate15;

    /** 22域 */
    @ISO8583Annotation(
            fldIndex = 22, dataFldLength = 3, encodeRule = "BCD", fldFlag = "1",
            fillRule = "BEFORE", fillChar = "30"
    )
    private String serviceInputModeCode22;

    /** 23域 */
    @ISO8583Annotation(
            fldIndex = 23, dataFldLength = 3, encodeRule = "BCD", fldFlag = "1",
            fillRule = "BEFORE", fillChar = "30"
    )
    private String cardSerialNo23;

    /** 25域 */
    @ISO8583Annotation(
            fldIndex = 25, dataFldLength = 2, encodeRule = "BCD", fldFlag = "1",
            fillRule = "BEFORE", fillChar = "30"
    )
    private String serviceConditionCode25;

    /** 26域 */
    @ISO8583Annotation(
            fldIndex = 26, dataFldLength = 2, encodeRule = "BCD", fldFlag = "1",
            fillRule = "BEFORE", fillChar = "30"
    )
    private String servicePINAccessCode26;

    /** 32域 */
    @ISO8583Annotation(
            fldIndex = 32, dataFldLength = 11, encodeRule = "BCD", fldFlag = "2",
            defalutValue = ""
    )
    private String acquirerMarkCode32;

    /** 35域 */
    @ISO8583Annotation(
            fldIndex = 35, dataFldLength = 37, encodeRule = "BCD", fldFlag = "2"
    )
    private String track2Data35;

    /** 36域 */
    @ISO8583Annotation(
            fldIndex = 36, dataFldLength = 999, encodeRule = "BCD", fldFlag = "3"
    )
    private String track3Data36;

    /** 37域 */
    @ISO8583Annotation(
            fldIndex = 37, dataFldLength = 12, encodeRule = "ASCII", fldFlag = "1",
            fillRule = "AFTER", fillChar = "20"
    )
    private String retrievalReferenceNo37;

    /** 38域 */
    @ISO8583Annotation(
            fldIndex = 38, dataFldLength = 6, encodeRule = "ASCII", fldFlag = "1",
            fillRule = "AFTER", fillChar = "20"
    )
    private String authIdentityRespCode38;

    /** 39域 */
    @ISO8583Annotation(
            fldIndex = 39, dataFldLength = 2, encodeRule = "ASCII", fldFlag = "1",
            fillRule = "AFTER", fillChar = "20"
    )
    private String respCode39;

    /** 40域 */
    @ISO8583Annotation(
            fldIndex = 40, dataFldLength = 99, encodeRule = "ASCII", fldFlag = "2"
    )
    private String respDesc40;

    /** 41域 */
    @ISO8583Annotation(
            fldIndex = 41, dataFldLength = 18, encodeRule = "ASCII", fldFlag = "1",
            fillRule = "AFTER", fillChar = "20"
    )
    private String cardAcceptorTerminalID41;

    /** 42域 */
    @ISO8583Annotation(
            fldIndex = 42, dataFldLength = 15, encodeRule = "ASCII", fldFlag = "1",
            fillRule = "AFTER", fillChar = "20"
    )
    private String cardAcceptorID42;

    /** 44域 */
    @ISO8583Annotation(
            fldIndex = 44, dataFldLength = 25, encodeRule = "ASCII", fldFlag = "2"
    )
    private String additionalRespData44;

    /** 48域 */
    @ISO8583Annotation(
            fldIndex = 48, dataFldLength = 322, encodeRule = "BCD", fldFlag = "3"
    )
    private String additionalDataPrivate48;

    /** 49域 */
    @ISO8583Annotation(
            fldIndex = 49, dataFldLength = 3, encodeRule = "ASCII", fldFlag = "1",
            fillRule = "AFTER", fillChar = "20"
    )
    private String currencyCode49;

    /** 52域 */
    @ISO8583Annotation(
            fldIndex = 52, dataFldLength = 8, encodeRule = "BINARY", fldFlag = "1",
            fillRule = "BEFORE", fillChar = "30"
    )
    private String personalIDCodeData52;

    /** 53域 */
    @ISO8583Annotation(
            fldIndex = 53, dataFldLength = 16, encodeRule = "BCD", fldFlag = "1",
            fillRule = "BEFORE", fillChar = "30"
    )
    private String safeControlInfo53;

    /** 54域 */
    @ISO8583Annotation(
            fldIndex = 54, dataFldLength = 256, encodeRule = "ASCII", fldFlag = "3"
    )
    private String additionalAmt54;

    /** 55域 */
    @ISO8583Annotation(
            fldIndex = 55, dataFldLength = 512, encodeRule = "ASCII", fldFlag = "3"
    )
    private String ICCardDataDomain55;

    /** 57域 */
    @ISO8583Annotation(
            fldIndex = 57, dataFldLength = 999, encodeRule = "ASCII", fldFlag = "3"
    )
    private String fld57Domain57;

    /** 58域 */
    @ISO8583Annotation(
            fldIndex = 58, dataFldLength = 512, encodeRule = "BINARY", fldFlag = "3"
    )
    private String eWalletTransInfo58;

    /** 60域 */
    @ISO8583Annotation(
            fldIndex = 60, dataFldLength = 17, encodeRule = "BCD", fldFlag = "3"
    )
    private String fld60Domain60;

    /** 61域 */
    @ISO8583Annotation(
            fldIndex = 61, dataFldLength = 29, encodeRule = "BCD", fldFlag = "3"
    )
    private String originalInfoDomain61;

    /** 62域 */
    @ISO8583Annotation(
            fldIndex = 62, dataFldLength = 999, encodeRule = "BINARY", fldFlag = "3"
    )
    private String fld62Domain62;

    /** 63域 */
    @ISO8583Annotation(
            fldIndex = 63, dataFldLength = 512, encodeRule = "ASCII", fldFlag = "3"
    )
    private String fld63Domain63;

    /** 64域 */
    @ISO8583Annotation(
            fldIndex = 64, dataFldLength = 8, encodeRule = "ASCII", fldFlag = "1",
            fillRule = "BEFORE", fillChar = "20", defalutValue = "0000000000000000"
    )
    private String mac64;
}

 

3. ISO8583 报文组/解包工具类

/**
 * ISO8583报文组/解包工具类
 */
public class TransISO8583MessageUtil {
    private final static String CHARSET = "GBK";

    /** 不用 */
    private final static String FLD_LENGTH_FLAG_0 = "0";
    /** 长度固定 */
    private final static String FLD_LENGTH_FLAG_1 = "1";
    /** 2位变长 */
    private final static String FLD_LENGTH_FLAG_2 = "2";
    /** 3位变长 */
    private final static String FLD_LENGTH_FLAG_3 = "3";

    /** BCD */
    private final static String ENCODE_RULE_BCD = "BCD";
    /** HEX */
    private final static String ENCODE_RULE_HEX = "HEX";
    /** BINARY */
    private final static String ENCODE_RULE_BINARY = "BINARY";

    /** 前补 */
    private final static String FILL_RULE_BEFORE = "BEFORE";
    /** 后补 */
    private final static String FILL_RULE_AFTER = "AFTER";

    /** ASCII */
    private final static String LEN_ENCODE_RULE_ASCII = "ASCII";
    /** BCD */
    private final static String LEN_ENCODE_RULE_BCD = "BCD";
    /** HEX */
    private final static String LEN_ENCODE_RULE_HEX = "HEX";
    /** BINARY */
    private final static String LEN_ENCODE_RULE_BINARY = "BINARY";


    /**
     * ISO8583报文组包
     * @param obj               组包对象
     * @param bitmap            位图(十六进制表示法)
     * @param tpdu              tpdu
     * @param msgHead           报文头
     * @param msgType           消息类型
     * @exception Exception .
     * */
    public static String packISO8583(Object obj, String bitmap, String tpdu, String msgHead, String msgType)
            throws Exception {
        StringBuilder sendMsg = new StringBuilder();
        sendMsg.append(tpdu).append(msgHead).append(msgType).append(bitmap);
        // 位图十六进制转二进制
        bitmap = NumberStringUtil.byteToBinary(NumberStringUtil.hexStringToBytes(bitmap));
        Map<Integer, String> iso8583FldMap = obtISO8583FldMap(obj.getClass());

        String currentFld = "";
        for (int i = 0; i < bitmap.length(); i++) {
            if ("1".equals(bitmap.substring(i, i + 1))) {
                currentFld = iso8583FldMap.get(i + 1);
                String fldHexValue = getFldHexValue(obj, currentFld);
                sendMsg.append(fldHexValue);
            }
        }
        // 计算报文长度
        sendMsg.insert(0, NumberStringUtil.addLeftZero(Integer.toHexString(NumberStringUtil.hexStringToBytes(sendMsg.toString()).length).toUpperCase(), 4));

        return sendMsg.toString();
    }


    /**
     * ISO8583报文解包
     * @param clazz             解包对象的类名
     * @param recvMsg           接收报文字符串
     * @return Object           返回解包生成的对象信息
     * @exception Exception .
     * */
    public static Object unpackISO8583(Class clazz, String recvMsg)
            throws Exception {
        return unpackISO8583(clazz.getName(), recvMsg);
    }


    /**
     * ISO8583报文解包
     * @param className         解包对象的类名
     * @param recvMsg           接收报文字符串
     * @return Object           返回解包生成的对象信息
     * @exception Exception .
     * */
    public static Object unpackISO8583(String className, String recvMsg)
            throws Exception {
        recvMsg = recvMsg.substring(30, recvMsg.length());
        byte[] recvMsgByte = NumberStringUtil.hexStringToBytes(recvMsg);
        // 字节数据索引位置
        int index = 0;
        int[] indexArr = new int[1];
        // 位元表,获取前八个字节
        byte[] bitTable = NumberStringUtil.getBytes(recvMsgByte, index, 8);
        String bitTableBinary = NumberStringUtil.byteToBinary(bitTable);
        // 判断第一位如果是0,则为64域,为1则为128域(需再获取8个字节)
        if ("1".equals(bitTableBinary.substring(0, 1))) {
            bitTable = NumberStringUtil.getBytes(recvMsgByte, index, 16);
            index += 16;
            bitTableBinary = NumberStringUtil.byteToBinary(bitTable);
        } else {
            index += 8;
        }
        Class<?> clazz = Class.forName(className);
        Object obj = clazz.newInstance();
        Map<Integer, String> iso8583FldMap = obtISO8583FldMap(clazz);

        String currentFld;
        indexArr[0] = index;
        for (int i = 1; i < bitTableBinary.length(); i++) {
            // 位元表值等1的说明存在该域
            if ("1".equals(bitTableBinary.substring(i, i + 1))) {
                currentFld = iso8583FldMap.get(i + 1);
                String fldValue = getFldValue(clazz, currentFld, recvMsgByte, indexArr);
                setFldValue(obj, currentFld, fldValue);
            }
        }
        return obj;
    }


    /**
     * 获取实体类中位索引域和字段的关系表 PACK&UNPACK
     * @param clazz             类名
     * @exception ClassNotFoundException .
     * */
    private static Map<Integer, String> obtISO8583FldMap(Class clazz)
            throws ClassNotFoundException {
        Map<Integer, String> map = new HashMap<>();
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            boolean fldHasAnnotation = field.isAnnotationPresent(ISO8583Annotation.class);
            if (fldHasAnnotation) {
                ISO8583Annotation fldAnnotation = field.getAnnotation(ISO8583Annotation.class);
                map.put(fldAnnotation.fldIndex(), field.getName());
            }
        }
        return map;
    }


    /**
     * 字段值转十六进制字符串 PACK
     * @param obj               组包对象
     * @param fldName           字段名
     * @exception Exception .
     * */
    private static String getFldHexValue(Object obj, String fldName)
            throws Exception {
        PropertyDescriptor propertyDescriptor = new PropertyDescriptor(fldName, obj.getClass());
        String fldValue = (String) propertyDescriptor.getReadMethod().invoke(obj);

        Field field = obj.getClass().getDeclaredField(fldName);
        boolean fldHasAnnotation = field.isAnnotationPresent(ISO8583Annotation.class);
        if (fldHasAnnotation) {
            ISO8583Annotation fldAnnotation = field.getAnnotation(ISO8583Annotation.class);
            String defaultValue = fldAnnotation.defalutValue();
            // 如果设置了默认值, 使用默认值
            if (StringUtils.isNotEmpty(defaultValue)) {
                fldValue = defaultValue;
            } else {
                fldValue = transToHexValue(fldAnnotation, fldValue);
            }
        }
        return fldValue;
    }


    /**
     * 组包时根据字段原值按照其配置规则转为十六进制 PACK
     * @param iso8583Annotation ISO8583字段包含的注解对象信息
     * @param fldValue          字段值
     * @exception Exception .
     * */
    private static String transToHexValue(ISO8583Annotation iso8583Annotation, String fldValue)
            throws Exception {
        byte[] fldValueBytes = null;
        String fldFlag = iso8583Annotation.fldFlag();
        String encodeRule = iso8583Annotation.encodeRule();
        int dataLength = iso8583Annotation.dataFldLength();
        String fillRule = iso8583Annotation.fillRule();
        String fillChar = iso8583Annotation.fillChar();
        String lenEncodeRule = iso8583Annotation.lenEncodeRule();

        // 固定长度
        if (FLD_LENGTH_FLAG_1.equals(fldFlag)) {
            int dataLen = (ENCODE_RULE_BINARY.equals(encodeRule)) ? dataLength * 2 : dataLength;
            fldValue = NumberStringUtil.getByteLengthStr(fldValue, dataLen, CHARSET);

            // 前补
            if (FILL_RULE_BEFORE.equals(fillRule)) {
                String lpad = new String(NumberStringUtil.hexStringToBytes(fillChar), CHARSET);
                fldValue = NumberStringUtil.addLeftChar(fldValue, dataLength, lpad.charAt(0), CHARSET);
            // 后补
            } else if (FILL_RULE_AFTER.equals(fillRule)) {
                String rpad = new String(NumberStringUtil.hexStringToBytes(fillChar), CHARSET);
                fldValue = NumberStringUtil.addRightChar(fldValue, dataLength, rpad.charAt(0), CHARSET);
            }

            // 根据域编码规则,把数据转换
            fldValueBytes = fieldEncodeRule(fldValue, CHARSET, encodeRule);

            // 2位和3位变长
        } else if (FLD_LENGTH_FLAG_2.equals(fldFlag) || FLD_LENGTH_FLAG_3.equals(fldFlag)) {
            int fixLength = fldValue.getBytes(CHARSET).length;
            if (ENCODE_RULE_BINARY.equals(encodeRule)) {
                fixLength = (fixLength + 1) / 2;
            }
            int fldLenSize = (FLD_LENGTH_FLAG_2.equals(fldFlag)) ? 1 : 2;

            byte[] lengthByte = null;
            // 根据域长度编码规则,把数据长度头转换
            if (LEN_ENCODE_RULE_ASCII.equals(lenEncodeRule)) {
                lengthByte = NumberStringUtil.addLeftZero(
                        Integer.toString(fixLength), Integer.parseInt(Integer.toString(fldLenSize))).getBytes(CHARSET);
            } else if (LEN_ENCODE_RULE_BCD.equals(lenEncodeRule)) {
                int fldLenSizeTmp = fldLenSize * 2;
                lengthByte = NumberStringUtil.hexStringToBytes(
                        NumberStringUtil.addLeftZero(Integer.toString(fixLength), fldLenSizeTmp));
            } else if (LEN_ENCODE_RULE_HEX.equals(lenEncodeRule)) {
                int fldLenSizeTmp = fldLenSize * 2;
                lengthByte = NumberStringUtil.hexStringToBytes(
                        NumberStringUtil.addLeftZero(Integer.toHexString(fixLength), fldLenSizeTmp));
            } else {
                // 没有域长度编码规则信息抛异常
                throw new AIException("[AI]Error of lenEncodeRule.");
            }
            // 根据域编码规则,把数据转换
            fldValueBytes = fieldEncodeRule(fldValue, CHARSET, encodeRule);
            fldValueBytes = NumberStringUtil.byteArrayAdd(lengthByte, fldValueBytes);
        } else if (FLD_LENGTH_FLAG_0.equals(fldFlag)) {
            // TODO Answer 暂不做处理
        } else {
            throw new AIException("[AI]Error of fldFlag.");
        }
        return NumberStringUtil.bytesToHexString(fldValueBytes);
    }


    /**
     * 根据域编码规则,把数据转换 PACK
     * @param fldValue          字段值
     * @param charset           编码格式
     * @param fldEncodeRule     字段编码规则
     * @exception Exception .
     */
    private static byte[] fieldEncodeRule(String fldValue, String charset, String fldEncodeRule)
            throws Exception{
        byte[] fieldByte;
        if (ENCODE_RULE_BCD.equals(fldEncodeRule)) {
            if (fldValue.length() % 2 != 0) {
                fldValue = fldValue + "0";
            }
            fieldByte = NumberStringUtil.hexStringToBytes(fldValue);
        } else if (ENCODE_RULE_HEX.equals(fldEncodeRule)) {
            String fieldHexStr = Integer.toHexString(Integer.parseInt(fldValue));
            if (fieldHexStr.length() % 2 != 0)  {
                fieldHexStr = fieldHexStr + "0";
            }
            fieldByte = NumberStringUtil.hexStringToBytes(fieldHexStr);
        } else if (ENCODE_RULE_BINARY.equals(fldEncodeRule)) {
            if (fldValue.length() % 2 != 0) {
                fldValue = fldValue + "0";
            }
            fieldByte = NumberStringUtil.hexStringToBytes(fldValue);
        } else {
            //默认ASSIC编码 ENCODE_RULE_ASCII
            fieldByte = fldValue.getBytes(charset);
        }
        return fieldByte;
    }


    /**
     * 获取解码后的字段值 UNPACK
     * @param clazz             类名
     * @param fldName           字段名
     * @param byteArray         报文字节数组
     * @param indexArr          字段所在报文的索引位置
     * @exception Exception .
     * */
    private static String getFldValue(Class clazz, String fldName, byte[] byteArray, int[] indexArr)
            throws Exception {
        String transFldValue = "";
        Field field = clazz.getDeclaredField(fldName);
        boolean fldHasAnnotation = field.isAnnotationPresent(ISO8583Annotation.class);
        if (fldHasAnnotation) {
            ISO8583Annotation fldAnnotation = field.getAnnotation(ISO8583Annotation.class);
            int dataLength = fldAnnotation.dataFldLength();
            String lenEncodeRule = fldAnnotation.lenEncodeRule();
            String fldFlag = fldAnnotation.fldFlag();
            String encodeRule = fldAnnotation.encodeRule();

            // 字段长度固定
            if (FLD_LENGTH_FLAG_1.equals(fldFlag)) {
                byte[] fieldByte;
                if (ENCODE_RULE_BCD.equals(encodeRule)) {
                    int fldLen = (dataLength + 1) / 2;
                    fieldByte = NumberStringUtil.getBytes(byteArray, indexArr[0], fldLen);
                    indexArr[0] += fldLen;
                    transFldValue = fieldDecodeRule(fieldByte, CHARSET, encodeRule);
                    // 截取字段长度
                    transFldValue = transFldValue.substring(0, dataLength);
                } else {
                    fieldByte = NumberStringUtil.getBytes(byteArray, indexArr[0], dataLength);
                    indexArr[0] += dataLength;
                    transFldValue = fieldDecodeRule(fieldByte, CHARSET, encodeRule);
                }
            // 字段长度可变长度
            } else if (FLD_LENGTH_FLAG_2.equals(fldFlag) || FLD_LENGTH_FLAG_3.equals(fldFlag)) {
                int lenSize = Integer.parseInt(fldFlag);
                lenSize = (lenSize + 1) / 2;
                byte[] fldLenByte = NumberStringUtil.getBytes(byteArray, indexArr[0], lenSize);
                indexArr[0] += lenSize;
                int fieldLength = fieldLenDecodeRule(fldLenByte, lenEncodeRule);
                // 编码规则是BCD
                if (ENCODE_RULE_BCD.equals(encodeRule)) {
                    byte[] fieldByte = NumberStringUtil.getBytes(byteArray, indexArr[0], (fieldLength + 1) / 2);
                    indexArr[0] += (fieldLength + 1) / 2;
                    transFldValue = fieldDecodeRule(fieldByte, CHARSET, encodeRule);
                    //左靠
                    transFldValue = transFldValue.substring(0, fieldLength);
                } else {
                    byte[] fieldByte = NumberStringUtil.getBytes(byteArray, indexArr[0], fieldLength);
                    indexArr[0] += fieldLength;
                    transFldValue = fieldDecodeRule(fieldByte, CHARSET, encodeRule);
                }
            } else if (FLD_LENGTH_FLAG_0.equals(fldFlag)) {
                // TODO Answer 暂不做处理
            } else {
                throw new AIException("[AI]Error of fldFlag.");
            }

        }
        return transFldValue;
    }


    /**
     * 把解码后的值注入到对象obj中 UNPACK
     * @param obj               对象
     * @param fldName           字段名称
     * @param fldValue          字段值
     * @exception Exception .
     * */
    private static void setFldValue(Object obj, String fldName, String fldValue)
            throws Exception {
        fldName = (fldName.substring(0, 1)).toUpperCase() + fldName.substring(1);
        PropertyDescriptor propertyDescriptor = new PropertyDescriptor(fldName, obj.getClass());
        propertyDescriptor.getWriteMethod().invoke(obj, fldValue);
    }


    /**
     * 根据域编码规则,把数据转换 UNPACK
     * @param fieldByte         字段值(字节数组)
     * @param charset           编码格式
     * @param fldEncodeRule     编码规则
     * @exception Exception .
     * */
    private static String fieldDecodeRule(byte[] fieldByte, String charset, String fldEncodeRule)
            throws Exception{
        String fieldValue;
        if (ENCODE_RULE_BCD.equals(fldEncodeRule)) {
            fieldValue = NumberStringUtil.bytesToHexString(fieldByte);
        } else if (ENCODE_RULE_HEX.equals(fldEncodeRule)) {
            fieldValue = NumberStringUtil.bytesToHexString(fieldByte);
            fieldValue = Integer.toString(Integer.parseInt(fieldValue, 16));
        } else if (ENCODE_RULE_BINARY.equals(fldEncodeRule)) {
            fieldValue = NumberStringUtil.bytesToHexString(fieldByte);
        } else {  // 默认 ENCODE_RULE_ASCII
            fieldValue = new String(fieldByte, charset);
        }
        return fieldValue.trim();
    }


    /**
     * 根据域长度编码规则,把数据转换 UNPACK
     * @param fldLenByte        变长字段的长度(字节数组)
     * @param fldLenEncRule     域长度编码规则(针对变长字段的实际长度)
     * @exception Exception .
     */
    private static int fieldLenDecodeRule(byte[] fldLenByte, String fldLenEncRule)
            throws Exception{
        int fieldLength = 0;

        //根据域长度编码规则,把数据长度头转换
        if (LEN_ENCODE_RULE_ASCII.equals(fldLenEncRule)) {
            fieldLength = Integer.parseInt(new String(fldLenByte), 10);
        } else if (LEN_ENCODE_RULE_BCD.equals(fldLenEncRule)) {
            fieldLength = Integer.parseInt(NumberStringUtil.bytesToHexString(fldLenByte), 10);
        } else if (LEN_ENCODE_RULE_HEX.equals(fldLenEncRule)) {
            fieldLength = Integer.parseInt(NumberStringUtil.bytesToHexString(fldLenByte), 16);
        } else if (LEN_ENCODE_RULE_BINARY.equals(fldLenEncRule)) {
            fieldLength = Integer.parseInt(NumberStringUtil.byteToBinary(fldLenByte), 10);
        } else {
            // 没有域长度编码规则信息 抛异常
            throw new AIException("[AI]Error of fieldLenDecodeRule.");
        }
        return fieldLength;
    }

}

 

测试演示

public static void main(String[] args) throws Exception {
        final String TPDU = "6000000000";
        final String HEAD = "612200000000";
        String recvMsg = "00BA600000000061220000000003007020048000C1805B193106660188888886520012345600001000000088888810006630383032323230362020202020202020202030303031303030303030303030303500040000313638005553560118FFFFFFFFFFFF03104890100000006059FFFFFFFF0101000200000064020000080000032017122310225672FB47880000012B01001141000006666000120006660001810016303030303030303030303030303030300000000000000000";
        ISO8583 aiISO8583DTO = (ISO8583) TransISO8583MessageUtil.unpackISO8583(ISO8583.class, recvMsg);
        System.out.println("UNPACK ISO8583: \n" + JSON.toJSONString(aiISO8583DTO));

        System.out.println("\n\n##################################################\n\n");

        ISO8583 aiiso8583DTO = new ISO8583();

        aiiso8583DTO.setCardNo02("3106660188888886520");
        aiiso8583DTO.setTransProcCode03("123456");
        aiiso8583DTO.setTransAmt04("000010000000");
        aiiso8583DTO.setSysTrackNo11("888888");
        aiiso8583DTO.setServiceInputModeCode22("100");
        aiiso8583DTO.setServiceConditionCode25("66");
        aiiso8583DTO.setCardAcceptorTerminalID41("08022206");
        aiiso8583DTO.setCardAcceptorID42("000100000000005");
        aiiso8583DTO.setAdditionalDataPrivate48("0000");
        aiiso8583DTO.setCurrencyCode49("168");
        aiiso8583DTO.setEWalletTransInfo58("53560118FFFFFFFFFFFF03104890100000006059FFFFFFFF0101000200000064020000080000032017122310225672FB47880000012B01");
        aiiso8583DTO.setFld60Domain60("41000006666");
        aiiso8583DTO.setOriginalInfoDomain61("000666000181");
        aiiso8583DTO.setFld63Domain63("0000000000000000");

        String maxBitmap = "7020048000C1805B";
        String sendMsg = TransISO8583MessageUtil.packISO8583(aiiso8583DTO, maxBitmap, TPDU, HEAD, "0300");
        System.out.println("PACK ISO8583: \n" + sendMsg);
    }

UNPACK ISO8583: 
{"additionalDataPrivate48":"0000","cardAcceptorID42":"000100000000005","cardAcceptorTerminalID41":"08022206","cardNo02":"3106660188888886520","currencyCode49":"168","eWalletTransInfo58":"53560118FFFFFFFFFFFF03104890100000006059FFFFFFFF0101000200000064020000080000032017122310225672FB47880000012B01","fld60Domain60":"41000006666","fld63Domain63":"0000000000000000","mac64":"","originalInfoDomain61":"000666000181","serviceConditionCode25":"66","serviceInputModeCode22":"100","sysTrackNo11":"888888","transAmt04":"000010000000","transProcCode03":"123456"}


##################################################


PACK ISO8583: 
00BA600000000061220000000003007020048000C1805B193106660188888886520012345600001000000088888810006630383032323230362020202020202020202030303031303030303030303030303500040000313638005553560118FFFFFFFFFFFF03104890100000006059FFFFFFFF0101000200000064020000080000032017122310225672FB47880000012B01001141000006666000120006660001810016303030303030303030303030303030300000000000000000
Jaemon
关注
专栏目录
ISO8583报文工具类（组装和解析报文）
11-06 1万+
很久没来csdn了。现在的工作地点在银行，妈的，不让上网啊。 写写博客其实是对自己知识的总结，这么长时间了，也该写点东西了。接触银行的项目，避免不了 遇上8583报文。具体介绍就不细讲了，这个网上一大堆介绍的。关键是怎么去组装和解析8583报文？ 这个代码还真不好找。在此，我把自己的研究写成一个工具类，看的懂其实很好改写，看不懂就直接拿去用吧。   package com.lsy.com
iso8583 bitMap生成与解析详解
chenglie8801的博客
02-24 1135
大家都知道可以用8个字节或者16个字节表示64个域或者128个域，那么具体是怎么来的呢？在8583报文中，如果是64位，那么就用64个0表示所有的域，哪一个域有值，那么代表这个域的0换成1，比如0000005...那么代表的是64域中第7域有值；如果是128域，那么应该是128个0，第一个0变...
BIM-ISO8583.JAVA:用Java实现ISO 8583协议-开源
05-13
BIM-ISO8583.JAVA是基于Java的库，允许开发人员解析和创建ISO8583消息。 该库的发布是为了帮助金融系统的开发人员完全符合ISO 8583协议的标准，并使开发变得轻松快捷。 该库中使用的编程方法和技术由总部位于菲律宾，太平洋岛屿的财务软件工程师Bim Garcia开发。 为增强和改进专门用于金融行业的现有技术做出巨大贡献，这是他自己的方法。
java发送iso8583报文接口框架,ISO8583报文工具类（组装和解析报文）
weixin_39581318的博客
03-21 698
packagecom.lsy.common.util;importjava.io.FileInputStream;importjava.io.UnsupportedEncodingException;importjava.util.HashMap;importjava.util.Iterator;importjava.util.Map;importjava.util.Properti...
ISO 8583报文：常用业务域解析
最新发布
FIN技术铺掌柜的。
08-02 958
本文介绍了一个简单的ISO 8583消息解析器的实现。该解析器能够处理十六进制字符串形式的ISO 8583消息，提取并解析消息类型指示器（MTI）和位图，识别出消息中存在的域。文章详细解释了解析器的各个组成部分，包括主要解析方法、MTI解析、位图解析以及辅助方法。
IS08583报文协议包的解析和封装java源代码 【转】
zhaokuner的专栏
11-30 2041
一：IS08583包介绍：      ISO8583包（简称8583包）是一个国际标准的包格式，最多由128个字段域组成，每个域都有统一的规定，并有定长与变长之分。      8583包前面一段为位图，用来确定包的字段域组成情况。其中位图是8583包的灵魂，它是打包解包确定字段域的关键， 而了解每个字段域的属性则是填写数据的基础。     1：位图说明：      位置：在8583包的第1
iso8583自动组包解包常用工具
09-03
ISO8583报文自动解包组包工具，每个域还可以自己定义与配置，使用方便。
Java版ISO8583报文组包/解包
晓呆同学的专栏
03-02 4837
文章目录一、8583协议简介二、位图规则三、8583格式报文参考四、组包/解包思路五、相关代码 一、8583协议简介   8583协议是基于ISO8583报文国际标准的包格式的通讯协议，8583包最多由128个字段域组成，每个域都有统一的规定，并有定长与变长之分。8583包前面一段为位图，它是组包解包确定字段域的关键索引。 二、位图规则   位图是8583报文组包和解包的关键。我们将位图转换为二进...
Java版ISO8583包解析工具
hellohorizon的编程笔记
09-09 4920
1、解析类 /** * ISO8583数据解析器 * ISO8583数据结构：2字节消息类型（BCD码） + 域1至域64/128 * @author yanhang0610 */ public class Iso8583Package { // 报文结构 private byte[] messageTypeBytes = new byte[2]; // BCD编码的消息类型
iso8583实例解析银联报文（java）
05-22
一个简单的实例，用于解析银联标准8583报文的过程，仅限参考
最新背诵版 Java 面经汇总囊括了基本所有考点（建议收藏）
m0_73256420的博客
09-06 897
集群就是多台机器，是一种线上的部署方案，很多机器加起来，性能就比一台机器强，一般用这种部署方案来解决高并发，高可用，容灾，集群也有不同的叫法，负载均衡集群，高可用集群，扩容集群等。什么是分布式分布式也叫做SOA，是一种设计方案，以前使用所有模块在一个项目中的写法，叫做垂直架构，后来由于互联网的兴起，为了模块间的解耦和扩展性以及部署的灵活性，会将一个项目按照模块进行拆分，一个模块就是一个项目这种设计方案叫做分布式架构，也叫做SOA架构。什么是负载均衡器以及作用？
ISO8583解析工具
04-09
银联报文分析工具，用以分析基于ISO8583协议的报文。当然还有支持TLV BITMAP的工具
ISO8583报文解包工具
09-26
ISO8583报文解包工具，每个域的定义可以自己配置，使用方便。
iso8583自动组包解包工具Iso8583tools.zip
09-04
软件介绍: ISO8583报文自动解包组包工具Iso8583tools，填空上IP地址和端口，用于解析生成ibox8583报文、解析生成iso8583包，生成或解析JSON包，每个域还可以自己定义与配置，使用方便。
ISO8583 辅助工具
04-07
NULL 博文链接：https://xutao5641745.iteye.com/blog/1560558
Java知识点概览
qq_48403611的博客
08-03 3307
java后端开发常见面试题总结
自用JAVA基础面试八股文（简单易记不踩坑）
weixin_53805188的博客
03-13 953
java基础易懂的实时更新知识点，自用！！！！
2021 Java面试真题集锦
热门推荐
GL1765852966的博客
12-26 8万+
目录 … 1 大厂面试的基本流程 17 字节跳动 17 阿里 17 腾讯 18 网易游戏 18 面试前需要准备： 18 面试中可以借鉴的套路 19 用简历争取到更多的面试机会 19 自我介绍时，立即全面抛出技术栈和亮点 20 先介绍项目背景，打消面试官疑问 21 通过说项目管理工具，说明你不仅会写代码 22 用 SPRING BOOT 项目举例，说明你的技术基本面 23 用实例说明你在内存调优方面的经验 24 展示你在数据库调优方面的经验 25 总结前文说辞 26 准备项目说辞时，更可以准备后继面试官的问
Java实现ISO8583报文解析与封装示例源码详解
本文档主要介绍了IS08583报文协议包的解析和封装在Java编程中的实现方法。ISO8583是一种国际通用的通信协议包结构，它允许最多包含128个字段域，这些字段域按定长或变长进行编码，具有明确的规则和位图管理机制。...
评论 16
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Jaemon

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值