Android支付宝支付封装代码

投稿:lijiao 字体:[增加 减小] 类型:转载 时间:2015-12-22我要评论

这篇文章主要介绍了Android支付宝支付封装代码,Android支付的时候肯定会使用支付宝进行支付,封装可以简化操作步骤,感兴趣的小伙伴们可以参考一下

在做Android支付的时候肯定会用到支付宝支付, 根据官方给出的demo做起来非常费劲,所以我们需要一次简单的封装。 
封装的代码也很简单,就是将官网给的demo提取出一个类来方便使用。

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
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
public class Alipay {
  // 商户PID
  public static final String PARTNER = "123456789";
  // 商户收款账号
  public static final String SELLER = "qibin0506@gmail.com";
  // 商户私钥,pkcs8格式
  public static final String RSA_PRIVATE = "rsa_private";
  // 支付宝公钥
  public static final String RSA_PUBLIC = "rsa_public";
 
  private static final int SDK_PAY_FLAG = 1;
 
  private WeakReference<Activity> mActivity;
 
  private OnAlipayListener mListener;
 
  public Alipay(Activity activity) {
    mActivity = new WeakReference<Activity>(activity);
  }
 
  @SuppressLint("HandlerLeak")
  private Handler mHandler = new Handler() {
    public void handleMessage(Message msg) {
      if (msg.what == SDK_PAY_FLAG) {
        PayResult payResult = new PayResult((String) msg.obj);
        // 支付宝返回此次支付结果及加签,建议对支付宝签名信息拿签约时支付宝提供的公钥做验签
        String resultInfo = payResult.getResult();
        String resultStatus = payResult.getResultStatus();
        // 判断resultStatus 为“9000”则代表支付成功,具体状态码代表含义可参考接口文档
        if (TextUtils.equals(resultStatus, "9000")) {
          if (mListener != null) mListener.onSuccess();
        } else {
          // 判断resultStatus 为非“9000”则代表可能支付失败
          // “8000”代表支付结果因为支付渠道原因或者系统原因还在等待支付结果确认,
          // 最终交易是否成功以服务端异步通知为准(小概率状态)
          if (TextUtils.equals(resultStatus, "8000")) {
            if (mListener != null) mListener.onWait();
          } else {
            // 其他值就可以判断为支付失败,包括用户主动取消支付,或者系统返回的错误
            if (mListener != null) mListener.onCancel();
          }
        }
      }
    }
  };
 
  /**
   * 支付
   *
   * @param title  标题 不能为空或者“”
   * @param desc 描述 不能为空或者“”
   * @param price 价格 不能为空或者“”
   * @param sn 商品唯一货号 不能为空或者“”
   * @param url 服务器回调url 不能为空或者“”
   */
  public void pay(String title, String desc, String price, String sn, String url) {
    // 订单
    String orderInfo = getOrderInfo(title, desc, price, sn, url);
 
    // 对订单做RSA 签名
    String sign = sign(orderInfo);
    try {
      // 仅需对sign 做URL编码
      sign = URLEncoder.encode(sign, "UTF-8");
    } catch (UnsupportedEncodingException e) {
      e.printStackTrace();
    }
 
    // 完整的符合支付宝参数规范的订单信息
    final String payInfo = orderInfo + "&sign=\"" + sign + "\"&"
        + getSignType();
 
    Runnable payRunnable = new Runnable() {
 
      @Override
      public void run() {
        Activity activity = mActivity.get();
        if(activity == null) return;
        // 构造PayTask 对象
        PayTask alipay = new PayTask(activity);
        // 调用支付接口,获取支付结果
        String result = alipay.pay(payInfo);
 
        Message msg = new Message();
        msg.what = SDK_PAY_FLAG;
        msg.obj = result;
        mHandler.sendMessage(msg);
      }
    };
 
    // 必须异步调用
    Thread payThread = new Thread(payRunnable);
    payThread.start();
  }
 
