Java前端Rsa公钥加密，后端Rsa私钥解密（支持字符和中文）

Base64工具类，可以让rsa编码的乱码变成一串字符序列

 package com.utils;

 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.InputStream;
 import java.io.OutputStream;

 import it.sauronsoftware.base64.Base64;

 /** */
 /**
  * <p>
  * BASE64编码解码工具包
  * </p>
  * <p>
  * 依赖javabase64-1.3.1.jar
  * </p>
  *
  * @author IceWee
  * @date 2012-5-19
  * @version 1.0
  */
 public class Base64Utils {

     /** */
     /**
      * 文件读取缓冲区大小
      */
     private static final int CACHE_SIZE = 1024;

     /** */
     /**
      * <p>
      * BASE64字符串解码为二进制数据
      * </p>
      *
      * @param base64
      * @return
      * @throws Exception
      */
     public static byte[] decode(String base64) throws Exception {
         return Base64.decode(base64.getBytes());
     }

     /** */
     /**
      * <p>
      * 二进制数据编码为BASE64字符串
      * </p>
      *
      * @param bytes
      * @return
      * @throws Exception
      */
     public static String encode(byte[] bytes) throws Exception {
         return new String(Base64.encode(bytes));
     }

     /** */
     /**
      * <p>
      * 将文件编码为BASE64字符串
      * </p>
      * <p>
      * 大文件慎用，可能会导致内存溢出
      * </p>
      *
      * @param filePath
      *            文件绝对路径
      * @return
      * @throws Exception
      */
     public static String encodeFile(String filePath) throws Exception {
         byte[] bytes = fileToByte(filePath);
         return encode(bytes);
     }

     /** */
     /**
      * <p>
      * BASE64字符串转回文件
      * </p>
      *
      * @param filePath
      *            文件绝对路径
      * @param base64
      *            编码字符串
      * @throws Exception
      */
     public static void decodeToFile(String filePath, String base64) throws Exception {
         byte[] bytes = decode(base64);
         byteArrayToFile(bytes, filePath);
     }

     /** */
     /**
      * <p>
      * 文件转换为二进制数组
      * </p>
      *
      * @param filePath
      *            文件路径
      * @return
      * @throws Exception
      */
     public static byte[] fileToByte(String filePath) throws Exception {
         byte[] data = new byte[0];
         File file = new File(filePath);
         if (file.exists()) {
             FileInputStream in = new FileInputStream(file);
             ByteArrayOutputStream out = new ByteArrayOutputStream(2048);
             byte[] cache = new byte[CACHE_SIZE];
             int nRead = 0;
             while ((nRead = in.read(cache)) != -1) {
                 out.write(cache, 0, nRead);
                 out.flush();
             }
             out.close();
             in.close();
             data = out.toByteArray();
         }
         return data;
     }

     /** */
     /**
      * <p>
      * 二进制数据写文件
      * </p>
      *
      * @param bytes
      *            二进制数据
      * @param filePath
      *            文件生成目录
      */
     public static void byteArrayToFile(byte[] bytes, String filePath) throws Exception {
         InputStream in = new ByteArrayInputStream(bytes);
         File destFile = new File(filePath);
         if (!destFile.getParentFile().exists()) {
             destFile.getParentFile().mkdirs();
         }
         destFile.createNewFile();
         OutputStream out = new FileOutputStream(destFile);
         byte[] cache = new byte[CACHE_SIZE];
         int nRead = 0;
         while ((nRead = in.read(cache)) != -1) {
             out.write(cache, 0, nRead);
             out.flush();
         }
         out.close();
         in.close();
     }

 }

