JAVA中DES对称加密

把下面两个工具类直接复制过去，再参考最下面的用法就OK了，简单快捷，亲测有效。

//加密解密工具类
public class DesEncryptUtil {
 public final static String KEY = "demo";

 /**
  * 对称加解密DES
  */
 // -----------DES加密与解密--------------

 /**
  * 使用对称加密DES方式对数据进行加密
  * 
  * @param data
  *            要加密的数据（字节数组）
  * @param keyData
  *            加密用的密钥（字节数组）长度必须为8个字节否则返回null
  * @return 返回加密过的数据（字节数组）
  */
 public static byte[] desEncrypt(byte[] data, byte[] keyData) {
  return des(Cipher.ENCRYPT_MODE, data, keyData);
 }

 /**
  * 解密使用对称加密DES方式加密过的数据
  * 
  * @param data
  *            加密过的数据（字节数组）
  * @param keyData
  *            解密用的密钥（字节数组）长度必须为8个字节否则返回null
  * @return 返回解密后的字节数组
  */
 public static byte[] desDecrypt(byte[] data, byte[] keyData) {
  return des(Cipher.DECRYPT_MODE, data, keyData);
 }

 private static byte[] des(int mode, byte[] data, byte[] keyData) {
  byte[] ret = null;
  if (data != null && data.length > 0 && keyData != null && keyData.length == 8) {
   try {
    Cipher cipher = Cipher.getInstance("DES");
    // 3、准备Key对象
    // 3.1、DES 使用DESKeySpec,内部构造指定8个字节密码即可
    DESKeySpec keySpec = new DESKeySpec(keyData);

    // 3.2、DeSKeySpec 需要转换成Key对象，才可以继续使用
    // 需要使用SecretKeyFactory来处理
    SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
    // 3.3 生成Key对象
    SecretKey key = keyFactory.generateSecret(keySpec);
    // 2、设置Cipher是加密还是解密，模式
    // 同时对于对称加密还需要设置密码Key对象
    // 参数2使用Key对象
    cipher.init(mode, key);

    ret = cipher.doFinal(data);

   } catch (Exception e) {
    e.printStackTrace();
   }
  }
  return ret;
 }
}

//HEX转码工具类
public class HexUtils {
 /**
  * 用于建立十六进制字符的输出的小写字符数组
  */
 private static final char[] DIGITS_LOWER = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };

 /**
  * 用于建立十六进制字符的输出的大写字符数组
  */
 private static final char[] DIGITS_UPPER = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };

 /**
  * 将字节数组转换为十六进制字符数组
  * 
  * @param data
  *            byte[]
  * @return 十六进制char[]
  */
 public static char[] encodeHex(byte[] data) {
  return encodeHex(data, true);
 }

 /**
  * 将字节数组转换为十六进制字符数组
  * 
  * @param data
  *            byte[]
  * @param toLowerCase
  *            <code>true</code> 传换成小写格式 ， <code>false</code> 传换成大写格式
  * @return 十六进制char[]
  */
 public static char[] encodeHex(byte[] data, boolean toLowerCase) {
  return encodeHex(data, toLowerCase ? DIGITS_LOWER : DIGITS_UPPER);
 }

 /**
  * 将字节数组转换为十六进制字符数组
  * 
  * @param data
  *            byte[]
  * @param toDigits
  *            用于控制输出的char[]
  * @return 十六进制char[]
  */
 protected static char[] encodeHex(byte[] data, char[] toDigits) {
  int l = data.length;
  char[] out = new char[l << 1];
  // two characters form the hex value.
  for (int i = 0, j = 0; i < l; i++) {
   out[j++] = toDigits[(0xF0 & data[i]) >>> 4];
   out[j++] = toDigits[0x0F & data[i]];
  }
  return out;
 }

 /**
  * 将字节数组转换为十六进制字符串
  * 
  * @param data
  *            byte[]
  * @return 十六进制String
  */
 public static String encodeHexStr(byte[] data) {
  return encodeHexStr(data, true);
 }

 /**
  * 将字节数组转换为十六进制字符串
  * 
  * @param data
  *            byte[]
  * @param toLowerCase
  *            <code>true</code> 传换成小写格式 ， <code>false</code> 传换成大写格式
  * @return 十六进制String
  */
 public static String encodeHexStr(byte[] data, boolean toLowerCase) {
  return encodeHexStr(data, toLowerCase ? DIGITS_LOWER : DIGITS_UPPER);
 }

 /**
  * 将字节数组转换为十六进制字符串
  * 
  * @param data
  *            byte[]
  * @param toDigits
  *            用于控制输出的char[]
  * @return 十六进制String
  */
 protected static String encodeHexStr(byte[] data, char[] toDigits) {
  return new String(encodeHex(data, toDigits));
 }

 /**
  * 将十六进制字符数组转换为字节数组
  * 
  * @param data
  *            十六进制char[]
  * @return byte[]
  * @throws RuntimeException
  *             如果源十六进制字符数组是一个奇怪的长度，将抛出运行时异常
  */
 public static byte[] decodeHex(char[] data) {

  int len = data.length;

  if ((len & 0x01) != 0) {
   throw new RuntimeException("Odd number of characters.");
  }

  byte[] out = new byte[len >> 1];

  // two characters form the hex value.
  for (int i = 0, j = 0; j < len; i++) {
   int f = toDigit(data[j], j) << 4;
   j++;
   f = f | toDigit(data[j], j);
   j++;
   out[i] = (byte) (f & 0xFF);
  }

  return out;
 }

 /**
  * 将十六进制字符转换成一个整数
  * 
  * @param ch
  *            十六进制char
  * @param index
  *            十六进制字符在字符数组中的位置
  * @return 一个整数
  * @throws RuntimeException
  *             当ch不是一个合法的十六进制字符时，抛出运行时异常
  */
 protected static int toDigit(char ch, int index) {
  int digit = Character.digit(ch, 16);
  if (digit == -1) {
   throw new RuntimeException("Illegal hexadecimal character " + ch + " at index " + index);
  }
  return digit;
 }
}

加密：
HexUtils.encodeHexStr(DesEncryptUtil.desEncrypt("iamapassword".getBytes(), DesEncryptUtil.KEY.getBytes()));

解密：
new String(DesEncryptUtil.desDecrypt(HexUtils.decodeHex(取到的加密数据字符串.toCharArray()),
      DesEncryptUtil.KEY.getBytes()));