IS08583报文协议包的解析和封装java源代码

一：IS08583包介绍：

ISO8583包（简称8583包）是一个国际标准的包格式，最多由128个字段域组成，每个域都有统一的规定，并有定长与变长之分。

8583包前面一段为位图，用来确定包的字段域组成情况。其中位图是8583包的灵魂，它是打包解包确定字段域的关键， 而了解每个字段域的属性则是填写数据的基础。

1：位图说明：

位置：在8583包的第1 位

格式：定长

类型：B16（二进制16位，16*8=128bit）

描述：

如将位图的第一位设为'1'，表示使用扩展位图（128个域），否则表示只使用基本位图（64个域）。

如使用某数据域，应在位图中将相应的位设位'1'，如使用41域，需将位图的41位设为'1'。

选用条件：如使用65到128域，需设位图域第一位为'1'

2：域的定义：

typedef struct ISO8583

{

int bit_flag; /*域数据类型0 -- string, 1 -- int, 2 -- binary*/

char *data_name; /*域名*/

int length; /*数据域长度*/

int length_in_byte;/*实际长度（如果是变长）*/

int variable_flag; /*是否变长标志0：否 2：2位变长, 3：3位变长*/

int datatyp; /*0 -- string, 1 -- int, 2 -- binary*/

char *data; /*存放具体值*/

int attribute; /*保留*/

} ISO8583;

二：定义BitMap类

类说明：根据ISO8583 包的域定义，定义BitMap类存储每个域的信息。例如：

package com.lottery.pos.model;

public class BitMap {

private int bit; //位

private int bittype; //数据类型 1 ascii 2 binary

private int variable; //是否变长0 不是 2 两位变长 3 三位变长

private int len; //数据长度

private byte[] dat; //数据

public int getBit() {

return bit;

}

public void setBit(int bit) {

this.bit = bit;

}

public int getBittype() {

return bittype;

}

public void setBittype(int bittype) {

this.bittype = bittype;

}

public int getVariable() {

return variable;

}

public void setVariable(int variable) {

this.variable = variable;

}

public byte[] getDat() {

return dat;

}

public void setDat(byte[] dat) {

this.dat = dat;

}

public int getLen() {

return len;

}

public void setLen(int len) {

this.len = len;

}

}

三：定义PortConfig类

类说明：定义配置信息类。根据此类解析和封装数据。例如：

package com.lottery.pos.model;

