微信支付/支付宝支付

# 微信支付相关参数
# 商户号
wxpay.mch-id=
# 商户API证书序列号
wxpay.mch-serial-no=

# 商户私钥文件 （放到src同目录下）
wxpay.private-key-path=apiclient_key.pem
# APIv3密钥
wxpay.api-v3-key=
# APPID
wxpay.appid=
# 微信服务器地址
wxpay.domain=https://api.mch.weixin.qq.com
# 接收结果通知地址
# 注意：每次重新启动ngrok，都需要根据实际情况修改这个配置
wxpay.notify-domain=

# APIv2密钥
wxpay.partnerKey: 

@PostMapping("/native/{productId}")
@ApiOperation("调用统一下单Api，返回code_url，前端生成支付二维码")
public R nativePay(@PathVariable Long productId) throws IOException {
    log.info("发送请求"+productId);
    //返回支付二维码和订单号
    Map<String,Object> map= wxPayService.nativePay(productId);
    return R.ok().setData(map);
}

@Override
public Map<String, Object> nativePay(Long productId) throws IOException {
    log.info("生成订单");
    //        // 创建一个临时的订单对象，放数据
    //        OrderInfo orderInfo=new OrderInfo();
    //        orderInfo.setTitle("Test");
    //        orderInfo.setOrderNo(OrderNoUtils.getOrderNo());//生成订单编号
    //        orderInfo.setProductId(productId);
    //        orderInfo.setTotalFee(1); //1分
    //        orderInfo.setOrderStatus(OrderStatus.NOTPAY.getType());

    // 订单数据生成，要保存到数据库中
    OrderInfo orderInfo = orderInfoService.createOrderByProductId(productId);

    // 先查询数据库，看二维码是否存在
    // 如果不存在，再调用微信下单api
    // 下边订单超过五分钟会进行关单操作，以保证每次的二维码都是可以使用的
    String codeUrl=orderInfo.getCodeUrl();
    if(codeUrl!=null && !StringUtils.isEmpty(codeUrl)){
        log.info("=====二维码已经存在====");
        Map map=new HashMap();
        map.put("codeUrl",codeUrl);
        map.put("orderNo",orderInfo.getOrderNo());
        return map;
    }
    log.info("开始调用统一下单api");
    HttpPost httpPost = new HttpPost(wxPayConfig.getDomain().concat(WxApiType.NATIVE_PAY.getType()));
    // 开始拼接参数
    Map<Object,Object> paramsMap=new HashMap<>();
    paramsMap.put("appid",wxPayConfig.getAppid());
    paramsMap.put("mchid",wxPayConfig.getMchId());
    paramsMap.put("description",orderInfo.getTitle());// 商品描述，可以自己随意填写
    paramsMap.put("out_trade_no",orderInfo.getOrderNo());// 要唯一
    paramsMap.put("notify_url",
                  wxPayConfig.getNotifyDomain().concat(WxNotifyType.NATIVE_NOTIFY.getType()));

    Map<Object,Object> amountMap =new HashMap<>();
    amountMap.put("total",orderInfo.getTotalFee());//订单金额
    amountMap.put("currency","CNY");
    paramsMap.put("amount",amountMap);

    // 参数拼接完成，接下来要进行数据类型转换
    // map--->json
    Gson gson = new Gson();
    String jsonParams = gson.toJson(paramsMap);
    log.info(jsonParams);
    // 把json形式的参数，封装到请求体中
    StringEntity entity=new StringEntity(jsonParams,"utf-8");
    entity.setContentType("application/json");//设置请求体数据类型
    httpPost.setEntity(entity);//设置请求体
    httpPost.setHeader("Accept","application/json");//设置请求头
    // 发送请求（到微信服务器），并获取响应
    CloseableHttpResponse response = wxPayClient.execute(httpPost);
    try{
        // 得到状态码
        String bodyAsString = EntityUtils.toString(response.getEntity());
        int statusCode = response.getStatusLine().getStatusCode();
        if (statusCode==200){
            log.info("处理成功"+bodyAsString);

        }else if ( statusCode == 204){ //处理成功，但是没有返回值
            log.info("sucess");
        }else {
            log.info("失败"+statusCode+"    返回体"+bodyAsString);
            // 微信支付出现问题，可以手动抛出异常
            throw new IOException("请求异常");
        }
        //解析响应结果，得到code_url
        // 把返回结果转换成map类型
        HashMap<String,String> resultMap = gson.fromJson(bodyAsString, HashMap.class);
        String code_url= resultMap.get("code_url");

        // 把二维码保存到数据库
        String orderNo=orderInfo.getOrderNo();
        orderInfoService.saveCodeUrl(orderNo,code_url);

        // 把结果给前端，让前端根据code_url生成支付二维码
        Map map=new HashMap();
        map.put("codeUrl",code_url);
        map.put("orderNo",orderInfo.getOrderNo());
        return map;
    }finally {
        response.close();
    }
}

