ISO8583报文工具类

                                     ISO8583报文工具类（组装和解析报文）

     很久没来csdn了。现在的工作地点在银行，妈的，不让上网啊。

写写博客其实是对自己知识的总结，这么长时间了，也该写点东西了。接触银行的项目，避免不了

遇上8583报文。具体介绍就不细讲了，这个网上一大堆介绍的。关键是怎么去组装和解析8583报文？

这个代码还真不好找。在此，我把自己的研究写成一个工具类，看的懂其实很好改写，看不懂就直接拿去用吧。

 

001package com.lsy.common.util;

002  

003import java.io.FileInputStream;

004import java.io.UnsupportedEncodingException;

005import java.util.HashMap;

006import java.util.Iterator;

007import java.util.Map;

008import java.util.Properties;

009import java.util.TreeMap;

010  

011/**

012 * 

013 * 这是本人写的ISO8583报文工具类，包含了报文的组装和解析。

014 * 

015 * 简单介绍下ISO8583。

016 * 这个东西说白了就是一种数据结构。我们定义一种规则把一堆东西放进去，再按照规则

017 * 把数据正确拿出来。这就是报文的实质。

018 * 

019 * ISO8583报文的结构是：前面有16字节（128位）位图数据，后面就是数据。

020 * 报文最多有128个域（字段）。具体的一个报文不会有这么多，一般是几个域。

021 * 有哪几个就记录在位图中。而且域有定长和变长之分。

022 * 这些都是事先定义好的，具体可以看我写的properties定义文件.

023 * 

024 * 位图转化成01字符串就是128个，如果某一位是1，代表这个域有值，然后按照properties定义的规则取值。

025 * 如果是0，则这个域没有值。

026 * 

027 * 再说定长和变长。

028 * 定长域(定长比较好理解，一个字段规定是N位，那么字段值绝对不能超过N位，不足N位就在后面补空格)

029 * 变长域(变长域最后组装成的效果：例如变长3位，定义var3，这里的3是指长度值占3位，字段值是123456，最后结果就是006123456)

030 * 注意（变长的长度按照域值得字节长度计算，而不是按照域值字符串长度算！）

031 * 

032 * 从网上不难找到ISO8583报文的介绍，这里就不多说了。

033 * 但是具体解析和组装的代码还真不好找，所以本人就写了一个让刚接触ISO8583报文的人更好入门。

034 * 

035 * 

036 * 

037 * 解析的容器，我使用了Map，具体到工作中，还是要换成其他的容器的。

038 * 报文定义说明：config_8583.properties

039 * 例如

040 * FIELD031 = string,10

041 * FIELD032 = string,VAR2

042 * 

043 * FIELD031是定长，长度是10

044 * FIELD032是变长，长度值占2位，也就是说长度值最大99，也就是域值最大长度99.

045 * 

046 * @author lushuaiyin

047 * 

048 */