public class PortConfig {

/**

* 存放所有接口的配置信息

* [][0] bit 位:在Map中的位

* [][1] type 类型:1 ascii 2 binary

* [][2] len 长度:(对定长有效)

* [][3] varLen 变长:0非变长 2位变长 3位变长

*/

// 定义一个二位数组存放配置信息。

public static final int[][] config= {

{11,1,6,0},

{12,1,6,0},

{13,1,4,0},

{32,1,11,0},

{37,1,12,0},

{39,1,2,0},

{40,2,50,2},

{41,1,8,0},

{48,1,52,3},

{120,2,128,3},

};

｝

四：定义BitMapiso类

类说明：此类提供解析请求包和封装信息包两个方法，例如：

package com.lottery.pos.utils;

import java.util.ArrayList;

import java.util.List;

import com.lottery.pos.model.BitMap;

public class BitMapiso {

/**

* 解析请求包

* @param body

* @param config

* @return List

*/

@SuppressWarnings("unchecked")

public static List unpackRequest(byte[] body, int[][] config) {

List outList = new ArrayList();

// 取得除信息类型以外的包信息。也就是取得位图的初始位置。

byte[] realbody = new byte[body.length - 4];

System.arraycopy(body, 4, realbody, 0, realbody.length);

// 取得位图

byte[] map = null;

byte[] map8 = new byte[8];

System.arraycopy(realbody, 0, map8, 0, 8);

boolean[] bmap8 = LoUtils.getBinaryFromByte(map8);

if (bmap8[1]) {

// 如果第一位为1，则是可扩展位图，设为16字节长度。

map = new byte[16];

System.arraycopy(realbody, 0, map, 0, 16);

} else {

map = map8;

}

boolean[] bmap = LoUtils.getBinaryFromByte(map);

int tmplen = map.length;

for (int i = 2; i < bmap.length; i++) {

if (bmap[i]) {

//BitMap bitMap = null;

// 寻找位图中的1对应的数据

int bit=-1;

for (int j = 0; j < config.length; j++) {

if (config[j][0] == i) {

bit=j;

break;

}

}

BitMap outBitMap = new BitMap();

outBitMap.setBit(i);

outBitMap.setBittype(config[bit][1]);

//len对变长是无用的。

outBitMap.setLen(config[bit][2]);

outBitMap.setVariable(config[bit][3]);

byte[] nextData = null;

if (config[bit][3] > 0) {

//取出变长部分的值。

int varLen = config[bit][3];

if (config[bit][1] == 2) {

varLen = varLen - 1;

}

byte[] varValue = new byte[varLen];

System.arraycopy(realbody, tmplen, varValue, 0, varValue.length);

int datLen = 0;

if (config[bit][1] == 2) {

datLen = LoUtils.bcdToint(varValue);

} else {

datLen = byteToInt(varValue);

}

tmplen += varLen;

// 取出变长部分后带的值。

nextData = new byte[datLen];

System.arraycopy(realbody, tmplen, nextData, 0,nextData.length);

tmplen += nextData.length;

} else {

nextData = new byte[config[bit][2]];

System.arraycopy(realbody, tmplen, nextData, 0,nextData.length);

tmplen += config[bit][2];

}

outBitMap.setDat(nextData);

outList.add(outBitMap);

}

}

return outList;

}

/**

* 打包响应包,不包括消息类型

* @param list

* @return byte[]

*/

@SuppressWarnings("unchecked")

public static byte[] PackResponse(List list) {

int len = 16;

for (int i = 0; i < list.size(); i++) {

BitMap bitMap = (BitMap) list.get(i);

// 计算请求包总长度

if (bitMap.getBittype() == 2) {

if (bitMap.getVariable() > 0) {

len += bitMap.getVariable() - 1 + bitMap.getDat().length;

} else {

len += bitMap.getVariable() + bitMap.getDat().length;

}

} else {

len += bitMap.getVariable() + bitMap.getDat().length;

}

}

byte[] body = new byte[len];

// 位图

boolean[] bbitMap = new boolean[129];

bbitMap[1] = true;

int temp = (bbitMap.length - 1) / 8;

for (int j = 0; j < list.size(); j++) {

BitMap bitMap = (BitMap) list.get(j);

bbitMap[bitMap.getBit()] = true;

byte[] bitmap = LoUtils.getByteFromBinary(bbitMap);

System.arraycopy(bitmap, 0, body, 0, bitmap.length);

// 数据

if (bitMap.getVariable() > 0) {

// 数据是可变长的:拼变长的值

byte[] varValue = null;

if (bitMap.getBittype() == 2) {

varValue = LoUtils.StrToBCDBytes(String.format("%0"+ bitMap.getVariable() + "d",bitMap.getDat().length));

} else {

varValue = String.format("%0" + bitMap.getVariable() + "d",bitMap.getDat().length).getBytes();

}

System.arraycopy(varValue, 0, body, temp, varValue.length);

temp += varValue.length;

// 拼变长部分后所带的数的值。

System.arraycopy(bitMap.getDat(), 0, body, temp, bitMap.getDat().length);

temp += bitMap.getDat().length;

} else {

// 数据是固定长度的。

byte dat[] =new byte[bitMap.getLen()];

if (bitMap.getDat().length!=bitMap.getLen()){

System.arraycopy(bitMap.getDat(), 0, dat, 0, bitMap.getLen());

}else{

dat=bitMap.getDat();

}

System.arraycopy(dat, 0, body, temp, dat.length);

temp += bitMap.getDat().length;

}

}

return body;

}

｝

package com.lottery.utils;

import java.io.BufferedInputStream;

import java.io.ByteArrayOutputStream;

import java.io.IOException;

import javax.servlet.http.HttpServletRequest;

import sun.misc.BASE64Decoder;

import sun.misc.BASE64Encoder;

/**

* 编码与数据类型类

*

* @author LLH

*/

public class LoUtils

{

private static BASE64Encoder encoder = new BASE64Encoder ();

private static BASE64Decoder decoder = new BASE64Decoder ();

/**

* BASE64 编码

*

* @param s

* @return

*/

public static String encodeBufferBase64(byte [] buff)

{

return buff == null ? null : encoder.encode (buff);

}

/**

* BASE64解码

*

* @param s

* @return

*/

public static byte [] decodeBufferBase64(String s)

{

try

{

return s == null ? null : decoder.decodeBuffer (s);

}catch (IOException e)

{

e.printStackTrace ();

}

return null;

}

/**

* BASE64 字节数组编码

*

* @param s

* @return String

*/

public static String encodeBase64(byte [] s)

{

if(s == null)

return null;

String res = new BASE64Encoder ().encode (s);

res = res.replace ("\n","");

res = res.replace ("\r","");

return res;

}

/**

* BASE64解码

*

* @param s

* @return

*/

public static byte [] decodeBase64(byte [] buff)

{

if(buff == null)

return null;

BASE64Decoder decoder = new BASE64Decoder ();

try

{

byte [] b = decoder.decodeBuffer (new String (buff));

return b;

}catch (Exception e)

{

return null;

}

}

/**

* 将reauest里的数据包转成字符串

*

* @param request

* @return String

*/

public static String getRequestBodyTxt(HttpServletRequest request)

{

// 接收手机传过来的参数

BufferedInputStream bufferedInputStream = null;

// 此类实现了一个输出流，其中的数据被写入一个字节数组

ByteArrayOutputStream bytesOutputStream = null;

String body = null;

try

{

// BufferedInputStream 输入流

bufferedInputStream = new BufferedInputStream (

request.getInputStream ());

bytesOutputStream = new ByteArrayOutputStream ();

// 写入数据

int ch;

while ((ch = bufferedInputStream.read ()) != -1)

{

bytesOutputStream.write (ch);

}

// 转换为String类型

body = new String (bytesOutputStream.toByteArray (),"UTF-8");

}catch (Exception ex)

{

ex.printStackTrace ();

}

finally

{

// 关闭此输入流并释放与该流关联的所有系统资源。

try

{

bytesOutputStream.flush ();

bytesOutputStream.close ();

bufferedInputStream.close ();

}catch (IOException e)

{

e.printStackTrace ();

}

}

return body;

}

/**

* 将reauest里的数据包转成字节数组

*

* @param request

* @return

*/

public static byte [] getRequestBodyByte(HttpServletRequest request)

{

// 接收手机传过来的参数

BufferedInputStream bufferedInputStream = null;

// 此类实现了一个输出流，其中的数据被写入一个字节数组

ByteArrayOutputStream bytesOutputStream = null;

byte [] body = null;

try

{

// BufferedInputStream 输入流

bufferedInputStream = new BufferedInputStream (

request.getInputStream ());

bytesOutputStream = new ByteArrayOutputStream ();

// 写入数据

int ch;

while ((ch = bufferedInputStream.read ()) != -1)

{

bytesOutputStream.write (ch);

}

// 转换为String类型

body = bytesOutputStream.toByteArray ();

}catch (Exception ex)

{

ex.printStackTrace ();

}

finally

{

// 关闭此输入流并释放与该流关联的所有系统资源。

try

{

bytesOutputStream.flush ();

bytesOutputStream.close ();

bufferedInputStream.close ();

}catch (IOException e)

{

e.printStackTrace ();

}

}

return body;

}

public static String getEigthBitsStringFromByte(int b)

{

// if this is a positive number its bits number will be less

// than 8

// so we have to fill it to be a 8 digit binary string

// b=b+100000000(2^8=256) then only get the lower 8 digit

b |= 256; // mark the 9th digit as 1 to make sure the string

// has at

// least 8 digits

String str = Integer.toBinaryString (b);

int len = str.length ();

return str.substring (len - 8,len);

}

public static byte getByteFromEigthBitsString(String str)

{

// if(str.length()!=8)

// throw new Exception("It's not a 8 length string");

byte b;

// check if it's a minus number

if(str.substring (0,1).equals ("1"))

{

// get lower 7 digits original code

str = "0" + str.substring (1);

b = Byte.valueOf (str,2);

// then recover the 8th digit as 1 equal to plus

// 1000000

b |= 128;

}

else

{

b = Byte.valueOf (str,2);

}

return b;

}

/**

* 将一个16字节数组转成128二进制数组

*

* @param b

* @return

*/

public static boolean [] getBinaryFromByte(byte [] b)

{

boolean [] binary = new boolean [b.length * 8 + 1];

String strsum = "";

for (int i = 0;i < b.length;i++ )

{

strsum += getEigthBitsStringFromByte (b [i]);

}

for (int i = 0;i < strsum.length ();i++ )

{

if(strsum.substring (i,i + 1).equalsIgnoreCase ("1"))

{

binary [i + 1] = true;

}

else

{

binary [i + 1] = false;

}

}

return binary;

}

/**

* 将一个128二进制数组转成16字节数组

*

* @param binary

* @return

*/

public static byte [] getByteFromBinary(boolean [] binary)

{

int num = (binary.length - 1) / 8;

if((binary.length - 1) % 8 != 0)

{

num = num + 1;

}

byte [] b = new byte [num];

String s = "";

for (int i = 1;i < binary.length;i++ )

{

if(binary [i])

{

s += "1";

}

else

{

s += "0";

}

}

String tmpstr;

int j = 0;

for (int i = 0;i < s.length ();i = i + 8)

{

tmpstr = s.substring (i,i + 8);

b [j] = getByteFromEigthBitsString (tmpstr);

j = j + 1;

}

return b;

}

/**

* 将一个byte位图转成字符串

*

* @param b

* @return

*/

public static String getStrFromBitMap(byte [] b)

{

String strsum = "";

for (int i = 0;i < b.length;i++ )

{

strsum += getEigthBitsStringFromByte (b [i]);

}

return strsum;

}

/**

* bytes转换成十六进制字符串

*

* @param b

* @return

*/

public static String byte2HexStr(byte [] b)

{

String hs = "";

String stmp = "";

for (int n = 0;n < b.length;n++ )

{

stmp = (Integer.toHexString (b
& 0XFF));

if(stmp.length () == 1)

hs = hs + "0" + stmp;

else

hs = hs + stmp;

}

return hs.toUpperCase ();

}

private static byte uniteBytes(String src0, String src1)

{

byte b0 = Byte.decode ("0x" + src0).byteValue ();

b0 = (byte) (b0 << 4);

byte b1 = Byte.decode ("0x" + src1).byteValue ();

byte ret = (byte) (b0 | b1);

return ret;

}

/**

* 十六进制字符串转换成bytes

*

* @param src

* @return

*/

public static byte [] hexStr2Bytes(String src)

{

int m = 0, n = 0;

int l = src.length () / 2;

byte [] ret = new byte [l];

for (int i = 0;i < l;i++ )

{

m = i * 2 + 1;

n = m + 1;

ret [i] = uniteBytes (src.substring (i * 2,m),

src.substring (m,n));

}

return ret;

}

/**

* 将String转成BCD码

*

* @param s

* @return

*/

public static byte [] StrToBCDBytes(String s)

{

if(s.length () % 2 != 0)

{

s = "0" + s;

}

ByteArrayOutputStream baos = new ByteArrayOutputStream ();

char [] cs = s.toCharArray ();

for (int i = 0;i < cs.length;i += 2)

{

int high = cs [i] - 48;

int low = cs [i + 1] - 48;

baos.write (high << 4 | low);

}

return baos.toByteArray ();

}

/**

* 将BCD码转成int

*

* @param b

* @return

*/

public static int bcdToint(byte [] b)

{

StringBuffer sb = new StringBuffer ();

for (int i = 0;i < b.length;i++ )

{

int h = ((b [i] & 0xff) >> 4) + 48;

sb.append ((char) h);

int l = (b [i] & 0x0f) + 48;

sb.append ((char) l);

}

return Integer.parseInt (sb.toString ());

}

/**

* 输出调试信息

*

* @param str

*/

public static void trace(String str)

{

// System.out.println ("["

// + (new SimpleDateFormat ("yyyy-MM-dd HH:mm:ss.S")).format (new Date ())

// + "]>" + str);

}

}