阅读 63

关于接入微信、支付宝支付,看这篇就够了

前言

由于公司项目需要,安排我负责接入微信、支付宝支付功能。从最开始的申请账号到最后的功能完成,全程参与其中。现在功能完成了,正好写篇总结文档。顺便写了个Android端的demo,把整个功能都整合了一下。里面包括获取订单,签名,验证,调起支付,支付完成同步回调整个流程。配合总结文档食用最佳,欢迎star ~

接入支付宝支付

支付宝接入相对而言比较简单,按照官方文档和demo基本没什么大问题。先看下支付宝支付的流程图。

体验demo

如果你已经按照官方教程完成了接入支付宝的准备工作,那么用申请的appid和生成的公钥私钥替换demo中PayConstants的相关属性,就可以直接体验支付宝支付了。这其中需要注意RSA_PRIVATE 和 RSA2_PRIVATE 都是支付宝私钥,分别对应着RSA和RSA2签名算法。 目前新建应用只能使用RSA2签名算法,老应用还是可以使用RSA签名算法,不过在调用支付时需要标注是否是使用RSA2签名算法。

    /**
     * RSA_PRIVATE 和支付宝私钥
     */
    public static final String RSA2_PRIVATE = "XXXXXXX";
    /**
     * 支付宝APP_ID
     */
    public static final String ALI_APP_ID = "2018083061113973";
复制代码

接入支付SDK

下载最新版的支付SDK,将其复制到你项目的libs文件夹中。在项目的build.gradle中添加如下代码:

allprojects {
    repositories {

        // 添加下面的内容
        flatDir {
            dirs 'libs'
        }

        // ... jcenter() 等其他仓库
    }
}
复制代码

在APP的build.gradle中,添加支付SDK的aar包依赖:

    compile (name: 'alipaySdk-15.5.9-20181123210601', ext: 'aar')
复制代码

在AndroidManifest中添加以下权限:


    <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.INTERNET" />

    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
复制代码

以上就完成了接入SDK的工作。这其中需要注意,WRITE_EXTERNAL_STORAGE和READ_PHONE_STATE权限需要在代码中动态获取。

获取签名订单

按照接入流程图所示,第一步是先获取签名订单。为了防止应用的支付宝私钥暴露,这一步都是在服务器中完成。demo中为了方便方便体验,直接写在了客户端中。如果是开发线上APP,不建议这么做。支付宝获取签名订单需要以下几个步骤:

  • 将请求参数按照key=value&key=value方式拼接的未签名原始字符串。
  • 再对原始字符串进行签名
  • 最后对请求字符串的所有一级value(biz_content作为一个value)进行encode,编码格式按请求串中的charset为准,没传charset按UTF-8处理,获得最终的请求字符串

