正经夜光杯

这个屌丝很懒，什么也没留下！

热门标签

Android接入支付宝实现支付功能_android studio 支付宝支付

作者：正经夜光杯 | 2024-08-16 16:31:55

踩

android studio 支付宝支付

转载地址：http://blog.csdn.net/qq_26787115/article/details/73838765

我本来是想直接讲Android支付这一块的，包括支付宝，微信，其他第三方整合支付等，但是微信开放平台他对我的账号做了限制，所有我今天就先把重心放在支付宝的支付上，也算是写得尽可能详细些吧，毕竟是第三方的SDK，只要我们耐心的阅读文档和开发引导，这个其实不是很难的，我也是没有用过支付宝的支付，但是我相信，你看完这篇博客，也会对他了如指掌的，好的，我们正文开始

一.准备步骤

1.登录官网

他的官网就是蚂蚁金服的开放平台了，我们可以访问蚂蚁金服开放平台，并且注册账号进行登录

这里写图片描述

创建应用

如果你是现有的应用直接接入支付功能的话，可以不看这里，我这里是因为需要讲博客所有重新创建了一个项目并且在Android Studio里也重新创建了一个项目，Android Studio里创建的项目我把他叫做SimpleMall，简单商城的意思，那在开放平台我们又是如何去创建应用呢，点击-进入我的开放平台-应用，就可以看到应用管理了。我们点击创建应用

这里写图片描述

创建成果之后有很多的选项包括需要你上传

这里写图片描述

这些先不管，我们这个时候可以看到已经拿到了APPID: 2017062807585767，这样我们就可以继续下一步的准备了

3.签约

大部分的功能需要签约才能使用，很遗憾，我这个个体户就不行了

这里写图片描述

4.配置密钥

配置秘钥是支付这一环节很重要的因素，也是分了两个步骤，生成秘钥和配置秘钥，这里使用的RAS非对称加密

生成RSA秘钥

我们按照文档上来，首先是下载工具了，这里有win和mac两个地址，我是win，下载下来是这个样子的

这里写图片描述

我们按照图中的配置拿到了公钥和私钥

这里写图片描述

那我们可以配置了，我们找到项目详情

这里写图片描述

然后这里是两种方式，我们选择的是RSA方式么其实哪种方式都是可以的

这里写图片描述

到这里，这个也配置好了

5.SDK 下载

到这里，我们就可以直接去下载他的SDK了SDK下载地址

这个压缩包下载下来什么都有，要找到Android的部分

这里写图片描述

二.SDK集成

我们现在就开始来把jar集成进去，支付宝给我们提供的就是一个jar，我们放进我们的工程里面去

并且在我们的app/build.gradle里配置一下

compile files('libs/alipaySdk-20170623-proguard.jar')
 
 1

这样Jar就集成好了，然后配置一下清单文件


        <activity
            android:name="com.alipay.sdk.app.H5PayActivity"
            android:configChanges="orientation|keyboardHidden|navigation"
            android:exported="false"
            android:screenOrientation="behind"/>
 
        <activity
            android:name="com.alipay.sdk.auth.AuthActivity"
            android:configChanges="orientation|keyboardHidden|navigation"
            android:exported="false"
            android:screenOrientation="behind"/>
 
 1
2
3
4
5
6
7
8
9
10
11

并且添加权限


<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
<uses-permission android:name="android.permission.READ_PHONE_STATE" />
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
 
 1
2
3
4
5

如大于等于Android6.0，还需要动态申请下权限

如果你的项目需要混淆，需要添加混淆规则


-libraryjars libs/alipaySDK-20150602.jar
 
-keep class com.alipay.android.app.IAlixPay{*;}
-keep class com.alipay.android.app.IAlixPay$Stub{*;}
-keep class com.alipay.android.app.IRemoteServiceCallback{*;}
-keep class com.alipay.android.app.IRemoteServiceCallback$Stub{*;}
-keep class com.alipay.sdk.app.PayTask{ public *;}
-keep class com.alipay.sdk.app.AuthTask{ public *;}
 
 1
2
3
4
5
6
7
8

嗯，可以说得上是比较简单的，我们继续

三.支付接口调用

其实支付宝的调用还是比较简单的，我们来看一下我的调用方式


public class MainActivity extends AppCompatActivity implements View.OnClickListener {
 
