Test.java

package fuiou.sdk;


import java.io.IOException;
import net.sf.json.JSONObject;

public class Test {

     //测试环境机构公钥
     public static String ins_pub_key = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDWbeSPxvfbpY2uWHbX2YXcrHXa88NITHajSmjTWdY0wqS9WqF8OyMT3ucIEuumP20/5D5+OaSETSBxrD7+1HA87TdTcCLn/FUuzVWiu4cD7Oln2/FJDwPxC/5/u14APBU30aLRWJbPVu0W8ZPmCF8718fAiYjP0RjvXU0gSnA/wwIDAQAB";

    public static void main(String[] args) {  
        try {
            postRequestTest();
        } catch (IOException e) {
            e.printStackTrace();
        }  
    }    

    //body接收，得到JSON字符串
    @RequestMapping(value = "/notify",produces="application/json; charset=UTF-8")
    public void postRequestTest(@RequestBody String respJson) throws IOException {  
        //String respJson = "{"mchnt_cd":"","resp_code":"","resp_desc":"","message":""}";
        System.out.println("返回的报文=="+respJson);
        String message = respJson.getString("message");
        //富友公钥解密出来密文
        String plain = RsaUtil.decryptByRsaPub(message, ins_pub_key, "GBK");
        System.out.println("富友公钥解密出来的明文plain=="+plain);
        //商户处理自己的逻辑
    }  
}

RsaUtil

import java.security.Key;
import java.security.KeyFactory;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Signature;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import javax.crypto.Cipher;
import org.apache.commons.codec.binary.Base64;

public class RsaUtil {

    private static final String KEY_ALGORITHM = "RSA";
    private static final String ALGORITHM_SHA1 = "SHA1withRSA";
    private static final String ALGORITHM_SHA2 = "SHA256withRSA";
    private static final String ALGORITHM_MD5RSA = "MD5WithRSA";