按照官方的请求参数说明,demo中的代码示例如下:

    /**
     * 生成map格式订单
     *
     * @param app_id  支付平台中你APP的app_id
     * @param rsa2    是否是使用RSA2签名算法
     * @param payBean 包括订单金额,订单描述,订单详细内容,创建订单时间戳
     * @param version 接入的支付宝SDK版本号
     * @return
     */
    public static Map<String, String> buildOrderParamMap(String app_id, boolean rsa2, PayBean payBean, String version) {
        Map<String, String> keyValues = new HashMap<>();
        //支付宝的amount单位为元
        float amount = (payBean.getAmount()) / 100;

        keyValues.put("app_id", app_id);
        /**
         * biz_content参数包括所有的订单信息
         */
        keyValues.put("biz_content", "{\"timeout_express\":\"30m\",\"product_code\":\"QUICK_MSECURITY_PAY\",\"total_amount\":\"" + amount + "\",\"subject\":\"" + payBean.getBody() + "\",\"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("notify_url",payBean.getNotify_url());

        keyValues.put("timestamp", getDateToString(payBean.getTime(), "yyyy-MM-dd HH:mm:ss"));

        keyValues.put("version", version);

        return keyValues;
    }

    
        /**
     * 将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();
    }
复制代码

先根据用户支付的订单参数,如订单价格、订单描述等,构建原始map格式订单。这其中需要注意,所有的订单参数(total_amount,timeout_express,subject)都一起存入biz_content中。然后将map格式原始订单参数,进行排序,转换为string格式。这其中还需要传入一个notify_url参数,后面会用到。

    /**
     * 将订单信息签名,encode
     *
     * @param map 待签名的订单信息
     * @param rsaKey     支付宝私钥
     * @param rsa2       是否使用RSA2签名算法
     * @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);
        //签名的数据需要没有经过encode处理
        authInfo.append(buildKeyValue(tailKey, tailValue, false));

        //将排序后的序列进行签名
        String oriSign = sign(authInfo.toString(), rsaKey, rsa2);
        String encodedSign = "";

        try {
            encodedSign = URLEncoder.encode(oriSign, "UTF-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return "sign=" + encodedSign;
    }
    

    /**
     * 签名
     *
     * @param content    待签名信息
     * @param privateKey 支付宝私钥
     * @param rsa2       是否使用RSA2签名算法
     * @return
     */
    public static String sign(String content, String privateKey, boolean rsa2) {
        try {
            PKCS8EncodedKeySpec priPKCS8 = new PKCS8EncodedKeySpec(
                    Base64.decode(privateKey));
            KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM, "BC");
            PrivateKey priKey = keyFactory.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;
    }
复制代码

然后将排序后的订单信息进行签名和encode,获取最终请求支付的字符串。

请求支付

支付宝请求支付,只需要调用alipay.payV2方法。

        Runnable payRunnable = new Runnable() {

            @Override
            public void run() {
                PayTask alipay = new PayTask(MainActivity.this);
                String  orderInfo = AliPayUtil.getKidoOrderInfo(getPayBean(),alipay.getVersion());
                Map<String, String> result = alipay.payV2(orderInfo, true);
                Log.i("msp", result.toString());
                Message msg = new Message();
                msg.what = SDK_PAY_FLAG;
                msg.obj = result;
                mHandler.sendMessage(msg);
            }
        };

        Thread payThread = new Thread(payRunnable);
        payThread.start();
复制代码

其中,同步支付结果通过message传递出来。这其中需要注意,支付结果必须通过服务器端返回的异步结果来进行最终确认。不能仅根据本地结果来显示给用户。

    @SuppressLint("HandlerLeak")
    private Handler mHandler = new Handler() {
        @SuppressWarnings("unused")
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case SDK_PAY_FLAG: {
                    @SuppressWarnings("unchecked")
                    PayResult payResult = new PayResult((Map<String, String>) msg.obj);
                    /**
                     对于支付结果,请商户依赖服务端的异步通知结果。同步通知结果,仅作为支付结束的通知。
                     */
                    String resultInfo = payResult.getResult();// 同步返回需要验证的信息
                    String resultStatus = payResult.getResultStatus();
                    // 判断resultStatus 为9000则代表支付成功
                    if (TextUtils.equals(resultStatus, "9000")) {
                        // 该笔订单是否真实支付成功,需要依赖服务端的异步通知。
                        paymentSucceed();
                    } else {
                        // 该笔订单真实的支付结果,需要依赖服务端的异步通知。
                        paymentFailed();
                    }
                    break;
                }
                default:
                    break;
            }
        }
    };
复制代码

前面传入的支付参数中,有一个notify_url。支付宝服务器会把异步支付结果通过调用这个notify_url来返回给我们服务器,然后通过服务器返回给APP,APP通过与本地结果对比,来反馈给用户支付结果。

以上,整个支付流程就走完了。

微信支付

微信支付接入起来稍微有点复杂。官方文档上面也有相应介绍。先看下官方流程图。

