Android支付宝支付封装代码

内容摘要

在做Android支付的时候肯定会用到支付宝支付，根据官方给出的demo做起来非常费劲，所以我们需要一次简单的封装。

封装的代码也很简单，就是将官网给的demo提取出一个类来方便

文章正文

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

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出来的，现在我们就将支付功能封装到了一个类中，那么如何使用呢？

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支付宝支付的代码，希望对大家的学习有所启发。

代码注释

上一篇 jquery实现checkbox 全选/全不选的通用写法下一篇 jQuery mobile转换url地址及获取url中目录部分的方法

作者：喵哥笔记

学的不仅是技术，更是梦想！