049public class Lsy8583Util {

050      

051    publicstatic String packet_encoding="UTF-8";//报文编码 UTF-8 GBK

052    privatestatic Map map8583Definition =null;// 8583报文128域定义器

053      

054    static{

055        String basepath=Lsy8583Util.class.getClassLoader().getResource("").getPath();

056        System.out.println(basepath);

057        System.out.println("Lsy8583Util使用编码配置:[encoding:"+packet_encoding+"]");

058        Properties property =new Properties();

059        String path =  basepath+"/config_8583.properties";

060        FileInputStream fis;

061        try{

062            fis =new FileInputStream(path);

063            property.load(fis);

064            Lsy8583Util.map8583Definition =new HashMap(property);

065            fis.close();

066        }catch (Exception e) {

067            e.printStackTrace();

068        }

069    }

070    // 8583报文初始位图:128位01字符串

071    publicstatic String getInitBitMap(){

072        String initBitMap = 

073          "10000000"+ "00000000" + "00000000" + "00000000" 

074        +"00000000" + "00000000" + "00000000"+ "00000000" 

075        +"00000000" + "00000000" + "00000000"+ "00000000" 

076        +"00000000" + "00000000" + "00000000"+ "00000000";

077        returninitBitMap;

078    }

079      

080    /**

081     * @param args

082     */

083    publicstatic void main(String[] args) {

084        try{

085            //***********************组装8583报文测试--start***********************//

086            TreeMap filedMap=newTreeMap();//报文域

087            filedMap.put("FIELD003","1799");//交易码

088            filedMap.put("FIELD013","2013-11-06");//交易日期

089            filedMap.put("FIELD008","12345678901");//账号

090            filedMap.put("FIELD033","aa索隆bb");//注意这个域是变长域!

091            filedMap.put("FIELD036","123456");//注意这个域是变长域!

092              

093            byte[] send=make8583(filedMap);

094            System.out.println("完成组装8583报文=="+newString(send,packet_encoding)+"==");

095            //***********************组装8583报文测试--end***********************//

096              

097              

098            //***********************解析8583报文测试--start***********************//

099            Map back=analyze8583(send);

100            System.out.println("完成解析8583报文=="+back.toString()+"==");

101            //***********************解析8583报文测试--end***********************//

102        }catch (UnsupportedEncodingException e) {

103            e.printStackTrace();

104        }

105          

106    }

107      

108    /**

109     * 组装8583报文

110     * @param hm

111     * @return

112     */

113    publicstatic byte[] make8583(TreeMap  filedMap){

114        byte[] whoe8583=null;

115        if(filedMap==null){

116            returnnull;

117        }

118        try{

119            String  bitMap128=getInitBitMap();//获取初始化的128位图

120            //按照8583定义器格式化各个域的内容

121            Map all=formatValueTo8583(filedMap,bitMap128);

122            // 获取上送报文内容

123            whoe8583=getWhole8583Packet(all);

124            returnwhoe8583;

125        }catch (Exception e) {

126            e.printStackTrace();

127        }

128        returnwhoe8583;

129    }

130    /**

131     * 获取完整的8583报文体（128域）

132     * @param pacBody

133     * @return

134     */

135    publicstatic byte[] getWhole8583Packet(Map all){

136        if(all==null||all.get("formatedFiledMap")==null||all.get("bitMap128")==null){

137            returnnull;

138        }

139        try{

140            String  bitMap128=(String)all.get("bitMap128");

141            // 128域位图二进制字符串转16位16进制

142            byte[] bitmaps= get16BitByteFromStr(bitMap128);

143              

144            TreeMap pacBody=(TreeMap)all.get("formatedFiledMap");

145            StringBuffer last128=newStringBuffer();

146            Iterator it=pacBody.keySet().iterator();

147            for(;it.hasNext();){

148                String key=(String)it.next();

149                String value=(String)pacBody.get(key);

150                last128.append(value);

151            }

152            byte[] bitContent = last128.toString().getBytes(packet_encoding);//域值

153              

154            //组装

155            byte[] package8583=null;

156            package8583=Lsy8583Util.arrayApend(package8583, bitmaps);

157            package8583=Lsy8583Util.arrayApend(package8583, bitContent);

158  

159            returnpackage8583;

160        }catch (Exception e) {

161            e.printStackTrace();

162            returnnull;

163        }

164    }

165      

166    publicstatic Map formatValueTo8583(TreeMap filedMap,String  bitMap128){

167        Map all=newHashMap();

168        TreeMap formatedFiledMap=newTreeMap();//格式化结果

169        if(filedMap!=null){

170            Iterator it=filedMap.keySet().iterator();

171            for(;it.hasNext();){

172                String fieldName=(String)it.next();//例如FIELD005

173                String fieldValue=(String)filedMap.get(fieldName);//字段值

174                  

175                try{

176                    if(fieldValue == null) {

177                        System.out.println("error:报文域 {"+ fieldName + "}为空值");

178                        fieldValue ="";

179                        returnnull;

180                    }

181                    //将域值编码转换，保证报文编码统一

182                    fieldValue=newString(fieldValue.getBytes(packet_encoding),packet_encoding);

183                      

184                    // 数据域名称FIELD开头的为128域

185                    if(fieldName.startsWith("FIELD") && fieldValue.length() >=0) {

186                        String fieldNo = fieldName.substring(5,8);//例如005

187                        // 组二进制位图串

188                        bitMap128 = change16bitMapFlag(fieldNo, bitMap128);

189  

190                        // 获取域定义信息

191                        String[] fieldDef = Lsy8583Util.map8583Definition.get("FIELD"+ fieldNo).toString().split(",");

192                        String defType=fieldDef[0];//类型定义例string

193                        String defLen=fieldDef[1];//长度定义,例20

194                        booleanisFixLen=true;//是否定长判断

195                          

196                        if(defLen.startsWith("VAR")){//变长域

197                            isFixLen=false;

198                            defLen=defLen.substring(3);//获取VAR2后面的2

199                        }

200                        intfieldLen = fieldValue.getBytes(packet_encoding).length;//字段值得实际长度

201                          

202                        // 判断是否为变长域

203                        if(!isFixLen) {// 变长域(变长域最后组装成的效果：例如变长3位，定义var3，这里的3是指长度值占3位，字段值是123456，最后结果就是006123456)

204                            intdefLen1 = Integer.valueOf(defLen);

205                            if(String.valueOf(fieldLen).length() > (10*defLen1)) {

206                                System.out.println("error:字段"+ fieldName + "的数据定义长度的长度为"+ defLen + "位,长度不能超过"+(10*defLen1));

207                                returnnull;

208                            }else{

209                                //将长度值组装入字段

210                                fieldValue = getVaryLengthValue(fieldValue, defLen1) + fieldValue;

211                            }

212                        }else {//定长域(定长比较好理解，一个字段规定是N位，那么字段值绝对不能超过N位，不足N位就在后面补空格)

213                            intdefLen2 = Integer.valueOf(defLen);

214                            if(fieldLen > defLen2) {

215                                System.out.println("error:字段"+ fieldName + "的数据定义长度为"+ defLen + "位,长度不能超过"+defLen);

216                                returnnull;

217                            }else{

218                                fieldValue=getFixFieldValue(fieldValue,defLen2);//定长处理

219                            }

220                        }

221                        System.out.println("组装后报文域 {"+ fieldName + "}=="+ fieldValue+"==,域长度:"+fieldValue.getBytes(packet_encoding).length);

222                    }

223                      

224                    // 返回结果赋值

225                    if(filedMap.containsKey(fieldName)) {

226                        if(formatedFiledMap.containsKey(fieldName)) {

227                            formatedFiledMap.remove(fieldName);

228                        }

229                        formatedFiledMap.put(fieldName, fieldValue);

230                    }else {

231                        System.out.println("error:"+fieldName + "配置文件中不存在!");

232                    }

233                }catch (Exception e) {

234                    e.printStackTrace();

235                }

236            }//end for

237        }

238        System.out.println("");

239        all.put("formatedFiledMap", formatedFiledMap);

240        all.put("bitMap128", bitMap128);

241        returnall;

242    }

243      

244      

245  

246    /**

247     * 解析8583报文

248     * 

249     * @param content8583

250     */

251    publicstatic Map analyze8583(byte[] content8583) {

252        TreeMap filedMap=newTreeMap();

253        try{

254            // 取位图

255            byte[] bitMap16byte =new byte[16];

256            System.arraycopy(content8583,0, bitMap16byte, 0, 16);

257            // 16位图转2进制位图128位字符串

258            String bitMap128Str = get16BitMapStr(bitMap16byte);

259              

260            //记录当前位置,从位图后开始遍历取值 

261            intpos = 16;

262            // 遍历128位图，取值。注意从FIELD002开始

263            for(int i = 1; i < bitMap128Str.length(); i++) {

264                String filedValue ="";//字段值

265                String filedName ="FIELD" + getNumThree((i+1));//FIELD005

266                  

267                if(bitMap128Str.charAt(i) == '1') {

268                    // 获取域定义信息

269                    String[] fieldDef = Lsy8583Util.map8583Definition.get(filedName).toString().split(",");

270                    String defType=fieldDef[0];//类型定义例string

271                    String defLen=fieldDef[1];//长度定义,例20

272                    booleanisFixLen=true;//是否定长判断

273                      

274                    if(defLen.startsWith("VAR")){//变长域

275                        isFixLen=false;

276                        defLen=defLen.substring(3);//获取VAR2后面的2

277                    }

278                    // 截取该域信息

279                    if(!isFixLen) {//变长域

280                        intdefLen1 = Integer.valueOf(defLen);//VAR2后面的2

281                        String realLen1=newString(content8583, pos, defLen1, packet_encoding);//报文中实际记录域长,例如16,023

282                        intrealAllLen=defLen1+Integer.valueOf(realLen1);//该字段总长度（包括长度值占的长度）

283//                      filedValue = new String(content8583, pos+defLen1, Integer.valueOf(realLen1), packet_encoding);

284                        byte[] filedValueByte=newbyte[Integer.valueOf(realLen1)];

285                        System.arraycopy(content8583, pos+defLen1, filedValueByte,0, filedValueByte.length);

286                        filedValue=newString(filedValueByte,packet_encoding);

287                        pos += realAllLen;//记录当前位置

288                    }else {//定长域

289                        intdefLen2 = Integer.valueOf(defLen);//长度值占的位数

290                        filedValue =new String(content8583, pos, defLen2, packet_encoding);

291                        pos += defLen2;//记录当前位置

292                    }

293                    filedMap.put(filedName, filedValue);

294                }

295            }//end for

296        }catch (Exception e) {

297            e.printStackTrace();

298        }

299        returnfiledMap;

300    }

301      

302    //********************************以下是工具方法,有些没有使用到***********************************************************//

303  

304    /**

305     * 复制字符

306     * @param str

307     * @param count

308     * @return

309     */

310    publicstatic String strCopy(String str,intcount){

311        StringBuffer sb =new StringBuffer();

312        for(inti=0;i < count;i++){

313            sb.append(str);

314        }

315        returnsb.toString();

316    }

317    /**

318     * 将setContent放入set（考虑到数组越界）

319     * @param set

320     * @param setContent

321     * @return

322     */

323    publicstatic byte[] setToByte(byte[] set,byte[] setContent){

324        byte[] res=newbyte[set.length];

325        if(set==null||setContent==null){

326              

327        }else{

328            if(set.length<setContent.length){

329                  

330            }else{

331                System.arraycopy(setContent,0, res, 0, setContent.length);

332            }

333        }

334        returnres;

335    }

336    publicstatic byte[] setToByte(byte[] set,String setContentStr){

337        byte[] res=newbyte[set.length];

338        byte[] setContent;

339        try{

340            setContent = setContentStr.getBytes(packet_encoding);

341            res=setToByte(res,setContent);

342        }catch (UnsupportedEncodingException e) {

343            e.printStackTrace();

344        }

345        returnres;

346    }

347      

348    publicstatic String getPacketLen(intlen){

349        String res="";

350        String lenStr=String.valueOf(len);

351        intlenC=4-lenStr.length();

352        res=strCopy("0",lenC)+lenStr;

353        returnres;

354    }

355    publicstatic String getPacketLen(String lenStr){

356        String res="";

357        if(lenStr==null){

358              

359        }else{

360            res=getPacketLen(Integer.valueOf(lenStr));

361        }

362        returnres;

363    }

364      

365      

366    /**

367     * 返回a和b的组合,实现累加功能

368     * @param a

369     * @param b

370     * @return

371     */

372    publicstatic byte[] arrayApend(byte[] a,byte[] b){

373        inta_len=(a==null?0:a.length);

374        intb_len=(b==null?0:b.length);

375        byte[] c=newbyte[a_len+b_len];

376        if(a_len==0&&b_len==0){

377            returnnull;

378        }elseif(a_len==0){

379            System.arraycopy(b,0, c, 0, b.length);

380        }elseif(b_len==0){

381            System.arraycopy(a,0, c, 0, a.length);

382        }else{

383            System.arraycopy(a,0, c, 0, a.length);

384            System.arraycopy(b,0, c, a.length, b.length);

385        }

386        returnc;

387    }

388      

389      

390    /**

391     * 改变128位图中的标志为1

392     * @param fieldNo

393     * @param res

394     * @return

395     */

396    publicstatic String change16bitMapFlag(String fieldNo, String res) {

397        intindexNo=Integer.parseInt(fieldNo);

398        res = res.substring(0, indexNo-1) +"1" + res.substring(indexNo);

399        returnres;

400    }

401      

402      

403    /**

404     * 位图操作 

405     * 

406     * 把16位图的字节数组转化成128位01字符串

407     * @param packet_header_map

408     * @return

409     */

410    publicstatic String get16BitMapStr(byte[] bitMap16){

411        String bitMap128 ="";

412        // 16位图转2进制位图128位字符串

413        for(int i = 0; i < bitMap16.length; i++) {

414            intbc = bitMap16[i];

415            bc=(bc<0)?(bc+256):bc;

416            String bitnaryStr=Integer.toBinaryString(bc);//二进制字符串

417            // 左补零，保证是8位

418            String rightBitnaryStr = strCopy("0",Math.abs(8-bitnaryStr.length())) + bitnaryStr;//位图二进制字符串

419            // 先去除多余的零，然后组装128域二进制字符串

420            bitMap128+=rightBitnaryStr;

421        }

422        returnbitMap128;

423    }

424      

425    /**

426     *  位图操作 

427     *  

428     * 把128位01字符串转化成16位图的字节数组

429     * @param packet_header_map

430     * @return

431     */

432    publicstatic byte[] get16BitByteFromStr(String str_128){

433        byte[]  bit16=newbyte[16];

434        try{

435            if(str_128==null||str_128.length()!=128){

436                returnnull;

437            }

438            // 128域位图二进制字符串转16位16进制

439            byte[]  tmp=str_128.getBytes(packet_encoding);

440            intweight;//权重

441            byte[] strout =new byte[128];

442            inti, j, w = 0;

443            for(i = 0; i <16; i++) {

444                weight =0x0080;

445                for(j = 0; j <8; j++) {

446                    strout[i] += ((tmp[w]) -'0') * weight;

447                    weight /=2;

448                    w++;

449                }

450                bit16[i] = strout[i];

451            }

452        }catch (UnsupportedEncodingException e) {

453            e.printStackTrace();

454        }

455        returnbit16;

456    }

457      

458      

459    /**

460     * 从完整的8583报文中获取位图（16字节数组）

461     * @param packet

462     * @return

463     */

464    publicstatic byte[] getPacketHeaderMap(byte[] packet){

465        byte[] packet_header_map =new byte[16];

466        if(packet==null||packet.length<16){

467            returnnull;

468        }

469        for(inti=0;i<16;i++){

470            packet_header_map[i]=packet[i];

471        }

472        returnpacket_header_map;

473    }

474    /**

475     * 从完整的8583报文中获取16位图，转化成128位的01字符串

476     * 

477     * @param content8583

478     * @return

479     */

480    publicstatic String get16BitMapFrom8583Byte(byte[] content8583){

481        // 取位图

482        byte[] bitMap16 = getPacketHeaderMap(content8583);

483        // 16位图转2进制位图128位字符串

484        String bitMap128 = get16BitMapStr(bitMap16);

485          

486        returnbitMap128;

487    }

488      

489  

490      

491    //返回字段号码，例如005

492    publicstatic String getNumThree(inti){

493        String len="";

494        String iStr=String.valueOf(i);

495        len=strCopy("0",3-iStr.length())+iStr;

496        returnlen;

497    }

498      

499    /**

500     * 获取字符串变长值

501     * @param valueStr

502     * @param defLen

503     * 例如getFixLengthValue("12345678", 2)返回08

504     * 例如getFixLengthValue("12345678", 3)返回008

505     * 

506     * 注意变长长度的计算：

507     * 长度的判断使用转化后的字节数组长度，因为中文在不同的编码方式下，长度是不同的，GBK是2，UTF-8是3，按字符创长度算就是1.

508     * 解析报文是按照字节来解析的，所以长度以字节长度为准，防止中文带来乱码。

509     * 

510     * 比如一个变长域:aa索隆bb，如果按照字符串计算长度那么就是6，最后是06aa索隆bb。

511     * 这样在解析时按照字节解析长度就乱了，因为按照GBK字节解析，一个汉字占2，按照UTF-8解析，一个汉字占3.

512     * 所以在计算时必须按照字节长度为准！按照我们设置的UTF-8编码结果就是10aa索隆bb.

513     * 这样在解析时长度正好是10，也就不会乱了。

514     * @return

515     */

516    publicstatic String getVaryLengthValue(String valueStr,intdefLen){

517        returngetVaryLengthValue(valueStr,defLen,packet_encoding);

518    }

519    publicstatic String getVaryLengthValue(String valueStr,intdefLen,String encoding){

520        String fixLen="";

521        try{

522            if(valueStr==null){

523                returnstrCopy("0",defLen);

524            }else{

525                byte[] valueStrByte=null;

526                //这里最好指定编码，不使用平台默认编码

527                if(encoding==null||encoding.trim().equals("")){

528                    valueStrByte=valueStr.getBytes();

529                }else{

530                    valueStrByte=valueStr.getBytes(encoding);

531                }

532                //长度的判断使用转化后的字节数组长度，因为中文在不同的编码方式下，长度是不同的，GBK是2，UTF-8是3，按字符创长度算就是1.

533                //解析报文是按照字节来解析的，所以长度以字节长度为准，防止中文带来乱码

534                if(valueStrByte.length>(10*defLen)){

535                    returnnull;

536                }else{

537                    intlen=valueStrByte.length;//字段实际长度

538                    String len1=String.valueOf(len);

539                    fixLen=strCopy("0",(defLen-len1.length()))+len1;

540                }

541            } 

542        }catch (UnsupportedEncodingException e) {

543            e.printStackTrace();

544        }

545        returnfixLen;

546    }

547      

548    /**

549     * 将字段值做定长处理，不足定长则在后面补空格

550     * @param valueStr

551     * @param defLen

552     * @return

553     */

554    publicstatic String getFixFieldValue(String valueStr,intdefLen){

555        returngetFixFieldValue(valueStr,defLen,packet_encoding);

556    }

557    publicstatic String getFixFieldValue(String valueStr,intdefLen,String encoding){

558        String fixLen="";

559        try{

560            if(valueStr==null){

561                returnstrCopy(" ",defLen);

562            }else{

563                byte[] valueStrByte=null;

564                //这里最好指定编码，不使用平台默认编码

565                if(encoding==null||encoding.trim().equals("")){

566                    valueStrByte=valueStr.getBytes();

567                }else{

568                    valueStrByte=valueStr.getBytes(encoding);

569                }

570                //长度的判断使用转化后的字节数组长度，因为中文在不同的编码方式下，长度是不同的，GBK是2，UTF-8是3，按字符创长度算就是1.

571                //解析报文是按照字节来解析的，所以长度以字节长度为准，防止中文带来乱码

572                if(valueStrByte.length>defLen){

573                    returnnull;

574                }else{

575                    fixLen=valueStr+strCopy(" ",defLen-valueStrByte.length);

576                }

577            }

578        }catch (UnsupportedEncodingException e) {

579            e.printStackTrace();

580        }

581          

582        returnfixLen;

583    }

584      

585  

586    publicstatic String getPacket_encoding() {

587        returnpacket_encoding;

588    }

589  

590    publicstatic void setPacket_encoding(String packet_encoding) {

591        Lsy8583Util.packet_encoding = packet_encoding;

592    }

593  

594    publicstatic Map getMap8583Definition() {

595        returnmap8583Definition;

596    }

597  

598    publicstatic void setMap8583Definition(Map map8583Definition) {

599        Lsy8583Util.map8583Definition = map8583Definition;

600    }

601  

602}

