1.下单支付接口

请求参数详解：app支付接口2.0 - 支付宝文档中心 (alipay.com)

流程： 1.用户打开页面下单，此时生成订单并插入数据库中的订单表

2.商家系统调用支付宝接口，发起请求支付。填写请求参数。参数看文档

3.用户输入沙箱提供的账号密码或者二维码付款，支付宝跳转到支付页面，输入支付密码。最后确认支付。

4.如果设置了ReturnUrl就会跳转到相应页面

5.支付是否成功以异步通知为准。支付宝会向我们的应用程序发出post请求

@ApiOperation("统一收单下单并支付页面接口的调用")
@PostMapping("/trade/page/pay/{productId}")
public R tradePagePay(@PathVariable Long productId){
    log.info("统一收单下单并支付页面接口的调用");

    //看支付宝文档，发现请求发到支付宝后，返回的数据是一个表单，这个表单
    //是个字符串，然后我们把这个字符串通过json返回给前端，其中返回的html页面
    //的js有个自动提交脚本，页面就会自动发请求到支付宝，从而为用户提示一个支付页面
    String formStr = aliPayService.tradeCreate(productId);
    return R.ok().data("formStr",formStr);
}

@Transactional(rollbackFor = Exception.class)
    @Override
    public String tradeCreate(Long productId) {

        try {
            //生成订单
            log.info("生成订单");
            OrderInfo orderInfo = orderInfoService.createOrderByProductId(productId);

            //调用支付宝接口
            AlipayTradePagePayRequest request = new AlipayTradePagePayRequest();
            //配置需要的公共请求参数
            //支付完成后，支付宝向网站发起异步通知的地址
            request.setNotifyUrl(config.getProperty("alipay.notify-url"));
            //支付完成后，我们想让页面跳转回自己的页面，配置returnUrl
            request.setReturnUrl(config.getProperty("alipay.return-url"));

            //组装当前业务方法的请求参数
            JSONObject bizContent = new JSONObject();
            bizContent.put("out_trade_no", orderInfo.getOrderNo());
            BigDecimal total = new BigDecimal(orderInfo.getTotalFee().toString()).divide(new BigDecimal("100"));
            bizContent.put("total_amount", total);
            bizContent.put("subject", orderInfo.getTitle());
            bizContent.put("product_code", "FAST_INSTANT_TRADE_PAY");

            request.setBizContent(bizContent.toString());

            //执行请求，调用支付宝接口
            AlipayTradePagePayResponse response = alipayClient.pageExecute(request);

            if(response.isSuccess()){
                log.info("调用成功，返回结果 ===> " + response.getBody());
                return response.getBody();
            } else {
                log.info("调用失败，返回码 ===> " + response.getCode() + ", 返回描述 ===> " + response.getMsg());
                throw new RuntimeException("创建支付交易失败");
            }
        } catch (AlipayApiException e) {
            e.printStackTrace();
            throw new RuntimeException("创建支付交易失败");
        }
    }

公共参数一般会设置配置类与properties绑定进行预先定义。 普通参数一般在类中直接定义。使用的时候自动注入alipayClient就行

@Configuration
@PropertySource("classpath:alipay-sandbox.properties")
public class AlipayClientConfig {

    @Resource
    private Environment config;

    /**
     * 封装了签名和验签的过程
     * @return
     * @throws AlipayApiException
     */
    @Bean
    public AlipayClient alipayClient() throws AlipayApiException {

        AlipayConfig alipayConfig = new AlipayConfig();

        //设置网关地址
        alipayConfig.setServerUrl(config.getProperty("alipay.gateway-url"));
        //设置应用Id
        alipayConfig.setAppId(config.getProperty("alipay.app-id"));
        //设置应用私钥
        alipayConfig.setPrivateKey(config.getProperty("alipay.merchant-private-key"));
        //设置请求格式，固定值json
        alipayConfig.setFormat(AlipayConstants.FORMAT_JSON);
        //设置字符集
        alipayConfig.setCharset(AlipayConstants.CHARSET_UTF8);
        //设置支付宝公钥
        alipayConfig.setAlipayPublicKey(config.getProperty("alipay.alipay-public-key"));
        //设置签名类型
        alipayConfig.setSignType(AlipayConstants.SIGN_TYPE_RSA2);
        //构造client
        AlipayClient alipayClient = new DefaultAlipayClient(alipayConfig);

        return alipayClient;
    }

}

