自写AES加密解密工具类

此类主要用于加密与解密，采用128位ECB模式，PKCS5Padding填充补位。

可使用方法为加密返回二进制encryptBin(content, key)、加密返回十六进制encryptHex(content, key)、二进制内容解密decryptBin(content, key)、十六进制内容解密decryptHex(content, key)。

content是需要加密的字符串，key是密钥，随意一个字符串。

 package com.test;

 import java.io.UnsupportedEncodingException;
 import java.security.InvalidKeyException;
 import java.security.NoSuchAlgorithmException;
 import java.security.SecureRandom;

 import javax.crypto.BadPaddingException;
 import javax.crypto.Cipher;
 import javax.crypto.IllegalBlockSizeException;
 import javax.crypto.KeyGenerator;
 import javax.crypto.NoSuchPaddingException;
 import javax.crypto.SecretKey;
 import javax.crypto.spec.SecretKeySpec;

 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;

 public class AESCode {

     private static final String algorithm = "AES";
     private static final String transformation = "AES/ECB/PKCS5Padding";
     private static final String charset = "utf-8";

     private static final Log _log = LogFactory.getLog(AESCode.class);

     /**
      * 获取key 填充密匙 获取加密的密匙数据
      *
      * @paramString key
      * @return byte[] enCodeFormat;
      * @author panjianghong 2016-8-29
      * */
     private static byte[] getEnCodeFormat(String key){

         try {
             KeyGenerator kgen = KeyGenerator.getInstance("AES");
             kgen.init(128, new SecureRandom(key.getBytes()));
             SecretKey secretKey = kgen.generateKey();
             byte[] enCodeFormat = secretKey.getEncoded();
             return enCodeFormat;
         } catch (NoSuchAlgorithmException e) {
             _log.error("获取密匙数据失败！");
         }
         return null;
     }

     /**
      * 获取加密数据的二进制字符串数据
      *
      * @param  content
      * @param  enCodeFormat
      * @return String
      * @author panjianghong 2016-8-29
      * */
     public static String encryptBin(String content, String key){

         try {
             byte[] byteConten = encrypt(content, key);
             return byte2BinString(byteConten);
         } catch (Exception e) {
             _log.error("获取二进制加密数据失败！");
         }
         return null;
     }

     /**
      * 获取加密数据的十六进制字符串数据
      *
      * @param  content
      * @param  enCodeFormat
      * @return String
      * @author panjianghong 2016-8-29
      * */
     public static String encryptHex(String content, String key){

         try {
             byte[] byteConten = encrypt(content, key);
             return byte2HexString(byteConten);
         } catch (Exception e) {
             _log.error("获取十六进制加密数据失败！");
         }
         return null;
     }

     /**
      * 获取文件的加密数据
      * 返回加密数据的字节数组 byte[]
      *
      * @param  content
      * @param  enCodeFormat
      * @return  byte[] byteResoult
      * @author panjianghong 2016-8-29
      * */
     private static byte[] encrypt(String content, String key){

         try {
             SecretKeySpec secretyKey = new SecretKeySpec(getEnCodeFormat(key), algorithm);
             Cipher cipher = Cipher.getInstance(transformation);
             byte[] byteContent = content.getBytes(charset);
             cipher.init(Cipher.ENCRYPT_MODE, secretyKey);
             byte[] byteResoult = cipher.doFinal(byteContent);
             return byteResoult;
         } catch (InvalidKeyException e) {
             _log.error("获取加密数据的字节数组失败！");
         } catch (NoSuchAlgorithmException e) {
             _log.error("获取加密数据的字节数组失败！");
         } catch (NoSuchPaddingException e) {
             _log.error("获取加密数据的字节数组失败！");
         } catch (UnsupportedEncodingException e) {
             _log.error("获取加密数据的字节数组失败！");
         } catch (IllegalBlockSizeException e) {
             _log.error("获取加密数据的字节数组失败！");
         } catch (BadPaddingException e) {
             _log.error("获取加密数据的字节数组失败！");
         }

         return null;
     }

     /**
      * 以二进制字符串数据进行解密
      *
      * @param  content
      * @param  enCodeFormat
      * @return  String
      * @author panjianghong 2016-8-29
      * */

     public static String decryptBin(String binContent, String key){

         try {
             SecretKeySpec secretyKey = new SecretKeySpec(getEnCodeFormat(key), algorithm);
             Cipher cipher = Cipher.getInstance(transformation);
             cipher.init(Cipher.DECRYPT_MODE, secretyKey);
             byte[] byteResoult = cipher.doFinal(binString2Byte(binContent));
             try {
                 return new String(byteResoult,"utf-8");
             } catch (UnsupportedEncodingException e) {
                 _log.error("解密二进制数据失败！");
                 return null;
             }
         } catch (InvalidKeyException e) {
             _log.error("解密二进制数据失败！");
         } catch (NoSuchAlgorithmException e) {
             _log.error("解密二进制数据失败！");
         } catch (NoSuchPaddingException e) {
             _log.error("解密二进制数据失败！");
         } catch (IllegalBlockSizeException e) {
             _log.error("解密二进制数据失败！");
         } catch (BadPaddingException e) {
             _log.error("解密二进制数据失败！");
         }

         return null;
     }

     /**
      * 以十六进制字符串数据进行解密
      *
      * @param  content
      * @param  enCodeFormat
      * @return  String
      * @author panjianghong 2016-8-29
      * */
     public static String decryptHex(String binContent, String key){

         try {
             SecretKeySpec secretyKey = new SecretKeySpec(getEnCodeFormat(key), algorithm);
             Cipher cipher = Cipher.getInstance(transformation);
             cipher.init(Cipher.DECRYPT_MODE, secretyKey);
             byte[] byteResoult = cipher.doFinal(hexString2Byte(binContent));
             try {
                 return new String(byteResoult,"utf-8");
             } catch (UnsupportedEncodingException e) {
                 _log.error("解密十六进制数据失败！");
                 return null;
             }
         } catch (InvalidKeyException e) {
             _log.error("解密十六进制数据失败！");
         } catch (NoSuchAlgorithmException e) {
             _log.error("解密十六进制数据失败！");
         } catch (NoSuchPaddingException e) {
             _log.error("解密十六进制数据失败！");
         } catch (IllegalBlockSizeException e) {
             _log.error("解密十六进制数据失败！");
         } catch (BadPaddingException e) {
             _log.error("解密十六进制数据失败！");
         }

         return null;
     }

     /**
      * 字节数组转化成二进制数
      * @param  content
      * @return  string
      * @author panjianghong 2016-8-29
      * */
     private static String byte2BinString(byte[] content){
         if(null == content){
             _log.error("需要转换的参数为空！");
             return null;
         }

         return hexString2BinString(byte2HexString(content));
     }    

     /**
      * 字节数组转化成十六进制数的小写形式
      * @param  content
      * @return  string
      * @author panjianghong 2016-8-29
      * */
     private static String byte2HexString(byte[] content){
         if(null == content){
             _log.error("需要转换的参数为空！");
             return null;
         }

         StringBuffer sb = new StringBuffer();
         for (int i = 0; i < content.length; i++) {
             String hex = Integer.toHexString(content[i] & 0xFF);
             if (hex.length() == 1) {
                 hex = '0' + hex;
             }
             sb.append(hex.toLowerCase());
         }

         return sb.toString();
     }

     /**
      * 十六进制数转化成二进制数
      * @param  content
      * @return string
      * @author panjianghong 2016-8-29
      * */
     private static String hexString2BinString(String content){

         if (null == content || content.length() % 2 != 0) {
             _log.error("需要转换的参数为空或者参数长度不是2的倍数！");
             return null;
         }

         StringBuffer bString = new StringBuffer();
         StringBuffer tmp = new StringBuffer();
         for (int i = 0; i < content.length(); i++)
         {
             tmp.append("0000").append(Integer.toBinaryString(Integer.parseInt(content.substring(i, i + 1), 16)));
             bString.append(tmp.toString().substring(tmp.toString().length() - 4));
             tmp.delete(0, tmp.toString().length());
         }
         return bString.toString();
     }
     /**
      * 二进制数转化成十六进制数
      * @param  content
      * @return string
      * @author panjianghong 2016-8-29
      * */
     private static String BinString2hexString(String content){

         if (null == content || content.equals("") || content.length() % 8 != 0){
             _log.error("需要转换的参数为空或者参数长度不是8的倍数！");
             return null;
         }

         StringBuffer tmp = new StringBuffer();
         int iTmp = 0;
         for (int i = 0; i < content.length(); i += 4)
         {
             iTmp = 0;
             for (int j = 0; j < 4; j++)
             {
                 iTmp += Integer.parseInt(content.substring(i + j, i + j + 1)) << (4 - j - 1);
             }
             tmp.append(Integer.toHexString(iTmp));
         }
         return tmp.toString();
     }

     /**
      * 16进制数转化成字节数组
      * @param  content
      * @return string
      * @author panjianghong 2016-8-29
      * */
     private static byte[] hexString2Byte(String content){
          if (content.length() < 1){
              _log.error("需要转换的参数为空或者参数长度<1！");
              return null;
          }

         byte[] byteRresult = new byte[content.length() / 2];
         for (int i = 0; i < content.length() / 2; i++) {
             int high = Integer.parseInt(content.substring(i * 2, i * 2 + 1), 16);
             int low = Integer.parseInt(content.substring(i * 2 + 1, i * 2 + 2), 16);
             byteRresult[i] = (byte) (high * 16 + low);
         }
         return byteRresult;
     }

     /**
      * 二进制数转化成字节数组
      * @param  content
      * @return string
      * @author panjianghong 2016-8-29
      * */
     private static byte[] binString2Byte(String content){
          if (content.length() < 1){
              _log.error("需要转换的参数为空或者参数长度<1！");
              return null;
          }

         return hexString2Byte(BinString2hexString(content));
     }

 }