RsaUtil工具类，可以调用里面的方法，产生公钥私钥对，和采用公钥加密，私钥加密等

 package com.utils;

 import java.io.ByteArrayOutputStream;
 import java.security.Key;
 import java.security.KeyFactory;
 import java.security.KeyPair;
 import java.security.KeyPairGenerator;
 import java.security.PrivateKey;
 import java.security.PublicKey;
 import java.security.Signature;
 import java.security.interfaces.RSAPrivateKey;
 import java.security.interfaces.RSAPublicKey;
 import java.security.spec.PKCS8EncodedKeySpec;
 import java.security.spec.X509EncodedKeySpec;
 import java.util.HashMap;
 import java.util.Map;

 import javax.crypto.Cipher;

 /** */
 /**
  * <p>
  * RSA公钥/私钥/签名工具包
  * </p>
  * <p>
  * 罗纳德·李维斯特（Ron [R]ivest）、阿迪·萨莫尔（Adi [S]hamir）和伦纳德·阿德曼（Leonard [A]dleman）
  * </p>
  * <p>
  * 字符串格式的密钥在未在特殊说明情况下都为BASE64编码格式<br/>
  * 由于非对称加密速度极其缓慢，一般文件不使用它来加密而是使用对称加密，<br/>
  * 非对称加密算法可以用来对对称加密的密钥加密，这样保证密钥的安全也就保证了数据的安全
  * </p>
  *
  * @author IceWee
  * @date 2012-4-26
  * @version 1.0
  */
 public class RSAUtils {

     /** */
     /**
      * 加密算法RSA
      */
     public static final String KEY_ALGORITHM = "RSA";

     /** */
     /**
      * 签名算法
      */
     public static final String SIGNATURE_ALGORITHM = "MD5withRSA";

     /** */
     /**
      * 获取公钥的key
      */
     private static final String PUBLIC_KEY = "RSAPublicKey";

     /** */
     /**
      * 获取私钥的key
      */
     private static final String PRIVATE_KEY = "RSAPrivateKey";

     /** */
     /**
      * RSA最大加密明文大小
      */
     private static final int MAX_ENCRYPT_BLOCK = 117;

     /** */
     /**
      * RSA最大解密密文大小
      */
     private static final int MAX_DECRYPT_BLOCK = 128;

     /** */
     /**
      * <p>
      * 生成密钥对(公钥和私钥)
      * </p>
      *
      * @return
      * @throws Exception
      */
     public static Map<String, Object> genKeyPair() throws Exception {
         KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
         keyPairGen.initialize(1024);
         KeyPair keyPair = keyPairGen.generateKeyPair();
         RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
         RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
         Map<String, Object> keyMap = new HashMap<String, Object>(2);
         keyMap.put(PUBLIC_KEY, publicKey);
         keyMap.put(PRIVATE_KEY, privateKey);
         return keyMap;
     }

     /** */
     /**
      * <p>
      * 用私钥对信息生成数字签名
      * </p>
      *
      * @param data
      *            已加密数据
      * @param privateKey
      *            私钥(BASE64编码)
      *
      * @return
      * @throws Exception
      */
     public static String sign(byte[] data, String privateKey) throws Exception {
         byte[] keyBytes = Base64Utils.decode(privateKey);
         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
         PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
         Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
         signature.initSign(privateK);
         signature.update(data);
         return Base64Utils.encode(signature.sign());
     }

     /** */
     /**
      * <p>
      * 校验数字签名
      * </p>
      *
      * @param data
      *            已加密数据
      * @param publicKey
      *            公钥(BASE64编码)
      * @param sign
      *            数字签名
      *
      * @return
      * @throws Exception
      *
      */
     public static boolean verify(byte[] data, String publicKey, String sign) throws Exception {
         byte[] keyBytes = Base64Utils.decode(publicKey);
         X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
         PublicKey publicK = keyFactory.generatePublic(keySpec);
         Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
         signature.initVerify(publicK);
         signature.update(data);
         return signature.verify(Base64Utils.decode(sign));
     }

     /** */
     /**
      * <P>
      * 私钥解密
      * </p>
      *
      * @param encryptedData
      *            已加密数据
      * @param privateKey
      *            私钥(BASE64编码)
      * @return
      * @throws Exception
      */
     public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey) throws Exception {
         byte[] keyBytes = Base64Utils.decode(privateKey);
         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
         Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
         cipher.init(Cipher.DECRYPT_MODE, privateK);
         int inputLen = encryptedData.length;
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         int offSet = 0;
         byte[] cache;
         int i = 0;
         // 对数据分段解密
         while (inputLen - offSet > 0) {
             if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                 cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
             } else {
                 cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
             }
             out.write(cache, 0, cache.length);
             i++;
             offSet = i * MAX_DECRYPT_BLOCK;
         }
         byte[] decryptedData = out.toByteArray();
         out.close();
         return decryptedData;
     }

     /** */
     /**
      * <p>
      * 公钥解密
      * </p>
      *
      * @param encryptedData
      *            已加密数据
      * @param publicKey
      *            公钥(BASE64编码)
      * @return
      * @throws Exception
      */
     public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey) throws Exception {
         byte[] keyBytes = Base64Utils.decode(publicKey);
         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
         Key publicK = keyFactory.generatePublic(x509KeySpec);
         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
         cipher.init(Cipher.DECRYPT_MODE, publicK);
         int inputLen = encryptedData.length;
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         int offSet = 0;
         byte[] cache;
         int i = 0;
         // 对数据分段解密
         while (inputLen - offSet > 0) {
             if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                 cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
             } else {
                 cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
             }
             out.write(cache, 0, cache.length);
             i++;
             offSet = i * MAX_DECRYPT_BLOCK;
         }
         byte[] decryptedData = out.toByteArray();
         out.close();
         return decryptedData;
     }

     /** */
     /**
      * <p>
      * 公钥加密
      * </p>
      *
      * @param data
      *            源数据
      * @param publicKey
      *            公钥(BASE64编码)
      * @return
      * @throws Exception
      */
     public static byte[] encryptByPublicKey(byte[] data, String publicKey) throws Exception {
         byte[] keyBytes = Base64Utils.decode(publicKey);
         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
         Key publicK = keyFactory.generatePublic(x509KeySpec);
         // 对数据加密
         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
         cipher.init(Cipher.ENCRYPT_MODE, publicK);
         int inputLen = data.length;
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         int offSet = 0;
         byte[] cache;
         int i = 0;
         // 对数据分段加密
         while (inputLen - offSet > 0) {
             if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
                 cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
             } else {
                 cache = cipher.doFinal(data, offSet, inputLen - offSet);
             }
             out.write(cache, 0, cache.length);
             i++;
             offSet = i * MAX_ENCRYPT_BLOCK;
         }
         byte[] encryptedData = out.toByteArray();
         out.close();
         return encryptedData;
     }

     /** */
     /**
      * <p>
      * 私钥加密
      * </p>
      *
      * @param data
      *            源数据
      * @param privateKey
      *            私钥(BASE64编码)
      * @return
      * @throws Exception
      */
     public static byte[] encryptByPrivateKey(byte[] data, String privateKey) throws Exception {
         byte[] keyBytes = Base64Utils.decode(privateKey);
         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
         Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
         cipher.init(Cipher.ENCRYPT_MODE, privateK);
         int inputLen = data.length;
         ByteArrayOutputStream out = new ByteArrayOutputStream();
         int offSet = 0;
         byte[] cache;
         int i = 0;
         // 对数据分段加密
         while (inputLen - offSet > 0) {
             if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
                 cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
             } else {
                 cache = cipher.doFinal(data, offSet, inputLen - offSet);
             }
             out.write(cache, 0, cache.length);
             i++;
             offSet = i * MAX_ENCRYPT_BLOCK;
         }
         byte[] encryptedData = out.toByteArray();
         out.close();
         return encryptedData;
     }

     /** */
     /**
      * <p>
      * 获取私钥
      * </p>
      *
      * @param keyMap
      *            密钥对
      * @return
      * @throws Exception
      */
     public static String getPrivateKey(Map<String, Object> keyMap) throws Exception {
         Key key = (Key) keyMap.get(PRIVATE_KEY);
         return Base64Utils.encode(key.getEncoded());
     }

     /** */
     /**
      * <p>
      * 获取公钥
      * </p>
      *
      * @param keyMap
      *            密钥对
      * @return
      * @throws Exception
      */
     public static String getPublicKey(Map<String, Object> keyMap) throws Exception {
         Key key = (Key) keyMap.get(PUBLIC_KEY);
         return Base64Utils.encode(key.getEncoded());
     }

     /**
      * java端公钥加密
      */
     public static String encryptedDataOnJava(String data, String PUBLICKEY) {
         try {
             data = Base64Utils.encode(encryptByPublicKey(data.getBytes(), PUBLICKEY));
         } catch (Exception e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
         return data;
     }

     /**
      * java端私钥解密
      */
     public static String decryptDataOnJava(String data, String PRIVATEKEY) {
         String temp = "";
         try {
             byte[] rs = Base64Utils.decode(data);
             temp = new String(RSAUtils.decryptByPrivateKey(rs, PRIVATEKEY),"UTF-8"); //以utf-8的方式生成字符串

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

 }

json工具类

 package com.utils;

 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.google.gson.JsonNull;

 public class JsonUtil {

     private static Gson gson = new GsonBuilder().setDateFormat("yyyy-MM-dd").serializeNulls().create();

     /**
      * @MethodName : toJson
      * @Description : 将对象转为JSON串，此方法能够满足大部分需求
      * @param src
      *            :将要被转化的对象
      * @return :转化后的JSON串
      */
     public static String toJson(Object src) {
         if (src == null) {
             return gson.toJson(JsonNull.INSTANCE);
         }
         return gson.toJson(src);
     }
 }

到这一步我们的工具类准备的差不多了，可以开始进入我们的主题了，java端Rsa测试类和web端交互的demo了

Rsa测试java测试类

 package com.test;

 import java.util.Map;

 import org.junit.Test;

 import com.utils.Base64Utils;
 import com.utils.RSAUtils;

 public class RSATester {

     static String publicKey;
     static String privateKey;

     static {
         try {
             Map<String, Object> keyMap = RSAUtils.genKeyPair();
             publicKey = RSAUtils.getPublicKey(keyMap);
             privateKey = RSAUtils.getPrivateKey(keyMap);
             System.err.println("公钥: \n\r" + publicKey);
             System.err.println("私钥： \n\r" + privateKey);
         } catch (Exception e) {
             e.printStackTrace();
         }
     }

     public static void main(String[] args) throws Exception {
         testJavaRsa();
     }

     @Test
     public void tests() throws Exception {
         String data = "hNYdT0/8wxljGvLQVPYUDeoWS217rmB5msKOljb6OBsOhdL1Domxt6Sy3BqdGqS3StGJuZuQ9wEFzGdyoTQ7IRiC0gRrkLuxvCUq8FANt1JpJCBqvzLdQD/ygCjkJMWWkMU4EFUW3xYkAsidqM8Zynhpk+mdja3789Ng4s68xJI=";

         String privateKey = "MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAIn2zWqU7K/2qm5pOpq5bp9R+3MTnStWTfJU9nC/Vo7UKH9dITPvrELCTK+qlqpx5Fes+l0GY7n6u4n4jyiw4ejsvkZYQ5ww477yLOn2FcoEGuZEwPgSCmfTST0OFUgQqn+/J11k9L92jEHyieE3qmhMkMt0UsVUSJwx/nZxo30ZAgMBAAECgYBD3YHigeuEC4R+14iaf8jo2j0kuGtB3Cxvnlez0otTqw1YyYkBsU49cLKkXvfKVEgM0Ow/QltgKvSBxCE31PrrDka5TygVMqqA/IM7NrDvjUcGLjyoeNmLA8660fWcDxUTlAGN5kxIvUATayVwKVflpWPWu0FPKsWrZustnEo+4QJBAMCmYsWqAKWYMVRXFP3/XGRfio8DV793TOckyBSN9eh8UhgoZyT3u7oeHmDJEwm4aNMHlg1Pcdc6tNsvi1FRCiUCQQC3VNzfF4xOtUgX7vWPL8YVljLuXmy12iVYmg6ofu9l31nwM9FLQ1TRFglvF5LWrIXTQb07PgGd5DJMAQWGsqLlAkAPE7Z9M73TN+L8b8hDzJ1leZi1cpSGdoa9PEKwYR/SrxAZtefEm+LEQSEtf+8OfrEtetWCeyo0pvKKiOEFXytFAkEAgynL/DC0yXsZYUYtmYvshHU5ayFTVagFICbYZeSrEo+BoUDxdI9vl0fU6A5NmBlGhaZ65G+waG5jLc1tTrlvoQJAXBEoPcBNAosiZHQfYBwHqU6mJ9/ZacJh3MtJzGGebfEwJgtln5b154iANqNWXpySBLvkK+Boq7FYRiD83pqmUg==";
         byte[] rs = Base64Utils.decode(data);

         String r1 = new String(RSAUtils.decryptByPrivateKey(rs, privateKey));

         System.out.println("\r\n\r\n" + r1 + "okb");

     }

     static void testSign() throws Exception {
         System.err.println("私钥加密——公钥解密");
         String source = "32232";
         System.out.println("原文字：\r\n" + source);
         byte[] data = source.getBytes();
         byte[] encodedData = RSAUtils.encryptByPrivateKey(data, privateKey);
         System.out.println("加密后：\r\n" + new String(encodedData));
         byte[] decodedData = RSAUtils.decryptByPublicKey(encodedData, publicKey);
         String target = new String(decodedData);
         System.out.println("解密后: \r\n" + target);
         System.err.println("私钥签名——公钥验证签名");
         String sign = RSAUtils.sign(encodedData, privateKey);
         System.err.println("签名:\r" + sign);
         boolean status = RSAUtils.verify(encodedData, publicKey, sign);
         System.err.println("验证结果:\r" + status);
     }

     static void test() throws Exception {
         System.err.println("公钥加密——私钥解密");
         String source = "这是一行没有任何意义的文字，你看完了等于没看，不是吗？";
         System.out.println("\r加密前文字：\r\n" + source);
         byte[] data = source.getBytes();
         byte[] encodedData = RSAUtils.encryptByPublicKey(data, publicKey);
         System.out.println("加密后文字：\r\n" + new String(encodedData));
         System.out.println("----------------:base64处理：" + Base64Utils.encode(encodedData));
         byte[] decodedData = RSAUtils.decryptByPrivateKey(encodedData, privateKey);
         String target = new String(decodedData);
         System.out.println("解密后文字: \r\n" + target);
     }

     /*
      * 测试自己封装java端加密和解密的方法
      */

     static void testJavaRsa() {
         String PUBLICKEY = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCcd+0zTY9Gn94iqkQJTlxYnEnCeFsLkk0a7hoAvi2B74VzDVV3xH0ZO9RkXvo1SgCB+uzbEWdrgQkzTqyjfTtgOguu3OnkVxIMJF34ibchTY0LWHGxq1m2gLGuVVqrlu1LtdV0X7xo/5zc8Mr+46veWb86kSpqe6rOAm69WWo5GwIDAQAB";
         String PRIVATEKEY = "MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAJx37TNNj0af3iKqRAlOXFicScJ4WwuSTRruGgC+LYHvhXMNVXfEfRk71GRe+jVKAIH67NsRZ2uBCTNOrKN9O2A6C67c6eRXEgwkXfiJtyFNjQtYcbGrWbaAsa5VWquW7Uu11XRfvGj/nNzwyv7jq95ZvzqRKmp7qs4Cbr1ZajkbAgMBAAECgYAHp349EkA+DjgJrhah9elilFKvZr/dcwy+koNHIgaL4rG+jRpvP3d3MowTVOocjUA1G5dWqCVNBwTyM5kSbl/nIxSCYwdUoDid4r0JbqkXkTTsIq3euHG8eiWr9rr3SDmwDojWoJEc4liVlfme8dQuMfgxe1QKq7wTrJwCKwbeMQJBAPwpknRPRK8W9hefbbtEu8mlbzUy+ER8Puq6dvS+lnWzJ8n2chJcHRYQFwWpjl4+SZuKeEcDmYmuQ7xuqEIayO0CQQCe2YeaxcU4uuDC45RAwCcMaNw1nDJuA+Gi47lXbroBXoeOiNZunViSZVUgDgrV/Ku6V54TaZIzZ21QFjf7mXEnAkEA7dZwMpAJonOvzfwrzbQ4wyrsx2q5zC68UT1qsdGJrJ48azutwC9tp7+pV0fj5nQtjS1/4Ms+aCQb84ET5rXIyQJAM0m45tgEHZT5DPO94kooUXFp6EVOYwcNyzILnZc6p0aGLhcwZPaYqmvdWEQwa3bxW3D+sPXdJou2V61U1f9s8QJALccvYwwWlCTq1iTmegYk9fOoc+isZKH+Z0YW70kFi94AYEO+utYwmXBEAqQ5VC/bywa1O71xdL4/RGCOSxBf2A==";
         String data = "你好啊，冯老师！s 223 1@324234234sfsfsf";
         data = RSAUtils.encryptedDataOnJava(data, PUBLICKEY);
         System.out.println("加密数据：" + data);

         System.out.println("解密数据：" + RSAUtils.decryptDataOnJava(data, PRIVATEKEY));
     }

     static void testFrontEncrptAndAfterDecrypt() {
         String PRIVATEKEY = "MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAIn2zWqU7K/2qm5pOpq5bp9R+3MTnStWTfJU9nC/Vo7UKH9dITPvrELCTK+qlqpx5Fes+l0GY7n6u4n4jyiw4ejsvkZYQ5ww477yLOn2FcoEGuZEwPgSCmfTST0OFUgQqn+/J11k9L92jEHyieE3qmhMkMt0UsVUSJwx/nZxo30ZAgMBAAECgYBD3YHigeuEC4R+14iaf8jo2j0kuGtB3Cxvnlez0otTqw1YyYkBsU49cLKkXvfKVEgM0Ow/QltgKvSBxCE31PrrDka5TygVMqqA/IM7NrDvjUcGLjyoeNmLA8660fWcDxUTlAGN5kxIvUATayVwKVflpWPWu0FPKsWrZustnEo+4QJBAMCmYsWqAKWYMVRXFP3/XGRfio8DV793TOckyBSN9eh8UhgoZyT3u7oeHmDJEwm4aNMHlg1Pcdc6tNsvi1FRCiUCQQC3VNzfF4xOtUgX7vWPL8YVljLuXmy12iVYmg6ofu9l31nwM9FLQ1TRFglvF5LWrIXTQb07PgGd5DJMAQWGsqLlAkAPE7Z9M73TN+L8b8hDzJ1leZi1cpSGdoa9PEKwYR/SrxAZtefEm+LEQSEtf+8OfrEtetWCeyo0pvKKiOEFXytFAkEAgynL/DC0yXsZYUYtmYvshHU5ayFTVagFICbYZeSrEo+BoUDxdI9vl0fU6A5NmBlGhaZ65G+waG5jLc1tTrlvoQJAXBEoPcBNAosiZHQfYBwHqU6mJ9/ZacJh3MtJzGGebfEwJgtln5b154iANqNWXpySBLvkK+Boq7FYRiD83pqmUg==";
         String data = "FBGU7sQfpSfCgB2hqFuIqkivEUHVRHD8JFdyxYeWqQHsTj9UEuVmvi28n1fOHRwW+3aZD3ttdzfUHWiXD2NErcX/CYs5BtSXT7RcJfWWcXvegq5BBDEAJCADWCRdYnblN+SLUC+ctDXcLw4xmjwAajowSzhCfY/lU3TdnJjO488=";
         System.out.println("解密数据：" + RSAUtils.decryptDataOnJava(data, PRIVATEKEY));
     }

 }

前端加密jsp页面

 <%@ page language="java" contentType="text/html; charset=UTF-8"
     pageEncoding="UTF-8"%>
 <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 <title>Insert title here</title>
 <script src="js/jquery-2.1.3.js"></script>
 <script src="js/jsencrypt.min.js"></script>
 </head>
 <body>

     <script type="text/javascript">
         $(function() {
             $("#bt").click(
                     function() {

                         var encrypt = new JSEncrypt();
                         encrypt.setPublicKey($("#publickey").val());
                         encrypt.setPrivateKey($("#privatekey").val());
                         var password = $("#password").val();
                         var uname = $("#uname").val();
                         password = encrypt.encrypt(password);

                         uname = encrypt.encrypt(uname);
                         $("#jmName").val(uname);
                         $("#jmPasswrod").val(password);
                         var jsonData = {
                             "password" : password,
                             "uname" : uname
                         };

                         $.post("jiemi.do", jsonData, function(result) {
                             alert("解密的用户名：" + result.uname + "\n" + "解密的密码："
                                     + result.password);

                         }, 'json');
                     });
         });
     </script>
     <h2>公钥：</h2>
     <textarea id="publickey" rows="5" cols="45">MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCJ9s1qlOyv9qpuaTqauW6fUftzE50rVk3yVPZwv1aO1Ch/XSEz76xCwkyvqpaqceRXrPpdBmO5+ruJ+I8osOHo7L5GWEOcMOO+8izp9hXKBBrmRMD4Egpn00k9DhVIEKp/vyddZPS/doxB8onhN6poTJDLdFLFVEicMf52caN9GQIDAQAB
         </textarea>
     <h2>私钥</h2>
     <textarea rows="10" cols="45" id="privatekey">MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAIn2zWqU7K/2qm5pOpq5bp9R+3MTnStWTfJU9nC/Vo7UKH9dITPvrELCTK+qlqpx5Fes+l0GY7n6u4n4jyiw4ejsvkZYQ5ww477yLOn2FcoEGuZEwPgSCmfTST0OFUgQqn+/J11k9L92jEHyieE3qmhMkMt0UsVUSJwx/nZxo30ZAgMBAAECgYBD3YHigeuEC4R+14iaf8jo2j0kuGtB3Cxvnlez0otTqw1YyYkBsU49cLKkXvfKVEgM0Ow/QltgKvSBxCE31PrrDka5TygVMqqA/IM7NrDvjUcGLjyoeNmLA8660fWcDxUTlAGN5kxIvUATayVwKVflpWPWu0FPKsWrZustnEo+4QJBAMCmYsWqAKWYMVRXFP3/XGRfio8DV793TOckyBSN9eh8UhgoZyT3u7oeHmDJEwm4aNMHlg1Pcdc6tNsvi1FRCiUCQQC3VNzfF4xOtUgX7vWPL8YVljLuXmy12iVYmg6ofu9l31nwM9FLQ1TRFglvF5LWrIXTQb07PgGd5DJMAQWGsqLlAkAPE7Z9M73TN+L8b8hDzJ1leZi1cpSGdoa9PEKwYR/SrxAZtefEm+LEQSEtf+8OfrEtetWCeyo0pvKKiOEFXytFAkEAgynL/DC0yXsZYUYtmYvshHU5ayFTVagFICbYZeSrEo+BoUDxdI9vl0fU6A5NmBlGhaZ65G+waG5jLc1tTrlvoQJAXBEoPcBNAosiZHQfYBwHqU6mJ9/ZacJh3MtJzGGebfEwJgtln5b154iANqNWXpySBLvkK+Boq7FYRiD83pqmUg==</textarea>
     <hr />
     <form>
         用户名：<input type="text" name="uname" id="uname" /> 密码：<input
             type="text" name="password" id="password" />
         <hr />
         用户密文
         <textarea id="jmName">
     </textarea>
         密码密文
         <textarea id="jmPasswrod">
     </textarea>
         <input type="button" id="bt" value="提交" />
     </form>

 </body>
 </html>

后端servlet解密

 package com;

 import java.io.IOException;
 import java.util.HashMap;

 import javax.servlet.ServletException;
 import javax.servlet.http.HttpServlet;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;

 import com.utils.JsonUtil;
 import com.utils.RSAUtils;

 /**
  * Servlet implementation class JieMiServlet
  */
 public class JieMiServlet extends HttpServlet {
     private static final long serialVersionUID = 1L;

     protected void doGet(HttpServletRequest request, HttpServletResponse response)
             throws ServletException, IOException {
         doPost(request, response);
     }

     protected void doPost(HttpServletRequest request, HttpServletResponse response)
             throws ServletException, IOException {
         // 获取数据
         String uname = request.getParameter("uname");
         String password = request.getParameter("password");
         String PRIVATEKEY = "MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAIn2zWqU7K/2qm5pOpq5bp9R+3MTnStWTfJU9nC/Vo7UKH9dITPvrELCTK+qlqpx5Fes+l0GY7n6u4n4jyiw4ejsvkZYQ5ww477yLOn2FcoEGuZEwPgSCmfTST0OFUgQqn+/J11k9L92jEHyieE3qmhMkMt0UsVUSJwx/nZxo30ZAgMBAAECgYBD3YHigeuEC4R+14iaf8jo2j0kuGtB3Cxvnlez0otTqw1YyYkBsU49cLKkXvfKVEgM0Ow/QltgKvSBxCE31PrrDka5TygVMqqA/IM7NrDvjUcGLjyoeNmLA8660fWcDxUTlAGN5kxIvUATayVwKVflpWPWu0FPKsWrZustnEo+4QJBAMCmYsWqAKWYMVRXFP3/XGRfio8DV793TOckyBSN9eh8UhgoZyT3u7oeHmDJEwm4aNMHlg1Pcdc6tNsvi1FRCiUCQQC3VNzfF4xOtUgX7vWPL8YVljLuXmy12iVYmg6ofu9l31nwM9FLQ1TRFglvF5LWrIXTQb07PgGd5DJMAQWGsqLlAkAPE7Z9M73TN+L8b8hDzJ1leZi1cpSGdoa9PEKwYR/SrxAZtefEm+LEQSEtf+8OfrEtetWCeyo0pvKKiOEFXytFAkEAgynL/DC0yXsZYUYtmYvshHU5ayFTVagFICbYZeSrEo+BoUDxdI9vl0fU6A5NmBlGhaZ65G+waG5jLc1tTrlvoQJAXBEoPcBNAosiZHQfYBwHqU6mJ9/ZacJh3MtJzGGebfEwJgtln5b154iANqNWXpySBLvkK+Boq7FYRiD83pqmUg==";
         // 解密
         uname = RSAUtils.decryptDataOnJava(uname, PRIVATEKEY);
         password = RSAUtils.decryptDataOnJava(password, PRIVATEKEY);
         // 用map封装返回的数据
         HashMap<String, Object> result = new HashMap<String, Object>();
         result.put("uname", uname);
         result.put("password", password);

         response.getWriter().print(JsonUtil.toJson(result));

     }

 }

需要注意的是：前端需要加入jquery-2.1.3.js和jsencrypt.min.js库，后端需要加入javabase64-1.3.1.jar和gson-2.5.jar(方便json返回)

项目演示代码链接：项目demo下载

github的项目链接地址