Main.java

  1. public class Main {
  3.     public static void main(String[] args) {
  5.         String pfxpwd = "217526";// 私钥密码
  6.         String pfxpath = "D:\\CER\\8000013189_pri.pfx";//商户私钥路径
  7.         String base64str = "123456";// 待加密的字符串
  8.         base64str.replaceAll("\r", "").replaceAll("\n", "");//重要 避免出现换行空格符
  9.         String data_content = RsaCodingUtil.encryptByPriPfxFile(base64str, pfxpath, pfxpwd);//加密数据
  10.         System.out.println(data_content);
  12.     }
  14. }

RsaCodingUtil.java

  1. import java.io.UnsupportedEncodingException;
  2. import java.security.InvalidKeyException;
  3. import java.security.NoSuchAlgorithmException;
  4. import java.security.PrivateKey;
  5. import java.security.PublicKey;
  6. import java.text.SimpleDateFormat;
  7. import java.util.Date;
  8. import javax.crypto.BadPaddingException;
  9. import javax.crypto.Cipher;
  10. import javax.crypto.IllegalBlockSizeException;
  11. import javax.crypto.NoSuchPaddingException;
  13. /**
  14.  * <b>Rsa加解密工具</b><br>
  15.  * <br>
  16.  * 公钥采用X509,Cer格式的<br>
  17.  * 私钥采用PKCS12加密方式的PFX私钥文件<br>
  18.  * 加密算法为1024位的RSA，填充算法为PKCS1Padding<br>
  19.  * 
  20.  * @author 行者
  21.  * @version 4.1.0
  22.  */
  23. public final class RsaCodingUtil {
  25.     // ======================================================================================
  26.     // 公钥加密私钥解密段
  27.     // ======================================================================================
  29.     /**
  30.      * 指定Cer公钥路径加密
  31.      * 
  32.      * @param src
  33.      * @param pubCerPath
  34.      * @return hex串
  35.      */
  36.     public static String encryptByPubCerFile(String src, String pubCerPath) {
  38.         PublicKey publicKey = RsaReadUtil.getPublicKeyFromFile(pubCerPath);
  39.         if (publicKey == null) {
  40.             return null;
  41.         }
  42.         return encryptByPublicKey(src, publicKey);
  43.     }
  45.     /**
  46.      * 用公钥内容加密
  47.      * 
  48.      * @param src
  49.      * @param pubKeyText
  50.      * @return hex串
  51.      */
  52.     public static String encryptByPubCerText(String src, String pubKeyText) {
  53.         PublicKey publicKey = RsaReadUtil.getPublicKeyByText(pubKeyText);
  54.         if (publicKey == null) {
  55.             return null;
  56.         }
  57.         return encryptByPublicKey(src, publicKey);
  58.     }
  60.     /**
  61.      * 公钥加密返回
  62.      * 
  63.      * @param src
  64.      * @param publicKey
  65.      * @param encryptMode
  66.      * @return hex串
  67.      */
  68.     public static String encryptByPublicKey(String src, PublicKey publicKey) {
  69.         byte[] destBytes = rsaByPublicKey(src.getBytes(), publicKey, Cipher.ENCRYPT_MODE);
  71.         if (destBytes == null) {
  72.             return null;
  73.         }
  75.         return FormatUtil.byte2Hex(destBytes);
  77.     }
  79.     /**
  80.      * 根据私钥文件解密
  81.      * 
  82.      * @param src
  83.      * @param pfxPath
  84.      * @param priKeyPass
  85.      * @return
  86.      */
  87.     public static String decryptByPriPfxFile(String src, String pfxPath, String priKeyPass) {
  88.         if (FormatUtil.isEmpty(src) || FormatUtil.isEmpty(pfxPath)) {
  89.             return null;
  90.         }
  91.         PrivateKey privateKey = RsaReadUtil.getPrivateKeyFromFile(pfxPath, priKeyPass);
  92.         if (privateKey == null) {
  93.             return null;
  94.         }
  95.         return decryptByPrivateKey(src, privateKey);
  96.     }
  98.     /**
  99.      * 根据私钥文件流解密
  100.      * 
  101.      * @param src
  102.      * @param pfxPath
  103.      * @param priKeyPass
  104.      * @return
  105.      */
  106.     public static String decryptByPriPfxStream(String src, byte[] pfxBytes, String priKeyPass) {
  107.         if (FormatUtil.isEmpty(src)) {
  108.             return null;
  109.         }
  110.         PrivateKey privateKey = RsaReadUtil.getPrivateKeyByStream(pfxBytes, priKeyPass);
  111.         if (privateKey == null) {
  112.             return null;
  113.         }
  114.         return decryptByPrivateKey(src, privateKey);
  115.     }
  117.     /**
  118.      * 私钥解密
  119.      * 
  120.      * @param src
  121.      * @param privateKey
  122.      * @return
  123.      */
  124.     public static String decryptByPrivateKey(String src, PrivateKey privateKey) {
  125.         if (FormatUtil.isEmpty(src)) {
  126.             return null;
  127.         }
  128.         try {
  129.             byte[] destBytes = rsaByPrivateKey(FormatUtil.hex2Bytes(src), privateKey, Cipher.DECRYPT_MODE);
  130.             if (destBytes == null) {
  131.                 return null;
  132.             }
  133.             return new String(destBytes, RsaConst.ENCODE);
  134.         } catch (UnsupportedEncodingException e) {
  135.             // //log.error("解密内容不是正确的UTF8格式:", e);
  136.         } catch (Exception e) {
  137.             // //log.error("解密内容异常", e);
  138.         }
  140.         return null;
  141.     }
  143.     // ======================================================================================
  144.     // 私钥加密公钥解密
  145.     // ======================================================================================
  147.     /**
  148.      * 根据私钥文件加密
  149.      * 
  150.      * @param src
  151.      * @param pfxPath
  152.      * @param priKeyPass
  153.      * @return
  154.      */
  155.     public static String encryptByPriPfxFile(String src, String pfxPath, String priKeyPass) {
  157.         PrivateKey privateKey = RsaReadUtil.getPrivateKeyFromFile(pfxPath, priKeyPass);
  158.         if (privateKey == null) {
  159.             return null;
  160.         }
  161.         return encryptByPrivateKey(src, privateKey);
  162.     }
  164.     /**
  165.      * 根据私钥文件流加密
  166.      * 
  167.      * @param src
  168.      * @param pfxPath
  169.      * @param priKeyPass
  170.      * @return
  171.      */
  172.     public static String encryptByPriPfxStream(String src, byte[] pfxBytes, String priKeyPass) {
  173.         PrivateKey privateKey = RsaReadUtil.getPrivateKeyByStream(pfxBytes, priKeyPass);
  174.         if (privateKey == null) {
  175.             return null;
  176.         }
  177.         return encryptByPrivateKey(src, privateKey);
  178.     }
  180.     /**
  181.      * 根据私钥加密
  182.      * 
  183.      * @param src
  184.      * @param privateKey
  185.      */
  186.     public static String encryptByPrivateKey(String src, PrivateKey privateKey) {
  188.         byte[] destBytes = rsaByPrivateKey(src.getBytes(), privateKey, Cipher.ENCRYPT_MODE);
  190.         if (destBytes == null) {
  191.             return null;
  192.         }
  193.         return FormatUtil.byte2Hex(destBytes);
  195.     }
  197.     /**
  198.      * 指定Cer公钥路径解密
  199.      * 
  200.      * @param src
  201.      * @param pubCerPath
  202.      * @return
  203.      */
  204.     public static String decryptByPubCerFile(String src, String pubCerPath) {
  205.         PublicKey publicKey = RsaReadUtil.getPublicKeyFromFile(pubCerPath);
  206.         if (publicKey == null) {
  207.             return null;
  208.         }
  209.         return decryptByPublicKey(src, publicKey);
  210.     }
  212.     /**
  213.      * 根据公钥文本解密
  214.      * 
  215.      * @param src
  216.      * @param pubKeyText
  217.      * @return
  218.      */
  219.     public static String decryptByPubCerText(String src, String pubKeyText) {
  220.         PublicKey publicKey = RsaReadUtil.getPublicKeyByText(pubKeyText);
  221.         if (publicKey == null) {
  222.             return null;
  223.         }
  224.         return decryptByPublicKey(src, publicKey);
  225.     }
  227.     /**
  228.      * 根据公钥解密
  229.      * 
  230.      * @param src
  231.      * @param publicKey
  232.      * @return
  233.      */
  234.     public static String decryptByPublicKey(String src, PublicKey publicKey) {
  236.         try {
  237.             byte[] destBytes = rsaByPublicKey(FormatUtil.hex2Bytes(src), publicKey, Cipher.DECRYPT_MODE);
  238.             if (destBytes == null) {
  239.                 return null;
  240.             }
  241.             return new String(destBytes, RsaConst.ENCODE);
  242.         } catch (UnsupportedEncodingException e) {
  243.             log("解密出错" + e);
  245.         }
  246.         return null;
  247.     }
  249.     // ======================================================================================
  250.     // 公私钥算法
  251.     // ======================================================================================
  252.     /**
  253.      * 公钥算法
  254.      * 
  255.      * @param srcData   源字节
  256.      * @param publicKey 公钥
  257.      * @param mode      加密 OR 解密
  258.      * @return
  259.      */
  260.     public static byte[] rsaByPublicKey(byte[] srcData, PublicKey publicKey, int mode) {
  261.         try {
  262.             Cipher cipher = Cipher.getInstance(RsaConst.RSA_CHIPER);
  263.             cipher.init(mode, publicKey);
  264.             // 分段加密
  265.             int blockSize = (mode == Cipher.ENCRYPT_MODE) ? RsaConst.ENCRYPT_KEYSIZE : RsaConst.DECRYPT_KEYSIZE;
  266.             byte[] encryptedData = null;
  267.             for (int i = 0; i < srcData.length; i += blockSize) {
  268.                 // 注意要使用2的倍数，否则会出现加密后的内容再解密时为乱码
  269.                 byte[] doFinal = cipher.doFinal(subarray(srcData, i, i + blockSize));
  270.                 encryptedData = addAll(encryptedData, doFinal);
  271.             }
  272.             return encryptedData;
  274.         } catch (NoSuchAlgorithmException e) {
  275.             // //log.error("公钥算法-不存在的解密算法:", e);
  276.         } catch (NoSuchPaddingException e) {
  277.             // //log.error("公钥算法-无效的补位算法:", e);
  278.         } catch (IllegalBlockSizeException e) {
  279.             // //log.error("公钥算法-无效的块大小:", e);
  280.         } catch (BadPaddingException e) {
  281.             // //log.error("公钥算法-补位算法异常:", e);
  282.         } catch (InvalidKeyException e) {
  283.             // //log.error("公钥算法-无效的私钥:", e);
  284.         }
  285.         return null;
  286.     }
  288.     /**
  289.      * 私钥算法
  290.      * 
  291.      * @param srcData    源字节
  292.      * @param privateKey 私钥
  293.      * @param mode       加密 OR 解密
  294.      * @return
  295.      */
  296.     public static byte[] rsaByPrivateKey(byte[] srcData, PrivateKey privateKey, int mode) {
  297.         try {
  298.             Cipher cipher = Cipher.getInstance(RsaConst.RSA_CHIPER);
  299.             cipher.init(mode, privateKey);
  300.             // 分段加密
  301.             int blockSize = (mode == Cipher.ENCRYPT_MODE) ? RsaConst.ENCRYPT_KEYSIZE : RsaConst.DECRYPT_KEYSIZE;
  302.             byte[] decryptData = null;
  304.             for (int i = 0; i < srcData.length; i += blockSize) {
  305.                 byte[] doFinal = cipher.doFinal(subarray(srcData, i, i + blockSize));
  307.                 decryptData = addAll(decryptData, doFinal);
  308.             }
  309.             return decryptData;
  310.         } catch (NoSuchAlgorithmException e) {
  311.             // //log.error("私钥算法-不存在的解密算法:", e);
  312.         } catch (NoSuchPaddingException e) {
  313.             // log.error("私钥算法-无效的补位算法:", e);
  314.         } catch (IllegalBlockSizeException e) {
  315.             // log.error("私钥算法-无效的块大小:", e);
  316.         } catch (BadPaddingException e) {
  317.             // log.error("私钥算法-补位算法异常:", e);
  318.         } catch (InvalidKeyException e) {
  319.             // log.error("私钥算法-无效的私钥:", e);
  320.         }
  321.         return null;
  322.     }
  324.     // /////////////==========================
  325.     public static byte[] subarray(byte[] array, int startIndexInclusive, int endIndexExclusive) {
  326.         if (array == null) {
  327.             return null;
  328.         }
  329.         if (startIndexInclusive < 0) {
  330.             startIndexInclusive = 0;
  331.         }
  332.         if (endIndexExclusive > array.length) {
  333.             endIndexExclusive = array.length;
  334.         }
  335.         int newSize = endIndexExclusive - startIndexInclusive;
  337.         if (newSize <= 0) {
  338.             return new byte[0];
  339.         }
  341.         byte[] subarray = new byte[newSize];
  343.         System.arraycopy(array, startIndexInclusive, subarray, 0, newSize);
  345.         return subarray;
  346.     }
  348.     public static byte[] addAll(byte[] array1, byte[] array2) {
  349.         if (array1 == null) {
  350.             return clone(array2);
  351.         } else if (array2 == null) {
  352.             return clone(array1);
  353.         }
  354.         byte[] joinedArray = new byte[array1.length + array2.length];
  355.         System.arraycopy(array1, 0, joinedArray, 0, array1.length);
  356.         System.arraycopy(array2, 0, joinedArray, array1.length, array2.length);
  357.         return joinedArray;
  358.     }
  360.     public static byte[] clone(byte[] array) {
  361.         if (array == null) {
  362.             return null;
  363.         }
  364.         return (byte[]) array.clone();
  365.     }
  367.     public static void log(String msg) {
  368.         System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()) + "\t: " + msg);
  369.     }
  370. }

