安卓APP调用支付宝接口的实现

aclncf1313

于 2025-01-29 02:14:55 发布

阅读量867

点赞数 6

文章标签： android java 前端

本文链接：https://blog.youkuaiyun.com/aclncf1313/article/details/145390873

版权

// 调用支付接口，获取支付结果

Map<String, String> result = alipay.payV2(params[0], true);

return result;

}

@Override

protected void onPostExecute(Map<String, String> result) {

@SuppressWarnings(“unchecked”)

PayResult payResult = new PayResult(result);

/**

对于支付结果，请商户依赖服务端的异步通知结果。同步通知结果，仅作为支付结束的通知。

String resultInfo = payResult.getResult();// 同步返回需要验证的信息

String resultStatus = payResult.getResultStatus();

Log.i(“lgq支付宝支付响应状态”, resultStatus);

if (resultStatus.equals(“6001”)){

Toast.makeText(MainActivity.this,“支付取消”,Toast.LENGTH_SHORT).show();

}

// 判断resultStatus 为9000则代表支付成功

if (TextUtils.equals(resultStatus, “9000”)) {

Toast.makeText(MainActivity.this,“支付成功”,Toast.LENGTH_LONG).show();

// 该笔订单是否真实支付成功，需要依赖服务端的异步通知。

// verifyPay();

} else {

// 该笔订单真实的支付结果，需要依赖服务端的异步通知。

// 判断resultStatus 为非“9000”则代表可能支付失败

// “8000”代表支付结果因为支付渠道原因或者系统原因还在等待支付结果确认，最终交易是否成功以服务端异步通知为准（小概率状态）

if (TextUtils.equals(resultStatus, “8000”)) {

// if (payResultListener != null) {

// payResultListener.onProcess();

// }

} else {

// 其他值就可以判断为支付失败，包括用户主动取消支付，或者系统返回的错误

// if (payResultListener != null) {

// payResultListener.onFail();

// }

}

// 9000 订单支付成功

// 8000 正在处理中，支付结果未知（有可能已经支付成功），请查询商户订单列表中订单的支付状态

// 4000 订单支付失败

// 5000 重复请求

// 6001 用户中途取消

// 6002 网络连接出错

// 6004 支付结果未知（有可能已经支付成功），请查询商户订单列表中订单的支付状态

// 其它其它支付错误

}

Base64.java

public final class Base64 {

private static final int BASELENGTH = 128;

private static final int LOOKUPLENGTH = 64;

private static final int TWENTYFOURBITGROUP = 24;

private static final int EIGHTBIT = 8;

private static final int SIXTEENBIT = 16;

private static final int FOURBYTE = 4;

private static final int SIGN = -128;

private static char PAD = ‘=’;

private static byte[] base64Alphabet = new byte[BASELENGTH];

private static char[] lookUpBase64Alphabet = new char[LOOKUPLENGTH];

static {

for (int i = 0; i < BASELENGTH; ++i) {

base64Alphabet[i] = -1;

}

for (int i = ‘Z’; i >= ‘A’; i–) {

base64Alphabet[i] = (byte) (i - ‘A’);

}

for (int i = ‘z’; i >= ‘a’; i–) {

base64Alphabet[i] = (byte) (i - ‘a’ + 26);

}

for (int i = ‘9’; i >= ‘0’; i–) {

base64Alphabet[i] = (byte) (i - ‘0’ + 52);

}

base64Alphabet[‘+’] = 62;

base64Alphabet[‘/’] = 63;

for (int i = 0; i <= 25; i++) {

lookUpBase64Alphabet[i] = (char) (‘A’ + i);

}

for (int i = 26, j = 0; i <= 51; i++, j++) {

lookUpBase64Alphabet[i] = (char) (‘a’ + j);

}

for (int i = 52, j = 0; i <= 61; i++, j++) {

lookUpBase64Alphabet[i] = (char) (‘0’ + j);

}

lookUpBase64Alphabet[62] = (char) ‘+’;

lookUpBase64Alphabet[63] = (char) ‘/’;

}

private static boolean isWhiteSpace(char octect) {

return (octect == 0x20 || octect == 0xd || octect == 0xa || octect == 0x9);

}

private static boolean isPad(char octect) {

return (octect == PAD);

}

private static boolean isData(char octect) {

return (octect < BASELENGTH && base64Alphabet[octect] != -1);

}

/**

Encodes hex octects into Base64
@param binaryData
```
       Array containing binaryData
```
@return Encoded Base64 array

public static String encode(byte[] binaryData) {

if (binaryData == null) {

return null;

}

int lengthDataBits = binaryData.length * EIGHTBIT;

if (lengthDataBits == 0) {

return “”;

}

int fewerThan24bits = lengthDataBits % TWENTYFOURBITGROUP;

int numberTriplets = lengthDataBits / TWENTYFOURBITGROUP;

int numberQuartet = fewerThan24bits != 0 ? numberTriplets + 1

numberTriplets;

char encodedData[] = null;

encodedData = new char[numberQuartet * 4];

byte k = 0, l = 0, b1 = 0, b2 = 0, b3 = 0;

int encodedIndex = 0;

int dataIndex = 0;

for (int i = 0; i < numberTriplets; i++) {

b1 = binaryData[dataIndex++];

b2 = binaryData[dataIndex++];

b3 = binaryData[dataIndex++];

l = (byte) (b2 & 0x0f);

k = (byte) (b1 & 0x03);

byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2)

(byte) ((b1) >> 2 ^ 0xc0);

byte val2 = ((b2 & SIGN) == 0) ? (byte) (b2 >> 4)

(byte) ((b2) >> 4 ^ 0xf0);

byte val3 = ((b3 & SIGN) == 0) ? (byte) (b3 >> 6)

(byte) ((b3) >> 6 ^ 0xfc);

encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];

encodedData[encodedIndex++] = lookUpBase64Alphabet[val2 | (k << 4)];

encodedData[encodedIndex++] = lookUpBase64Alphabet[(l << 2) | val3];

encodedData[encodedIndex++] = lookUpBase64Alphabet[b3 & 0x3f];

}

// form integral number of 6-bit groups

if (fewerThan24bits == EIGHTBIT) {

b1 = binaryData[dataIndex];

k = (byte) (b1 & 0x03);

byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2)

(byte) ((b1) >> 2 ^ 0xc0);

encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];

encodedData[encodedIndex++] = lookUpBase64Alphabet[k << 4];

encodedData[encodedIndex++] = PAD;

} else if (fewerThan24bits == SIXTEENBIT) {

b1 = binaryData[dataIndex];

b2 = binaryData[dataIndex + 1];

l = (byte) (b2 & 0x0f);

k = (byte) (b1 & 0x03);

byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2)

(byte) ((b1) >> 2 ^ 0xc0);

byte val2 = ((b2 & SIGN) == 0) ? (byte) (b2 >> 4)

(byte) ((b2) >> 4 ^ 0xf0);

encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];

encodedData[encodedIndex++] = lookUpBase64Alphabet[val2 | (k << 4)];

encodedData[encodedIndex++] = lookUpBase64Alphabet[l << 2];

encodedData[encodedIndex++] = PAD;

}

return new String(encodedData);

}

/**

Decodes Base64 data into octects
@param encoded
```
       string containing Base64 data
```
@return Array containind decoded data.

public static byte[] decode(String encoded) {

if (encoded == null) {

return null;

}

char[] base64Data = encoded.toCharArray();

// remove white spaces

int len = removeWhiteSpace(base64Data);

if (len % FOURBYTE != 0) {

return null;// should be divisible by four

}

int numberQuadruple = (len / FOURBYTE);

if (numberQuadruple == 0) {

return new byte[0];

}

byte decodedData[] = null;

byte b1 = 0, b2 = 0, b3 = 0, b4 = 0;

char d1 = 0, d2 = 0, d3 = 0, d4 = 0;

int i = 0;

int encodedIndex = 0;

int dataIndex = 0;

decodedData = new byte[(numberQuadruple) * 3];

for (; i < numberQuadruple - 1; i++) {

if (!isData((d1 = base64Data[dataIndex++]))

|| !isData((d2 = base64Data[dataIndex++]))

|| !isData((d3 = base64Data[dataIndex++]))

|| !isData((d4 = base64Data[dataIndex++]))) {

return null;

}// if found “no data” just return null

b1 = base64Alphabet[d1];

b2 = base64Alphabet[d2];

b3 = base64Alphabet[d3];

b4 = base64Alphabet[d4];

decodedData[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);

decodedData[encodedIndex++] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));

decodedData[encodedIndex++] = (byte) (b3 << 6 | b4);

}

if (!isData((d1 = base64Data[dataIndex++]))

|| !isData((d2 = base64Data[dataIndex++]))) {

return null;// if found “no data” just return null

}

b1 = base64Alphabet[d1];

b2 = base64Alphabet[d2];

d3 = base64Data[dataIndex++];

d4 = base64Data[dataIndex++];

if (!isData((d3)) || !isData((d4))) {// Check if they are PAD characters

if (isPad(d3) && isPad(d4)) {

if ((b2 & 0xf) != 0)// last 4 bits should be zero

{

return null;

}

byte[] tmp = new byte[i * 3 + 1];

System.arraycopy(decodedData, 0, tmp, 0, i * 3);

tmp[encodedIndex] = (byte) (b1 << 2 | b2 >> 4);

return tmp;

} else if (!isPad(d3) && isPad(d4)) {

b3 = base64Alphabet[d3];

if ((b3 & 0x3) != 0)// last 2 bits should be zero

{

return null;

}

byte[] tmp = new byte[i * 3 + 2];

System.arraycopy(decodedData, 0, tmp, 0, i * 3);

tmp[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);

tmp[encodedIndex] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));

return tmp;

} else {

return null;

}

} else { // No PAD e.g 3cQl

b3 = base64Alphabet[d3];

b4 = base64Alphabet[d4];

decodedData[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);

decodedData[encodedIndex++] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));

decodedData[encodedIndex++] = (byte) (b3 << 6 | b4);

}

return decodedData;

}

/**

remove WhiteSpace from MIME containing encoded Base64 data.
@param data

       the byte array of base64 data (with WS)

@return the new length

private static int removeWhiteSpace(char[] data) {

if (data == null) {

return 0;

}

// count characters that’s not whitespace

int newSize = 0;

int len = data.length;

for (int i = 0; i < len; i++) {

if (!isWhiteSpace(data[i])) {

data[newSize++] = data[i];

}

return newSize;

}

PayResult.java

public class PayResult {

private String resultStatus;

private String result;

private String memo;

public PayResult(Map<String, String> rawResult) {

if (rawResult == null) {

return;

}

for (String key : rawResult.keySet()) {

if (TextUtils.equals(key, “resultStatus”)) {

resultStatus = rawResult.get(key);

} else if (TextUtils.equals(key, “result”)) {

result = rawResult.get(key);

} else if (TextUtils.equals(key, “memo”)) {

memo = rawResult.get(key);

}

@Override

public String toString() {

return “resultStatus={” + resultStatus + “};memo={” + memo

“};result={” + result + “}”;

}

/**

@return the resultStatus

public String getResultStatus() {

return resultStatus;

}

/**

@return the memo

public String getMemo() {

return memo;

}

/**

@return the result

public String getResult() {

return result;

}

SignUtils.java

public class SignUtils {

private static final String ALGORITHM = “RSA”;

private static final String SIGN_ALGORITHMS = “SHA1WithRSA”;

private static final String DEFAULT_CHARSET = “UTF-8”;

public static String sign(String content, String privateKey) {

try {

PKCS8EncodedKeySpec priPKCS8 = new PKCS8EncodedKeySpec(

Base64.decode(privateKey));

KeyFactory keyf = KeyFactory.getInstance(ALGORITHM);

PrivateKey priKey = keyf.generatePrivate(priPKCS8);

java.security.Signature signature = java.security.Signature

.getInstance(SIGN_ALGORITHMS);

signature.initSign(priKey);

signature.update(content.getBytes(DEFAULT_CHARSET));

byte[] signed = signature.sign();

return Base64.encode(signed);

} catch (Exception e) {

e.printStackTrace();

}

return null;

}