报文域配置文件：config_8583.properties

view source

print?

001FIELD002 = string,16

002FIELD003 = string,4

003FIELD004 = string,20

004FIELD005 = string,20

005FIELD006 = string,20

006FIELD007 = string,10

007FIELD008 = string,32

008FIELD009 = string,3

009FIELD010 = string,20

010FIELD011 = string,6

011FIELD012 = string,6

012FIELD013 = string,10

013FIELD014 = string,10

014FIELD015 = string,10

015FIELD016 = string,6

016FIELD017 = string,6

017FIELD018 = string,6

018FIELD019 = string,6

019FIELD020 = string,7

020FIELD021 = string,7

021FIELD022 = string,3

022FIELD023 = string,3

023FIELD024 = string,8

024FIELD025 = string,5

025FIELD026 = string,8

026FIELD027 = string,1

027FIELD028 = string,5

028FIELD029 = string,5

029FIELD030 = string,5

030FIELD031 = string,10

031FIELD032 = string,VAR2

032FIELD033 = string,VAR2

033FIELD034 = string,VAR2

034FIELD035 = string,VAR2

035FIELD036 = string,VAR3

036FIELD037 = string,10

037FIELD038 = string,4

038FIELD039 = string,6

039FIELD040 = string,2

040FIELD041 = string,3

