⽀付宝基本入门使用
⽀付宝开放能⼒介绍
2.1、能⼒地图
⽀付能⼒、⽀付扩展、资⾦能⼒、⼝碑能⼒、营销能⼒、会员能⼒、⾏业能⼒、安全能⼒、基础能⼒2.2、电脑⽹站⽀付产品介绍
应⽤场景、准⼊条件、计费模式
3、接⼊准备
3.1、开放平台账号注册
https://opendocs.alipay.com/open
支付宝对接对接准备
常规接⼊流程
创建应⽤：选择应⽤类型、填写应⽤基本信息、添加应⽤功能、配置应⽤环境（获取⽀付宝公
钥、应⽤公钥、应⽤私钥、⽀付宝⽹关地址，配置接⼝内容加密⽅式）、查看 APPID
绑定应⽤：将开发者账号中的APPID和商家账号PID进⾏绑定
配置秘钥：即创建应⽤中的“配置应⽤环境”步骤
上线应⽤：将应⽤提交审核
签约功能：在商家中⼼上传营业执照、已备案⽹站信息等，提交审核进⾏签约
创建应用
第一步：
第二步：
第三步：
第四步：
第四步：
第五步：
绑定应用
商家中心：https://b.alipay.com/index2.htm
配置密钥
在地步骤以完成
上线应用
签约功能
签约在商家中心进行操作
https://b.alipay.com/signing/productDetailV2.htm?productId=I1011000290000001000
如果是上线的点击 产品中心-->电脑网站支付-->立即开通
个人用户使用砂箱
点击开放能力-->支付能力-->电脑网址支付-->接入指南-->基础功能划到最底下
点击： 开放平台控制台-->点击砂箱
Spring Boot整合支付对接
基本工作准备
参考⽂档：开放平台 => ⽂档 => 开发⼯具 => 服务端SDK => Java => 通⽤版 => Maven项⽬依赖
参考：https://opendocs.alipay.com/common/02kkv2
<!--导入阿里支付宝的sdk-->
<dependency>
<groupId>com.alipay.sdk</groupId>
<artifactId>alipay-sdk-java</artifactId>
<version>4.22.113.ALL</version>
</dependency>
数据签名
alipay-sandbox.properties
# 支付宝支付砂箱相关参数 ,里的的配置从准备工作获取
# 应用ID,您的APPID，收款账号既是您的APPID对应支付宝账号
alipay.app-id=
# 商户PID,卖家支付宝账号ID
alipay.seller-id=
# 支付宝网关
alipay.gateway-url=https://openapi.alipaydev.com/gateway.do
# 商户私钥，您的PKCS8格式RSA2私钥
alipay.merchant-private-key=
# 支付宝公钥,查看地址：https://openhome.alipay.com/platform/keyManage.htm 对应APPID下的支付宝公钥
alipay.alipay-public-key=
# 接口内容加密秘钥，对称秘钥
alipay.content-key=
# 页面跳转同步通知页面路径
alipay.return-url=http://localhost:8080/#/success
# 服务器异步通知页面路径 需http://格式的完整路径，不能加?id=123这类自定义参数，必须外网可以正常访问
# 注意：每次重新启动ngrok，都需要根据实际情况修改这个配置
alipay.notify-url=https://a863-180-174-204-169.ngrok.io/api/ali-pay/trade/notify
参考⽂档中 公钥方式 完善 AlipayClientConfig 类，添加 alipayClient() ⽅法 初始化 AlipayClient 对象
https://opendocs.alipay.com/common/02kf5q
AlipayClientConfig
package com.atguigu.paymentdemo.config;
import com.alipay.api.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
/**
支付宝支付配置文件
*/
@Configuration
@RestController
@PropertySource("classpath:alipay-sandbox.properties")
public class AlipayClientConfig {
@Resource
public Environment environment;
@Bean
public AlipayClient alipayClient() throws AlipayApiException {
AlipayConfig alipayConfig = new AlipayConfig();
//设置网关地址
alipayConfig.setServerUrl(environment.getProperty("alipay.gateway-url"));
//设置应用Id
alipayConfig.setAppId(environment.getProperty("alipay.app-id"));
//设置应用私钥
alipayConfig.setPrivateKey(environment.getProperty("alipay.merchant-private-key"));
//设置请求格式，固定值json
alipayConfig.setFormat(AlipayConstants.FORMAT_JSON);
//设置字符集
alipayConfig.setCharset(AlipayConstants.CHARSET_UTF8);
//设置支付宝公钥
alipayConfig.setAlipayPublicKey(environment.getProperty("alipay.alipay-public-key"));
//设置签名类型 ，SIGN_TYPE_RSA2：非对称加密类型
alipayConfig.setSignType(AlipayConstants.SIGN_TYPE_RSA2);
//构造client
AlipayClient alipayClient = new DefaultAlipayClient(alipayConfig);
return alipayClient;
}
}
https://opendocs.alipay.com/open/270/105899
支付宝下单处理（统一下单）
注意：controller的请求地址要和网址的支付名称对应不能随意更改，必须一一对应!!!!!
列如：
参考：https://opendocs.alipay.com/open/028r8t?scene=22
核心代码
后台
AliPayController
@CrossOrigin
@RestController
@RequestMapping("/api/ali-pay")
@Api(tags = "网站支付宝支付")
@Slf4j
public class AliPayController {
@Resource
private AliPayService aliPayService;
@ApiOperation("统一收单下单并支付页面接口的调用")
@PostMapping("/trade/page/pay/{productId}")
public R tradePagePay(@PathVariable Long productId){
log.info("统一收单下单并支付页面接口的调用");
//支付宝开放平台接受 request 请求对象后
// 会为开发者生成一个html 形式的 form表单，包含自动提交的脚本
String formStr = aliPayService.tradeCreate(productId);
//我们将form表单字符串返回给前端程序，之后前端将会调用自动提交脚本，进行表单的提交
//此时，表单会自动提交到action属性所指向的支付宝开放平台中，从而为用户展示一个支付页面
return R.ok().data("formStr", formStr);
}
}
AliPayService
public interface AliPayService {
/**
* 同步支付对接
* @param productId
* @return
*/
String tradeCreate(Long productId);
}
AliPayServiceImpl
@Service
@Slf4j
public class AliPayServiceImpl implements AliPayService {
@Resource
private OrderInfoService orderInfoService;
@Resource
private AlipayClient alipayClient;
@Resource
private Environment config;
@Transactional(rollbackFor = Exception.class)
@Override
public String tradeCreate(Long productId) {
try {
//生成订单
log.info("生成订单");
OrderInfo orderInfo = orderInfoService.createOrderByProductId(productId, PayType.ALIPAY.getType());
//调用支付接口
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()); //商户订单号。
//单位为元，精确到小数点后两位，取值范围为 [0.01,100000000]。金额不能为0 ,所以这里要除以100
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("创建支付交易失败");
}
}
}
前端⽀付按钮
(1)index.vue
//确认支付
toPay() {
//禁用按钮，防止重复提交
this.payBtnDisabled = true
//微信支付
if (this.payOrder.payType === 'wxpay') {
.....
})
//支付宝支付
} else if (this.payOrder.payType === 'alipay') {
//调用支付宝统一收单下单并支付页面接口
aliPayApi.tradePagePay(this.payOrder.productId).then((response) => {
//将支付宝返回的表单字符串写在浏览器中，表单会自动触发submit提交
document.write(response.data.formStr)
})
}
},
(2)aliPay.js
//发起支付请求
tradePagePay(productId) {
return request({
url: '/api/ali-pay/trade/page/pay/' + productId,
method: 'post'
})
},
支付宝下单处理（异步处理）
//配置需要的公共请求参数
//支付完成后，支付宝向谷粒学院发起异步通知的地址
request.setNotifyUrl(config.getProperty("alipay.notify-url"));
启动内⽹穿透ngrok
网址：https://dashboard.ngrok.com/get-started/setup
下载解压，在该目录下打开cmd
如何发现Authtoken无法使用可以重置
启动内⽹穿透ngrok
#8090根据自己的端口定义，后台接口
ngrok http 8090
修改内⽹穿透配置
根据ngrok每次启动的情况，修改 alipay-sandbox.properties ⽂件中的 alipay.notify-url
# 服务器异步通知页面路径 需http://格式的完整路径，不能加?id=123这类自定义参数，必须外网可以正常访问
# 注意：每次重新启动ngrok，都需要根据实际情况修改这个配置
alipay.notify-url=https://a863-180-174-204-169.ngrok.io/api/ali-pay/trade/notify
文档地址：https://opendocs.alipay.com/open/270/105902
AliPayController
@Autowired
private Environment config;
@Autowired
private OrderInfoService orderInfoService;
/**
* 支付对接
* @param params
* @return
*/
@ApiOperation("支付通知")
@PostMapping("/trade/notify")
public String tradeNotify(@RequestParam Map<String,String> params){
log.info("支付通知正在执行");
log.info("通知参数===>{}",params);
//失败为failure，成功为success
String result = "failure";
try {
//异步验签通知
boolean signVerified = AlipaySignature.rsaCheckV1(
params, //ngrok回调的参数
config.getProperty("alipay.alipay-public-key"), //支付宝公钥
AlipayConstants.CHARSET_UTF8,//编码格式
AlipayConstants.SIGN_TYPE_RSA2); //签名类型,非对称加密
if(!signVerified){
// TODO 验签失败则记录异常日志，并在response中返回failure.
log.error("支付成功异步通知验签失败!");
return result;
}
// TODO 验签成功后，按照支付结果异步通知中的描述，对支付结果中的业务内容进行二次校验，
//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 totaAmount = params.get("total_amount");
int totalAmountInt = new BigDecimal(totaAmount).multiply(new BigDecimal("100")).intValue();
int totalFee = order.getTotalFee().intValue();
if (totalFee!=totalAmountInt){
log.error("金额校验失败");
return result;
}
//3.校验通知中的 seller_id（或者 seller_email) 是否为 out_trade_no 这笔单据的对应的操作方；
String sellerId = params.get("seller_id");
String propertysellerId = config.getProperty("alipay.seller-id");
if (!sellerId.equals(propertysellerId)){
log.error("商家Id校验失败");
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 或 TRADE_FINISHED 时，
// 支付宝才会认定为买家付款成功。
String tradeStatus = params.get("trade_status");
if (!"TRADE_SUCCESS".equals(tradeStatus)){
log.error("支付为成功");
return result;
}
log.info("支付成功异步通知验签成功!");
//处理业务修改订单状态记录支付日志
aliPayService.processOrder(params);
// 校验成功后在response中返回success并继续商户自身业务处理
// 放回验签结果
result="success";
} catch (AlipayApiException e) {
e.printStackTrace();
}
return result;
}
AliPayService
/**
* 支付对接，订单处理
* @param params
*/
void processOrder(Map<String, String> params);
AliPayServiceImpl
/**
* 订单处理
* @param params
*/
@Override
@Transactional(rollbackFor = Exception.class)
public void processOrder(Map<String, String> params) {
/*在对业务数据进行状态检查和处理之前，要采用数据锁进行并发控制，
以避免函数重入造成的数据混乱*/
//尝试获取锁:
//成功获取则立即返回true，获取失败则立即返回false。不必一直等待锁的释放
if (lock.tryLock()){
try {
log.info("订单处理");
//获取订单号
String outTradeNo = params.get("out_trade_no");
//处理接口重复的通知
//接口调用的幂等性:无论接口被调用多少次，以下业务执行一次
String orderStatus = orderInfoService.getOrderStatus(outTradeNo);
if (OrderStatus.NOTPAY.getType().equals(orderStatus)) {//只有是未支付才执行，否则不执行
return;
}
//更新订单状态
orderInfoService.updateStatusByOrderNo(outTradeNo, OrderStatus.SUCCESS);
//记录支付日志
paymentInfoService.createPaymentInfoForAliPay(params);
}finally {
//释放锁
lock.unlock();
}
}
}
记录⽀付⽇志
PaymentInfoService
/**
* 支付记录日志
* @param params
*/
void createPaymentInfoForAliPay(Map<String, String> params);
PaymentInfoServiceImpl
@Service
@Slf4j
public class PaymentInfoServiceImpl extends ServiceImpl<PaymentInfoMapper, PaymentInfo> implements PaymentInfoService {
/**
* 记录支付日志：支付宝
* @param params
*/
@Override
public void createPaymentInfoForAliPay(Map<String, String> params) {
log.info("记录支付日志");
//获取订单号
String orderNo = params.get("out_trade_no");
//业务编号
String transactionId = params.get("trade_no");
//交易状态
String tradeStatus = params.get("trade_status");
//交易金额
String totalAmount = params.get("total_amount");
int totalAmountInt = new BigDecimal(totalAmount).multiply(new BigDecimal("100")).intValue();
PaymentInfo paymentInfo = new PaymentInfo();
paymentInfo.setOrderNo(orderNo);
paymentInfo.setPaymentType(PayType.ALIPAY.getType());
paymentInfo.setTransactionId(transactionId);
paymentInfo.setTradeType("电脑网站支付");
paymentInfo.setTradeState(tradeStatus);
paymentInfo.setPayerTotal(totalAmountInt);
Gson gson = new Gson();
String json = gson.toJson(params, HashMap.class);
paymentInfo.setContent(json);
baseMapper.insert(paymentInfo);
}
}
定义⽤⼾取消订单接⼝
在 AliPayController 中添加⽅法
/**
* 用户取消订单
* @param orderNo
* @return
*/
@ApiOperation("用户取消订单")
@PostMapping("/trade/close/{orderNo}")
public R cancel(@PathVariable String orderNo){
log.info("取消订单");
aliPayService.cancelOrder(orderNo);
return R.ok().setMessage("订单已取消");
}
关单并修改订单状态
AliPayService 接⼝
/**
* 用户取消订单
* @param orderNo
*/
void cancelOrder(String orderNo);
AliPayServiceImpl 实现
/**
* 用户取消订单
*
* @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());
}
} catch (AlipayApiException e) {
e.printStackTrace();
}
}
测试
注意：针对⼆维码⽀付，只有经过扫码的订单才在⽀付宝端有交易记录。针对⽀付宝账号⽀付，只有经
过登录的订单才在⽀付宝端有交易记录。
统⼀收单线下交易查询
商⼾后台未收到异步⽀付结果通知时，商⼾应该主动调⽤《统⼀收单线下交易查询接⼝》，同步订单状态。
AliPayController
/**
* 查询订单
* @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);
}
AliPayService
/**
* 查询订单接口
* @param orderNo
* @return
*/
String queryOrder(String orderNo);
AliPayServiceImpl
/**
* 查询订单
* 返回订单查询结果，如果返回null则表示支付宝端尚未创建订单
* @param orderNo
* @return
*/
@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("查单接口的调用失败");
}
}
定时查单
启动类
@SpringBootApplication
//引入Spring Task 定时任务
@EnableScheduling
public class PaymentDemoApplication {
public static void main(String[] args) {
SpringApplication.run(PaymentDemoApplication.class, args);
}
}
AliPayTask
@Slf4j
@Component
public class AliPayTask {
@Resource
private OrderInfoService orderInfoService;
@Resource
private AliPayService aliPayService;
/**
* 从第0秒开始每隔30秒执行1次，查询创建超过1分钟，并且未支付的订单
*/
@Scheduled(cron = "0/30 * * * * ?")
public void orderConfirm(){
log.info("orderConfirm 被执行......");
//传的参数为1代码查询1分钟查询为支付的订单
List<OrderInfo> orderInfoList = orderInfoService.getNoPayOrderByDuration(1, PayType.ALIPAY.getType());
for (OrderInfo orderInfo : orderInfoList) {
String orderNo = orderInfo.getOrderNo();
log.warn("超时订单 ===> {}", orderNo);
//核实订单状态：调用支付宝查单接口
aliPayService.checkOrderStatus(orderNo);
}
}
}
AliPayService
/**
* 定时查单
* @param orderNo
*/
void checkOrderStatus(String orderNo);
AliPayServiceImpl
/**
* 根据订单号调用支付宝查单接口，核实订单状态
* 如果订单未创建，则更新商户端订单状态
* 如果订单未支付，则调用关单接口关闭订单，并更新商户端订单状态
* 如果订单已支付，则更新商户端订单状态，并记录支付日志
* @param orderNo
*/
@Override
public void checkOrderStatus(String orderNo) {
log.warn("根据订单号核实订单状态 ===> {}", orderNo);
String result = this.queryOrder(orderNo);
//订单未创建，更新支付记录日志
if (result == null) {
log.warn("核实订单未创建====>{}",orderNo);
//更新本地状态为未超时
orderInfoService.updateStatusByOrderNo(orderNo,OrderStatus.CLOSED);
}
//订单未支付，更新支付记录日志
//解析响应结果
Gson gson = new Gson();
HashMap<String, LinkedTreeMap> resultMap = gson.fromJson(result, HashMap.class);
LinkedTreeMap alipayTradeQuerResponse = resultMap.get("alipay_trade_query_response");
String tradeStatus = (String) alipayTradeQuerResponse.get("trade_status");
if (AliPayTradeState.NOTPAY.getType().equals(tradeStatus)){
log.warn("订单未支付==>{}",orderNo);
//如果订单为支付，则调用关单接口关闭订单
this.closeOrder(orderNo);
//并更新商户订单状态
orderInfoService.updateStatusByOrderNo(orderNo,OrderStatus.CLOSED);
}
//订单已支付，更新支付记录日志
if (AliPayTradeState.SUCCESS.getType().equals(tradeStatus)){
log.warn("订单以支付==>{}",orderNo);
//如果订单以支付，则更新订单状态
orderInfoService.updateStatusByOrderNo(orderNo,OrderStatus.SUCCESS);
//并且记录支付日志
paymentInfoService.createPaymentInfoForAliPay(alipayTradeQuerResponse);
}
}
退款
AliPayController
/**
* 申请退款
* @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();
}
AliPayService
/**
* 申请退款
* @param orderNo 退款账户
* @param reason 退款原因
*/
void refund(String orderNo, String reason);
AliPayServiceImpl
/**
* 退款
* @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("创建退款申请失败");
}
}
创建退款记录
RefundInfoService
public interface RefundInfoService extends IService<RefundInfo> {
/**
* 据订单号创建退款订单
* @param orderNo 退款账户
* @param reason 退款原因
* @return
*/
RefundInfo createRefundByOrderNoForAliPay(String orderNo, String reason);
/**
* 更新退款记录
* @param refundNo 退款卡号
* @param content 申请退款返回参数
* @param refundStatus 退款状态
*/
void updateRefundForAliPay(String refundNo, String content, String refundStatus);
}
RefundInfoServiceImpl
@Service
public class RefundInfoServiceImpl extends ServiceImpl<RefundInfoMapper, RefundInfo> implements RefundInfoService {
@Resource
private OrderInfoService orderInfoService;
/**
* 根据订单号创建退款订单
* @param orderNo
* @return
*/
@Override
public RefundInfo createRefundByOrderNoForAliPay(String orderNo, String reason) {
//根据订单号获取订单信息
OrderInfo orderInfo = orderInfoService.getOrderByOrderNo(orderNo);
//根据订单号生成退款订单
RefundInfo refundInfo = new RefundInfo();
refundInfo.setOrderNo(orderNo);//订单编号
refundInfo.setRefundNo(OrderNoUtils.getRefundNo());//退款单编号
refundInfo.setTotalFee(orderInfo.getTotalFee());//原订单金额(分)
refundInfo.setRefund(orderInfo.getTotalFee());//退款金额(分)
refundInfo.setReason(reason);//退款原因
//保存退款订单
baseMapper.insert(refundInfo);
return refundInfo;
}
/**
* 更新退款记录
* @param refundNo
* @param content
* @param refundStatus
*/
@Override
public void updateRefundForAliPay(String refundNo, String content, String refundStatus) {
//根据退款单编号修改退款单
QueryWrapper<RefundInfo> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("refund_no", refundNo);
//设置要修改的字段
RefundInfo refundInfo = new RefundInfo();
refundInfo.setRefundStatus(refundStatus);//退款状态
refundInfo.setContentReturn(content);//将全部响应结果存入数据库的content字段
//更新退款单
baseMapper.update(refundInfo, queryWrapper);
}
}
退款查询
AliPayController
/**
* 退款查询
* @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);
}
AliPayService
/**
* 退款查询
* @param orderNo 退款账户
* @return
*/
String queryRefund(String orderNo);
AliPayServiceImpl
/**
* 查询退款
* @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("查单接口的调用失败");
}
对账
注意：不能选择当天日期，最少也要选择当天日期的前一天的日期
Controller
/**
* 根据账单类型和日期获取账单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);
}
AliPayService
/**
* 根据账单类型和日期获取账单url地址
* @param billDate 资金账单日期
* @param type 资金账单类型
* @return
*/
String queryBill(String billDate, String type);
AliPayServiceImpl
/**
* 根据账单类型和日期获取账单url地址
*
* @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("申请账单失败");
}
}