总结下就是:

  • 先准备本地下单信息,对下单信息进行排序、签名和XML格式化。
  • 用本地下单信息调用微信统一下单接口,获取统一下单信息。并对该信息进行签名验证。
  • 将微信返回的统一下单信息进行解析,并转化为调用微信支付所需格式。
  • 调用微信支付,同步返回支付结果。
  • 微信服务器调用传入的notify_url,异步返回支付结果。本地服务器将结果返回给APP,反馈给用户。

接入微信SDK

首先在官网上下载SDK,并将其复制到libs文件夹中。在APP的build.gradle中添加如下代码(一般Android studio会自动生成这段代码):

    implementation fileTree(dir: 'libs', include: ['*.jar'])

复制代码

微信支付的本地结果回调,需要在项目中新建wxapi文件夹,在其中添加WXPayEntryActivity,并继承IWXAPIEventHandler接口。当支付完成后,结果会同步到WXPayEntryActivity的onResp(BaseResp baseResp)方法中。

public class WXPayEntryActivity extends Activity implements IWXAPIEventHandler {


    private IWXAPI api;

    private static WXPayListenter mListener;

    public static void setmListener(WXPayListenter listener) {
        mListener = listener;
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        api = WXAPIFactory.createWXAPI(this, PayConstants.WX_APP_ID, false);

        try {
            api.handleIntent(getIntent(), this);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    protected void onNewIntent(Intent intent) {
        super.onNewIntent(intent);

        setIntent(intent);
        api.handleIntent(intent, this);
    }


    @Override
    public void onReq(BaseReq baseReq) {

    }

    @Override
    public void onResp(BaseResp baseResp) {
        int result = 0;
        //支付结果还需要发送给服务器确认支付状态
        if (baseResp.getType() == ConstantsAPI.COMMAND_PAY_BY_WX) {
            if (mListener != null) {
                if (baseResp.errCode == 0) {
                    mListener.paymentSucceed();
                } else if (baseResp.errCode == -2) {
                    mListener.paymentCanceled();
                } else {
                    mListener.paymentFailed();
                }
            }
            finish();
        }

    }

    public interface WXPayListenter {
        void paymentSucceed();

        void paymentCanceled();

        void paymentFailed();
    }

}
复制代码

在AndroidManifest中添加WXPayEntryActivity

        <activity
            android:name=".wxapi.WXPayEntryActivity"
            android:exported="true"
            android:launchMode="singleTop" />
复制代码

以上就完成了接入SDK的工作。如果已经接入过微信分享SDK,那么下载SDK和依赖这一步就可以跳过了,只需要再添加WXPayEntryActivity就行了。

准备本地下单信息

自我感觉,这一步是最麻烦的。首先我们需要本地订单信息进行排序和签名。

    
    /**
     * 生成订单信息
     *
     * @param ip      当前手机IP
     * @param orderId 当前生成的外部订单号
     * @return
     */
    public static SortedMap<String, Object> prepareOrder(String ip, String orderId,PayBean payBean) {

        Map<String, Object> oparams = new LinkedHashMap<String, Object>();
        oparams.put("appid", PayConstants.WX_APP_ID);// 服务号的应用号
        oparams.put("body",payBean.getDescribe());// 商品描述
        oparams.put("mch_id", PayConstants.WX_CHD_ID);// 商户号
        oparams.put("nonce_str", CreateNoncestr());// 16随机字符串(大小写字母加数字)
        oparams.put("out_trade_no", orderId);// 商户订单号
        oparams.put("total_fee", payBean.getAmount());// 支付金额 单位分 注意:前端负责传入分
        oparams.put("spbill_create_ip", ip);// IP地址
        oparams.put("notify_url", payBean.getNotify_url()); // 微信回调地址
        oparams.put("trade_type", PayConstants.TRADE_TYPE);// 支付类型 app
        return sortMap(oparams);
    }
    
    /**
     * 对map根据key进行排序 ASCII 顺序
     *
     * @param
     * @return
     */
    public static SortedMap<String, Object> sortMap(Map<String, Object> map) {

        List<Map.Entry<String, Object>> infoIds = new ArrayList<Map.Entry<String, Object>>(
                map.entrySet());
        // 排序
        Collections.sort(infoIds, new Comparator<Map.Entry<String, Object>>() {
            @Override
            public int compare(Map.Entry<String, Object> o1,
                               Map.Entry<String, Object> o2) {
                // return (o2.getValue() - o1.getValue());//value处理
                return (o1.getKey()).toString().compareTo(o2.getKey());
            }
        });
        // 排序后
        SortedMap<String, Object> sortmap = new TreeMap<String, Object>();
        for (int i = 0; i < infoIds.size(); i++) {
            String[] split = infoIds.get(i).toString().split("=");
            sortmap.put(split[0], split[1]);
        }
        return sortmap;
    }
    
    /**
     * 签名工具
     *
     * @param characterEncoding 编码格式 UTF-8
     * @param parameters        请求参数
     * @return
     */
    public static String createSign(String characterEncoding,
                                    Map<String, Object> parameters) {
        StringBuffer sb = new StringBuffer();
        Iterator<Map.Entry<String, Object>> it = parameters.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry<String, Object> entry = (Map.Entry<String, Object>) it.next();
            String key = (String) entry.getKey();
            Object value = entry.getValue();//去掉带sign的项
            if (null != value && !"".equals(value) && !"sign".equals(key)
                    && !"key".equals(key)) {
                sb.append(key + "=" + value + "&");
            }
        }
        sb.append("key=" + PayConstants.WX_KEY);
        return MD5Encode(sb.toString(), characterEncoding).toUpperCase();
    }