041FIELD042 = string,16

042FIELD043 = string,20

043FIELD044 = string,VAR2

044FIELD045 = string,VAR2

045FIELD046 = string,VAR3

046FIELD047 = string,VAR3

047FIELD048 = string,VAR3

048FIELD049 = string,3

049FIELD050 = string,VAR3

050FIELD051 = string,VAR3

051FIELD052 = string,16

052FIELD053 = string,VAR2

053FIELD054 = string,VAR3

054FIELD055 = string,VAR3

055FIELD056 = string,VAR3

056FIELD057 = string,VAR3

057FIELD058 = string,VAR3

058FIELD059 = string,VAR3

059FIELD060 = string,VAR3

060FIELD061 = string,VAR3

061FIELD062 = string,VAR3

062FIELD063 = string,VAR3

063FIELD064 = string,16

064FIELD065 = string,2

065FIELD066 = string,1

066FIELD067 = string,2

067FIELD068 = string,16

068FIELD069 = string,16

069FIELD070 = string,3

070FIELD071 = string,4

071FIELD072 = string,2

072FIELD073 = string,10

073FIELD074 = string,10

074FIELD075 = string,22

075FIELD076 = string,17

076FIELD077 = string,32

077FIELD078 = string,VAR3

078FIELD079 = string,6