    private Button btnPay;
    private static final int SDK_PAY_FLAG = 1001;
    private String RSA_PRIVATE = "MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQCNYm+oveZOECAjwrH1E+RHznGxVqdAKI/teijarKYIV7RjpNyfMaEaI0ms8vd9aXtN6gEeSPvBQmWVunY1FWfLpAOkSYGJLJ8GJEgiNTAstCgkHw21DaojrD9LxoUZbvfBwWXiDLDAPUGiU6pnG7AkClJuzSETMCTWsrcB35Y9MMprnPaXgNG8+MJ6P2Z1xmN51uNQw4Z99iDrR27lrQH/OXNzLnRDzlj0rwoYFHDSPds58qmjVRTcBXCVpZoLmuf4OfSc8gplNGz/qs/rjOfKEOrcZQeKw1SCkG5U4ZHsMM5XmwbCGg20G9+BokYdHJNKFKu/+kwu69No1Mcy8RTfAgMBAAECggEAIXBCkFo5egT+VPbbN+d4ejMtWI/yBo6RW80klHN44Ug89cQsGcqXG6N07V6ZgiPMceUCVrNUN6UIeZ0cD/n8DoHACr8Hz/Wptr4mAVErD6ecRs7BYyzULJO0dKuDFzzThBPFkO0HcLAMMeQvzSsTQbLfRC1nwS4FyHGELwE+e0IQy3wug7jAid/X2crGC438pwxS7iCjZxsO44WCteCLTjIG/y2AR42wJXSRlPpsGQP6CVgUKa1ATEsoGBDoImDAitnPAyADyOvRMf3jqOcadWq8MtXKPM1KyfM1Sq+NgPawwXxdBHPXB4aDPHmoZm3qb8Nat1VkbTfnmnFNVNiGAQKBgQDGcR0xEI/oP/HRdhKQJCNguUN2dcXIfbfLj4ff9yMtQ+086W3BpJYO5rq6B8mXU66wg3crKJHwpaQ5a6CXb1U757y2J2qPccKdy3ZXed7z0bEkGxwPzwkAiNXM30KvHO9QxVFX3oILDca2qOk7h5vRrRCH9GHdZkYgf7F0WRFwnwKBgQC2ZKYOVPE881ek0SFHURuTN99M+MsciyLzJNeRpopXCBvViRV3rMvyzCRsciJEqQmZnQM7VDkqh3MtutEDnPv2Qux3Qlhk756Q8PdmS9hPl9WK8NGSSA6AQFGqrV16ngjYRm1h+fm6c6K9YFaoJXw/5qYF48X0hXRE39++TXSzwQKBgBnji/Fovb2JCh1PkCBp9ouZ3+lGeCUt8ZqHAS0A6v/uyraVpZILzN/ozheTCIPLkRDKNfPVeSSyF3i+R9c52R7VntMM1WQdbUx0zN2gsquQgdG6D7EoS35cW7g8sFB0L+yTsYcLKmASzgfqhXMUwAlc0LlL8rCVtTRsNFR/gjz1AoGAUiANmSRsHvqe+wpjRp5hoS8mL51Srz6C9SIgomdvoPJ4vfRkoyc+Ccwblmzpuyq1tOI640rwFpM4rF2S4WKdHOxTVvubm489QZwOeZQrCOOf9liqtIgXZ24Ol6BKF/zylJdZhyUsaeTJYSXwvvNp98fd94bwykIQ8TYwo5pyssECgYAZC+l1Ok0VJyisBLgOHoAuwYmWbFRC0RJAwQQoTs4/ozHiR+kFOgiHY6W7sjfgdMej+0U0gNifm2nn0lj1KRuOXiAzkzRBTkiwDChP0PAa2ns9GSbxApRVPJJzeM2NlRX4ptscjKUqWB3tgqPNWDTjW0d7iCYeFWkx0GfRgSwHaQ==";
    public static final String APPID = "2017062807585767";
 