// 验签
// 签名： 就微信的私钥对信息加密
// 加密： 用微信的公钥解密
WechatPay2ValidatorForRequest wechatPay2ValidatorForRequest =
    new WechatPay2ValidatorForRequest(verifier, (String) id, body);

//开始组装数据 使用json和map
Gson gson = new Gson();
Map<String,String> paramsMap=new HashMap<>();
paramsMap.put("mchid",wxPayConfig.getMchId());
String jsonParams=gson.toJson(paramsMap);
log.info("请求参数===》{}",jsonParams);

// 将请求参数保存到请求对象中
StringEntity entity=new StringEntity(jsonParams,"utf-8");
entity.setContentType("application/json");
httpPost.setEntity(entity);
httpPost.setHeader("Accept","application/json");

//发送请求到微信服务器，并接受返回微信服务器响应数据
CloseableHttpResponse response = wxPayClient.execute(httpPost);

/**
 * 开启定时任务，需要在程序主类上添加 @EnableScheduling 开启定时任务
 * 秒  分  时  日  月   周
 * ？ 不指定
 * * 每...
 * 日和周不能同时指定，指定其中一个，则另一个设置为？
 * 例如   每三秒执行一次
          每天中午十二点执行一次  0 0 12 * * ?
          2022年  每天上午10:30执行一次  0 30 10 * * ? 2022

 */

@Scheduled(cron = "0/30 * * * * ?")
public void orderConfirm() throws IOException {
    log.info("定时任务查询超过五分钟没有支付的订单");
    List<OrderInfo> orderInfoList=orderInfoService.getNoPayOrderByDuration(5, PayType.WXPAY.getType());
    for(OrderInfo orderInfo:orderInfoList){
        String orderNo =orderInfo.getOrderNo();
        log.warn("超时订单号======》{}",orderNo);
        // 调用微信查单接口，核实订单状态
        // 这些订单超时了    我们要看时已支付没有接到回调通知，还是确实没有支付
        wxPayService.checkOrderStatus(orderNo);
    }
}

//构建参数
Gson gson=new Gson();
HashMap<Object, Object> paramsMap = new HashMap<>();
paramsMap.put("out_trade_no",orderNo);
paramsMap.put("out_refund_no",refundInfo.getRefundNo());
paramsMap.put("reason",reason);
paramsMap.put("notify_url", 					                          wxPayConfig.getNotifyDomain().concat(WxNotifyType.REFUND_NOTIFY.getType()));
HashMap<String,Object> amountMap=new HashMap<>();
amountMap.put("refund",refundInfo.getRefund());
amountMap.put("total",refundInfo.getTotalFee());
amountMap.put("currency","CNY");
paramsMap.put("amount",amountMap);

if(reentrantLock.tryLock()){
    try {
        String orderStatus = orderInfoService.getOrderStatus(orderNo);
        if (!OrderStatus.REFUND_PROCESSING.getType().equals(orderStatus)) {
            return;
        }
        // 更新订单状态
        orderInfoService.updateStatusByOrderNo(orderNo, OrderStatus.REFUND_SUCCESS);
        refundInfoService.updateRefund(plainText);
    }finally {
        reentrantLock.unlock();
    }
}

@Override
public String queryBill(String billData, String type) throws IOException {
    log.info("申请账单接口调用===》{}",billData);
    String url="";
    if ("tradebill".equals(type)){
        url=WxApiType.TRADE_BILLS.getType();
    }else if ("fundflowbill".equals(type)){
        url=WxApiType.FUND_FLOW_BILLS.getType();
    }else {
        throw new RuntimeException("不支持的账单类型");
    }
    url=wxPayConfig.getDomain().concat(url).concat("?bill_date=".concat(billData));

    HttpGet httpGet   =new HttpGet(url);
    httpGet.setHeader("Accept","application/json");

    CloseableHttpResponse response = wxPayClient.execute(httpGet);
    try{
        String bodyAsString =EntityUtils.toString(response.getEntity());
        int statusCode=response.getStatusLine().getStatusCode();
        if (statusCode==200){
            log.info("申请账单成功，账单返回值===》{}",bodyAsString);
        }else if (statusCode==204){
            log.info("申请账单成功");
        }else{
            throw  new RuntimeException("申请账单异常"+statusCode+"，返回信息===》"+bodyAsString);
        }
        Gson gson=new Gson();
        HashMap<String,String> hashMap = gson.fromJson(bodyAsString, HashMap.class);
        return hashMap.get("download_url");
    }finally {
        response.close();
    }
}