异步通知

为什么需要这个呢，因为支付是否完成，我们不知道，需要支付宝通知我们，过程就是支付宝通过回调，调用我们商户系统的一个接口，并且把需要参数传递给商户系统进行第二次验证订单没有问题，此时返回success给支付宝端。说明支付成功，再根据通知的参数，对订单信息可以改成已支付状态。

由于支付宝需要主动给我们发通知，而我们的系统全是内网之间的测试，支付宝服务器无法通过内网找到我们的服务器，因此必须做内网穿透，获取固定的外网地址。

@ApiOperation("支付通知")
@PostMapping("/trade/notify")
public String tradeNotify(@RequestParam Map<String, String> params) {

    log.info("支付通知正在执行");
    log.info("通知参数 ===> {}", params);
    String result = "failure";
    try {
        //验签
        boolean signVerified = AlipaySignature.rsaCheckV1(params, config.getProperty("alipay.alipay-public-key"),
                , AlipayConstants.CHARSET_UTF8, AlipayConstants.SIGN_TYPE_RSA2);  //调用SDK验证签名
        if (!signVerified) {
            //验签失败则记录异常日志，并在response中返回failure.
            log.error("支付成功异步通知验签失败！");
            return result;
        }

        // 验签成功后
        log.info("支付成功异步通知验签成功！");

        //按照支付结果异步通知中的描述，对支付结果中的业务内容进行二次校验，
        //1 商户需要验证该通知数据中的 out_trade_no 是否为商户系统中创建的订单号
        String outTradeNo = params.get("out_trade_no");
        OrderInfo order = orderInfoService.getOrderByOrderNo(outTradeNo);
        if (order == null) {
            log.error("订单不存在");
            return result;
        }

        //2 判断 total_amount 是否确实为该订单的实际金额（即商户订单创建时的金额）
        String totalAmount = params.get("total_amount");
        int totalAmountInt = new BigDecimal(totalAmount).multiply(new BigDecimal("100")).intValue();
        int totalFeeInt = order.getTotalFee().intValue();
        if (totalAmountInt != totalFeeInt) {
            log.error("金额校验失败");
            return result;
        }

        //3 校验通知中的 seller_id（或者 seller_email) 是否为 out_trade_no 这笔单据的对应的操作方
        String sellerId = params.get("seller_id");
        String sellerIdProperty = config.getProperty("alipay.seller-id");
        if (!sellerId.equals(sellerIdProperty)) {
            log.error("商家pid校验失败");
            return result;
        }

        //4 验证 app_id 是否为该商户本身
        String appId = params.get("app_id");
        String appIdProperty = config.getProperty("alipay.app-id");
        if (!appId.equals(appIdProperty)) {
            log.error("appid校验失败");
            return result;
        }

        //在支付宝的业务通知中，只有交易通知状态为 TRADE_SUCCESS时，
        // 支付宝才会认定为买家付款成功。
        String tradeStatus = params.get("trade_status");
        if (!"TRADE_SUCCESS".equals(tradeStatus)) {
            log.error("支付未成功");
            return result;
        }

        //处理业务 修改订单状态 记录支付日志
        aliPayService.processOrder(params);

        //校验成功后在response中返回success并继续商户自身业务处理，校验失败返回failure
        result = "success";
    } catch (
            AlipayApiException e) {
        e.printStackTrace();
    }
    return result;
}

解决支付宝可能存在重复通知的问题。

问题由来：因为支付宝在一段时间内没有收到，商家系统返回的success，就会不断通知25小时8次的量，此时如果系统已经返回了success由于网络波动等等导致没有及时返回给支付宝端，那么就会多次调用我们的异步接口，导致多次更新支付状态和插入支付日志。所以我们要求无论调用多少次接口，只能执行一次。