    private Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            switch (msg.what) {
                case SDK_PAY_FLAG:
                    PayResult payResult = new PayResult((Map<String, String>) msg.obj);
                    //同步获取结果
                    String resultInfo = payResult.getResult();
                    Log.i("Pay", "Pay:" + resultInfo);
                    String resultStatus = payResult.getResultStatus();
                    // 判断resultStatus 为9000则代表支付成功
                    if (TextUtils.equals(resultStatus, "9000")) {
                        Toast.makeText(MainActivity.this, "支付成功", Toast.LENGTH_SHORT).show();
                    } else {
                        Toast.makeText(MainActivity.this, "支付失败", Toast.LENGTH_SHORT).show();
                    }
                    break;
            }
        }
    };
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initView();
    }
 
    private void initView() {
        btnPay = (Button) findViewById(R.id.btnPay);
        btnPay.setOnClickListener(this);
    }
 
    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.btnPay:
                //秘钥验证的类型 true:RSA2 false:RSA
                boolean rsa = false;
                //构造支付订单参数列表
                Map<String, String> params = OrderInfoUtil2_0.buildOrderParamMap(APPID, rsa);
                //构造支付订单参数信息
                String orderParam = OrderInfoUtil2_0.buildOrderParam(params);
                //对支付参数信息进行签名
                String sign = OrderInfoUtil2_0.getSign(params, RSA_PRIVATE, rsa);
                //订单信息
                final String orderInfo = orderParam + "&" + sign;
                //异步处理
                Runnable payRunnable = new Runnable() {
 
                    @Override
                    public void run() {
                        //新建任务
                        PayTask alipay = new PayTask(MainActivity.this);
                        //获取支付结果
                        Map<String, String> result = alipay.payV2(orderInfo, true);
                        Message msg = new Message();
                        msg.what = SDK_PAY_FLAG;
                        msg.obj = result;
                        mHandler.sendMessage(msg);
                    }
                };
                // 必须异步调用
                Thread payThread = new Thread(payRunnable);
                payThread.start();
                break;
        }
    }
}
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

可以看到我们并没有多少代码，调用起来

这里写图片描述

但是还是提示有错误，我们来看一下他的返回值

{"alipay_trade_app_pay_response":{"code":"40006","msg":"Insufficient Permissions","sub_code":"isv.insufficient-isv-permissions","sub_msg":"ISV权限不足"}}
 
 1

这是因为我们这个应用并没有去签约功能，所有并没有这个权限，好的，但是起码可以看出我们已经可以调用支持包的支付了，那我们继续来了解他的功能吧

四.Api

首先我们看下他提供的OrderInfoUtil2_0这个工具类


public class OrderInfoUtil2_0 {
 
    /**
     * 构造授权参数列表
     * 
     * @param pid
     * @param app_id
     * @param target_id
     * @return
     */
    public static Map<String, String> buildAuthInfoMap(String pid, String app_id, String target_id, boolean rsa2) {
        Map<String, String> keyValues = new HashMap<String, String>();
 
        // 商户签约拿到的app_id，如：2013081700024223
        keyValues.put("app_id", app_id);
 
        // 商户签约拿到的pid，如：2088102123816631
        keyValues.put("pid", pid);
 
        // 服务接口名称， 固定值
        keyValues.put("apiname", "com.alipay.account.auth");
 
        // 商户类型标识， 固定值
        keyValues.put("app_name", "mc");
 
        // 业务类型， 固定值
        keyValues.put("biz_type", "openservice");
 
        // 产品码， 固定值
        keyValues.put("product_id", "APP_FAST_LOGIN");
 
        // 授权范围， 固定值
        keyValues.put("scope", "kuaijie");
 
        // 商户唯一标识，如：kkkkk091125
        keyValues.put("target_id", target_id);
 
        // 授权类型， 固定值
        keyValues.put("auth_type", "AUTHACCOUNT");
 
        // 签名类型
        keyValues.put("sign_type", rsa2 ? "RSA2" : "RSA");
 
        return keyValues;
    }
 
    /**
     * 构造支付订单参数列表
     * @param app_id
     * @return
     */
    public static Map<String, String> buildOrderParamMap(String app_id, boolean rsa2) {
        Map<String, String> keyValues = new HashMap<String, String>();
 
        keyValues.put("app_id", app_id);
 
        keyValues.put("biz_content", "{\"timeout_express\":\"30m\",\"product_code\":\"QUICK_MSECURITY_PAY\",\"total_amount\":\"0.01\",\"subject\":\"1\",\"body\":\"我是测试数据\",\"out_trade_no\":\"" + getOutTradeNo() +  "\"}");
 
        keyValues.put("charset", "utf-8");
 
        keyValues.put("method", "alipay.trade.app.pay");
 
        keyValues.put("sign_type", rsa2 ? "RSA2" : "RSA");
 
        keyValues.put("timestamp", "2016-07-29 16:55:53");
 
        keyValues.put("version", "1.0");
 
        return keyValues;
    }
 
    /**
     * 构造支付订单参数信息
     * 
     * @param map
     * 支付订单参数
     * @return
     */
    public static String buildOrderParam(Map<String, String> map) {
        List<String> keys = new ArrayList<String>(map.keySet());
 
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < keys.size() - 1; i++) {
            String key = keys.get(i);
            String value = map.get(key);
            sb.append(buildKeyValue(key, value, true));
            sb.append("&");
        }
 
        String tailKey = keys.get(keys.size() - 1);
        String tailValue = map.get(tailKey);
        sb.append(buildKeyValue(tailKey, tailValue, true));
 