  /**
   * create the order info. 创建订单信息
   *
   */
  public String getOrderInfo(String subject, String body, String price,
      String sn, String url) {
    // 签约合作者身份ID
    String orderInfo = "partner=" + "\"" + PARTNER + "\"";
 
    // 签约卖家支付宝账号
    orderInfo += "&seller_id=" + "\"" + SELLER + "\"";
 
    // 商户网站唯一订单号
    orderInfo += "&out_trade_no=" + "\"" + sn + "\"";
 
    // 商品名称
    orderInfo += "&subject=" + "\"" + subject + "\"";
 
    // 商品详情
    orderInfo += "&body=" + "\"" + body + "\"";
 
    // 商品金额
    orderInfo += "&total_fee=" + "\"" + price + "\"";
 
    // 服务器异步通知页面路径
    orderInfo += "¬ify_url=" + "\"" + url + "\"";
 
    // 服务接口名称, 固定值
    orderInfo += "&service=\"mobile.securitypay.pay\"";
 
    // 支付类型, 固定值
    orderInfo += "&payment_type=\"1\"";
 
    // 参数编码, 固定值
    orderInfo += "&_input_charset=\"utf-8\"";
 
    // 设置未付款交易的超时时间
    // 默认30分钟,一旦超时,该笔交易就会自动被关闭。
    // 取值范围:1m~15d。
    // m-分钟,h-小时,d-天,1c-当天(无论交易何时创建,都在0点关闭)。
    // 该参数数值不接受小数点,如1.5h,可转换为90m。
    orderInfo += "&it_b_pay=\"30m\"";
 
    // extern_token为经过快登授权获取到的alipay_open_id,带上此参数用户将使用授权的账户进行支付
    // orderInfo += "&extern_token=" + "\"" + extern_token + "\"";
 
    // 支付宝处理完请求后,当前页面跳转到商户指定页面的路径,可空
    orderInfo += "&return_url=\"m.alipay.com\"";
 
    // 调用银行卡支付,需配置此参数,参与签名, 固定值 (需要签约《无线银行卡快捷支付》才能使用)
    // orderInfo += "&paymethod=\"expressGateway\"";
 
    return orderInfo;
  }
 
  /**
   * sign the order info. 对订单信息进行签名
   *
   * @param content
   *      待签名订单信息
   */
  public String sign(String content) {
    return SignUtils.sign(content, RSA_PRIVATE);
  }
 
  /**
   * get the sign type we use. 获取签名方式
   *
   */
  public String getSignType() {
    return "sign_type=\"RSA\"";
  }
 
  public void setListener(OnAlipayListener l) {
    mListener = l;
  }
 
  /**
   * 支付回调接口
   *
   * @author lenovo
   *
   */
  public static class OnAlipayListener {
    /**
     * 支付成功
     */
    public void onSuccess() {}
 
    /**
     * 支付取消
     */
    public void onCancel() {}
 
    /**
     * 等待确认
     */
    public void onWait() {}
  }
}
 
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;
  }
}
 
class PayResult {
  private String resultStatus;
  private String result;
  private String memo;
 
  public PayResult(String rawResult) {
 
    if (TextUtils.isEmpty(rawResult))
      return;
 
    String[] resultParams = rawResult.split(";");
    for (String resultParam : resultParams) {
      if (resultParam.startsWith("resultStatus")) {
        resultStatus = gatValue(resultParam, "resultStatus");
      }
      if (resultParam.startsWith("result")) {
        result = gatValue(resultParam, "result");
      }
      if (resultParam.startsWith("memo")) {
        memo = gatValue(resultParam, "memo");
      }
    }
  }
 
  @Override
  public String toString() {
    return "resultStatus={" + resultStatus + "};memo={" + memo
        + "};result={" + result + "}";
  }
 
  private String gatValue(String content, String key) {
    String prefix = key + "={";
    return content.substring(content.indexOf(prefix) + prefix.length(),
        content.lastIndexOf("}"));
  }
 
  /**
   * @return the resultStatus
   */
  public String getResultStatus() {
    return resultStatus;
  }
 
  /**
   * @return the memo
   */
  public String getMemo() {
    return memo;
  }
 
  /**
   * @return the result
   */
  public String getResult() {
    return result;
  }
}
 
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;
  }
}

前面的几个常量是需要去支付宝官网获取的,获取后直接替换就ok, 
其他的代码基本都是从demo中copy出来的, 现在我们就将支付功能封装到了一个类中,那么如何使用呢?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Alipay alipay = new Alipay(OrderConfirmActivity.this);
alipay.setListener(mAlipayListener);
alipay.pay(desc, mOrder.getShopName(), String.valueOf(orderAmount), orderSn, url); /**
 * 支付宝支付回调
 */ private Alipay.OnAlipayListener mAlipayListener = new Alipay.OnAlipayListener() { @Override public void onSuccess() {
    onOrderSubmitSuccess();
  } @Override public void onCancel() {
    onUserOrderCanceled();
      Toast.makeText(OrderConfirmActivity.this, R.string.pay_failed,
          Toast.LENGTH_SHORT).show();
  } @Override public void onWait() {
 
  }
};

new出对象来,只需要调用pay方法就ok啦, 不过支付的回调我们还是必须的,当然这个也不麻烦。这里说一下pay方法的几个参数,

  • title 支付的标题
  • desc 支付的描述
  • price 支付的金额
  • sn 商品的唯一货号
  • url 服务器的回调url

这几个参数在做支付的时候服务器都会给到,但是要注意一下,这几个参数都不能为空或者空字符串,否则会支付失败。

以上就是封装Android支付宝支付的代码,希望对大家的学习有所启发。