RsaReadUtil.java

  1. import java.io.BufferedReader;
  2. import java.io.ByteArrayInputStream;
  3. import java.io.FileInputStream;
  4. import java.io.FileNotFoundException;
  5. import java.io.IOException;
  6. import java.io.InputStream;
  7. import java.io.StringReader;
  8. import java.security.KeyStore;
  9. import java.security.KeyStoreException;
  10. import java.security.NoSuchAlgorithmException;
  11. import java.security.PrivateKey;
  12. import java.security.PublicKey;
  13. import java.security.UnrecoverableKeyException;
  14. import java.security.cert.Certificate;
  15. import java.security.cert.CertificateException;
  16. import java.security.cert.CertificateFactory;
  17. import java.util.Enumeration;
  19. import sun.misc.BASE64Decoder;
  21. //import com.jweb.//log.Logger;
  23. /**
  24.  * <b>公私钥读取工具</b><br>
  25.  * <br>
  26.  * 
  27.  * @author 行者
  28.  * @version 4.1.0
  29.  */
  30. public final class RsaReadUtil {
  32.     /**
  33.      * 根据Cer文件读取公钥
  34.      * 
  35.      * @param pubCerPath
  36.      * @return
  37.      */
  38.     public static PublicKey getPublicKeyFromFile(String pubCerPath) {
  39.         FileInputStream pubKeyStream = null;
  40.         try {
  41.             pubKeyStream = new FileInputStream(pubCerPath);
  42.             byte[] reads = new byte[pubKeyStream.available()];
  43.             pubKeyStream.read(reads);
  44.             return getPublicKeyByText(new String(reads));
  45.         } catch (FileNotFoundException e) {
  46.             // //log.error("公钥文件不存在:", e);
  47.         } catch (IOException e) {
  48.             // log.error("公钥文件读取失败:", e);
  49.         } finally {
  50.             if (pubKeyStream != null) {
  51.                 try {
  52.                     pubKeyStream.close();
  53.                 } catch (Exception e) {
  54.                     e.printStackTrace();
  55.                 }
  56.             }
  57.         }
  58.         return null;
  59.     }
  61.     /**
  62.      * 根据公钥Cer文本串读取公钥
  63.      * 
  64.      * @param pubKeyText
  65.      * @return
  66.      */
  67.     public static PublicKey getPublicKeyByText(String pubKeyText) {
  68.         try {
  69.             CertificateFactory certificateFactory = CertificateFactory.getInstance(RsaConst.KEY_X509);
  70.             BufferedReader br = new BufferedReader(new StringReader(pubKeyText));
  71.             String line = null;
  72.             StringBuilder keyBuffer = new StringBuilder();
  73.             while ((line = br.readLine()) != null) {
  74.                 if (!line.startsWith("-")) {
  75.                     keyBuffer.append(line);
  76.                 }
  77.             }
  78.             Certificate certificate = certificateFactory.generateCertificate(
  79.                     new ByteArrayInputStream(new BASE64Decoder().decodeBuffer(keyBuffer.toString())));
  80.             return certificate.getPublicKey();
  81.         } catch (Exception e) {
  82.             // log.error("解析公钥内容失败:", e);
  83.         }
  84.         return null;
  85.     }
  87.     /**
  88.      * 根据私钥路径读取私钥
  89.      * 
  90.      * @param pfxPath
  91.      * @param priKeyPass
  92.      * @return
  93.      */
  94.     public static PrivateKey getPrivateKeyFromFile(String pfxPath, String priKeyPass) {
  95.         InputStream priKeyStream = null;
  96.         try {
  97.             priKeyStream = new FileInputStream(pfxPath);
  98.             byte[] reads = new byte[priKeyStream.available()];
  99.             priKeyStream.read(reads);
  100.             return getPrivateKeyByStream(reads, priKeyPass);
  101.         } catch (Exception e) {
  102.             // log.error("解析文件，读取私钥失败:", e);
  103.         } finally {
  104.             if (priKeyStream != null) {
  105.                 try {
  106.                     priKeyStream.close();
  107.                 } catch (Exception e) {
  108.                     //
  109.                 }
  110.             }
  111.         }
  112.         return null;
  113.     }
  115.     /**
  116.      * 根据PFX私钥字节流读取私钥
  117.      * 
  118.      * @param pfxBytes
  119.      * @param priKeyPass
  120.      * @return
  121.      */
  122.     public static PrivateKey getPrivateKeyByStream(byte[] pfxBytes, String priKeyPass) {
  123.         try {
  124.             KeyStore ks = KeyStore.getInstance(RsaConst.KEY_PKCS12);
  125.             char[] charPriKeyPass = priKeyPass.toCharArray();
  126.             ks.load(new ByteArrayInputStream(pfxBytes), charPriKeyPass);
  127.             Enumeration<String> aliasEnum = ks.aliases();
  128.             String keyAlias = null;
  129.             if (aliasEnum.hasMoreElements()) {
  130.                 keyAlias = (String) aliasEnum.nextElement();
  131.             }
  132.             return (PrivateKey) ks.getKey(keyAlias, charPriKeyPass);
  133.         } catch (IOException e) {
  134.             // 加密失败
  135.             // log.error("解析文件，读取私钥失败:", e);
  136.         } catch (KeyStoreException e) {
  137.             // log.error("私钥存储异常:", e);
  138.         } catch (NoSuchAlgorithmException e) {
  139.             // log.error("不存在的解密算法:", e);
  140.         } catch (CertificateException e) {
  141.             // log.error("证书异常:", e);
  142.         } catch (UnrecoverableKeyException e) {
  143.             // log.error("不可恢复的秘钥异常", e);
  144.         }
  145.         return null;
  146.     }
  147. }