    /**
     * MD5
     *
     * @param origin
     * @param charsetname
     * @return
     */
    public static String MD5Encode(String origin, String charsetname) {
        String resultString = null;
        try {
            resultString = new String(origin);
            MessageDigest md = MessageDigest.getInstance("MD5");
            if (charsetname == null || "".equals(charsetname)) {
                resultString = byteArrayToHexString(md.digest(resultString
                        .getBytes()));
            } else {
                resultString = byteArrayToHexString(md.digest(resultString
                        .getBytes(charsetname)));
            }
        } catch (Exception exception) {
        }
        return resultString;
    }
复制代码

这一部分,上面代码中已经备注的很详细,就不展开解释了。签名之后,将本地下单信息进行xml格式化。

    /**
     * 将请求参数转换为xml格式的string
     *
     * @param parameters 请求参数
     * @return
     */
    public static String getRequestXml(SortedMap<String, Object> parameters) {
        StringBuffer sb = new StringBuffer();
        sb.append("<xml>");
        Iterator<Map.Entry<String, Object>> iterator = parameters.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, Object> entry = (Map.Entry<String, Object>) iterator.next();
            String key = (String) entry.getKey();
            String value = (String) entry.getValue();
            if ("attach".equalsIgnoreCase(key) || "body".equalsIgnoreCase(key)
                    || "sign".equalsIgnoreCase(key)) {
                sb.append("<" + key + ">" + "<![CDATA[" + value + "]]></" + key + ">");
            } else {
                sb.append("<" + key + ">" + value + "</" + key + ">");
            }
        }
        sb.append("</xml>");
        return sb.toString();
    }
复制代码

这其中需要注意,attach,body,sign三个参数加了CDATA标签,用于说明数据不被XML解析器解析。以上我们就准备好了本地下单信息,可以直接调用微信统一下单接口,获取统一下单订单信息了。

获取统一下单信息

