package com.walker.pay;
|
|
import com.walker.infrastructure.ApplicationRuntimeException;
|
import com.walker.infrastructure.arguments.Variable;
|
import com.walker.infrastructure.utils.StringUtils;
|
import com.walker.pay.callback.OrderCallBack;
|
import com.walker.pay.exception.NotifyException;
|
import com.walker.pay.exception.OrderException;
|
import com.walker.pay.response.OrderStatusResponsePay;
|
import com.walker.pay.support.DefaultOrder;
|
import com.walker.pay.util.PayDefinitionUtils;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
|
import java.util.Map;
|
|
public abstract class AbstractPayEngineProvider implements PayEngineProvider{
|
|
protected final transient Logger logger = LoggerFactory.getLogger(this.getClass());
|
|
public Map<String, Variable> getConfiguration() {
|
return configuration;
|
}
|
|
private Map<String, Variable> configuration = null;
|
|
private ServiceProvider serviceProvider;
|
private String version;
|
private PayChannel payChannel;
|
|
private Convertor<NotifyValue<?>> orderNotifyConvertor = null;
|
|
/**
|
* 设置订单通知转换器对象。
|
* @param orderNotifyConvertor
|
* @date 2023-01-16
|
*/
|
public void setOrderNotifyConvertor(Convertor<NotifyValue<?>> orderNotifyConvertor) {
|
this.orderNotifyConvertor = orderNotifyConvertor;
|
}
|
|
public void setConfiguration(Map<String, Variable> configuration){
|
if(configuration == null || configuration.size() == 0){
|
logger.warn("支付引擎配置参数为空，请确认是否不需要参数。provider=" + this.getServiceProvider().getName() + ", version=" + this.getVersion());
|
}
|
this.configuration = configuration;
|
}
|
|
@Override
|
public ServiceProvider getServiceProvider() {
|
return this.serviceProvider;
|
}
|
|
@Override
|
public String getVersion() {
|
return this.version;
|
}
|
|
@Override
|
public PayChannel getPayChannel() {
|
return this.payChannel;
|
}
|
|
@Override
|
public String getPayDefinitionId(){
|
return PayDefinitionUtils.getPayDefinitionId(this.serviceProvider, this.version);
|
}
|
|
public void setPayChannel(PayChannel payChannel){
|
this.payChannel = payChannel;
|
}
|
|
public void setVersion(String version){
|
this.version = version;
|
}
|
|
public void setServiceProvider(ServiceProvider serviceProvider){
|
this.serviceProvider = serviceProvider;
|
}
|
|
@Override
|
public String getProviderPayType(PayType payType) {
|
String thirdPayType = this.acquireProviderPayType(this.serviceProvider, payType, this.payChannel);
|
if(StringUtils.isEmpty(thirdPayType)){
|
logger.warn("用户实现支付类型获取为空: acquireProviderPayType = null, payType = " + payType);
|
}
|
return thirdPayType;
|
}
|
|
/**
|
* 根据支付配置信息，获取第三方支付系统的"支付类型"字符串。
|
* @param serviceProvider
|
* @param payType
|
* @param payChannel
|
* @return
|
*/
|
protected abstract String acquireProviderPayType(ServiceProvider serviceProvider, PayType payType, PayChannel payChannel);
|
|
/**
|
* 获取(预)订单生成器对象，该对象执行具体的第三方订单调用并返回结果。
|
* @param providerPayType 第三方支付的"支付类型"，如:微信的native、h5等
|
* @param platformOrder 平台订单对象
|
* @param configuration 第三方对接配置参数
|
* @return
|
* @date 2023-01-16
|
*/
|
@Deprecated
|
protected abstract OrderGenerator acquireOrderGenerator(String providerPayType, Order platformOrder, Map<String, Variable> configuration);
|
|
// /**
|
// * 获取(预)订单生成器对象，该对象执行具体的第三方订单调用并返回结果。
|
// * @param payContext 支付操作上下文对象
|
// * @param platformOrder 平台订单对象
|
// * @return
|
// * @date 2023-02-17
|
// */
|
// protected abstract OrderGenerator acquireOrderGenerator(PayContext payContext, Order platformOrder);
|
|
/**
|
* 成功后，保存订单信息到平台。
|
* @param platformOrder
|
* @param responsePay
|
* @date 2023-01-16
|
*/
|
protected abstract void savePrepareOrder(Order platformOrder, ResponsePay responsePay);
|
|
@Override
|
public ResponsePay generatePrepareOrder(Order platformOrder) throws OrderException{
|
if(platformOrder == null){
|
throw new IllegalArgumentException("订单不能为空: platformOrder is required!");
|
}
|
// if(platformOrder.getServiceProvider() == null){
|
// throw new IllegalArgumentException("提供商不能为空: serviceProvider is required!");
|
// }
|
// if(platformOrder.getPayType() == null){
|
// throw new IllegalArgumentException("支付类型不能为空: payType is required!");
|
// }
|
if(StringUtils.isEmpty(platformOrder.getNotifyUrl())){
|
throw new IllegalArgumentException("支付回调地址未设置: notifyUrl is required!");
|
}
|
if(platformOrder.getId() <= 0){
|
throw new IllegalArgumentException("订单ID必须设置: id is required!");
|
}
|
/*if(StringUtils.isEmpty(platformOrder.getVersion())){
|
logger.warn("订单未设置支付提供者版本号，系统默认设置为:" + Constants.DEFAULT_VERSION);
|
((DefaultOrder)platformOrder).setVersion(Constants.DEFAULT_VERSION);
|
}*/
|
// 2023-02-20 由引擎设置支付提供者的版本号，让业务可以选择使用。
|
((DefaultOrder)platformOrder).setVersion(this.getVersion());
|
|
String providerPayType = this.acquireProviderPayType(this.serviceProvider, platformOrder.getPayType(), this.payChannel);
|
if(StringUtils.isEmpty(providerPayType)){
|
throw new IllegalArgumentException("请实现方法 'acquireProviderPayType', payType = " + platformOrder.getPayType());
|
}
|
|
// 业务生成的订单编号
|
String orderId = String.valueOf(platformOrder.getId());
|
|
OrderGenerator orderGenerator = this.acquireOrderGenerator(providerPayType, platformOrder, this.configuration);
|
if(orderGenerator == null){
|
// throw new IllegalArgumentException("获取订单生成器对象为空: acquireOrderGenerator is null!");
|
throw new OrderException(orderId, "不支持供应商的订单支付类型:" + providerPayType + ", payType=" + platformOrder.getPayType(), null);
|
}
|
|
// 2023-02-17 创建支付操作的上下文对象
|
PayContext payContext = this.acquirePayContext(providerPayType, platformOrder, this.configuration);
|
if(payContext == null){
|
logger.error("PayContext创建为空，无法执行操作。platformOrder={}", platformOrder);
|
return null;
|
}
|
AbstractPayContext abstractPayContext = (AbstractPayContext) payContext;
|
abstractPayContext.setProviderPayType(providerPayType);
|
abstractPayContext.setPayDefinition(this.getPayDefinition());
|
|
try {
|
// ResponsePay responsePay = orderGenerator.generate(providerPayType, platformOrder, this.configuration);
|
ResponsePay responsePay = orderGenerator.generate(payContext, platformOrder);
|
if(responsePay == null){
|
logger.error("预订单生成为空: responseValue is null! platformOrder={}", platformOrder);
|
return null;
|
}
|
// if(this.isOrderSuccess(responseValue)){
|
if(responsePay.getStatus()){
|
this.savePrepareOrder(platformOrder, responsePay);
|
} else {
|
logger.warn("预下单第三方返回失败: " + responsePay.getMessage());
|
}
|
return responsePay;
|
|
} catch (OrderException e) {
|
logger.error("订单生成异常:" + e.getMessage() + ", orderId=" + e.getOrderId(), e);
|
throw e;
|
}
|
}
|
|
@Override
|
public void notifyOrder(Object notifyData
|
// , OrderCallBack callBack
|
) throws NotifyException{
|
if(notifyData == null || StringUtils.isEmpty(notifyData.toString())){
|
throw new NotifyException(StringUtils.EMPTY_STRING, "订单通知数据为空", null);
|
}
|
if(this.orderNotifyConvertor == null){
|
throw new IllegalArgumentException("请先设置 orderNotifyConvertor 对象.");
|
}
|
|
try {
|
boolean signSuccess = this.verifySign(notifyData);
|
if(!signSuccess){
|
throw new NotifyException("", "签名验证未通过，source=" + notifyData, null);
|
}
|
} catch (Exception e) {
|
throw new NotifyException("", "验证签名异常:" + e.getMessage(), e);
|
}
|
|
// 转换接收的数据格式为支付系统定义的抽象数据。
|
NotifyValue<?> notifyValue = null;
|
try{
|
notifyValue = this.orderNotifyConvertor.toGenericObject(notifyData);
|
} catch (Exception ex){
|
throw new NotifyException(StringUtils.EMPTY_STRING, "notifyValue转换错误:" + ex.getMessage(), ex);
|
}
|
if(notifyValue == null){
|
throw new NotifyException(StringUtils.EMPTY_STRING, "notifyValue 转换为空:" + notifyData, null);
|
}
|
notifyValue.setSource(notifyData);
|
notifyValue.setPayChannel(this.payChannel);
|
notifyValue.setServiceProvider(this.serviceProvider);
|
notifyValue.setVersion(this.version);
|
|
// 1: 处理平台对通知调用, 一定要把异常抛出，为第三方支付确认准备。
|
try{
|
this.onNotifyOrder(notifyValue);
|
} catch (Exception ex){
|
if(ex instanceof CallBackException){
|
logger.error("订单通知在'业务回调'中执行错误:" + ex.getMessage(), ex);
|
}
|
throw new NotifyException(notifyValue.getOrderId(), "支付通知'平台调用'异常:" + ex.getMessage(), ex);
|
}
|
/*if(callBack == null){
|
logger.warn("业务未传入'订单通知回调对象',确定是否需要配置!");
|
return;
|
}
|
try {
|
callBack.onOrderNotify(notifyValue);
|
} catch (CallBackException e) {
|
throw new NotifyException(notifyValue.getOrderId(), "支付通知'业务调用'异常:" + e.getMessage(), e);
|
}*/
|
}
|
|
@Override
|
public OrderStatusResponsePay searchOrderStatus(Order order){
|
OrderStatusQuery orderStatusQuery = this.acquireOrderStatusQuery(order);
|
if(orderStatusQuery == null){
|
throw new IllegalArgumentException("OrderStatusQuery为空，请实现方法:acquireOrderStatusQuery();");
|
}
|
try {
|
return this.invokeOrderStatus(orderStatusQuery);
|
} catch (Exception ex){
|
throw new ApplicationRuntimeException("查询订单状态异常, orderId=" + order.getId() + ", msg=" + ex.getMessage(), ex);
|
}
|
}
|
|
/**
|
* 验证签名是否合法。
|
* @param notifyData
|
* @return
|
* @throws Exception
|
* @date 2023-03-05
|
*/
|
protected abstract boolean verifySign(Object notifyData) throws Exception;
|
|
/**
|
* 平台处理订单支付通知，目前与业务回调区分开。
|
* <pre>
|
* 1)需要处理多次通知的情况，否则无法给第三方确认(如:微信)
|
* 2)主要是保存平台订单操作。
|
* </pre>
|
* @param notifyValue
|
* @date 2023-01-17
|
*/
|
protected abstract void onNotifyOrder(NotifyValue<?> notifyValue) throws Exception;
|
|
/**
|
* 生成支付操作上下文对象。
|
* @param providerPayType 第三方支付类型
|
* @param platformOrder 平台订单
|
* @param configuration 参数配置
|
* @return
|
* @date 2023-02-17
|
*/
|
protected abstract PayContext acquirePayContext(String providerPayType, Order platformOrder, Map<String, Variable> configuration);
|
|
/**
|
* 获取订单查询条件对象，由子类组装定义。
|
* @param order 系统订单号
|
* @return
|
* @date 2023-02-23
|
*/
|
protected abstract OrderStatusQuery acquireOrderStatusQuery(Order order);
|
|
/**
|
* 实现具体查询订单状态过程。
|
* @param orderStatusQuery
|
* @return
|
* @date 2023-02-23
|
*/
|
protected abstract OrderStatusResponsePay invokeOrderStatus(OrderStatusQuery orderStatusQuery);
|
|
public PayDefinition getPayDefinition() {
|
return payDefinition;
|
}
|
|
@Override
|
public void setPayDefinition(PayDefinition payDefinition) {
|
this.payDefinition = payDefinition;
|
}
|
|
/**
|
* 返回订单业务操作回调实现，在订单下单以及通知等过程中可实现业务切入机会。
|
* @return
|
* @date 2023-02-20
|
*/
|
public OrderCallBack getOrderCallback() {
|
return orderCallback;
|
}
|
|
@Override
|
public void setOrderCallback(OrderCallBack orderCallback) {
|
this.orderCallback = orderCallback;
|
}
|
|
private OrderCallBack orderCallback;
|
private PayDefinition payDefinition;
|
}
|