        return sb.toString();
    }
 
    /**
     * 拼接键值对
     * 
     * @param key
     * @param value
     * @param isEncode
     * @return
     */
    private static String buildKeyValue(String key, String value, boolean isEncode) {
        StringBuilder sb = new StringBuilder();
        sb.append(key);
        sb.append("=");
        if (isEncode) {
            try {
                sb.append(URLEncoder.encode(value, "UTF-8"));
            } catch (UnsupportedEncodingException e) {
                sb.append(value);
            }
        } else {
            sb.append(value);
        }
        return sb.toString();
    }
 
    /**
     * 对支付参数信息进行签名
     * 
     * @param map
     *            待签名授权信息
     * 
     * @return
     */
    public static String getSign(Map<String, String> map, String rsaKey, boolean rsa2) {
        List<String> keys = new ArrayList<String>(map.keySet());
        // key排序
        Collections.sort(keys);
 
        StringBuilder authInfo = new StringBuilder();
        for (int i = 0; i < keys.size() - 1; i++) {
            String key = keys.get(i);
            String value = map.get(key);
            authInfo.append(buildKeyValue(key, value, false));
            authInfo.append("&");
        }
 
        String tailKey = keys.get(keys.size() - 1);
        String tailValue = map.get(tailKey);
        authInfo.append(buildKeyValue(tailKey, tailValue, false));
 
        String oriSign = SignUtils.sign(authInfo.toString(), rsaKey, rsa2);
        String encodedSign = "";
 
        try {
            encodedSign = URLEncoder.encode(oriSign, "UTF-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return "sign=" + encodedSign;
    }
 
    /**
     * 要求外部订单号必须唯一。
     * @return
     */
    private static String getOutTradeNo() {
        SimpleDateFormat format = new SimpleDateFormat("MMddHHmmss", Locale.getDefault());
        Date date = new Date();
        String key = format.format(date);
 
        Random r = new Random();
        key = key + r.nextInt();
        key = key.substring(0, 15);
        return key;
    }
 
}
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173

而我们一开始就需要构建订单参数列表，就是这个方法


    /**
     * 构造支付订单参数列表
     * @param app_id
     * @return
     */
    public static Map<String, String> buildOrderParamMap(String app_id, boolean rsa2) {
        Map<String, String> keyValues = new HashMap<String, String>();
 
        keyValues.put("app_id", app_id);
 
        keyValues.put("biz_content", "{\"timeout_express\":\"30m\",\"product_code\":\"QUICK_MSECURITY_PAY\",\"total_amount\":\"0.01\",\"subject\":\"1\",\"body\":\"我是测试数据\",\"out_trade_no\":\"" + getOutTradeNo() +  "\"}");
 
        keyValues.put("charset", "utf-8");
 
        keyValues.put("method", "alipay.trade.app.pay");
 
        keyValues.put("sign_type", rsa2 ? "RSA2" : "RSA");
 
        keyValues.put("timestamp", "2016-07-29 16:55:53");
 
        keyValues.put("version", "1.0");
 
        return keyValues;
    }
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

这个方法我们来解读一下吧，他其实就是构建一个Map的键值对，都有哪些内容呢

app_id(key)
biz_content(内容)
charset（编码）
method（方法）
sign_type（签名类型）
timestamp（时间戳）
version（版本）

这个demo里面可能都是写死了，但是如果我们真的要在实际应用中开发支付的话，这里要填写正确，我们主要关心的有方法和签名类型还有版本这三个

方法有几个类型，要注意一下

这里写图片描述

其次就是签名方式了，有两种，RSA和RSA2

最后就是版本，版本可以通过PayTask去获取


    //获取版本
    private String getPlayVersion(PayTask payTask){
        return payTask.getVersion();
    }
 
 1
2
3
4

而关于biz_content，就需要你们自己去定义了，我们来看下全部的参数说明

这里写图片描述

当我们拿到map之后就可以转换成一个string作为请求信息了，可以看到我们使用的是这个方法


    /**
     * 构造支付订单参数信息
     * 
     * @param map
     * 支付订单参数
     * @return
     */
    public static String buildOrderParam(Map<String, String> map) {
        List<String> keys = new ArrayList<String>(map.keySet());
 
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < keys.size() - 1; i++) {
            String key = keys.get(i);
            String value = map.get(key);
            sb.append(buildKeyValue(key, value, true));
            sb.append("&");
        }
 
        String tailKey = keys.get(keys.size() - 1);
        String tailValue = map.get(tailKey);
        sb.append(buildKeyValue(tailKey, tailValue, true));
 
        return sb.toString();
    }
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

他的本质就是拼接出最后的订单信息，如图