先调用接口获取统一下单信息。我这里使用的是最基本的httpsRequest。

    /**
     * 发送https请求
     *
     * @param requestUrl    请求地址
     * @param requestMethod 请求方式(GET、POST)
     * @param outputStr     提交的数据
     * @return 返回微信服务器响应的信息
     * @throws Exception
     */
    public static String httpsRequest(String requestUrl, String requestMethod,
                                      String outputStr) throws Exception {
        try {

            URL url = new URL(requestUrl);
            HttpsURLConnection conn = (HttpsURLConnection) url.openConnection();
            conn.setDoOutput(true);
            conn.setDoInput(true);
            conn.setUseCaches(false);
            // 设置请求方式(GET/POST)
            conn.setRequestMethod(requestMethod);
            conn.setRequestProperty("content-type",
                    "application/x-www-form-urlencoded");
            // 当outputStr不为null时向输出流写数据
            if (null != outputStr) {
                OutputStream outputStream = conn.getOutputStream();
                // 注意编码格式
                outputStream.write(outputStr.getBytes("UTF-8"));
                outputStream.close();
            }
            // 从输入流读取返回内容
            InputStream inputStream = conn.getInputStream();
            InputStreamReader inputStreamReader = new InputStreamReader(
                    inputStream, "UTF-8");
            BufferedReader bufferedReader = new BufferedReader(
                    inputStreamReader);
            String str = null;
            StringBuffer buffer = new StringBuffer();
            while ((str = bufferedReader.readLine()) != null) {
                buffer.append(str);
            }
            // 释放资源
            bufferedReader.close();
            inputStreamReader.close();
            inputStream.close();
            inputStream = null;
            conn.disconnect();
            return buffer.toString();
        } catch (ConnectException ce) {
            Log.e(TAG, "连接超时:{}" + ce);
            throw new RuntimeException("链接异常" + ce);
        } catch (Exception e) {
            Log.e(TAG, "https请求异常:{}" + e);
            throw new RuntimeException("https请求异常" + e);
        }

    }
复制代码