    static {
        try {
            java.security.Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /** SHA1withRSA     */
    public static String sign2Base64(String base64PriRsa, String inputStr) {
        return sign2Base64ByAlg(base64PriRsa, inputStr, ALGORITHM_SHA1, "GBK");
    }

    /** SHA256withRSA */
    public static String sign2Base64BySha2(String base64PriRsa, String inputStr) {
        return sign2Base64ByAlg(base64PriRsa, inputStr, ALGORITHM_SHA2,"GBK");
    }
    /** MD5WithRSA  */
    public static String sign2Base64ByMd5Rsa(String base64PriRsa, String inputStr) {
        return sign2Base64ByAlg(base64PriRsa, inputStr, ALGORITHM_MD5RSA,"GBK");
    }

    /** SHA1withRSA     */
    public static String sign2Base64(String base64PriRsa, String inputStr,String charset) {
        return sign2Base64ByAlg(base64PriRsa, inputStr, ALGORITHM_SHA1,charset);
    }

    /** SHA256withRSA */
    public static String sign2Base64BySha2(String base64PriRsa, String inputStr,String charset) {
        return sign2Base64ByAlg(base64PriRsa, inputStr, ALGORITHM_SHA2,charset);
    }
    /** MD5WithRSA  */
    public static String sign2Base64ByMd5Rsa(String base64PriRsa, String inputStr,String charset) {
        return sign2Base64ByAlg(base64PriRsa, inputStr, ALGORITHM_MD5RSA,charset);
    }

    private static String sign2Base64ByAlg(String base64PriRsa, String inputStr, String algorithm,String charset) {
        try {
            PrivateKey privateKey = genPrivateKey(base64PriRsa);
            Signature signature = Signature.getInstance(algorithm, "BC");
            signature.initSign(privateKey);
            signature.update(inputStr.getBytes(charset));
            return Base64.encodeBase64String(signature.sign());
        } catch (Exception e) {
            e.printStackTrace();
            throw new IllegalArgumentException("");
        }
    }

    /**
     * SHA1withRSA
     * @return
     */
    public static boolean verifySign(String base64PubRsa, String src, String base64SignValue) {
        return verifySignByAlg(base64PubRsa, src, base64SignValue, ALGORITHM_SHA1, "GBK");
    }

    /** 
     * SHA256withRSA 
     * @return
     */
    public static boolean verifySignBySha2(String base64PubRsa, String src, String base64SignValue) {
        return verifySignByAlg(base64PubRsa, src, base64SignValue, ALGORITHM_SHA2, "GBK");
    }

    /** 
     * MD5WithRSA  
     * @return
     */
    public static boolean verifySignByMd5Rsa(String base64PubRsa, String src, String base64SignValue) {
        return verifySignByAlg(base64PubRsa, src, base64SignValue, ALGORITHM_MD5RSA, "GBK");
    }

    /**
     * SHA1withRSA
     * @return
     */
    public static boolean verifySign(String base64PubRsa, String src, String base64SignValue,String charset) {
        return verifySignByAlg(base64PubRsa, src, base64SignValue, ALGORITHM_SHA1,charset);
    }

    /** SHA256withRSA
     *  @return
     */
    public static boolean verifySignBySha2(String base64PubRsa, String src, String base64SignValue,String charset) {
        return verifySignByAlg(base64PubRsa, src, base64SignValue, ALGORITHM_SHA2,charset);
    }

    /**MD5WithRSA  */
    public static boolean verifySignByMd5Rsa(String base64PubRsa, String src, String base64SignValue,String charset) {
        return verifySignByAlg(base64PubRsa, src, base64SignValue, ALGORITHM_MD5RSA,charset);
    }

    private static boolean verifySignByAlg(String base64PubRsa, String src, String base64SignValue, String algorithm,String charset) {
        try {
            PublicKey publicKey = genPublicKey(base64PubRsa);
            Signature signature = Signature.getInstance(algorithm, "BC");
            signature.initVerify(publicKey);
            signature.update(src.getBytes(charset));
            return signature.verify(Base64.decodeBase64(base64SignValue));
        } catch (Exception e) {
            e.printStackTrace();
            throw new IllegalArgumentException("RSA异常");
        }
    }

    private static PrivateKey genPrivateKey(String base64Rsa) {
        try {
            KeyFactory kf = KeyFactory.getInstance(KEY_ALGORITHM, "BC");
            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(Base64.decodeBase64(base64Rsa));
            return kf.generatePrivate(keySpec);
        } catch (Exception e) {
            e.printStackTrace();
            throw new IllegalArgumentException("RSA异常");
        }
    }

    private static PublicKey genPublicKey(String base64Rsa) {
        try {
            KeyFactory kf = KeyFactory.getInstance(KEY_ALGORITHM, "BC");
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(Base64.decodeBase64(base64Rsa));
            return kf.generatePublic(keySpec);
        } catch (Exception e) {
            e.printStackTrace();
            throw new IllegalArgumentException("RSA异常");
        }
    }

    public static String convertPubRsaFile2Str(String fileStr){
        PublicKey pk = genPublicKey(fileStr);
        return Base64.encodeBase64String(pk.getEncoded());
    }

    public static String convertPriRsaFile2Str(String fileStr){
        PrivateKey pk = genPrivateKey(fileStr);
        return Base64.encodeBase64String(pk.getEncoded());
    }



    public static String encryptByRsaPub(String src, String base64PubRsa) {
        try {
            PublicKey publicKey = genPublicKey(base64PubRsa);
            byte[] encryptBytes = encryptByKey(src.getBytes("GBK"), publicKey);
            return Base64.encodeBase64String(encryptBytes);
        } catch (Exception e) {
            e.printStackTrace();
            throw new IllegalArgumentException("RSA异常");
        }
    }

    public static String encryptByRsaPub(String src, String base64PubRsa,String charset) {
        try {
            PublicKey publicKey = genPublicKey(base64PubRsa);
            byte[] encryptBytes = encryptByKey(src.getBytes(charset), publicKey);
            return Base64.encodeBase64String(encryptBytes);
        } catch (Exception e) {
            e.printStackTrace();
            throw new IllegalArgumentException("RSA异常");
        }
    }

    public static String encryptByRsaPri(String src, String base64PubRsa) {
        try {
            PrivateKey privateKey = genPrivateKey(base64PubRsa);
            byte[] encryptBytes = encryptByKey(src.getBytes("GBK"), privateKey);
            return Base64.encodeBase64String(encryptBytes);
        } catch (Exception e) {
            e.printStackTrace();
            throw new IllegalArgumentException("RSA异常");
        }
    }

    public static String encryptByRsaPri(String src, String base64PubRsa,String charset) {
        try {
            PrivateKey privateKey = genPrivateKey(base64PubRsa);
            byte[] encryptBytes = encryptByKey(src.getBytes(charset), privateKey);
            return Base64.encodeBase64String(encryptBytes);
        } catch (Exception e) {
            e.printStackTrace();
            throw new IllegalArgumentException("RSA异常");
        }
    }

    public static String decryptByRsaPri(String base64Src, String base64PriRsa) {
        try {
            PrivateKey privateKey = genPrivateKey(base64PriRsa);
            return new String(decryptKey(Base64.decodeBase64(base64Src), privateKey), "GBK");
        } catch (Exception e) {
            e.printStackTrace();
            throw new IllegalArgumentException("RSA异常");
        }
    }

    public static String decryptByRsaPri(String base64Src, String base64PriRsa,String charset) {
        try {
            PrivateKey privateKey = genPrivateKey(base64PriRsa);
            return new String(decryptKey(Base64.decodeBase64(base64Src), privateKey), charset);
        } catch (Exception e) {
            e.printStackTrace();
            throw new IllegalArgumentException("RSA异常");
        }
    }

    public static String decryptByRsaPub(String base64Src, String base64PriRsa) {
        try {
            PublicKey publicKey = genPublicKey(base64PriRsa);
            return new String(decryptKey(Base64.decodeBase64(base64Src), publicKey), "GBK");
        } catch (Exception e) {
            e.printStackTrace();
            throw new IllegalArgumentException("RSA异常");
        }
    }

    public static String decryptByRsaPub(String base64Src, String base64PriRsa,String charset) {
        try {
            PublicKey publicKey = genPublicKey(base64PriRsa);
            return new String(decryptKey(Base64.decodeBase64(base64Src), publicKey),charset);
        } catch (Exception e) {
            e.printStackTrace();
            throw new IllegalArgumentException("RSA异常");
        }
    }

    /**
     * 用公钥加密
     */
    private static byte[] encryptByKey(byte[] srcData, Key publicKey) {
        try {
            Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
            int blockSize = cipher.getOutputSize(srcData.length) - 11;
            byte[] encryptedData = null;
            for (int i = 0; i 
<
srcData.length; i += blockSize) {
                byte[] doFinal = cipher.doFinal(subarray(srcData, i, i + blockSize));
                encryptedData = addAll(encryptedData, doFinal);
            }
            return encryptedData;

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

    private static byte[] decryptKey(byte[] srcData, Key key) {
        try {
            Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
            cipher.init(Cipher.DECRYPT_MODE, key);
            int blockSize = cipher.getOutputSize(srcData.length);
            byte[] decryptData = null;

            for (int i = 0; i 
<
srcData.length; i += blockSize) {
                byte[] doFinal = cipher.doFinal(subarray(srcData, i, i + blockSize));

                decryptData = addAll(decryptData, doFinal);
            }
            return decryptData;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    private static byte[] subarray(byte[] array, int startIndexInclusive, int endIndexExclusive) {
        if (array == null) {
            return null;
        }
        if (startIndexInclusive 
<
0) {
            startIndexInclusive = 0;
        }
        if (endIndexExclusive 
>
array.length) {
            endIndexExclusive = array.length;
        }
        int newSize = endIndexExclusive - startIndexInclusive;

        if (newSize 
<
= 0) {
            return new byte[0];
        }

        byte[] subarray = new byte[newSize];

        System.arraycopy(array, startIndexInclusive, subarray, 0, newSize);

        return subarray;
    }

    private static byte[] addAll(byte[] array1, byte[] array2) {
        if (array1 == null) {
            return clone(array2);
        } else if (array2 == null) {
            return clone(array1);
        }
        byte[] joinedArray = new byte[array1.length + array2.length];
        System.arraycopy(array1, 0, joinedArray, 0, array1.length);
        System.arraycopy(array2, 0, joinedArray, array1.length, array2.length);
        return joinedArray;
    }

    public static byte[] clone(byte[] array) {
        if (array == null) {
            return null;
        }
        return (byte[]) array.clone();
    }
}