public String decryptFromREsource(Map<String, Object> bodyMap) throws GeneralSecurityException {
    Map<String ,String> resourceMap =(Map<String, String>) bodyMap.get("resource");
    String ciphertext=resourceMap.get("ciphertext");
    String nonce = resourceMap.get("nonce");
    String associatedData = resourceMap.get("associated_data");
    log.info("密文开始解密");
    log .info("密文 ===>{}",ciphertext);
    // 得到自己的密钥
    AesUtil aesUtil = new AesUtil(wxPayConfig.getApiV3Key().getBytes(StandardCharsets.UTF_8));
    // 解密   得到明文
    String plainText=aesUtil.decryptToString(
            associatedData.getBytes(StandardCharsets.UTF_8),
            nonce.getBytes(StandardCharsets.UTF_8),
            ciphertext);
    log.info("明文=====> {}",plainText);
    return plainText;
}

//调用支付宝接口
AlipayTradePagePayRequest request = new AlipayTradePagePayRequest();
request.setNotifyUrl(config.getProperty("alipay.notify-url"));
request.setReturnUrl(config.getProperty("alipay.return-url"));
//组装当前业务方法的请求参数
JSONObject bizContent = new JSONObject();
bizContent.put("out_trade_no", orderInfo.getOrderNo());
BigDecimal totalFee = new BigDecimal(orderInfo.getTotalFee().toString()).divide(new BigDecimal("100"));
bizContent.put("total_amount", totalFee);
bizContent.put("subject", "测试商品");
bizContent.put("product_code", "FAST_INSTANT_TRADE_PAY");

request.setBizContent(bizContent.toString());
//执行请求，调用支付接口
AlipayTradePagePayResponse response = alipayClient.pageExecute(request);
if(response.isSuccess()){
    System.out.println("调用成功");
    log.info("调用成功，返回结果 "+response.getBody());
    return response.getBody();
} else {
    System.out.println("调用失败");
    log.info("调用失败，返回码 "+response.getCode()+" 返回描述 "+response.getMsg());
    throw new RuntimeException("创建支付交易失败");
}

//异步通知的验签
// Map<String, String> paramsMap = ... //将异步通知中收到的所有参数都存放到map中
boolean signVerified = AlipaySignature.rsaCheckV1(
        params, config.getProperty("alipay.alipay-public-key"),
        AlipayConstants.CHARSET_UTF8,
        AlipayConstants.SIGN_TYPE_RSA2); //调用SDK验证签名
if(!signVerified){
    // TODO 验签失败则记录异常日志，并在response中返回failure.
    log.error("支付成功异步通知验签失败！");
    return result;
}

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

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

@Scheduled(cron = "*/30 * * * * ?")
public void orderConfirm() throws IOException{
  log.info("支付宝，超过五分钟未支付的订单。。。。");
    List<OrderInfo> orderInfoList = orderInfoService.getNoPayOrderByDuration(5, PayType.ALIPAY.getType());
    for (OrderInfo orderInfo: orderInfoList){
        String orderNo=orderInfo.getOrderNo();
        log.info("超时未支付的订单=====》{}",orderNo);

        //核实订单状态，调用支付宝查单接口
        aliPayService.checkOrderStatus(orderNo);
    }
}

//创建退款单
RefundInfo refundInfo = refundInfoService.createRefundByOrderNo(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"));
bizContent.put("refund_amount", refund);
bizContent.put("refund_reason", reason);
request.setBizContent(bizContent.toString());
AlipayTradeRefundResponse response = alipayClient.execute(request);

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);

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 downloadurlQueryResponse = resultMap.get("alipay_data_dataservice_bill_downloadurl_query_response");
    String downloadUrl= (String) downloadurlQueryResponse.get("bill_download_url");
    return downloadUrl;
}else{
    log.info("调用失败，返回码===》"+response.getCode()+"，返回描述"+response.getMsg());
    throw new RuntimeException("申请账单失败");
}