@Transactional(rollbackFor = Exception.class)
@Override
public void processOrder(Map<String, String> params) {

    log.info("处理订单");

    //获取订单号
    String orderNo = params.get("out_trade_no");

    /*在对业务数据进行状态检查和处理之前，
    要采用数据锁进行并发控制，
    以避免函数重入造成的数据混乱*/
    //尝试获取锁：
    // 成功获取则立即返回true，获取失败则立即返回false。不必一直等待锁的释放
    if(lock.tryLock()) {
        try {

            //处理重复通知
            //接口调用的幂等性：无论接口被调用多少次，以下业务执行一次。要求订单状态==未支付才能执行，否则return
            String orderStatus = orderInfoService.getOrderStatus(orderNo);
            if (!OrderStatus.NOTPAY.getType().equals(orderStatus)) {
                return;
            }

            //更新订单状态
            orderInfoService.updateStatusByOrderNo(orderNo, OrderStatus.SUCCESS);

            //记录支付日志
            paymentInfoService.createPaymentInfoForAliPay(params);

        } finally {
            //要主动释放锁
            lock.unlock();
        }
    }

}

到此用户支付完成。从用户发起订单，到支付宝主动调用我们的回调接口进行二次校验并且更改订单状态，记录支付日志。全部完成。

2.用户取消订单

统一收单交易关闭接口 - 支付宝文档中心 (alipay.com) 这样用户就能取消未支付的订单。 注意当我们点击购买的时候，我们本地数据库的订单信息已经创建了，但是支付宝并没有，需要等到支付宝跳转到输入支付密码的时候，支付宝才会创建。

/**
 * 用户取消订单
 * @param orderNo
 * @return
 */
@ApiOperation("用户取消订单")
@PostMapping("/trade/close/{orderNo}")
public R cancel(@PathVariable String orderNo){

    log.info("取消订单");
    aliPayService.cancelOrder(orderNo);
    return R.ok().setMessage("订单已取消");
}

/**
 * 用户取消订单
 * @param orderNo
 */
@Override
public void cancelOrder(String orderNo) {

    //调用支付宝提供的统一收单交易关闭接口
    this.closeOrder(orderNo);

    //更新用户订单状态
    orderInfoService.updateStatusByOrderNo(orderNo, OrderStatus.CANCEL);
}

/**
 * 关单接口的调用
 * @param orderNo 订单号
 */
private void closeOrder(String orderNo) {

    try {
        log.info("关单接口的调用，订单号 ===> {}", orderNo);

        AlipayTradeCloseRequest request = new AlipayTradeCloseRequest();
        JSONObject bizContent = new JSONObject();
        bizContent.put("out_trade_no", orderNo);
        request.setBizContent(bizContent.toString());
        AlipayTradeCloseResponse response = alipayClient.execute(request);

        if(response.isSuccess()){
            log.info("调用成功，返回结果 ===> " + response.getBody());
        } else {
            log.info("调用失败，返回码 ===> " + response.getCode() + ", 返回描述 ===> " + response.getMsg());
            //throw new RuntimeException("关单接口的调用失败");
        }

    } catch (AlipayApiException e) {
        e.printStackTrace();
        throw new RuntimeException("关单接口的调用失败");
    }
}

3.查单接口

统一收单线下交易查询接口 - 支付宝文档中心 (alipay.com)

当异步消息没有收到时，可能是支付宝的原因也可能是我们系统的原因就会造成，明明支付宝端支付了，但是我们本地数据库显示未支付，我们需要主动查单。

下面这个接口我们可以主动调用，通过swaggerui能查到该订单在支付宝中的状态

/**
     * 查询订单
     * @param orderNo
     * @return
     */
    @ApiOperation("查询订单：测试订单状态用")
    @GetMapping("/trade/query/{orderNo}")
    public R queryOrder(@PathVariable String orderNo)  {

        log.info("查询订单");

        String result = aliPayService.queryOrder(orderNo);
        return R.ok().setMessage("查询成功").data("result", result);

    }

/**
 * 查询订单
 * @param orderNo
 * @return 返回订单查询结果，如果返回null则表示支付宝端尚未创建订单
 */
@Override
public String queryOrder(String orderNo) {

    try {
        log.info("查单接口调用 ===> {}", orderNo);

        AlipayTradeQueryRequest request = new AlipayTradeQueryRequest();
        JSONObject bizContent = new JSONObject();
        bizContent.put("out_trade_no", orderNo);
        request.setBizContent(bizContent.toString());

        AlipayTradeQueryResponse response = alipayClient.execute(request);
        if(response.isSuccess()){
            log.info("调用成功，返回结果 ===> " + response.getBody());
            return response.getBody();
        } else {
            log.info("调用失败，返回码 ===> " + response.getCode() + ", 返回描述 ===> " + response.getMsg());
            //throw new RuntimeException("查单接口的调用失败");
            return null;//订单不存在
        }

    } catch (AlipayApiException e) {
        e.printStackTrace();
        throw new RuntimeException("查单接口的调用失败");
    }
}