这里写图片描述

好的，现在订单详情已经有了我们就可以把订单加密了


    /**
     * 对支付参数信息进行签名
     * 
     * @param map
     *            待签名授权信息
     * 
     * @return
     */
    public static String getSign(Map<String, String> map, String rsaKey, boolean rsa2) {
        List<String> keys = new ArrayList<String>(map.keySet());
        // key排序
        Collections.sort(keys);
 
        StringBuilder authInfo = new StringBuilder();
        for (int i = 0; i < keys.size() - 1; i++) {
            String key = keys.get(i);
            String value = map.get(key);
            authInfo.append(buildKeyValue(key, value, false));
            authInfo.append("&");
        }
 
        String tailKey = keys.get(keys.size() - 1);
        String tailValue = map.get(tailKey);
        authInfo.append(buildKeyValue(tailKey, tailValue, false));
 
        String oriSign = SignUtils.sign(authInfo.toString(), rsaKey, rsa2);
        String encodedSign = "";
 
        try {
            encodedSign = URLEncoder.encode(oriSign, "UTF-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return "sign=" + encodedSign;
    }
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

这里的加密主要还是用到了SignUtils


public class SignUtils {
 
    private static final String ALGORITHM = "RSA";
 
    private static final String SIGN_ALGORITHMS = "SHA1WithRSA";
 
    private static final String SIGN_SHA256RSA_ALGORITHMS = "SHA256WithRSA";
 
    private static final String DEFAULT_CHARSET = "UTF-8";
 
    private static String getAlgorithms(boolean rsa2) {
        return rsa2 ? SIGN_SHA256RSA_ALGORITHMS : SIGN_ALGORITHMS;
    }
 
    public static String sign(String content, String privateKey, boolean rsa2) {
        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(getAlgorithms(rsa2));
 
            signature.initSign(priKey);
            signature.update(content.getBytes(DEFAULT_CHARSET));
 
            byte[] signed = signature.sign();
 
            return Base64.encode(signed);
        } catch (Exception e) {
            e.printStackTrace();
        }
 
        return null;
    }
 
}
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

而SignUtils则启动了Base64


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;
            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;
    }
}
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267

这些你都可以在我写的demo里获取到的，我们继续分析就是了，当加密成功之后他会返回一个sign的字符串给我，这就是加密信息，然后通过订单信息 & 加密订单这种公式就拼接出商品信息


//订单信息
 String orderInfo = orderParam + "&" + sign;
 
 1
2

好的，我们的下单需要在异步中操作，也就是我们所见到的Runnable


                Runnable payRunnable = new Runnable() {
 
                    @Override
                    public void run() {
                        //新建任务
                        PayTask alipay = new PayTask(MainActivity.this);
                        //获取支付结果
                        Map<String, String> result = alipay.payV2(orderInfo, true);
                        Message msg = new Message();
                        msg.what = SDK_PAY_FLAG;
                        msg.obj = result;
                        mHandler.sendMessage(msg);
                    }
                };
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14

在这里他同样的是构建一个PayTask 区调用payV2，里面的参数就是订单信息和一个boolean值，具体参数可以参考

这里写图片描述

好的，当我们拿到结果后通过Handler回到UI线程


    PayResult payResult = new PayResult((Map<String, String>) msg.obj);
    //同步获取结果
    String resultInfo = payResult.getResult();
    Log.i("Pay", "Pay:" + resultInfo);
    String resultStatus = payResult.getResultStatus();
    // 判断resultStatus 为9000则代表支付成功
    if (TextUtils.equals(resultStatus, "9000")) {
       Toast.makeText(MainActivity.this, "支付成功", Toast.LENGTH_SHORT).show();
    } else {
       Toast.makeText(MainActivity.this, "支付失败", Toast.LENGTH_SHORT).show();
    }
 
 1
2
3
4
5
6
7
8
9
10
11

这里其实PayResult只是把结果几个关键信息提取出来了


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;
    }
}
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

我们如果想看详细的结果，可以打印resultInfo，好的，关于返回参数，可以参考App支付同步通知参数说明

这里写图片描述

好的，事实上在实际开发中，要做的准备工作并不只是这么点，毕竟涉及到支付这个敏感话题，我这边也只是个人商户，没办法给大家展示正确的结果了，可能有些疏漏，但是大体就是这样，比微信稍微要简单点，我们下次细聊下微信支付，我们感觉去注册个账号去~~~

SimpleMall下载

对文章有兴趣的可以关注一下我的微信公众号或者QQ群

Android旅行的路途：

这里写图片描述

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/正经夜光杯/article/detail/989157