java.sql.SQLException: Session Time Zone not set!

中可以拿到connection，但是最终却发现这个connection对象是个代理对象，强制转换成oracle.jdbc.OracleConnection时就会抛出类型转换的异常。如此将问题解决的对象转移到如何拿到oracle.jdbc.OracleConnection对象，最终在网上找到一篇相关文章，可以使用org.apache.ibatis.datasource.pooled.PooledDataSource的静态方法unwrapConnection(Connection conn)获得real connection 对象。如此即可强制转换成oracle.jdbc.OracleConnection之后再对sessionTimeZone进行设置。设置方式如下：

但是很遗憾的是，这个静态方法在当前mybatis最新办3.1.1版本中还有问题存在，它返回的依然是个代理对象(详见：http://code.google.com/p/mybatis/issues/detail?id=591)。所以也只能等以后版本的更新了。如果大家有更好的办法set session time zone的话，希望能跟我分享一下，谢谢！！

注：在mybatis将这个bug修复前，应该可以通过connection.createStatement().getConnection()拿到real connection

今天又发现一种方式，可以使用java.sql.Connection.unwrap(Class)方法拿到real connection. 不过如果驱动包使用的是classes12.jar是不行的，估计是classes12.jar出现的时候java.sql.Connection接口中没有unwrap方法。不过ojdbc6.jar这个驱动包是可用的，并且需要注意的是，setSessionTimeZone方法的调用需要在拿到mybatis的sqlSession之后再设置，在创建SqlSessionFactory之后设置是不起作用的。具体原因应该是只有在拿SqlSession的时候才会去跟数据库建立连接吧。而且由于配置连接池的缘故，所以每次都的手动设置，具体代码如下：

好久没有更新百度博客，最近玩DOS，突然想找个地方把自己学习的东西总结整理一下，基本的DOS命令，希望和大家共同交流，如有关于本人的任何问题，我们可以互相交流一下。

MD(Make Directory)

功能：创建新的子目录　

类型：内部命令　 　　

格式：md <盘符:><路径名> <子目录名>

实例：

在本地磁盘E下新建一个love文件夹，并在其下新建dos文件夹目录

CD(Change Directory)

功能：改变当前目录

类型：内部命令　 　　

格式：cd <盘符:> <路径名> <子目录名>

实例：

根目录是驱动器的目录树状结构的顶层，要返回到根目录，在命令行输入：cd \

如果想返回到上一层目录，在当前命令提示符下输入cd..

如果想进入下一层目录，在当前命令提示符下输入cd 目录名。在命令提示符C:\>documents and setting\cd adminstrator

如果想改变当前驱动器的目录c:\documents and settings，进入到e驱动器默认目录，在当前命令行输入e: 

如果想在当前C驱动器上将E驱动器上的默认目录更改为E:\gqdp，在命令行输入cd /d e:\gdqp,同样可以直接进入其他驱动器目录

 

RD(Remove Directory)

功能：从指定的磁盘删除目录

类型：内部命令　 　　

格式：rd<盘符:> <路径名> <子目录名>

                                       q=quiet

实例：

如果要删除e:\abc下的def文件夹（空或非空）。可以在命令提示符窗口下执行以下命令：rd /s /q e:\abc\def

如果我们所删除的目录文件夹下面还有其他内容（.doc .ppt .txt .bat .tmp...）我们必须加上/s，若不加如下图

如果我们再删除磁盘目录文件夹的时候不加/q，那么他们会提示我们Y或N来确认删除与否，如下图

前面举的几个例子都是在磁盘c环境下删除其他磁盘的文件或目录，那么删除本盘的文件就更加简单了，在e盘根目录删除其下123所有目录及其子目录文件，不需要提示，直接删除 如下图

Tree

功能：显示指定驱动器上所有目录路径和这些目录下的所有文件名

类型：外部命令　 　　

格式：tree <盘符:> </f> </a>　

实例：

如果目录下子目录比较多，子目录下文件又比较多的话，我们使用tree命令会发现一屏还没有看完就直接刷过去了，这里可以用more命令，具体为tree /f | more，类似/p的作用，不过/p继续浏览是回车，但是 | more是空格 如下图

和dir原理相似，tree同样可以输出 E:\>tree /f>e:\123.txt&start e:\123.txt

单向认证 SSL 协议的具体过程
①客户端的浏览器向服务器传送客户端 SSL 协议的版本号，加密算法的种类，产生的随机数，以及其他服务器和客户端之间通讯所需要的各种信息。
②服务器向客户端传送 SSL 协议的版本号，加密算法的种类，随机数以及其他相关信息，同时服务器还将向客户端传送自己的证书。
③客户利用服务器传过来的信息验证服务器的合法性，服务器的合法性包括：证书是否过期，发行服务器证书的 CA 是否可靠，发行者证书的公钥能否正确解开服务器证书的“发行者的数字签名”，服务器证书上的域名是否和服务器的实际域名相匹配。如果合法性验证没有通过，通讯将断开；如果合法性验证通过，将继续进行第四步。
④用户端随机产生一个用于后面通讯的“对称密码”，然后用服务器的公钥（服务器的公钥从步骤②中的服务器的证书中获得）对其加密，然后将加密后的“预主密码”传给服务器。
⑤如果服务器要求客户的身份认证（在握手过程中为可选），用户可以建立一个随机数然后对其进行数据签名，将这个含有签名的随机数和客户自己的证书以及加密过的“预主密码”一起传给服务器。
⑥如果服务器要求客户的身份认证，服务器必须检验客户证书和签名随机数的合法性，具体的合法性验证过程包括：客户的证书使用日期是否有效，为客户提供证书的CA 是否可靠，发行CA 的公钥能否正确解开客户证书的发行 CA 的数字签名，检查客户的证书是否在证书废止列表（CRL）中。检验如果没有通过，通讯立刻中断；如果验证通过，服务器将用自己的私钥解开加密的“预主密码 ”，然后执行一系列步骤来产生主通讯密码（客户端也将通过同样的方法产生相同的主通讯密码）。
⑦服务器和客户端用相同的主密码即“通话密码”，一个对称密钥用于 SSL 协议的安全数据通讯的加解密通讯。同时在 SSL 通讯过程中还要完成数据通讯的完整性，防止数据通讯中的任何变化。
⑧客户端向服务器端发出信息，指明后面的数据通讯将使用的步骤⑦中的主密码为对称密钥，同时通知服务器客户端的握手过程结束。
⑨服务器向客户端发出信息，指明后面的数据通讯将使用的步骤⑦中的主密码为对称密钥，同时通知客户端服务器端的握手过程结束。
⑩SSL 的握手部分结束，SSL 安全通道的数据通讯开始，客户和服务器开始使用相同的对称密钥进行数据通讯，同时进行通讯完整性的检验。

双向认证 SSL 协议的具体过程
① 浏览器发送一个连接请求给安全服务器。
② 服务器将自己的证书，以及同证书相关的信息发送给客户浏览器。
③ 客户浏览器检查服务器送过来的证书是否是由自己信赖的 CA 中心所签发的。如果是，就继续执行协议；如果不是，客户浏览器就给客户一个警告消息：警告客户这个证书不是可以信赖的，询问客户是否需要继续。
④ 接着客户浏览器比较证书里的消息，例如域名和公钥，与服务器刚刚发送的相关消息是否一致，如果是一致的，客户浏览器认可这个服务器的合法身份。
⑤ 服务器要求客户发送客户自己的证书。收到后，服务器验证客户的证书，如果没有通过验证，拒绝连接；如果通过验证，服务器获得用户的公钥。
⑥ 客户浏览器告诉服务器自己所能够支持的通讯对称密码方案。
⑦ 服务器从客户发送过来的密码方案中，选择一种加密程度最高的密码方案，用客户的公钥加过密后通知浏览器。
⑧ 浏览器针对这个密码方案，选择一个通话密钥，接着用服务器的公钥加过密后发送给服务器。
⑨ 服务器接收到浏览器送过来的消息，用自己的私钥解密，获得通话密钥。
⑩ 服务器、浏览器接下来的通讯都是用对称密码方案，对称密钥是加过密的。
上面所述的是双向认证 SSL 协议的具体通讯过程，这种情况要求服务器和用户双方都有证书。单向认证 SSL 协议不需要客户拥有 CA 证书，具体的过程相对于上面的步骤，只需将服务器端验证客户证书的过程去掉，以及在协商对称密码方案，对称通话密钥时，服务器发送给客户的是没有加过密的（这并不影响 SSL 过程的安全性）密码方案。这样，双方具体的通讯内容，就是加过密的数据，如果有第三方攻击，获得的只是加密的数据，第三方要获得有用的信息，就需要对加密的数据进行解密，这时候的安全就依赖于密码方案的安全。而幸运的是，目前所用的密码方案，只要通讯密钥长度足够的长，就足够的安全。这也是我们强调要求使用 128 位加密通讯的原因。

前段时间做了一个涉及到IS08583报文协议的项目，自己总结写了这篇附有java源代码的文章，希望能给大家提供一些帮助，本文分四个部分介绍IS08583报文协议包的处理及如何解析请求包及怎样封装返回包，

一：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 [n] & 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);
 }
}

源代码测试没有问题。