服务器返回的下单信息是xml格式,我们需要先进行格式转换。

    /**
     * @param xml
     * @return Map
     * @description 将xml字符串转换成map
     */
    public static Map<String, Object> readStringXmlOut(String xml) {
        Map<String, Object> map = new HashMap<String, Object>();
        Document doc = null;
        try {
            doc = DocumentHelper.parseText(xml); // 将字符串转为XML
            Element rootElt = doc.getRootElement(); // 获取根节点
            @SuppressWarnings("unchecked")
            List<Element> list = rootElt.elements();// 获取根节点下所有节点
            for (Element element : list) { // 遍历节点
                map.put(element.getName(), element.getText()); // 节点的name为map的key,text为map的value
            }
        } catch (DocumentException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return map;
    }

复制代码

检验API返回的数据里面的签名是否合法,避免数据在传输的过程中被第三方篡改。

    /**
     * 检验API返回的数据里面的签名是否合法,避免数据在传输的过程中被第三方篡改
     *
     * @param map API返回的下单数据
     * @return API签名是否合法
     * @throws
     * @throws
     * @throws
     */
    public static boolean checkIsSignValidFromResponseString(Map<String, Object> map) {

        try {
            String signFromAPIResponse = map.get("sign").toString();
            if ("".equals(signFromAPIResponse) || signFromAPIResponse == null) {
                Log.d(TAG, "API返回的数据签名数据不存在,有可能被第三方篡改!!!");
                return false;
            }

            //清掉返回数据对象里面的Sign数据(不能把这个数据也加进去进行签名),然后用签名算法进行签名
            map.put("sign", "");
            //将API返回的数据根据用签名算法进行计算新的签名,用来跟API返回的签名进行比较
            String signForAPIResponse = createSign(Charsets.UTF_8.toString(), map);
            Log.d(TAG, "服务器回包里面的签名是:" + signFromAPIResponse + "==服务器回包数据签名是:" + signForAPIResponse);
            if (!signForAPIResponse.equals(signFromAPIResponse)) {
                //签名验不过,表示这个API返回的数据有可能已经被篡改了
                Log.d(TAG, "API返回的数据签名验证不通过,有可能被第三方篡改!!!");
                return false;
            }
            Log.d(TAG, "恭喜,API返回的数据签名验证通过!!!");
            return true;
        } catch (Exception e) {
            return false;
        }
    }
复制代码

最后,还需要对返回的订单信息进行整理,来得到我们需要的最终调用微信支付所需要的数据。

    /**
     * 提取微信服务器返回的下单数据,组合成调用微信支付所需的map
     * 对map进行排序签名
     *
     * @param resultMap
     * @return
     */
    private static Map<String, Object> getPayResultMap(Map<String, Object> resultMap) {
        Map<String, Object> map = new LinkedHashMap<String, Object>();
        map.put("appid", resultMap.get("appid"));
        map.put("partnerid", resultMap.get("mch_id"));
        map.put("prepayid", resultMap.get("prepay_id"));
        map.put("package", "Sign=WXPay");
        map.put("noncestr", resultMap.get("nonce_str"));
        map.put("timestamp", getTimeStamp());
        //对map进行排序
        SortedMap<String, Object> sortedMap = sortMap(map);
        //对map进行签名,并将签名加入map
        sortedMap.put("sign", createSign(Charsets.UTF_8.toString(), sortedMap));
        return sortedMap;
    }
复制代码

这其中需要注意,我们还是需要将最终的订单信息进行重新排序,然后重新签名。这里的签名方式一定要与统一下单接口使用的一致。具体可以参照官方签名文档

调用支付

总算是走到这一步了,维信调用支付需要先判断当前手机是否有安装维信,维信版本是否支持支付功能。

    /**
     * 判断当前手机是否支持维信支付
     * @return
     */
    private boolean wxCanPay(){
        try{
            if(!iwxapi.isWXAppInstalled()){
                Toast.makeText(MainActivity.this,"请安装微信客户端", Toast.LENGTH_SHORT).show();
                return false;
            }else if(!iwxapi.isWXAppSupportAPI()){
                Toast.makeText(MainActivity.this, "当前微信版本不支持支付", Toast.LENGTH_SHORT).show();
                return false;
            }
        }catch (Exception e){
            e.printStackTrace();
            Toast.makeText(MainActivity.this, "请安装最新微信客户端", Toast.LENGTH_SHORT).show();
            return false;
        }
        return true;
    }
复制代码

调用微信支付

        Runnable wxPayRunnable = new Runnable() {
            @Override
            public void run() {
                try{
                    Map<String,Object> orderInfo = WXPayUtil.getWXOrderInfo(getPayBean(),MainActivity.this);
                    PayReq req = new PayReq();
                    req.appId = (String)orderInfo.get("appid");
                    req.partnerId = (String)orderInfo.get("partnerid");
                    req.prepayId = (String)orderInfo.get("prepayid");
                    req.nonceStr = (String)orderInfo.get("noncestr");
                    req.timeStamp = (String)orderInfo.get("timestamp");
                    req.packageValue = (String)orderInfo.get("package");
                    req.sign = (String)orderInfo.get("sign");
                    iwxapi.sendReq(req);
                }catch (Exception e ){
                    e.printStackTrace();
                }


            }
        };
        Thread payThread = new Thread(wxPayRunnable);
        payThread.start();
复制代码

按照第一步接入准备中所说,支付结果会返回到WXPayEntryActivity的onResp(BaseResp baseResp)。我们需要获取到结果后,finish掉这个activity。然后在支付结果页面等待服务器返回异步支付结果。

总结

接入两个支付,收获还是有的。设计到支付相关,安全是最重要的。所以签名加密等所有操作都是在服务器端进行的,最终落实到APP端,也只是写个界面,调个接口而已。但是相关的流程和逻辑还是有必要理一理,总结一下的。最后再附上demo的地址,欢迎大家star

关注下面的标签,发现更多相似文章
评论