对支付宝进行设置再回主页面进行转义，具体步骤如下。
支付宝APP支付（Java后台生成签名具体步骤）
/**
*支付宝支付
* @param orderId 订单编号
* @param actualPay 实际支付金额
* @return
*/
private String getOrderInfoByAliPay(String orderId,float actualPay) {
//回调页面
String ali_call_back_url = propertiesService.ALI_CALL_BACK_URL
String seller_id = propertiesService.SELLER_ID//商户编号
String[] parameters={
"service=\"mobile.securitypay.pay\"",//固定值（手机快捷支付）
"partner=\"2088421544444\"",//合作身份者ID（16位）
"_input_charset=\"utf-8\"",
"notify_url=\""+ali_call_back_url+"\"",//通知地址
"out_trade_no=\""+orderId+"\"",//商户内部订单号
"subject=\"测试\"",//测试
"payment_type=\"1\"",//固定值
"seller_id=\""+seller_id+"\"",//账户邮箱
"total_fee=\""+"0.01"+"\"",//支付金额（元）
"body=\"订单说明\"",//订单说明
"it_b_pay=\"30m\""（订单过期时间 30分钟过期无效）
}
String signOrderUrl = signAllString(parameters)
return signOrderUrl
}
/**
* 支付宝签名
* @param array
* @return
*/
private String signAllString(String [] array){
StringBuffer sb = new StringBuffer("")
for (int i = 0i <array.lengthi++) {
if(i==(array.length-1)){
sb.append(array[i])
}else{
sb.append(array[i]+"&")
}
}
System.out.println(sb.toString())
String sign = ""
try {
sign = URLEncoder.encode(RSA.sign(sb.toString(), AlipayConfig.private_key, "utf-8"), "utf-8")//private_key私钥
} catch (UnsupportedEncodingException e) {
e.printStackTrace()
}
sb.append("&sign=\""+sign+"\"&")
sb.append("sign_type=\"RSA\"")
return sb.toString()
}
package com.alipay.sign
import javax.crypto.Cipher
import java.io.ByteArrayInputStream
import java.io.ByteArrayOutputStream
import java.io.InputStream
import java.security.KeyFactory
import java.security.PrivateKey
import java.security.PublicKey
import java.security.spec.PKCS8EncodedKeySpec
import java.security.spec.X509EncodedKeySpec
public class RSA{
public static final String SIGN_ALGORITHMS = "SHA1WithRSA"
/**
* RSA签名
* @param content 待签名数据
* @param privateKey 商户私钥
* @param input_charset 编码格式
* @return 签名值
*/
public static String sign(String content, String privateKey, String input_charset)
{
try
{
byte[] decode = Base64.decode(privateKey)
PKCS8EncodedKeySpec priPKCS8 = new PKCS8EncodedKeySpec(decode )
KeyFactory keyf= KeyFactory.getInstance("RSA")
PrivateKey priKey= keyf.generatePrivate(priPKCS8)
java.security.Signature signature = java.security.Signature.getInstance(SIGN_ALGORITHMS)
signature.initSign(priKey)
signature.update( content.getBytes(input_charset) )
byte[] signed = signature.sign()
return Base64.encode(signed)
}
catch (Exception e)
{
e.printStackTrace()
}
return null
}
/**
* RSA验签名检查
* @param content 待签名数据
* @param sign 签名值
* @param ali_public_key 支付宝公钥
* @param input_charset 编码格式
* @return 布尔值
*/
public static boolean verify(String content, String sign, String ali_public_key, String input_charset)
{
try
{
KeyFactory keyFactory = KeyFactory.getInstance("RSA")
byte[] encodedKey = Base64.decode(ali_public_key)
PublicKey pubKey = keyFactory.generatePublic(new X509EncodedKeySpec(encodedKey))
java.security.Signature signature = java.security.Signature
.getInstance(SIGN_ALGORITHMS)
signature.initVerify(pubKey)
signature.update( content.getBytes(input_charset) )
boolean bverify = signature.verify( Base64.decode(sign) )
return bverify
}
catch (Exception e)
{
e.printStackTrace()
}
return false
}
/**
* 解密
* @param content 密文
* @param private_key 商户私钥
* @param input_charset 编码格式
* @return 解密后的字符串
*/
public static String decrypt(String content, String private_key, String input_charset) throws Exception {
PrivateKey prikey = getPrivateKey(private_key)
Cipher cipher = Cipher.getInstance("RSA")
cipher.init(Cipher.DECRYPT_MODE, prikey)
InputStream ins = new ByteArrayInputStream(Base64.decode(content))
ByteArrayOutputStream writer = new ByteArrayOutputStream()
//rsa解密的字节大小最多是128，将需要解密的内容，按128位拆开解密
byte[] buf = new byte[128]
int bufl
while ((bufl = ins.read(buf)) != -1) {
byte[] block = null
if (buf.length == bufl) {
block = buf
} else {
block = new byte[bufl]
for (int i = 0i <bufli++) {
block[i] = buf[i]
}
}
writer.write(cipher.doFinal(block))
}
return new String(writer.toByteArray(), input_charset)
}
/**
* 得到私钥
* @param key 密钥字符串（经过base64编码）
* @throws Exception
*/
public static PrivateKey getPrivateKey(String key) throws Exception {
byte[] keyBytes
keyBytes = Base64.decode(key)
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes)
KeyFactory keyFactory = KeyFactory.getInstance("RSA")
PrivateKey privateKey = keyFactory.generatePrivate(keySpec)
return privateKey
}
}
由于项目要用到非对称加密解密签名校验什么的，于是参考《Java加密解密的艺术》写一个RSA进行加密解密签名及校验的Demo，代码很简单，特此分享！RSA加密解密类：
package com.ihep
import java.io.BufferedReader
import java.io.BufferedWriter
import java.io.FileReader
import java.io.FileWriter
import java.io.IOException
import java.security.InvalidKeyException
import java.security.KeyFactory
import java.security.KeyPair
import java.security.KeyPairGenerator
import java.security.NoSuchAlgorithmException
import java.security.SecureRandom
import java.security.interfaces.RSAPrivateKey
import java.security.interfaces.RSAPublicKey
import java.security.spec.InvalidKeySpecException
import java.security.spec.PKCS8EncodedKeySpec
import java.security.spec.X509EncodedKeySpec
import javax.crypto.BadPaddingException
import javax.crypto.Cipher
import javax.crypto.IllegalBlockSizeException
import javax.crypto.NoSuchPaddingException
import com.fcplay.Base64
public class RSAEncrypt {
/**
* 字节数据转字符串专用集合
*/
private static final char[] HEX_CHAR = { '0', '1', '2', '3', '4', '5', '6',
'7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' }
/**
* 随机生成密钥对
*/
public static void genKeyPair(String filePath) {
// KeyPairGenerator类用于生成公钥和私钥对，基于RSA算法生成对象
KeyPairGenerator keyPairGen = null
try {
keyPairGen = KeyPairGenerator.getInstance("RSA")
} catch (NoSuchAlgorithmException e) {
// TODO Auto-generated catch block
e.printStackTrace()
}
// 初始化密钥对生成器，密钥大小为96-1024位
keyPairGen.initialize(1024,new SecureRandom())
// 生成一个密钥对，保存在keyPair中
KeyPair keyPair = keyPairGen.generateKeyPair()
// 得到私钥
RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate()
// 得到公钥
RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic()
try {
// 得到公钥字符串
String publicKeyString = Base64.encode(publicKey.getEncoded())
// 得到私钥字符串
String privateKeyString = Base64.encode(privateKey.getEncoded())
// 将密钥对写入到文件
FileWriter pubfw = new FileWriter(filePath + "/publicKey.keystore")
FileWriter prifw = new FileWriter(filePath + "/privateKey.keystore")
BufferedWriter pubbw = new BufferedWriter(pubfw)
BufferedWriter pribw = new BufferedWriter(prifw)
pubbw.write(publicKeyString)
pribw.write(privateKeyString)
pubbw.flush()
pubbw.close()
pubfw.close()
pribw.flush()
pribw.close()
prifw.close()
} catch (Exception e) {
e.printStackTrace()
}
}
/**
* 从文件中输入流中加载公钥
*
* @param in
*公钥输入流
* @throws Exception
* 加载公钥时产生的异常
*/
public static String loadPublicKeyByFile(String path) throws Exception {
try {
BufferedReader br = new BufferedReader(new FileReader(path
+ "/publicKey.keystore"))
String readLine = null
StringBuilder sb = new StringBuilder()
while ((readLine = br.readLine()) != null) {
sb.append(readLine)
}
br.close()
return sb.toString()
} catch (IOException e) {
throw new Exception("公钥数据流读取错误")
} catch (NullPointerException e) {
throw new Exception("公钥输入流为空")
}
}
/**
* 从字符串中加载公钥
*
* @param publicKeyStr
*公钥数据字符串
* @throws Exception
* 加载公钥时产生的异常
*/
public static RSAPublicKey loadPublicKeyByStr(String publicKeyStr)
throws Exception {
try {
byte[] buffer = Base64.decode(publicKeyStr)
KeyFactory keyFactory = KeyFactory.getInstance("RSA")
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer)
return (RSAPublicKey) keyFactory.generatePublic(keySpec)
} catch (NoSuchAlgorithmException e) {
throw new Exception("无此算法")
} catch (InvalidKeySpecException e) {
throw new Exception("公钥非法")
} catch (NullPointerException e) {
throw new Exception("公钥数据为空")
}
}
/**
* 从文件中加载私钥
*
* @param keyFileName
*私钥文件名
* @return 是否成功
* @throws Exception
*/
public static String loadPrivateKeyByFile(String path) throws Exception {
try {
BufferedReader br = new BufferedReader(new FileReader(path
+ "/privateKey.keystore"))
String readLine = null
StringBuilder sb = new StringBuilder()
while ((readLine = br.readLine()) != null) {
sb.append(readLine)
}
br.close()
return sb.toString()
} catch (IOException e) {
throw new Exception("私钥数据读取错误")
} catch (NullPointerException e) {
throw new Exception("私钥输入流为空")
}
}
public static RSAPrivateKey loadPrivateKeyByStr(String privateKeyStr)
throws Exception {
try {
byte[] buffer = Base64.decode(privateKeyStr)
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(buffer)
KeyFactory keyFactory = KeyFactory.getInstance("RSA")
return (RSAPrivateKey) keyFactory.generatePrivate(keySpec)
} catch (NoSuchAlgorithmException e) {
throw new Exception("无此算法")
} catch (InvalidKeySpecException e) {
throw new Exception("私钥非法")
} catch (NullPointerException e) {
throw new Exception("私钥数据为空")
}
}
/**
* 公钥加密过程
*
* @param publicKey
*公钥
* @param plainTextData
*明文数据
* @return
* @throws Exception
* 加密过程中的异常信息
*/
public static byte[] encrypt(RSAPublicKey publicKey, byte[] plainTextData)
throws Exception {
if (publicKey == null) {
throw new Exception("加密公钥为空, 请设置")
}
Cipher cipher = null
try {
// 使用默认RSA
cipher = Cipher.getInstance("RSA")
// cipher= Cipher.getInstance("RSA", new BouncyCastleProvider())
cipher.init(Cipher.ENCRYPT_MODE, publicKey)
byte[] output = cipher.doFinal(plainTextData)
return output
} catch (NoSuchAlgorithmException e) {
throw new Exception("无此加密算法")
} catch (NoSuchPaddingException e) {
e.printStackTrace()
return null
} catch (InvalidKeyException e) {
throw new Exception("加密公钥非法,请检查")
} catch (IllegalBlockSizeException e) {
throw new Exception("明文长度非法")
} catch (BadPaddingException e) {
throw new Exception("明文数据已损坏")
}
}
/**
* 私钥加密过程
*
* @param privateKey
*私钥
* @param plainTextData
*明文数据
* @return
* @throws Exception
* 加密过程中的异常信息
*/
public static byte[] encrypt(RSAPrivateKey privateKey, byte[] plainTextData)
throws Exception {
if (privateKey == null) {
throw new Exception("加密私钥为空, 请设置")
}
Cipher cipher = null
try {
// 使用默认RSA
cipher = Cipher.getInstance("RSA")
cipher.init(Cipher.ENCRYPT_MODE, privateKey)
byte[] output = cipher.doFinal(plainTextData)
return output
} catch (NoSuchAlgorithmException e) {
throw new Exception("无此加密算法")
} catch (NoSuchPaddingException e) {
e.printStackTrace()
return null
} catch (InvalidKeyException e) {
throw new Exception("加密私钥非法,请检查")
} catch (IllegalBlockSizeException e) {
throw new Exception("明文长度非法")
} catch (BadPaddingException e) {
throw new Exception("明文数据已损坏")
}
}
/**
* 私钥解密过程
*
* @param privateKey
*私钥
* @param cipherData
*密文数据
* @return 明文
* @throws Exception
* 解密过程中的异常信息
*/
public static byte[] decrypt(RSAPrivateKey privateKey, byte[] cipherData)
throws Exception {
if (privateKey == null) {
throw new Exception("解密私钥为空, 请设置")
}
Cipher cipher = null
try {
// 使用默认RSA
cipher = Cipher.getInstance("RSA")
// cipher= Cipher.getInstance("RSA", new BouncyCastleProvider())
cipher.init(Cipher.DECRYPT_MODE, privateKey)
byte[] output = cipher.doFinal(cipherData)
return output
} catch (NoSuchAlgorithmException e) {
throw new Exception("无此解密算法")
} catch (NoSuchPaddingException e) {
e.printStackTrace()
return null
} catch (InvalidKeyException e) {
throw new Exception("解密私钥非法,请检查")
} catch (IllegalBlockSizeException e) {
throw new Exception("密文长度非法")
} catch (BadPaddingException e) {
throw new Exception("密文数据已损坏")
}
}