定时任务：主要是把过了5分钟还没取消的订单，状态改为超时未支付，并把订单在支付宝方面也取消了。每隔30s执行一次

注意：怎么把未支付超过5分钟的订单取消呢？这种需求还是我第一次见

@Slf4j
@Component
public class AliPayTask {

    @Resource
    private OrderInfoService orderInfoService;

    @Resource
    private AliPayService aliPayService;

    /**
     * 从第0秒开始每隔30秒执行1次，查询创建超过5分钟，并且未支付的订单
     */
    @Scheduled(cron = "0/30 * * * * ?")
    public void orderConfirm(){

        log.info("orderConfirm 被执行......");

        List<OrderInfo> orderInfoList = orderInfoService.getNoPayOrderByDuration(5, PayType.ALIPAY.getType());

        for (OrderInfo orderInfo : orderInfoList) {
            String orderNo = orderInfo.getOrderNo();
            log.warn("超时订单 ===> {}", orderNo);

            //核实订单状态：调用支付宝查单接口，如果查询的订单已经支付了，更改信息，记录日志。未支付取消订单，未创建则创建。这就是主动发起请求，30s一次，通过上面的queryOrder查到支付宝返回的response数据中的订单状态
            aliPayService.checkOrderStatus(orderNo);
        }
    }
}

/**
 * 查询创建超过minutes分钟并且未支付的订单
 * @param minutes
 * @return
 */
@Override
public List<OrderInfo> getNoPayOrderByDuration(int minutes, String paymentType) {

    //Duration.ofMinutes(minutes)能将分钟转换为秒。5分钟->300s
    //Instant.now().minus()在当前时间减去传入的秒速
    
    
    Instant instant = Instant.now().minus(Duration.ofMinutes(minutes));

    QueryWrapper<OrderInfo> queryWrapper = new QueryWrapper<>();
    queryWrapper.eq("order_status", OrderStatus.NOTPAY.getType());
    queryWrapper.le("create_time", instant);
    queryWrapper.eq("payment_type", paymentType);

    List<OrderInfo> orderInfoList = baseMapper.selectList(queryWrapper);

    return orderInfoList;
}

4.申请退款

/**
 * 申请退款
 * @param orderNo
 * @param reason
 * @return
 */
@ApiOperation("申请退款")
@PostMapping("/trade/refund/{orderNo}/{reason}")
public R refunds(@PathVariable String orderNo, @PathVariable String reason){

    log.info("申请退款");
    aliPayService.refund(orderNo, reason);
    return R.ok();
}

/**
 * 退款
 * @param orderNo
 * @param reason
 */
@Transactional(rollbackFor = Exception.class)
@Override
public void refund(String orderNo, String reason) {

    try {
        log.info("调用退款API");

        //创建退款单
        RefundInfo refundInfo = refundsInfoService.createRefundByOrderNoForAliPay(orderNo, reason);

        //调用统一收单交易退款接口
        AlipayTradeRefundRequest request = new AlipayTradeRefundRequest ();

        //组装当前业务方法的请求参数
        JSONObject bizContent = new JSONObject();
        bizContent.put("out_trade_no", orderNo);//订单编号
        BigDecimal refund = new BigDecimal(refundInfo.getRefund().toString()).divide(new BigDecimal("100"));
        //BigDecimal refund = new BigDecimal("2").divide(new BigDecimal("100"));
        bizContent.put("refund_amount", refund);//退款金额：不能大于支付金额
        bizContent.put("refund_reason", reason);//退款原因(可选)

        request.setBizContent(bizContent.toString());

        //执行请求，调用支付宝接口
        AlipayTradeRefundResponse response = alipayClient.execute(request);

        if(response.isSuccess()){
            log.info("调用成功，返回结果 ===> " + response.getBody());

            //更新订单状态
            orderInfoService.updateStatusByOrderNo(orderNo, OrderStatus.REFUND_SUCCESS);

            //更新退款单
            refundsInfoService.updateRefundForAliPay(
                    refundInfo.getRefundNo(),
                    response.getBody(),
                    AliPayTradeState.REFUND_SUCCESS.getType()); //退款成功

        } else {
            log.info("调用失败，返回码 ===> " + response.getCode() + ", 返回描述 ===> " + response.getMsg());

            //更新订单状态
            orderInfoService.updateStatusByOrderNo(orderNo, OrderStatus.REFUND_ABNORMAL);

            //更新退款单
            refundsInfoService.updateRefundForAliPay(
                    refundInfo.getRefundNo(),
                    response.getBody(),
                    AliPayTradeState.REFUND_ERROR.getType()); //退款失败
        }


    } catch (AlipayApiException e) {
        e.printStackTrace();
        throw new RuntimeException("创建退款申请失败");
    }
}