RsaConst.java

  1. public final class RsaConst {
  3.     /** 编码 */
  4.     public final static String ENCODE = "UTF-8";
  6.     public final static String KEY_X509 = "X509";
  7.     public final static String KEY_PKCS12 = "PKCS12";
  8.     public final static String KEY_ALGORITHM = "RSA";
  9.     public final static String CER_ALGORITHM = "MD5WithRSA";
  11.     public final static String RSA_CHIPER = "RSA/ECB/PKCS1Padding";
  13.     public final static int KEY_SIZE = 1024;
  14.     /** 1024bit 加密块 大小 */
  15.     public final static int ENCRYPT_KEYSIZE = 117;
  16.     /** 1024bit 解密块 大小 */
  17.     public final static int DECRYPT_KEYSIZE = 128;
  18. }

FormatUtil.java

  2. import java.math.BigDecimal;
  3. import java.text.DecimalFormat;
  4. import java.text.SimpleDateFormat;
  5. import java.util.ArrayList;
  6. import java.util.Date;
  7. import java.util.HashSet;
  8. import java.util.Iterator;
  9. import java.util.List;
  10. import java.util.Set;
  12. public final class FormatUtil {
  13.     /** ==============IS Base=================== */
  14.     /** 判断是否为整数(包括负数) */
  15.     public static boolean isNumber(Object arg) {
  16.         return NumberBo(0, toString(arg));
  17.     }
  19.     /** 判断是否为小数(包括整数,包括负数) */
  20.     public static boolean isDecimal(Object arg) {
  21.         return NumberBo(1, toString(arg));
  22.     }
  24.     /** 判断是否为空 ,为空返回true */
  25.     public static boolean isEmpty(Object arg) {
  26.         return toStringTrim(arg).length() == 0 ? true : false;
  27.     }
  29.     /** ==============TO Base=================== */
  30.     /**
  31.      * Object 转换成 Int 转换失败 返回默认值 0 <br>
  32.      * 使用:toInt(值,默认值[选填])
  33.      */
  34.     public static int toInt(Object... args) {
  35.         int def = 0;
  36.         if (args != null) {
  37.             String str = toStringTrim(args[0]);
  38.             // 判断小数情况。舍弃小数位
  39.             int stri = str.indexOf('.');
  40.             str = stri > 0 ? str.substring(0, stri) : str;
  41.             if (args.length > 1)
  42.                 def = Integer.parseInt(args[args.length - 1].toString());
  43.             if (isNumber(str))
  44.                 return Integer.parseInt(str);
  45.         }
  46.         return def;
  47.     }
  49.     /**
  50.      * Object 转换成 Long 转换失败 返回默认值 0 <br>
  51.      * 使用:toLong(值,默认值[选填])
  52.      */
  53.     public static long toLong(Object... args) {
  54.         Long def = 0L;
  55.         if (args != null) {
  56.             String str = toStringTrim(args[0]);
  57.             if (args.length > 1)
  58.                 def = Long.parseLong(args[args.length - 1].toString());
  59.             if (isNumber(str))
  60.                 return Long.parseLong(str);
  61.         }
  62.         return def;
  63.     }
  65.     /**
  66.      * Object 转换成 Double 转换失败 返回默认值 0 <br>
  67.      * 使用:toDouble(值,默认值[选填])
  68.      */
  69.     public static double toDouble(Object... args) {
  70.         double def = 0;
  71.         if (args != null) {
  72.             String str = toStringTrim(args[0]);
  73.             if (args.length > 1)
  74.                 def = Double.parseDouble(args[args.length - 1].toString());
  75.             if (isDecimal(str))
  76.                 return Double.parseDouble(str);
  77.         }
  78.         return def;
  79.     }
  81.     /**
  82.      * Object 转换成 BigDecimal 转换失败 返回默认值 0 <br>
  83.      * 使用:toDecimal(值,默认值[选填]) 特别注意: new BigDecimal(Double) 会有误差，得先转String
  84.      */
  85.     public static BigDecimal toDecimal(Object... args) {
  86.         return new BigDecimal(Double.toString(toDouble(args)));
  87.     }
  89.     /**
  90.      * Object 转换成 Boolean 转换失败 返回默认值 false <br>
  91.      * 使用:toBoolean(值,默认值[选填])
  92.      */
  93.     public static boolean toBoolean(String bool) {
  94.         if (isEmpty(bool) || (!bool.equals("1") && !bool.equalsIgnoreCase("true") && !bool.equalsIgnoreCase("ok")))
  95.             return false;
  96.         else
  97.             return true;
  98.     }
  100.     /**
  101.      * Object 转换成 String 为null 返回空字符 <br>
  102.      * 使用:toString(值,默认值[选填])
  103.      */
  104.     public static String toString(Object... args) {
  105.         String def = "";
  106.         if (args != null) {
  107.             if (args.length > 1)
  108.                 def = toString(args[args.length - 1]);
  109.             Object obj = args[0];
  110.             if (obj == null)
  111.                 return def;
  112.             return obj.toString();
  113.         } else {
  114.             return def;
  115.         }
  116.     }
  118.     /**
  119.      * Object 转换成 String[去除所以空格]; 为null 返回空字符 <br>
  120.      * 使用:toStringTrim(值,默认值[选填])
  121.      */
  122.     public static String toStringTrim(Object... args) {
  123.         String str = toString(args);
  124.         return str.replaceAll("\\s*", "");
  125.     }
  127.     /** ==============Other Base=================== */
  128.     public static String getNowTime() {
  129.         return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
  130.     }
  132.     /** 数字左边补0 ,obj:要补0的数， length:补0后的长度 */
  133.     public static String leftPad(Object obj, int length) {
  134.         return String.format("%0" + length + "d", toInt(obj));
  135.     }
  137.     /** 小数 转 百分数 */
  138.     public static String toPercent(Double str) {
  139.         StringBuffer sb = new StringBuffer(Double.toString(str * 100.0000d));
  140.         return sb.append("%").toString();
  141.     }
  143.     /** 百分数 转 小数 */
  144.     public static Double toPercent2(String str) {
  145.         if (str.charAt(str.length() - 1) == '%')
  146.             return Double.parseDouble(str.substring(0, str.length() - 1)) / 100.0000d;
  147.         return 0d;
  148.     }
  150.     /**
  151.      * 将byte[] 转换成字符串
  152.      */
  153.     public static String byte2Hex(byte[] srcBytes) {
  154.         StringBuilder hexRetSB = new StringBuilder();
  155.         for (byte b : srcBytes) {
  156.             String hexString = Integer.toHexString(0x00ff & b);
  157.             hexRetSB.append(hexString.length() == 1 ? 0 : "").append(hexString);
  158.         }
  159.         return hexRetSB.toString();
  160.     }
  162.     /**
  163.      * 将16进制字符串转为转换成字符串
  164.      */
  165.     public static byte[] hex2Bytes(String source) {
  166.         try {
  167.             byte[] sourceBytes = new byte[source.length() / 2];
  168.             for (int i = 0; i < sourceBytes.length; i++) {
  169.                 sourceBytes[i] = (byte) Integer.parseInt(source.substring(i * 2, i * 2 + 2), 16);
  170.             }
  171.             return sourceBytes;
  173.         } catch (NumberFormatException e) {
  174.             log("转换出错" + e);
  175.             throw new NumberFormatException();
  177.         }
  178.     }
  180.     /** String 转 Money */
  181.     public static String toMoney(Object str, String MoneyType) {
  182.         DecimalFormat df = new DecimalFormat(MoneyType);
  183.         if (isDecimal(str))
  184.             return df.format(toDecimal(str)).toString();
  185.         return df.format(toDecimal("0.00")).toString();
  186.     }
  188.     /** 获取字符串str 左边len位数 */
  189.     public static String getLeft(Object obj, int len) {
  190.         String str = toString(obj);
  191.         if (len <= 0)
  192.             return "";
  193.         if (str.length() <= len)
  194.             return str;
  195.         else
  196.             return str.substring(0, len);
  197.     }
  199.     /** 获取字符串str 右边len位数 */
  200.     public static String getRight(Object obj, int len) {
  201.         String str = toString(obj);
  202.         if (len <= 0)
  203.             return "";
  204.         if (str.length() <= len)
  205.             return str;
  206.         else
  207.             return str.substring(str.length() - len, str.length());
  208.     }
  210.     /**
  211.      * 首字母变小写
  212.      */
  213.     public static String firstCharToLowerCase(String str) {
  214.         Character firstChar = str.charAt(0);
  215.         String tail = str.substring(1);
  216.         str = Character.toLowerCase(firstChar) + tail;
  217.         return str;
  218.     }
  220.     /**
  221.      * 首字母变大写
  222.      */
  223.     public static String firstCharToUpperCase(String str) {
  224.         Character firstChar = str.charAt(0);
  225.         String tail = str.substring(1);
  226.         str = Character.toUpperCase(firstChar) + tail;
  227.         return str;
  228.     }
  230.     /**
  231.      * List集合去除重复值 只能用于基本数据类型，。 对象类集合，自己写
  232.      */
  233.     @SuppressWarnings({ "rawtypes", "unchecked" })
  234.     public static List delMoreList(List list) {
  235.         Set set = new HashSet();
  236.         List newList = new ArrayList();
  237.         for (Iterator iter = list.iterator(); iter.hasNext();) {
  238.             Object element = iter.next();
  239.             if (set.add(element))
  240.                 newList.add(element);
  241.         }
  242.         return newList;
  243.     }
  245.     public static String formatParams(String message, Object[] params) {
  246.         StringBuffer msg = new StringBuffer();
  247.         String temp = "";
  248.         for (int i = 0; i < params.length + 1; i++) {
  249.             int j = message.indexOf("{}") + 2;
  250.             if (j > 1) {
  251.                 temp = message.substring(0, j);
  252.                 temp = temp.replaceAll("\\{\\}", FormatUtil.toString(params[i]));
  253.                 msg.append(temp);
  254.                 message = message.substring(j);
  255.             } else {
  256.                 msg.append(message);
  257.                 message = "";
  258.             }
  259.         }
  260.         return msg.toString();
  261.     }
  263.     /** ============== END =================== */
  264.     public final static class MoneyType {
  265.         /** * 保留2位有效数字，整数位每3位逗号隔开 （默认） */
  266.         public static final String DECIMAL = "#,##0.00";
  267.         /** * 保留2位有效数字 */
  268.         public static final String DECIMAL_2 = "0.00";
  269.         /** * 保留4位有效数字 */
  270.         public static final String DECIMAL_4 = "0.0000";
  271.     }
  273.     private static boolean NumberBo(int type, Object obj) {
  274.         if (isEmpty(obj))
  275.             return false;
  276.         int points = 0;
  277.         int chr = 0;
  278.         String str = toString(obj);
  279.         for (int i = str.length(); --i >= 0;) {
  280.             chr = str.charAt(i);
  281.             if (chr < 48 || chr > 57) { // 判断数字
  282.                 if (i == 0 && chr == 45) // 判断 - 号
  283.                     return true;
  284.                 if (i >= 0 && chr == 46 && type == 1) { // 判断 . 号
  285.                     ++points;
  286.                     if (points <= 1)
  287.                         continue;
  288.                 }
  289.                 return false;
  290.             }
  291.         }
  292.         return true;
  293.     }
  295.     public static void log(String msg) {
  296.         System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()) + "\t: " + msg);
  297.     }
  298. }
文档更新时间: 2019-06-17 14:44   作者：support