079FIELD080 = string,32

080FIELD081 = string,32

081FIELD082 = string,4

082FIELD083 = string,4

083FIELD084 = string,6

084FIELD085 = string,15

085FIELD086 = string,20

086FIELD087 = string,20

087FIELD088 = string,20

088FIELD089 = string,6

089FIELD090 = string,9

090FIELD091 = string,9

091FIELD092 = string,9

092FIELD093 = string,VAR3

093FIELD094 = string,2

094FIELD095 = string,42

095FIELD096 = string,8

096FIELD097 = string,42

097FIELD098 = string,3

098FIELD099 = string,3

099FIELD100 = string,80

100FIELD101 = string,VAR3

101FIELD102 = string,80

102FIELD103 = string,80

103FIELD104 = string,VAR3

104FIELD105 = string,VAR3

105FIELD106 = string,VAR3

106FIELD107 = string,VAR3

107FIELD108 = string,2

108FIELD109 = string,VAR3

109FIELD110 = string,9

110FIELD111 = string,VAR3

111FIELD112 = string,VAR3

112FIELD113 = string,VAR3

113FIELD114 = string,VAR3

114FIELD115 = string,3

115FIELD116 = string,VAR3

116FIELD117 = string,VAR3

117FIELD118 = string,VAR3

118FIELD119 = string,VAR3

119FIELD120 = string,VAR3

120FIELD121 = string,32

121FIELD122 = string,VAR3

122FIELD123 = string,VAR3

123FIELD124 = string,VAR3

124FIELD125 = string,VAR3

125FIELD126 = string,VAR3

126FIELD127 = string,VAR3

127FIELD128 = string,8

简单说下，

FIELD031 = string,10
FIELD032 = string,VAR2

string代表域值类型（我只用到了string，别的就没定义了），10表示该域是定长10位。

如果是变长就定义成var,后面的2表示变长长度占2位，那么域最大就是99位。

 

运行打印结果：

view source

print?

1/D:/AppleZero/workSpace/apple/target/classes/

2Lsy8583Util使用编码配置:[encoding:UTF-8]

3组装后报文域 {FIELD003}==1799==,域长度:4

4组装后报文域 {FIELD008}==12345678901                     ==,域长度:32

5组装后报文域 {FIELD013}==2013-11-06==,域长度:10

6组装后报文域 {FIELD033}==10aa索隆bb==,域长度:12

7组装后报文域 {FIELD036}==006123456==,域长度:9

8  

9完成组装8583报文==?

打印的有些字节复制出来就看不到了，我把控制台打印截图吧。

图片分享：