5.退款查询接口

若退款接口由于网络等原因返回异常，商户可调用退款查询接口 alipay.trade.fastpay.refund.query(统一收单交易退款查询接口）查询指定交易的退款信息。

/**
 * 查询退款
 * @param orderNo
 * @return
 * @throws Exception
 */
@ApiOperation("查询退款：测试用")
@GetMapping("/trade/fastpay/refund/{orderNo}")
public R queryRefund(@PathVariable String orderNo) throws Exception {

    log.info("查询退款");

    String result = aliPayService.queryRefund(orderNo);
    return R.ok().setMessage("查询成功").data("result", result);
}

/**
 * 查询退款
 * @param orderNo
 * @return
 */
@Override
public String queryRefund(String orderNo) {

    try {
        log.info("查询退款接口调用 ===> {}", orderNo);

        AlipayTradeFastpayRefundQueryRequest request = new AlipayTradeFastpayRefundQueryRequest();
        JSONObject bizContent = new JSONObject();
        bizContent.put("out_trade_no", orderNo);
        bizContent.put("out_request_no", orderNo);
        request.setBizContent(bizContent.toString());

        AlipayTradeFastpayRefundQueryResponse response = alipayClient.execute(request);
        if(response.isSuccess()){
            log.info("调用成功，返回结果 ===> " + response.getBody());
            return response.getBody();
        } else {
            log.info("调用失败，返回码 ===> " + response.getCode() + ", 返回描述 ===> " + response.getMsg());
            //throw new RuntimeException("查单接口的调用失败");
            return null;//订单不存在
        }

    } catch (AlipayApiException e) {
        e.printStackTrace();
        throw new RuntimeException("查单接口的调用失败");
    }
}

6.对账

下载账单用的，只要前端传入日期和类型，发送给后端，后端在发送给支付宝。支付宝返回的数据中包含了下载地址，拿到这个返回给前端就OK。

/**
     * 根据账单类型和日期获取账单url地址
     *
     * @param billDate
     * @param type
     * @return
     */
    @ApiOperation("获取账单url")
    @GetMapping("/bill/downloadurl/query/{billDate}/{type}")
    public R queryTradeBill(
            @PathVariable String billDate,
            @PathVariable String type)  {
        log.info("获取账单url");
        String downloadUrl = aliPayService.queryBill(billDate, type);
        return R.ok().setMessage("获取账单url成功").data("downloadUrl", downloadUrl);
    }
   

/**
 * 申请账单
 * @param billDate
 * @param type
 * @return
 */
@Override
public String queryBill(String billDate, String type) {

    try {

        AlipayDataDataserviceBillDownloadurlQueryRequest request = new AlipayDataDataserviceBillDownloadurlQueryRequest();
        JSONObject bizContent = new JSONObject();
        bizContent.put("bill_type", type);
        bizContent.put("bill_date", billDate);
        request.setBizContent(bizContent.toString());
        AlipayDataDataserviceBillDownloadurlQueryResponse response = alipayClient.execute(request);

        if(response.isSuccess()){
            log.info("调用成功，返回结果 ===> " + response.getBody());

            //获取账单下载地址
            Gson gson = new Gson();
            HashMap<String, LinkedTreeMap> resultMap = gson.fromJson(response.getBody(), HashMap.class);
            LinkedTreeMap billDownloadurlResponse = resultMap.get("alipay_data_dataservice_bill_downloadurl_query_response");
            String billDownloadUrl = (String)billDownloadurlResponse.get("bill_download_url");

            return billDownloadUrl;
        } else {
            log.info("调用失败，返回码 ===> " + response.getCode() + ", 返回描述 ===> " + response.getMsg());
            throw new RuntimeException("申请账单失败");
        }

    } catch (AlipayApiException e) {
        e.printStackTrace();
        throw new RuntimeException("申请账单失败");
    }
}