java实现DES加密与解密，md5加密

很多时候要对秘要进行持久化加密，此时的加密采用md5。采用对称加密的时候就采用DES方法了

 import java.io.IOException;
 import java.security.MessageDigest;
 import java.security.SecureRandom;

 import javax.crypto.Cipher;
 import javax.crypto.SecretKey;
 import javax.crypto.SecretKeyFactory;
 import javax.crypto.spec.DESKeySpec;

 import sun.misc.BASE64Decoder;
 import sun.misc.BASE64Encoder;

 /**
  * 密匙工具类(包含des加密与md5加密)
  * @author mingge
  *
  */
 public class KeysUtil {

         private final static String DES = "DES";

         private final static String MD5 = "MD5";

         private final static String KEY="opeddsaead323353484591dadbc382a18340bf83414536";

         /**
          * MD5加密算法
          * @param data
          * @return
          */
         public static String md5Encrypt(String data) {
             String resultString = null;
             try {
                 resultString = new String(data);
                 MessageDigest md = MessageDigest.getInstance(MD5);
                 resultString =byte2hexString(md.digest(resultString.getBytes()));
             } catch (Exception ex) {
             }
             return resultString;
         }

         private  static String byte2hexString(byte[] bytes) {
             StringBuffer bf = new StringBuffer(bytes.length * 2);
             for (int i = 0; i < bytes.length; i++) {
                 if ((bytes[i] & 0xff) < 0x10) {
                     bf.append("T0");
                 }
                 bf.append(Long.toString(bytes[i] & 0xff, 16));
             }
             return bf.toString();
         }

         /**
          * Description 根据键值进行加密
          * @param data
          * @param key  加密键byte数组
          * @return
          * @throws Exception
          */
         public static String desEncrypt(String data, String key) throws Exception {
             if (key==null) {
                 key=KEY;
             }
             byte[] bt = encrypt(data.getBytes(), key.getBytes());
             String strs = new BASE64Encoder().encode(bt);
             return strs;
         }

         /**
          * Description 根据键值进行解密
          * @param data
          * @param key  加密键byte数组
          * @return
          * @throws IOException
          * @throws Exception
          */
         public static String desDecrypt(String data, String key) throws IOException,
                 Exception {
             if (data == null){
                 return null;
             }
             if (key==null) {
                 key=KEY;
             }
             BASE64Decoder decoder = new BASE64Decoder();
             byte[] buf = decoder.decodeBuffer(data);
             byte[] bt = decrypt(buf,key.getBytes());
             return new String(bt);
         }

         /**
          * Description 根据键值进行加密
          * @param data
          * @param key  加密键byte数组
          * @return
          * @throws Exception
          */
         private static byte[] encrypt(byte[] data, byte[] key) throws Exception {
             // 生成一个可信任的随机数源
             SecureRandom sr = new SecureRandom();
             // 从原始密钥数据创建DESKeySpec对象
             DESKeySpec dks = new DESKeySpec(key);
             // 创建一个密钥工厂，然后用它把DESKeySpec转换成SecretKey对象
             SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);
             SecretKey securekey = keyFactory.generateSecret(dks);
             // Cipher对象实际完成加密操作
             Cipher cipher = Cipher.getInstance(DES);
             // 用密钥初始化Cipher对象
             cipher.init(Cipher.ENCRYPT_MODE, securekey, sr);
             return cipher.doFinal(data);
         }

         /**
          * Description 根据键值进行解密
          * @param data
          * @param key  加密键byte数组
          * @return
          * @throws Exception
          */
         private static byte[] decrypt(byte[] data, byte[] key) throws Exception {
             // 生成一个可信任的随机数源
             SecureRandom sr = new SecureRandom();
             // 从原始密钥数据创建DESKeySpec对象
             DESKeySpec dks = new DESKeySpec(key);
             // 创建一个密钥工厂，然后用它把DESKeySpec转换成SecretKey对象
             SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);
             SecretKey securekey = keyFactory.generateSecret(dks);
             // Cipher对象实际完成解密操作
             Cipher cipher = Cipher.getInstance(DES);
             // 用密钥初始化Cipher对象
             cipher.init(Cipher.DECRYPT_MODE, securekey, sr);
             return cipher.doFinal(data);
         }
 }

看到最后我也醉了。。。