如对本文有疑问,请提交到交流社区,广大热心网友会为你解答!!  点击进入社区

 

(转载)Android支付宝支付封装代码的更多相关文章

  1. android支付宝支付开发过程

    原文:android支付宝支付开发过程 支付宝开发流程: 1.在支付宝申请一个账号并开通开发者功能和移动支付的功能. 支付宝地址:https://auth.alipay.com/login/index ...

  2. 支付宝支付Java代码

    支付宝调用流程 开发前的准备工作 配置应用网关 应用网关里面填写的值就是商户后台的异步回调地址.也就是在支付宝付完款之后,由支付宝调用商户,便于商户验证订单各信息和更新订单状态 授权回调地址 授权回调 ...

  3. uni-app支付宝支付成功代码处理,获取trade_no数据

    uni-app支付宝支付成功以后返回很多代码,我简单梳理一下,提出trade_no数据 uni.requestPayment({ provider: 'alipay', orderInfo: orde ...

  4. android app 集成 支付宝支付 微信支付

    项目中部分功能点需要用到支付功能,移动端主要集成支付宝支付和微信支付 支付宝sdk以及demo下载地址:https://doc.open.alipay.com/doc2/detail.htm?spm= ...

  5. MUI 支付宝支付接入

    沙箱测试地址:https://openhome.alipay.com/platform/appDaily.htm 1资源下载地址:https://docs.open.alipay.com/54/106 ...

  6. 移动应用端的支付宝支付php开发流程

    1.https://openhome.alipay.com/ 支付宝开放平台并创建应用,审核通过后并签约app支付拿到pid 2.按照官方文档用 [RSA签名验签工具.bat]生成应用公钥和私钥 3. ...

  7. Android支付——支付宝支付总结

    摘要:分享牛系列.分享牛转载.第三方支付,java第三方支付.android第三方支付. 原文地址:http://blog.csdn.net/zwl5670/article/details/51219 ...

  8. Android 支付宝以及微信支付快速接入流程

    简介 随着移动支付的普及,越来越多的App采用第三发支付,在这里我们以支付宝为例,做一个快速集成! 一.Android快速实现支付宝支付 1.首先,我们需要前往支付宝开放平台,申请我们的支付功能:ht ...

  9. android支付宝app支付(原生态)-包括android前端与java后台

    本文讲解了 android开发的原生态app集成了支付宝支付, 还提供了java后台服务器处理支付宝支付的加密代码, app前端与java后台服务器使用json数据格式交互信息,java后台服务主要用 ...

随机推荐

  1. Python 对象初识

    # Demo1class Penson: animal = 'big mom' plant = 'flower' def __init__(self,name,age,sex,job): self.n ...

  2. CLR寄宿和应用程序域

    Win实际上将CLR作为一个COM服务器实现在一个DLL内,即为CLR定义了标准的COM接口,并为该接口和COM服务器分配一GUID,安装FrameWork时表示CLR的COM服务器被注册到注册表内. ...

  3. .csv文件内容分隔符

    CSV文件默认以英文逗号做为列分隔符,换行符作为行分隔符.  如果不提供网页形式只用命令行或二进制程序输出数据到CSV,只需要将数据段按,分割,行按\n分割,写入到一个.csv文件即可.  但有时字段 ...

  4. jquery获取自定义属性的值

    //获取属性值 1 <div id="text" value="黑哒哒的盟友"><div> jQuery取值: $("#tex ...

  5. vue 中判断向上滚动还是向下滚动

    <script> export default { data(){ return{ i = 0 } }, mounted () { window.addEventListener('scr ...

  6. Windows10 下安装 Mongodb

    一.先登录Mongodb官网https://www.mongodb.com/download-center#community 下载   安装包.32.64位的都行.

  7. Java以流的方式将指定文件夹里的.txt文件全部复制到另一文件夹,并删除原文件夹中所有.txt文件

    import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.File; import java.io.Fi ...

  8. BZOJ 4182 Shopping (点分治+树上多重背包)

    题目大意:给你一颗树,你有$m$元钱,每个节点都有一种物品,价值为$w$,代价为$c$,有$d$个,如果在$u$和$v$两个城市都购买了至少一个物品,那么$u,v$路径上每个节点也都必须买至少一个物品 ...

  9. [CodeForces]529B Group Photo 2

    AK爷GhostCai的电脑又蓝屏了Orz 贪心题,确定一个maxh,限定h不大于一个值.枚举maxh. check的时候的细节很多: 1.h>maxh但w<maxh交换的时候需要占用交换 ...

  10. Python 绘图与可视化 matplotlib 填充fill和fill_between

    参考链接:https://blog.csdn.net/You_are_my_dream/article/details/53457960 fill()填充函数曲线与坐标轴之间的区域: x = np.l ...