payment pipeline supported

huanggang
1 parent b2e74712
Showing 66 changed files with 4211 additions and 5 deletions
cashier-boss/src/main/java/com/diligrp/cashier/boss/BossConfiguration.java
cashier-boss/src/main/java/com/diligrp/cashier/boss/CashierServiceBootstrap.java
cashier-pipeline/src/main/java/com/diligrp/cashier/pipeline/Constants.java
cashier-pipeline/src/main/java/com/diligrp/cashier/pipeline/PipelineConfiguration.java
cashier-pipeline/src/main/java/com/diligrp/cashier/pipeline/client/CardPaymentHttpClient.java
cashier-pipeline/src/main/java/com/diligrp/cashier/pipeline/client/WechatDirectHttpClient.java
cashier-pipeline/src/main/java/com/diligrp/cashier/pipeline/client/WechatHttpClient.java
cashier-pipeline/src/main/java/com/diligrp/cashier/pipeline/client/WechatPartnerHttpClient.java
cashier-pipeline/src/main/java/com/diligrp/cashier/pipeline/core/CardPipeline.java
cashier-pipeline/src/main/java/com/diligrp/cashier/pipeline/core/DefaultTimeStrategy.java
cashier-pipeline/src/main/java/com/diligrp/cashier/pipeline/core/DiliCardPipeline.java
cashier-pipeline/src/main/java/com/diligrp/cashier/pipeline/core/IPipeline.java
cashier-pipeline/src/main/java/com/diligrp/cashier/pipeline/core/OnlinePipeline.java
cashier-pipeline/src/main/java/com/diligrp/cashier/pipeline/core/PaymentPipeline.java
cashier-pipeline/src/main/java/com/diligrp/cashier/pipeline/core/ScanTimeStrategy.java
cashier-pipeline/src/main/java/com/diligrp/cashier/pipeline/core/WechatDirectPipeline.java
cashier-pipeline/src/main/java/com/diligrp/cashier/pipeline/core/WechatPartnerPipeline.java
cashier-pipeline/src/main/java/com/diligrp/cashier/pipeline/core/WechatPipeline.java
cashier-pipeline/src/main/java/com/diligrp/cashier/pipeline/dao/IPaymentPipelineDao.java
cashier-pipeline/src/main/java/com/diligrp/cashier/pipeline/domain/MiniProPrepayRequest.java
 package com.diligrp.cashier.boss;
  
+import com.diligrp.cashier.shared.service.LifeCycle;
+import org.springframework.beans.BeansException;
+import org.springframework.boot.ApplicationArguments;
+import org.springframework.boot.ApplicationRunner;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.ApplicationContextAware;
 import org.springframework.context.annotation.ComponentScan;
 import org.springframework.context.annotation.Configuration;
  
+import java.util.Map;
+
 @Configuration
 @ComponentScan("com.diligrp.cashier.boss")
-public class BossConfiguration {
+public class BossConfiguration implements ApplicationContextAware, ApplicationRunner {
+
+    private ApplicationContext applicationContext;
+
+    @Override
+    public void run(ApplicationArguments args) throws Exception {
+        Map<String, LifeCycle> beans = applicationContext.getBeansOfType(LifeCycle.class);
+        for (LifeCycle lifeCycle : beans.values()) {
+            lifeCycle.start();
+        }
+    }
+
+    @Override
+    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
+        this.applicationContext = applicationContext;
+    }
 }
 package com.diligrp.cashier.boss;
  
 import com.diligrp.cashier.assistant.AssistantConfiguration;
+import com.diligrp.cashier.pipeline.PipelineConfiguration;
+import com.diligrp.cashier.shared.SharedConfiguration;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.SpringBootConfiguration;
 import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
@@ -10,7 +12,7 @@ import org.springframework.context.annotation.Import;
  
 @SpringBootConfiguration
 @EnableAutoConfiguration
-@Import({BossConfiguration.class, AssistantConfiguration.class})
+@Import({BossConfiguration.class, PipelineConfiguration.class, AssistantConfiguration.class, SharedConfiguration.class})
 @EnableDiscoveryClient
 public class CashierServiceBootstrap {
     public static void main(String[] args) {
+package com.diligrp.cashier.pipeline;
+
+public final class Constants {
+
+    // 附加参数列表
+    // 外部商户号
+    public static final String PARAM_MCH_ID = "outMchId";
+    // 用户标识
+    public static final String PARAM_OPEN_ID = "openId";
+
+    // 微信支付结果通知URI: 参数1-baseUri 参数2-paymentId
+    public static final String WECHAT_PAYMENT_NOTIFY_URI = "%s/wechat/payment/%s/notify.do";
+    // 微信退款结果通知URI: 参数1-baseUri 参数2-refundId
+    public static final String WECHAT_REFUND_NOTIFY_URI = "%s/wechat/refund/%s/notify.do";
+
+    public static final long ONE_MINUTE = 60 * 1000;
+
+    public static final long TEN_MINUTES = 10 * ONE_MINUTE;
+
+    public static final long ONE_SECOND = 1000;
+}
+package com.diligrp.cashier.pipeline;
+
+import com.diligrp.cashier.shared.mybatis.MybatisMapperSupport;
+import org.mybatis.spring.annotation.MapperScan;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+@ComponentScan("com.diligrp.cashier.pipeline")
+@MapperScan(basePackages =  {"com.diligrp.cashier.pipeline.dao"}, markerInterface = MybatisMapperSupport.class)
+public class PipelineConfiguration {
+}
+package com.diligrp.cashier.pipeline.client;
+
+import com.diligrp.cashier.pipeline.domain.*;
+import com.diligrp.cashier.pipeline.type.PaymentState;
+import com.diligrp.cashier.shared.service.ServiceEndpointSupport;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class CardPaymentHttpClient extends ServiceEndpointSupport {
+
+    private static final Logger LOG = LoggerFactory.getLogger(CardPaymentHttpClient.class);
+
+    private static final String QUERY_PAYMENT_URI = "/api/cardPayment/queryResult";
+
+    private static final String LIST_CARD_URI = "/api/query/list";
+
+    private final String baseUri;
+
+    public CardPaymentHttpClient(String baseUri) {
+        this.baseUri = baseUri;
+    }
+
+    public OnlinePaymentResponse sendPaymentRequest(OnlinePaymentRequest request) {
+        return null;
+    }
+
+    public OnlinePaymentResponse queryPrepayResponse(OnlinePrepayOrder order) {
+        return null;
+    }
+
+    public OnlineRefundResponse sendRefundRequest(OnlineRefundRequest request) {
+        return null;
+    }
+
+    private PaymentState paymentState(int stateCode) {
+        return switch (stateCode) {
+            case 4 -> PaymentState.SUCCESS;
+            case 5 -> PaymentState.FAILED;
+            default -> PaymentState.PENDING;
+        };
+    }
+
+    private Long convertLong(Object value) {
+        return value != null ? ((Number) value).longValue() : null;
+    }
+}
+package com.diligrp.cashier.pipeline.client;
+
+import com.diligrp.cashier.pipeline.domain.*;
+import com.diligrp.cashier.pipeline.domain.wechat.ErrorMessage;
+import com.diligrp.cashier.pipeline.domain.wechat.WechatConfig;
+import com.diligrp.cashier.pipeline.exception.PaymentPipelineException;
+import com.diligrp.cashier.pipeline.type.PaymentState;
+import com.diligrp.cashier.pipeline.util.WechatConstants;
+import com.diligrp.cashier.pipeline.util.WechatSignatureUtils;
+import com.diligrp.cashier.pipeline.util.WechatStateUtils;
+import com.diligrp.cashier.shared.ErrorCode;
+import com.diligrp.cashier.shared.util.AssertUtils;
+import com.diligrp.cashier.shared.util.DateUtils;
+import com.diligrp.cashier.shared.util.JsonUtils;
+import com.fasterxml.jackson.core.type.TypeReference;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.time.Duration;
+import java.time.LocalDateTime;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/**
+ * 微信支付HTTP客户端-直联模式
+ */
+public class WechatDirectHttpClient extends WechatHttpClient {
+
+    private static final Logger LOG = LoggerFactory.getLogger(WechatDirectHttpClient.class);
+
+    private static final String NATIVE_PREPAY = "/v3/pay/transactions/native";
+
+    private static final String JSAPI_PREPAY = "/v3/pay/transactions/jsapi";
+    // 查询订单状态
+    private static final String TRANSACTION_QUERY = "/v3/pay/transactions/out-trade-no/%s?mchid=%s";
+    // 关闭订单
+    private static final String TRANSACTION_CLOSE = "/v3/pay/transactions/out-trade-no/%s/close";
+    // 退款
+    private static final String TRANSACTION_REFUND = "/v3/refund/domestic/refunds";
+    // 退款查询
+    private static final String REFUND_QUERY = "/v3/refund/domestic/refunds/%s";
+
+    // 退款
+    public WechatDirectHttpClient(String wechatBaseUri, WechatConfig wechatConfig) {
+        super(wechatBaseUri, wechatConfig);
+    }
+
+    /**
+     * Native支付下单, 返回二维码链接
+     */
+    @Override
+    public NativePrepayResponse sendNativePrepayRequest(NativePrepayRequest request, String notifyUri) throws Exception {
+        String payload = nativePrepayRequest(request, notifyUri);
+        // 获取认证信息和签名信息
+        String authorization = WechatSignatureUtils.authorization(wechatConfig.getMchId(), WechatConstants.HTTP_POST,
+            NATIVE_PREPAY, payload, wechatConfig.getPrivateKey(), wechatConfig.getSerialNo());
+        HttpHeader[] headers = new HttpHeader[3];
+        headers[0] = HttpHeader.create(WechatConstants.HEADER_USER_AGENT, WechatConstants.USER_AGENT);
+        headers[1] = HttpHeader.create(WechatConstants.HEADER_ACCEPT, WechatConstants.ACCEPT_JSON);
+        headers[2] = HttpHeader.create(WechatConstants.HEADER_AUTHORIZATION, authorization);
+
+        LOG.info("Sending wechat native prepay request...");
+        LOG.debug("Authorization: {}\n{}", authorization, payload);
+        HttpResult result = send(wechatBaseUri + NATIVE_PREPAY, headers, payload);
+        verifyHttpResult(result);
+        if (result.statusCode == 200) { // 200 处理成功有返回，204处理成功无返回
+            Map<String, Object> response = JsonUtils.fromJsonString(result.responseText, new TypeReference<>() {});
+            return NativePrepayResponse.of(request.getPaymentId(), null, (String) response.get("code_url"));
+        } else {
+            LOG.error("Wechat native prepay failed: {}\n{}", result.statusCode, result.responseText);
+            ErrorMessage message = JsonUtils.fromJsonString(result.responseText, ErrorMessage.class);
+            throw new PaymentPipelineException(ErrorCode.SYSTEM_UNKNOWN_ERROR, "发起微信预支付失败: " + message.getMessage());
+        }
+    }
+
+    /**
+     * 小程序支付下单
+     */
+    @Override
+    public String sendMiniProPrepayRequest(MiniProPrepayRequest request, String notifyUri) throws Exception {
+        String payload = miniProPrepayRequest(request, notifyUri);
+        // 获取认证信息和签名信息
+        String authorization = WechatSignatureUtils.authorization(wechatConfig.getMchId(), WechatConstants.HTTP_POST, JSAPI_PREPAY,
+            payload, wechatConfig.getPrivateKey(), wechatConfig.getSerialNo());
+        HttpHeader[] headers = new HttpHeader[3];
+        headers[0] = HttpHeader.create(WechatConstants.HEADER_USER_AGENT, WechatConstants.USER_AGENT);
+        headers[1] = HttpHeader.create(WechatConstants.HEADER_ACCEPT, WechatConstants.ACCEPT_JSON);
+        headers[2] = HttpHeader.create(WechatConstants.HEADER_AUTHORIZATION, authorization);
+
+        LOG.info("Sending wechat jsapi prepay request...");
+        LOG.debug("Authorization: {}\n{}", authorization, payload);
+        HttpResult result = send(wechatBaseUri + JSAPI_PREPAY, headers, payload);
+        verifyHttpResult(result);
+        if (result.statusCode == 200) { // 200 处理成功有返回，204处理成功无返回
+            Map<String, Object> response = JsonUtils.fromJsonString(result.responseText, new TypeReference<>() {});
+            return (String) response.get("prepay_id");
+        } else {
+            LOG.error("Wechat jsapi prepay failed: {}\n{}", result.statusCode, result.responseText);
+            ErrorMessage message = JsonUtils.fromJsonString(result.responseText, ErrorMessage.class);
+            throw new PaymentPipelineException(ErrorCode.SYSTEM_UNKNOWN_ERROR, "发起微信预支付失败: " + message.getMessage());
+        }
+    }
+
+    /**
+     * 查询微信预支付订单状态
+     */
+    @Override
+    public OnlinePaymentResponse queryPrepayResponse(OnlinePrepayOrder order) throws Exception {
+        // 获取认证信息和签名信息
+        String uri = String.format(TRANSACTION_QUERY, order.getPaymentId(), wechatConfig.getMchId());
+        String authorization = WechatSignatureUtils.authorization(wechatConfig.getMchId(), WechatConstants.HTTP_GET, uri,
+            wechatConfig.getPrivateKey(), wechatConfig.getSerialNo());
+
+        HttpRequest.Builder httpRequest = HttpRequest.newBuilder().uri(URI.create(wechatBaseUri + uri))
+            .version(HttpClient.Version.HTTP_2).timeout(Duration.ofMillis(MAX_REQUEST_TIMEOUT_TIME))
+            .header(CONTENT_TYPE, CONTENT_TYPE_JSON).header(WechatConstants.HEADER_AUTHORIZATION, authorization)
+            .header(WechatConstants.HEADER_ACCEPT, WechatConstants.ACCEPT_JSON)
+            .header(WechatConstants.HEADER_USER_AGENT, WechatConstants.USER_AGENT);
+        LOG.info("Sending wechat query merchant order request...");
+        LOG.debug("Authorization: {}\n", authorization);
+        HttpResult result = execute(httpRequest.GET().build());
+        verifyHttpResult(result);
+        if (result.statusCode == 200) { // 200 处理成功有返回，204处理成功无返回(关闭的订单trade_state = CLOSED)
+            Map<String, Object> response = JsonUtils.fromJsonString(result.responseText, new TypeReference<>() {});
+            LocalDateTime when = DateUtils.parseDateTime((String)response.get("success_time"), WechatConstants.RFC3339_FORMAT);
+            @SuppressWarnings("unchecked")
+            Map<String, Object> payer = (Map<String, Object>) response.get("payer");
+            String openId = payer == null ? null : (String) payer.get("openid");
+            PaymentState state = WechatStateUtils.getPaymentState((String) response.get("trade_state"));
+            return OnlinePaymentResponse.of((String) response.get("out_trade_no"), (String) response.get("transaction_id"),
+                openId, when, state.getCode(), (String) response.get("trade_state_desc"));
+        } else {
+            LOG.info("Wechat query transaction status failed: {}", result.statusCode);
+            ErrorMessage message = JsonUtils.fromJsonString(result.responseText, ErrorMessage.class);
+            throw new PaymentPipelineException(ErrorCode.SYSTEM_UNKNOWN_ERROR, "发起微信订单查询失败: " + message.getMessage());
+        }
+    }
+
+    /**
+     * 关闭微信订单 - 关闭订单不会回调通知
+     * 返回码204标识关闭成功, 其他错误码表明关闭异常失败;
+     * 已支付完成的订单调用关闭返回400, 订单不存在返回404
+     */
+    @Override
+    public void closePrepayOrder(OnlinePrepayOrder request) throws Exception {
+        // 获取认证信息和签名信息
+        String uri = String.format(TRANSACTION_CLOSE, request.getPaymentId());
+        Map<String, Object> params = new LinkedHashMap<>();
+        params.put("mchid", wechatConfig.getMchId());
+        String payload = JsonUtils.toJsonString(params);
+        String authorization = WechatSignatureUtils.authorization(wechatConfig.getMchId(), WechatConstants.HTTP_POST, uri,
+            payload, wechatConfig.getPrivateKey(), wechatConfig.getSerialNo());
+
+        HttpHeader[] headers = new HttpHeader[3];
+        headers[0] = HttpHeader.create(WechatConstants.HEADER_USER_AGENT, WechatConstants.USER_AGENT);
+        headers[1] = HttpHeader.create(WechatConstants.HEADER_ACCEPT, WechatConstants.ACCEPT_JSON);
+        headers[2] = HttpHeader.create(WechatConstants.HEADER_AUTHORIZATION, authorization);
+        LOG.info("Sending close wechat prepay order request...");
+        LOG.debug("Authorization: {}\n{}", authorization, payload);
+        HttpResult result = send(wechatBaseUri + uri, headers, payload);
+        verifyHttpResult(result);
+        LOG.info("Close wechat prepay order statusCode: {}", result.statusCode);
+        if (result.statusCode != 200 && result.statusCode != 204) {
+            ErrorMessage message = JsonUtils.fromJsonString(result.responseText, ErrorMessage.class);
+            throw new PaymentPipelineException(ErrorCode.INVALID_OBJECT_STATE, "关闭微信订单失败: " + message.getMessage());
+        }
+    }
+
+    /**
+     * 申请微信支付退款
+     */
+    @Override
+    public OnlineRefundResponse sendRefundRequest(OnlineRefundRequest request, String notifyUri) throws Exception {
+        String payload = refundRequest(request, notifyUri);
+        // 获取认证信息和签名信息
+        String authorization = WechatSignatureUtils.authorization(wechatConfig.getMchId(), WechatConstants.HTTP_POST,
+            TRANSACTION_REFUND, payload, wechatConfig.getPrivateKey(), wechatConfig.getSerialNo());
+        HttpHeader[] headers = new HttpHeader[3];
+        headers[0] = HttpHeader.create(WechatConstants.HEADER_USER_AGENT, WechatConstants.USER_AGENT);
+        headers[1] = HttpHeader.create(WechatConstants.HEADER_ACCEPT, WechatConstants.ACCEPT_JSON);
+        headers[2] = HttpHeader.create(WechatConstants.HEADER_AUTHORIZATION, authorization);
+
+        LOG.info("Sending wechat payment refund request...");
+        LOG.debug("Authorization: {}\n{}", authorization, payload);
+        HttpResult result = send(wechatBaseUri + TRANSACTION_REFUND, headers, payload);
+        verifyHttpResult(result);
+        if (result.statusCode == 200) { // 200 处理成功有返回，204处理成功无返回
+            Map<String, Object> response = JsonUtils.fromJsonString(result.responseText, new TypeReference<>() {});
+            LocalDateTime when = DateUtils.parseDateTime((String) response.get("success_time"), WechatConstants.RFC3339_FORMAT);
+            PaymentState state = WechatStateUtils.getRefundState((String) response.get("status"));
+            return OnlineRefundResponse.of((String) response.get("out_refund_no"), (String) response.get("refund_id"),
+                when, state.getCode(), (String) response.get("status"));
+        } else {
+            LOG.info("send wechat refund failed: {}", result.statusCode);
+            ErrorMessage message = JsonUtils.fromJsonString(result.responseText, ErrorMessage.class);
+            throw new PaymentPipelineException(ErrorCode.SYSTEM_UNKNOWN_ERROR, "发起微信退款失败: " + message.getMessage());
+        }
+    }
+
+    /**
+     * 微信支付退款查询
+     */
+    @Override
+    public OnlineRefundResponse queryRefundOrder(OnlineRefundOrder request) throws Exception {
+        String uri = String.format(REFUND_QUERY, request.getRefundId());
+        String authorization = WechatSignatureUtils.authorization(wechatConfig.getMchId(), WechatConstants.HTTP_GET,
+            uri, wechatConfig.getPrivateKey(), wechatConfig.getSerialNo());
+
+        HttpRequest.Builder httpRequest = HttpRequest.newBuilder().uri(URI.create(wechatBaseUri + uri))
+            .version(HttpClient.Version.HTTP_2).timeout(Duration.ofMillis(MAX_REQUEST_TIMEOUT_TIME))
+            .header(CONTENT_TYPE, CONTENT_TYPE_JSON).header(WechatConstants.HEADER_AUTHORIZATION, authorization)
+            .header(WechatConstants.HEADER_ACCEPT, WechatConstants.ACCEPT_JSON)
+            .header(WechatConstants.HEADER_USER_AGENT, WechatConstants.USER_AGENT);
+        LOG.info("Sending wechat refund query request...");
+        LOG.debug("Authorization: {}\n", authorization);
+        HttpResult result = execute(httpRequest.GET().build());
+        verifyHttpResult(result);
+        if (result.statusCode == 200) { // 200 处理成功有返回，204处理成功无返回
+            Map<String, Object> response = JsonUtils.fromJsonString(result.responseText, new TypeReference<>() {});
+            LocalDateTime when = DateUtils.parseDateTime((String) response.get("success_time"), WechatConstants.RFC3339_FORMAT);
+            PaymentState state = WechatStateUtils.getRefundState((String) response.get("status"));
+            return OnlineRefundResponse.of((String) response.get("out_refund_no"), (String) response.get("refund_id"),
+                when, state.getCode(), (String) response.get("user_received_account"));
+        } else if (result.statusCode == 404) {
+            throw new PaymentPipelineException(ErrorCode.OBJECT_NOT_FOUND, "发起微信退款查询失败: 退款单不存在");
+        } else {
+            LOG.info("Wechat refund query failed: {}", result.statusCode);
+            ErrorMessage message = JsonUtils.fromJsonString(result.responseText, ErrorMessage.class);
+            throw new PaymentPipelineException(ErrorCode.SYSTEM_UNKNOWN_ERROR, "微信退款查询失败: " + message.getMessage());
+        }
+    }
+
+    private String nativePrepayRequest(NativePrepayRequest request, String notifyUri) {
+        Map<String, Object> params = new LinkedHashMap<>();
+        params.put("appid", wechatConfig.getAppId());
+        params.put("mchid", wechatConfig.getMchId());
+        params.put("description", request.getGoods());
+        params.put("out_trade_no", request.getPaymentId());
+        params.put("time_expire", DateUtils.formatDateTime(request.getWhen().plusMinutes(WechatConstants.PAY_DURATION_MINS),
+            WechatConstants.RFC3339_FORMAT));
+        params.put("notify_url", notifyUri);
+        Map<String, Object> amount = new LinkedHashMap<>();
+        amount.put("total", request.getAmount());
+        amount.put("currency", "CNY");
+        params.put("amount", amount);
+
+        return JsonUtils.toJsonString(params);
+    }
+
+    private String miniProPrepayRequest(MiniProPrepayRequest request, String notifyUri) {
+        AssertUtils.notEmpty(request.getOpenId(), "参数错误: 缺失用户标识openId");
+        Map<String, Object> params = new LinkedHashMap<>();
+        params.put("appid", wechatConfig.getAppId());
+        params.put("mchid", wechatConfig.getMchId());
+        params.put("description", request.getGoods());
+        params.put("out_trade_no", request.getPaymentId());
+        params.put("time_expire", DateUtils.formatDateTime(request.getWhen().plusMinutes(WechatConstants.PAY_DURATION_MINS),
+            WechatConstants.RFC3339_FORMAT));
+        params.put("notify_url", notifyUri);
+        Map<String, Object> amount = new LinkedHashMap<>();
+        amount.put("total", request.getAmount());
+        amount.put("currency", "CNY");
+        params.put("amount", amount);
+        Map<String, Object> payer = new LinkedHashMap<>();
+        payer.put("openid", request.getOpenId());
+        params.put("payer", payer);
+        return JsonUtils.toJsonString(params);
+    }
+
+    private String refundRequest(OnlineRefundRequest request, String notifyUri) {
+        Map<String, Object> params = new LinkedHashMap<>();
+        params.put("out_trade_no", request.getPaymentId());
+        params.put("out_refund_no", request.getRefundId());
+        params.put("reason", request.getDescription());
+        params.put("notify_url", notifyUri);
+        Map<String, Object> amount = new LinkedHashMap<>();
+        amount.put("refund", request.getAmount());
+        amount.put("total", request.getMaxAmount());
+        amount.put("currency", "CNY");
+        params.put("amount", amount);
+        return JsonUtils.toJsonString(params);
+    }
+}
+package com.diligrp.cashier.pipeline.client;
+
+import com.diligrp.cashier.pipeline.domain.*;
+import com.diligrp.cashier.pipeline.domain.wechat.*;
+import com.diligrp.cashier.pipeline.exception.PaymentPipelineException;
+import com.diligrp.cashier.pipeline.util.WechatConstants;
+import com.diligrp.cashier.pipeline.util.WechatSignatureUtils;
+import com.diligrp.cashier.shared.ErrorCode;
+import com.diligrp.cashier.shared.service.ServiceEndpointSupport;
+import com.diligrp.cashier.shared.util.DateUtils;
+import com.diligrp.cashier.shared.util.JsonUtils;
+import com.diligrp.cashier.shared.util.ObjectUtils;
+import com.fasterxml.jackson.core.type.TypeReference;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.ByteArrayInputStream;
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.nio.charset.StandardCharsets;
+import java.security.cert.Certificate;
+import java.security.cert.CertificateFactory;
+import java.time.Duration;
+import java.util.*;
+
+/**
+ * 微信支付基础功能HTTP客户端
+ */
+public class WechatHttpClient extends ServiceEndpointSupport {
+    private static final Logger LOG = LoggerFactory.getLogger(WechatHttpClient.class);
+
+    // 获取微信平台证书列表
+    private static final String LIST_CERTIFICATE = "/v3/certificates";
+
+    private static final String WECHAT_BASE_URL = "https://api.weixin.qq.com";
+
+    private static final String CODE_TO_SESSION = "/sns/jscode2session?appid=%s&secret=%s&js_code=%s&grant_type=authorization_code";
+
+    private static final String ACCESS_TOKEN_URL = "https://api.weixin.qq.com/cgi-bin/stable_token";
+
+    private static final String UPLOAD_SHIPPING_URL = "https://api.weixin.qq.com/wxa/sec/order/upload_shipping_info";
+
+    protected String wechatBaseUri;
+
+    protected WechatConfig wechatConfig;
+
+    public WechatHttpClient(String wechatBaseUri, WechatConfig wechatConfig) {
+        this.wechatBaseUri = wechatBaseUri;
+        this.wechatConfig = wechatConfig;
+    }
+
+    /**
+     * Native预支付下单, 返回二维码链接
+     */
+    public NativePrepayResponse sendNativePrepayRequest(NativePrepayRequest request, String notifyUri) throws Exception {
+        throw new PaymentPipelineException(ErrorCode.OPERATION_NOT_ALLOWED, "支付通道不支持Native支付");
+    }
+
+    /**
+     * 小程序支付预支付下单
+     */
+    public String sendMiniProPrepayRequest(MiniProPrepayRequest request, String notifyUri) throws Exception {
+        throw new PaymentPipelineException(ErrorCode.OPERATION_NOT_ALLOWED, "支付通道不支持JsApi支付");
+    }
+
+    /**
+     * 查询微信预支付订单状态
+     */
+    public OnlinePaymentResponse queryPrepayResponse(OnlinePrepayOrder order) throws Exception {
+        throw new PaymentPipelineException(ErrorCode.OPERATION_NOT_ALLOWED, "支付通道不支持此操作");
+    }
+
+    /**
+     * 关闭预支付订单
+     */
+    public void closePrepayOrder(OnlinePrepayOrder request) throws Exception {
+        throw new PaymentPipelineException(ErrorCode.OPERATION_NOT_ALLOWED, "支付通道不支持此操作");
+    }
+
+    /**
+     * 支付退款申请
+     */
+    public OnlineRefundResponse sendRefundRequest(OnlineRefundRequest request, String notifyUri) throws Exception {
+        throw new PaymentPipelineException(ErrorCode.OPERATION_NOT_ALLOWED, "支付通道不支持此操作");
+    }
+
+    /**
+     * 查询退款状态
+     */
+    public OnlineRefundResponse queryRefundOrder(OnlineRefundOrder request) throws Exception {
+        throw new PaymentPipelineException(ErrorCode.OPERATION_NOT_ALLOWED, "支付通道不支持此操作");
+    }
+
+    /**
+     * 刷新微信支付平台数字证书(公钥)
+     * 微信支付平台证书 - 当旧证书即将过期时，微信将新老证书将并行使用
+     * <a href="https://pay.weixin.qq.com/wiki/doc/apiv3_partner/apis/wechatpay5_1.shtml">...</a>
+     * <a href="https://pay.weixin.qq.com/docs/merchant/apis/platform-certificate/api-v3-get-certificates/get.html">...</a>
+     */
+    public void refreshCertificates() throws Exception {
+        // 获取认证信息和签名信息
+        String authorization = WechatSignatureUtils.authorization(wechatConfig.getMchId(), WechatConstants.HTTP_GET,
+            LIST_CERTIFICATE, wechatConfig.getPrivateKey(), wechatConfig.getSerialNo());
+
+        HttpRequest.Builder request = HttpRequest.newBuilder().uri(URI.create(wechatBaseUri + LIST_CERTIFICATE))
+            .version(HttpClient.Version.HTTP_2).timeout(Duration.ofMillis(MAX_REQUEST_TIMEOUT_TIME))
+            .header(CONTENT_TYPE, CONTENT_TYPE_JSON).header(WechatConstants.HEADER_AUTHORIZATION, authorization)
+            .header(WechatConstants.HEADER_ACCEPT, WechatConstants.ACCEPT_JSON)
+            .header(WechatConstants.HEADER_USER_AGENT, WechatConstants.USER_AGENT);
+        LOG.info("Sending wechat list certificate request...");
+        LOG.debug("Authorization: {}\n", authorization);
+        ServiceEndpointSupport.HttpResult result = execute(request.GET().build());
+        if (result.statusCode == 200) { // 200 处理成功有返回，204处理成功无返回; 返回成功时再进行数据验签，对数据无安全隐患
+            // 获取验签使用的微信平台证书序列号, 本地获取平台证书到则进行验签, 如获取不到则说明旧证书即将过期，新老证书正并行使用
+            String serialNo = result.header(WechatConstants.HEADER_SERIAL_NO);
+            String timestamp = result.header(WechatConstants.HEADER_TIMESTAMP);
+            String nonce = result.header(WechatConstants.HEADER_NONCE);
+            String sign = result.header(WechatConstants.HEADER_SIGNATURE);
+            LOG.debug("\n------Wechat Platform Data Verify------\nWechatpay-Serial={}\nWechatpay-Timestamp={}\n" +
+                "Wechatpay-Nonce={}\nWechatpay-Signature={}\n--------------------------------------", serialNo, timestamp, nonce, sign);
+            LOG.debug(result.responseText);
+            Optional<WechatCertificate> certificate = wechatConfig.getCertificate(serialNo);
+            if (certificate.isPresent()) {
+                boolean success = WechatSignatureUtils.verify(result.responseText, timestamp, nonce, sign,
+                    certificate.get().getPublicKey());
+                if (!success) {
+                    throw new PaymentPipelineException(ErrorCode.OPERATION_NOT_ALLOWED, "获取微信支付平台证书验签失败");
+                }
+            } else {
+                LOG.warn("Old certificate is about to expire, new one is in use");
+            }
+
+            CertificateResponse response = JsonUtils.fromJsonString(result.responseText, CertificateResponse.class);
+            List<CertificateResponse.Certificate> certificates = response.getData();
+            if (ObjectUtils.isNotEmpty(certificates)) {
+                for (CertificateResponse.Certificate cert : certificates) {
+                    // 利用ApiV3Key解密平台公钥
+                    String certStr = WechatSignatureUtils.decrypt(cert.getEncrypt_certificate().getCiphertext(),
+                        cert.getEncrypt_certificate().getNonce(), cert.getEncrypt_certificate().getAssociated_data(),
+                        wechatConfig.getApiV3Key());
+                    ByteArrayInputStream is = new ByteArrayInputStream(certStr.getBytes(StandardCharsets.UTF_8));
+                    Certificate x509Cert = CertificateFactory.getInstance("X509").generateCertificate(is);
+                    wechatConfig.putCertificate(WechatCertificate.of(cert.getSerial_no(), x509Cert.getPublicKey()));
+                    LOG.info("{} certificate added", cert.getSerial_no());
+                }
+            }
+            LOG.info("Refresh certificate repository success");
+        } else {
+            LOG.info("Refresh certificate repository failed: {}", result.statusCode);
+        }
+    }
+
+    public String loginAuthorization(String code) {
+        return loginAuthorization(wechatConfig.getAppId(), wechatConfig.getAppSecret(), code);
+    }
+
+    /**
+     * 小程序登录授权，根据wx.login获得的临时登录凭证code，获取登录信息openId等
+     */
+    public String loginAuthorization(String appId, String appSecret, String code) {
+        String uri = String.format(CODE_TO_SESSION, appId, appSecret, code);
+        HttpRequest.Builder request = HttpRequest.newBuilder().uri(URI.create(WECHAT_BASE_URL + uri))
+            .version(HttpClient.Version.HTTP_2).timeout(Duration.ofMillis(MAX_REQUEST_TIMEOUT_TIME))
+            .header(CONTENT_TYPE, CONTENT_TYPE_JSON).header(WechatConstants.HEADER_ACCEPT, WechatConstants.ACCEPT_JSON)
+            .header(WechatConstants.HEADER_USER_AGENT, WechatConstants.USER_AGENT);
+        LOG.info("Requesting MiniPro login authorization info: {}\n{}", code, uri);
+        HttpResult result = execute(request.GET().build());
+        if (result.statusCode == 200) {
+            LOG.debug("MiniPro login authorization info response\n{}", result.responseText);
+            AuthorizationSession session = JsonUtils.fromJsonString(result.responseText, AuthorizationSession.class);
+            if (session.getErrcode() != null && session.getErrcode() != 0) {
+                LOG.error("Request MiniPro login authorization info failed: {}", session.getErrmsg());
+                throw new PaymentPipelineException(ErrorCode.SERVICE_ACCESS_ERROR, "获取小程序登录授权信息失败: " + session.getErrmsg());
+            }
+            return session.getOpenid();
+        } else {
+            LOG.error("Request MiniPro login authorization info failed: {}", result.statusCode);
+            throw new PaymentPipelineException(ErrorCode.SERVICE_ACCESS_ERROR, "获取小程序登录授权信息失败");
+        }
+    }
+
+    public WechatAccessToken getAccessToken() {
+        return getAccessToken(wechatConfig.getAppId(), wechatConfig.getAppSecret());
+    }
+
+    /**
+     * 获取小程序接口调用凭证：Token有效期内重复调用该接口不会更新Token，有效期5分钟前更新Token，新旧Token并行5分钟；该接口调用频率限制为 1万次每分钟，每天限制调用 50万次；
+     * @see <a href="https://developers.weixin.qq.com/miniprogram/dev/OpenApiDoc/mp-access-token/getStableAccessToken.html">...</a>
+     */
+    public WechatAccessToken getAccessToken(String appId, String appSecret) {
+        Map<String, Object> params = new HashMap<>();
+        params.put("grant_type", "client_credential");
+        params.put("appid", appId);
+        params.put("secret", appSecret);
+        params.put("force_refresh", Boolean.FALSE);
+        String payload = JsonUtils.toJsonString(params);
+        LOG.debug("Request MiniPro Api access token: {}", payload);
+        HttpResult result = send(ACCESS_TOKEN_URL, payload);
+        if (result.statusCode == 200) {
+            LOG.debug("MiniPro Api access token response: {}", result.responseText);
+            Map<String, Object> data = JsonUtils.fromJsonString(result.responseText, new TypeReference<>() {});
+            return WechatAccessToken.of((String)data.get("access_token"), (Integer) data.get("expires_in"));
+        } else {
+            LOG.error("Request MiniPro Api access token failed: {}", result.statusCode);
+            throw new PaymentPipelineException(ErrorCode.SERVICE_ACCESS_ERROR, "获取微信接口调用凭证失败");
+        }
+    }
+
+    /**
+     * 微信发货信息录入接口
+     * @see <a href="https://developers.weixin.qq.com/miniprogram/dev/platform-capabilities/business-capabilities/order-shipping/order-shipping.html">...</a>
+     */
+    public void sendUploadShippingRequest(UploadShippingRequest request, String accessToken) {
+        String uri = String.format("%s?access_token=%s", UPLOAD_SHIPPING_URL, accessToken);
+        Map<String, Object> orderKey = new HashMap<>();
+        orderKey.put("order_number_type", 2);
+        orderKey.put("transaction_id", request.getTransactionId());
+
+        Map<String, Object> shipping = new HashMap<>();
+        shipping.put("item_desc", request.getGoods());
+        List<Map<String, Object>> shippingList = new ArrayList<>();
+        shippingList.add(shipping);
+
+        Map<String, Object> payer = new HashMap<>();
+        payer.put("openid", request.getOpenId());
+
+        Map<String, Object> params = new HashMap<>();
+        params.put("order_key", orderKey);
+        params.put("logistics_type", request.getLogisticsType());
+        params.put("delivery_mode", 1);
+        params.put("shipping_list", shippingList);
+        params.put("upload_time", DateUtils.format(new Date(), "yyyy-MM-dd'T'HH:mm:ssZ"));
+        params.put("payer", payer);
+
+        String payload = JsonUtils.toJsonString(params);
+        LOG.debug("Request wechat upload shipping: {}", payload);
+        HttpResult result = send(uri, payload);
+        if (result.statusCode == 200) {
+            LOG.debug("Wechat upload shipping response: {}", result.responseText);
+            Map<String, Object> data = JsonUtils.fromJsonString(result.responseText, new TypeReference<>() {});
+            int errorCode = (Integer) data.get("errcode");
+            if (errorCode != 0) {
+                String errorMessage = (String)data.get("errmsg");
+                throw new PaymentPipelineException(ErrorCode.SERVICE_ACCESS_ERROR, "微信发货信息录入失败: " + errorMessage);
+            }
+        } else {
+            LOG.error("Request wechat upload shipping failed: {}", result.statusCode);
+            throw new PaymentPipelineException(ErrorCode.SERVICE_ACCESS_ERROR, "调用微信发货信息录入接口失败");
+        }
+    }
+
+    /**
+     * 用于微信支付结果通知数据验签
+     */
+    public boolean dataVerify(String serialNo, String timestamp, String nonce, String sign, String payload) throws Exception {
+        LOG.debug("\n------Wechat Platform Data Verify------\nWechatpay-Serial={}\nWechatpay-Timestamp={}\n"
+            + "Wechatpay-Nonce={}\nWechatpay-Signature={}\n{}\n--------------------------------------",
+            serialNo, timestamp, nonce, sign, payload == null ? "" : payload);
+        Optional<WechatCertificate> certOpt = wechatConfig.getCertificate(serialNo);
+        if (certOpt.isEmpty()) { // 找不到证书则重新向微信平台请求新证书(旧证书即将过期时出现)
+            refreshCertificates();
+        }
+
+        WechatCertificate certificate = wechatConfig.getCertificate(serialNo).orElseThrow(() ->
+            new PaymentPipelineException(ErrorCode.OPERATION_NOT_ALLOWED, "找不到微信平台数字证书"));
+        return WechatSignatureUtils.verify(payload, timestamp, nonce, sign, certificate.getPublicKey());
+    }
+
+    protected void verifyHttpResult(HttpResult result) throws Exception {
+        if (result.statusCode == 401) {
+            return; // 微信签名失败，则不进行验签操作
+        }
+        // 获取验签使用的微信平台证书序列号, 本地获取平台证书到则进行验签, 如获取不到则说明旧证书即将过期，新老证书正并行使用
+        String serialNo = result.header(WechatConstants.HEADER_SERIAL_NO);
+        String timestamp = result.header(WechatConstants.HEADER_TIMESTAMP);
+        String nonce = result.header(WechatConstants.HEADER_NONCE);
+        String sign = result.header(WechatConstants.HEADER_SIGNATURE);
+        if (!dataVerify(serialNo, timestamp, nonce, sign, result.responseText)) {
+            throw new PaymentPipelineException(ErrorCode.OPERATION_NOT_ALLOWED, "微信数据验签失败");
+        }
+    }
+
+    public WechatConfig getWechatConfig() {
+        return wechatConfig;
+    }
+}
+package com.diligrp.cashier.pipeline.client;
+
+import com.diligrp.cashier.pipeline.Constants;
+import com.diligrp.cashier.pipeline.domain.*;
+import com.diligrp.cashier.pipeline.domain.wechat.ErrorMessage;
+import com.diligrp.cashier.pipeline.domain.wechat.WechatConfig;
+import com.diligrp.cashier.pipeline.exception.PaymentPipelineException;
+import com.diligrp.cashier.pipeline.type.PaymentState;
+import com.diligrp.cashier.pipeline.util.WechatConstants;
+import com.diligrp.cashier.pipeline.util.WechatSignatureUtils;
+import com.diligrp.cashier.pipeline.util.WechatStateUtils;
+import com.diligrp.cashier.shared.ErrorCode;
+import com.diligrp.cashier.shared.util.AssertUtils;
+import com.diligrp.cashier.shared.util.DateUtils;
+import com.diligrp.cashier.shared.util.JsonUtils;
+import com.fasterxml.jackson.core.type.TypeReference;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.time.Duration;
+import java.time.LocalDateTime;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/**
+ * 微信支付HTTP客户端-服务商模式
+ */
+public class WechatPartnerHttpClient extends WechatHttpClient {
+
+    private static final Logger LOG = LoggerFactory.getLogger(WechatPartnerHttpClient.class);
+
+    private static final String NATIVE_PREPAY = "/v3/pay/partner/transactions/native";
+
+    private static final String JSAPI_PREPAY = "/v3/pay/partner/transactions/jsapi";
+
+    // 查询订单状态
+    private static final String TRANSACTION_QUERY = "/v3/pay/partner/transactions/out-trade-no/%s?sp_mchid=%s&sub_mchid=%s";
+    // 关闭订单
+    private static final String TRANSACTION_CLOSE = "/v3/pay/partner/transactions/out-trade-no/%s/close";
+    // 退款
+    private static final String NATIVE_REFUND = "/v3/refund/domestic/refunds";
+    // 退款查询
+    private static final String NATIVE_REFUND_QUERY = "/v3/refund/domestic/refunds/%s?sub_mchid=%s";
+
+    public WechatPartnerHttpClient(String wechatBaseUri, WechatConfig wechatConfig) {
+        super(wechatBaseUri, wechatConfig);
+    }
+
+    /**
+     * Native支付下单, 返回二维码链接
+     */
+    @Override
+    public NativePrepayResponse sendNativePrepayRequest(NativePrepayRequest request, String notifyUri) throws Exception {
+        String payload = nativePrepayRequest(request, notifyUri);
+        // 获取认证信息和签名信息
+        String authorization = WechatSignatureUtils.authorization(wechatConfig.getMchId(), WechatConstants.HTTP_POST, NATIVE_PREPAY,
+            payload, wechatConfig.getPrivateKey(), wechatConfig.getSerialNo());
+        HttpHeader[] headers = new HttpHeader[3];
+        headers[0] = HttpHeader.create(WechatConstants.HEADER_USER_AGENT, WechatConstants.USER_AGENT);
+        headers[1] = HttpHeader.create(WechatConstants.HEADER_ACCEPT, WechatConstants.ACCEPT_JSON);
+        headers[2] = HttpHeader.create(WechatConstants.HEADER_AUTHORIZATION, authorization);
+
+        LOG.info("Sending wechat native prepay request...");
+        LOG.debug("Authorization: {}\n{}", authorization, payload);
+        HttpResult result = send(wechatBaseUri + NATIVE_PREPAY, headers, payload);
+        verifyHttpResult(result);
+        if (result.statusCode == 200) { // 200 处理成功有返回，204处理成功无返回
+            Map<String, Object> response = JsonUtils.fromJsonString(result.responseText, new TypeReference<>() {});
+            return NativePrepayResponse.of(request.getPaymentId(), null, (String) response.get("code_url"));
+        } else {
+            LOG.error("Wechat native prepay failed: {}\n{}", result.statusCode, result.responseText);
+            ErrorMessage message = JsonUtils.fromJsonString(result.responseText, ErrorMessage.class);
+            throw new PaymentPipelineException(ErrorCode.SYSTEM_UNKNOWN_ERROR, "发起微信预支付失败: " + message.getMessage());
+        }
+    }
+
+    /**
+     * 小程序支付下单, 返回prepay_id
+     */
+    @Override
+    public String sendMiniProPrepayRequest(MiniProPrepayRequest request, String notifyUri) throws Exception {
+        String payload = miniProPrepayRequest(request, notifyUri);
+        // 获取认证信息和签名信息
+        String authorization = WechatSignatureUtils.authorization(wechatConfig.getMchId(), WechatConstants.HTTP_POST, JSAPI_PREPAY,
+            payload, wechatConfig.getPrivateKey(), wechatConfig.getSerialNo());
+        HttpHeader[] headers = new HttpHeader[3];
+        headers[0] = HttpHeader.create(WechatConstants.HEADER_USER_AGENT, WechatConstants.USER_AGENT);
+        headers[1] = HttpHeader.create(WechatConstants.HEADER_ACCEPT, WechatConstants.ACCEPT_JSON);
+        headers[2] = HttpHeader.create(WechatConstants.HEADER_AUTHORIZATION, authorization);
+
+        LOG.info("Sending wechat JsApI prepay request...");
+        LOG.debug("Authorization: {}\n{}", authorization, payload);
+        HttpResult result = send(wechatBaseUri + JSAPI_PREPAY, headers, payload);
+        verifyHttpResult(result);
+        if (result.statusCode == 200) { // 200 处理成功有返回，204处理成功无返回
+            Map<String, Object> response = JsonUtils.fromJsonString(result.responseText, new TypeReference<>() {});
+            return (String) response.get("prepay_id");
+        } else {
+            LOG.error("Wechat JsApI prepay failed: {}\n{}", result.statusCode, result.responseText);
+            ErrorMessage message = JsonUtils.fromJsonString(result.responseText, ErrorMessage.class);
+            throw new PaymentPipelineException(ErrorCode.SYSTEM_UNKNOWN_ERROR, "发起微信预支付失败: " + message.getMessage());
+        }
+    }
+
+    /**
+     * 查询微信预支付订单状态
+     */
+    @Override
+    public OnlinePaymentResponse queryPrepayResponse(OnlinePrepayOrder order) throws Exception {
+        String subMchId = order.getString(Constants.PARAM_MCH_ID);
+        AssertUtils.notEmpty(subMchId, "参数错误: 服务商模式下缺失子商户号");
+
+        // 获取认证信息和签名信息
+        String uri = String.format(TRANSACTION_QUERY, order.getPaymentId(), wechatConfig.getMchId(), subMchId);
+        String authorization = WechatSignatureUtils.authorization(wechatConfig.getMchId(), WechatConstants.HTTP_GET, uri,
+            wechatConfig.getPrivateKey(), wechatConfig.getSerialNo());
+
+        HttpRequest.Builder httpRequest = HttpRequest.newBuilder().uri(URI.create(wechatBaseUri + uri))
+            .version(HttpClient.Version.HTTP_2).timeout(Duration.ofMillis(MAX_REQUEST_TIMEOUT_TIME))
+            .header(CONTENT_TYPE, CONTENT_TYPE_JSON).header(WechatConstants.HEADER_AUTHORIZATION, authorization)
+            .header(WechatConstants.HEADER_ACCEPT, WechatConstants.ACCEPT_JSON)
+            .header(WechatConstants.HEADER_USER_AGENT, WechatConstants.USER_AGENT);
+        LOG.info("Sending wechat query merchant order request...");
+        LOG.debug("Authorization: {}\n", authorization);
+        HttpResult result = execute(httpRequest.GET().build());
+        verifyHttpResult(result);
+        if (result.statusCode == 200) { // 200 处理成功有返回，204处理成功无返回(关闭的订单trade_state = CLOSED)
+            Map<String, Object> response = JsonUtils.fromJsonString(result.responseText, new TypeReference<>() {});
+            LocalDateTime when = DateUtils.parseDateTime((String) response.get("success_time"), WechatConstants.RFC3339_FORMAT);
+            @SuppressWarnings("unchecked")
+            Map<String, Object> payer = (Map<String, Object>) response.get("payer");
+            String openId = payer == null ? null : (String) payer.get("sp_openid"); // 获取服务商APPID下的openId，而非子商户APPID下的openId
+            PaymentState state = WechatStateUtils.getPaymentState((String) response.get("trade_state"));
+            return OnlinePaymentResponse.of((String) response.get("out_trade_no"), (String) response.get("transaction_id"),
+                openId, when, state.getCode(), (String) response.get("trade_state_desc"));
+        } else {
+            LOG.info("Wechat query transaction status failed: {}", result.statusCode);
+            ErrorMessage message = JsonUtils.fromJsonString(result.responseText, ErrorMessage.class);
+            throw new PaymentPipelineException(ErrorCode.SYSTEM_UNKNOWN_ERROR, "发起微信订单查询失败: " + message.getMessage());
+        }
+    }
+
+    /**
+     * 关闭微信订单 - 关闭订单不会回调通知
+     * 返回码204标识关闭成功, 其他错误码表明关闭异常失败;
+     * 已支付完成的订单调用关闭返回400, 订单不存在返回404
+     */
+    @Override
+    public void closePrepayOrder(OnlinePrepayOrder request) throws Exception {
+        String subMchId = request.getString(Constants.PARAM_MCH_ID);
+        AssertUtils.notEmpty(subMchId, "参数错误: 服务商模式下缺失子商户号");
+
+        // 获取认证信息和签名信息
+        String uri = String.format(TRANSACTION_CLOSE, request.getPaymentId());
+        Map<String, Object> params = new LinkedHashMap<>();
+        params.put("sp_mchid", wechatConfig.getMchId());
+        params.put("sub_mchid", subMchId);
+        String payload = JsonUtils.toJsonString(params);
+        String authorization = WechatSignatureUtils.authorization(wechatConfig.getMchId(), WechatConstants.HTTP_POST, uri,
+            payload, wechatConfig.getPrivateKey(), wechatConfig.getSerialNo());
+
+        HttpHeader[] headers = new HttpHeader[3];
+        headers[0] = HttpHeader.create(WechatConstants.HEADER_USER_AGENT, WechatConstants.USER_AGENT);
+        headers[1] = HttpHeader.create(WechatConstants.HEADER_ACCEPT, WechatConstants.ACCEPT_JSON);
+        headers[2] = HttpHeader.create(WechatConstants.HEADER_AUTHORIZATION, authorization);
+        LOG.info("Sending close wechat prepay order request...");
+        LOG.debug("Authorization: {}\n{}", authorization, payload);
+        HttpResult result = send(wechatBaseUri + uri, headers, payload);
+        verifyHttpResult(result);
+        LOG.info("Close wechat prepay order statusCode: {}", result.statusCode);
+        if (result.statusCode != 200 && result.statusCode != 204) {
+            ErrorMessage message = JsonUtils.fromJsonString(result.responseText, ErrorMessage.class);
+            throw new PaymentPipelineException(ErrorCode.INVALID_OBJECT_STATE, "关闭微信订单失败: " + message.getMessage());
+        }
+    }
+
+    /**
+     * 申请微信支付退款
+     */
+    @Override
+    public OnlineRefundResponse sendRefundRequest(OnlineRefundRequest request, String notifyUri) throws Exception {
+        String payload = refundRequest(request, notifyUri);
+        // 获取认证信息和签名信息
+        String authorization = WechatSignatureUtils.authorization(wechatConfig.getMchId(), WechatConstants.HTTP_POST, NATIVE_REFUND,
+            payload, wechatConfig.getPrivateKey(), wechatConfig.getSerialNo());
+        HttpHeader[] headers = new HttpHeader[3];
+        headers[0] = HttpHeader.create(WechatConstants.HEADER_USER_AGENT, WechatConstants.USER_AGENT);
+        headers[1] = HttpHeader.create(WechatConstants.HEADER_ACCEPT, WechatConstants.ACCEPT_JSON);
+        headers[2] = HttpHeader.create(WechatConstants.HEADER_AUTHORIZATION, authorization);
+
+        LOG.info("Sending wechat payment refund request...");
+        LOG.debug("Authorization: {}\n{}", authorization, payload);
+        HttpResult result = send(wechatBaseUri + NATIVE_REFUND, headers, payload);
+        verifyHttpResult(result);
+        if (result.statusCode == 200) { // 200 处理成功有返回，204处理成功无返回
+            Map<String, Object> response = JsonUtils.fromJsonString(result.responseText, new TypeReference<>() {});
+            LocalDateTime when = DateUtils.parseDateTime((String) response.get("success_time"), WechatConstants.RFC3339_FORMAT);
+            PaymentState state = WechatStateUtils.getRefundState((String) response.get("status"));
+            return OnlineRefundResponse.of((String) response.get("out_refund_no"), (String) response.get("refund_id"),
+                when, state.getCode(), (String) response.get("status"));
+        } else {
+            LOG.info("send wechat payment refund failed: {}", result.statusCode);
+            ErrorMessage message = JsonUtils.fromJsonString(result.responseText, ErrorMessage.class);
+            throw new PaymentPipelineException(ErrorCode.SYSTEM_UNKNOWN_ERROR, "发起微信退款失败: " + message.getMessage());
+        }
+    }
+
+    /**
+     * 微信支付退款查询
+     */
+    @Override
+    public OnlineRefundResponse queryRefundOrder(OnlineRefundOrder request) throws Exception {
+        String subMchId = request.getString(Constants.PARAM_MCH_ID);
+        AssertUtils.notEmpty(subMchId, "参数错误: 服务商模式下缺失子商户号");
+
+        String uri = String.format(NATIVE_REFUND_QUERY, request.getRefundId(), subMchId);
+        String authorization = WechatSignatureUtils.authorization(wechatConfig.getMchId(), WechatConstants.HTTP_GET, uri,
+            wechatConfig.getPrivateKey(), wechatConfig.getSerialNo());
+
+        HttpRequest.Builder httpRequest = HttpRequest.newBuilder().uri(URI.create(wechatBaseUri + uri))
+            .version(HttpClient.Version.HTTP_2).timeout(Duration.ofMillis(MAX_REQUEST_TIMEOUT_TIME))
+            .header(CONTENT_TYPE, CONTENT_TYPE_JSON).header(WechatConstants.HEADER_AUTHORIZATION, authorization)
+            .header(WechatConstants.HEADER_ACCEPT, WechatConstants.ACCEPT_JSON)
+            .header(WechatConstants.HEADER_USER_AGENT, WechatConstants.USER_AGENT);
+        LOG.info("Sending wechat refund query request...");
+        LOG.debug("Authorization: {}\n", authorization);
+        HttpResult result = execute(httpRequest.GET().build());
+        verifyHttpResult(result);
+        if (result.statusCode == 200) { // 200 处理成功有返回，204处理成功无返回
+            Map<String, Object> response = JsonUtils.fromJsonString(result.responseText, new TypeReference<>() {});
+            LocalDateTime when = DateUtils.parseDateTime((String) response.get("success_time"), WechatConstants.RFC3339_FORMAT);
+            PaymentState state = WechatStateUtils.getRefundState((String) response.get("status"));
+            return OnlineRefundResponse.of((String) response.get("out_refund_no"), (String) response.get("refund_id"),
+                when, state.getCode(), (String) response.get("user_received_account"));
+        } else if (result.statusCode == 404) {
+            throw new PaymentPipelineException(ErrorCode.OBJECT_NOT_FOUND, "发起微信退款查询失败: 退款单不存在");
+        } else {
+            LOG.info("Wechat query mch refund failed: {}", result.statusCode);
+            ErrorMessage message = JsonUtils.fromJsonString(result.responseText, ErrorMessage.class);
+            throw new PaymentPipelineException(ErrorCode.SYSTEM_UNKNOWN_ERROR, "微信退款查询失败: " + message.getMessage());
+        }
+    }
+
+    private String nativePrepayRequest(NativePrepayRequest request, String notifyUri) {
+        String subMchId = request.getString(Constants.PARAM_MCH_ID);
+        AssertUtils.notEmpty(subMchId, "参数错误: 服务商模式下缺失子商户号");
+
+        Map<String, Object> params = new LinkedHashMap<>();
+        params.put("sp_appid", wechatConfig.getAppId());
+        params.put("sp_mchid", wechatConfig.getMchId());
+//        params.put("sub_appid", subMerchant.getAppId());
+        params.put("sub_mchid", subMchId);
+        params.put("description", request.getGoods());
+        params.put("out_trade_no", request.getPaymentId());
+        params.put("time_expire", DateUtils.formatDateTime(request.getWhen().plusMinutes(WechatConstants.PAY_DURATION_MINS),
+            WechatConstants.RFC3339_FORMAT));
+        params.put("notify_url", notifyUri);
+        Map<String, Object> amount = new LinkedHashMap<>();
+        amount.put("total", request.getAmount());
+        amount.put("currency", "CNY");
+        params.put("amount", amount);
+        return JsonUtils.toJsonString(params);
+    }
+
+    private String miniProPrepayRequest(MiniProPrepayRequest request, String notifyUri) {
+        String subMchId = request.getString(Constants.PARAM_MCH_ID);
+        AssertUtils.notEmpty(subMchId, "参数错误: 服务商模式下缺失子商户号");
+        AssertUtils.notEmpty(request.getOpenId(), "参数错误: 缺失用户标识openId");
+
+        Map<String, Object> params = new LinkedHashMap<>();
+        params.put("sp_appid", wechatConfig.getAppId());
+        params.put("sp_mchid", wechatConfig.getMchId());
+//        params.put("sub_appid", subMerchant.getAppId());
+        params.put("sub_mchid", subMchId);
+        params.put("description", request.getGoods());
+        params.put("out_trade_no", request.getPaymentId());
+        params.put("time_expire", DateUtils.formatDateTime(request.getWhen().plusMinutes(WechatConstants.PAY_DURATION_MINS),
+            WechatConstants.RFC3339_FORMAT));
+        params.put("notify_url", notifyUri);
+        Map<String, Object> amount = new LinkedHashMap<>();
+        amount.put("total", request.getAmount());
+        amount.put("currency", "CNY");
+        params.put("amount", amount);
+        Map<String, Object> payer = new LinkedHashMap<>();
+        // 传入微信用户在服务商APPID下的openid，如果是子商户APPID下的openid，则应该使用sub_appid
+        payer.put("sp_openid", request.getOpenId());
+        params.put("payer", payer);
+        return JsonUtils.toJsonString(params);
+    }
+
+    private String refundRequest(OnlineRefundRequest request, String notifyUri) {
+        String subMchId = request.getString(Constants.PARAM_MCH_ID);
+        AssertUtils.notEmpty(subMchId, "参数错误: 服务商模式下缺失子商户号");
+
+        Map<String, Object> params = new LinkedHashMap<>();
+        params.put("sub_mchid", subMchId);
+        params.put("out_trade_no", request.getPaymentId());
+        params.put("out_refund_no", request.getRefundId());
+        params.put("reason", request.getDescription());
+        params.put("notify_url", notifyUri);
+        Map<String, Object> amount = new LinkedHashMap<>();
+        amount.put("refund", request.getAmount());
+        amount.put("total", request.getMaxAmount());
+        amount.put("currency", "CNY");
+        params.put("amount", amount);
+
+        return JsonUtils.toJsonString(params);
+    }
+}
+package com.diligrp.cashier.pipeline.core;
+
+import com.diligrp.cashier.pipeline.client.CardPaymentHttpClient;
+import com.diligrp.cashier.pipeline.domain.*;
+import com.diligrp.cashier.pipeline.exception.PaymentPipelineException;
+import com.diligrp.cashier.shared.ErrorCode;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * 园区卡支付通道抽象模型
+ */
+public abstract class CardPipeline extends PaymentPipeline<CardPipeline.CardParams> {
+
+    private static final Logger LOG = LoggerFactory.getLogger(CardPipeline.class);
+
+    private final ScanTimeStrategy strategy;
+
+    private final CardPaymentHttpClient client;
+
+    public CardPipeline(long mchId, long pipelineId, String name, String uri, String params) throws Exception {
+        super(mchId, pipelineId, name, uri, params);
+        this.strategy = new DefaultTimeStrategy();
+        this.client = new CardPaymentHttpClient(uri);
+    }
+
+    /**
+     * 发送预支付订单的支付申请 - 目前针对园区卡扫码支付
+     */
+    public OnlinePaymentResponse sendPaymentRequest(OnlinePaymentRequest request) {
+        try {
+            return client.sendPaymentRequest(request);
+        } catch (PaymentPipelineException | IllegalArgumentException pse) {
+            throw pse;
+        } catch (Exception ex) {
+            LOG.error("Send card payment request exception", ex);
+            throw new PaymentPipelineException(ErrorCode.SYSTEM_UNKNOWN_ERROR, "发起地利支付申请失败");
+        }
+    }
+
+    /**
+     * 查询支付订单状态
+     */
+    public OnlinePaymentResponse queryPrepayResponse(OnlinePrepayOrder order) {
+        try {
+            return client.queryPrepayResponse(order);
+        } catch (PaymentPipelineException | IllegalArgumentException pse) {
+            throw pse;
+        } catch (Exception ex) {
+            LOG.error("Query card payment state request exception", ex);
+            throw new PaymentPipelineException(ErrorCode.SYSTEM_UNKNOWN_ERROR, "查询地利支付状态失败");
+        }
+    }
+
+    /**
+     * 关闭预支付订单
+     */
+    public void closePrepayOrder(OnlinePrepayOrder request) {
+        // 不调用远程关单接口
+    }
+
+    /**
+     * 退款申请
+     */
+    public OnlineRefundResponse sendRefundRequest(OnlineRefundRequest request) {
+        try {
+            return client.sendRefundRequest(request);
+        } catch (PaymentPipelineException | IllegalArgumentException pse) {
+            throw pse;
+        } catch (Exception ex) {
+            LOG.error("Send card refund request exception", ex);
+            throw new PaymentPipelineException(ErrorCode.SYSTEM_UNKNOWN_ERROR, "发起微信退款失败");
+        }
+    }
+
+    public CardPaymentHttpClient getClient() {
+        return this.client;
+    }
+
+    public ScanTimeStrategy getTimeStrategy() {
+        return strategy;
+    }
+
+    @Override
+    public Class<CardParams> paramClass() {
+        return CardParams.class;
+    }
+
+    public static class CardParams extends PipelineParams {
+        public CardParams(String params) {
+            super(params);
+        }
+    }
+}
+package com.diligrp.cashier.pipeline.core;
+
+import static com.diligrp.cashier.pipeline.Constants.*;
+
+public class DefaultTimeStrategy implements ScanTimeStrategy {
+    // 预支付订单扫描时间策略
+    private long[] prepayTimeArray = { 10 * ONE_MINUTE };
+
+    // 直接支付订单扫描时间策略
+    private long[] paymentTimeArray = {5 * ONE_SECOND, 5 * ONE_SECOND, 5 * ONE_SECOND, 5 * ONE_SECOND, 5 * ONE_SECOND, 5 * ONE_SECOND, 5 * ONE_SECOND, 5 * ONE_SECOND, 10 * ONE_SECOND, 15 * ONE_SECOND};
+
+    // 退款订单扫描时间策略
+    private long[] refundTimeArray = { 10 * ONE_MINUTE };
+
+    @Override
+    public long nextPrepayScanTime(int times) {
+        if (times - 1 < prepayTimeArray.length) {
+            return prepayTimeArray[times - 1];
+        }
+        return -1;
+    }
+
+    @Override
+    public long nextPaymentScanTime(int times) {
+        if (times - 1 < paymentTimeArray.length) {
+            return paymentTimeArray[times - 1];
+        }
+        return -1;
+    }
+
+    @Override
+    public long nextRefundScanTime(int times) {
+        if (times - 1 < refundTimeArray.length) {
+            return refundTimeArray[times - 1];
+        }
+        return -1;
+    }
+}
+package com.diligrp.cashier.pipeline.core;
+
+import com.diligrp.cashier.pipeline.type.ChannelType;
+
+/**
+ * 地利园区支付通道模型
+ */
+public class DiliCardPipeline extends CardPipeline {
+
+    public DiliCardPipeline(long mchId, long pipelineId, String name, String uri, String params) throws Exception {
+        super(mchId, pipelineId, name, uri, params);
+    }
+
+    @Override
+    public ChannelType supportedChannel() {
+        return ChannelType.DILIPAY;
+    }
+}
+package com.diligrp.cashier.pipeline.core;
+
+import com.diligrp.cashier.pipeline.type.ChannelType;
+
+/**
+ * 支付通道领域模型接口
+ */
+public interface IPipeline<T> {
+    /**
+     * 通道所属商户
+     */
+    long mchId();
+
+    /**
+     * 通道ID
+     */
+    long pipelineId();
+
+    /**
+     * 通道名称
+     */
+    String name();
+
+    /**
+     * 通道服务URI
+     */
+    String uri();
+
+    /**
+     * 通道所属渠道
+     */
+    ChannelType supportedChannel();
+
+    /**
+     * 配置参数
+     */
+    T params();
+
+    /**
+     * 配置参数类
+     */
+    Class<T> paramClass();
+}
+package com.diligrp.cashier.pipeline.core;
+
+import com.diligrp.cashier.pipeline.domain.*;
+import com.diligrp.cashier.pipeline.exception.PaymentPipelineException;
+import com.diligrp.cashier.shared.ErrorCode;
+
+/**
+ * 在线支付通道抽象模型
+ *
+ * TODO: 此支付通道类是否所有支付通道的基类(微信、支付宝、银行聚合支付），还是仅仅作为银行聚合支付的基类，需要仔细斟酌
+ */
+public abstract class OnlinePipeline<T extends PaymentPipeline.PipelineParams> extends PaymentPipeline<T> {
+
+    public OnlinePipeline(long mchId, long pipelineId, String name, String uri, String params) throws Exception {
+        super(mchId, pipelineId, name, uri, params);
+    }
+
+    /**
+     * 扫码支付 - 客户扫商户收款码
+     */
+    public NativePrepayResponse sendNativePrepayRequest(NativePrepayRequest request) {
+       throw new PaymentPipelineException(ErrorCode.OPERATION_NOT_ALLOWED, "支付通道暂不支持扫码支付");
+    }
+
+    /**
+     * 付款码支付 - 商户扫客户付款码
+     */
+    public OnlinePaymentResponse sendQrCodePaymentRequest(OnlinePaymentRequest request) {
+        throw new PaymentPipelineException(ErrorCode.OPERATION_NOT_ALLOWED, "支付通道暂不支持付款码支付");
+    }
+
+    /**
+     * 小程序支付
+     */
+    public MiniProPrepayResponse sendMiniProPrepayRequest(MiniProPrepayRequest request) {
+        throw new PaymentPipelineException(ErrorCode.OPERATION_NOT_ALLOWED, "支付通道暂不支持小程序支付");
+    }
+
+    /**
+     * 查询预支付订单状态
+     */
+    public OnlinePaymentResponse queryPrepayResponse(OnlinePrepayOrder order) {
+        throw new PaymentPipelineException(ErrorCode.OPERATION_NOT_ALLOWED, "支付通道暂不支持查询支付状态");
+    }
+
+    /**
+     * 关闭预支付订单
+     */
+    public void closePrepayOrder(OnlinePrepayOrder order) {
+        throw new PaymentPipelineException(ErrorCode.OPERATION_NOT_ALLOWED, "支付通道暂不支持关闭订单");
+    }
+
+    /**
+     * 退款申请
+     */
+    public OnlineRefundResponse sendRefundRequest(OnlineRefundRequest request) {
+        throw new PaymentPipelineException(ErrorCode.OPERATION_NOT_ALLOWED, "支付通道暂不支持退款");
+    }
+
+    /**
+     * 查询退款状态
+     */
+    public OnlineRefundResponse queryRefundResponse(OnlineRefundOrder request) {
+        throw new PaymentPipelineException(ErrorCode.OPERATION_NOT_ALLOWED, "支付通道暂不支持查询退款状态");
+    }
+
+    public abstract ScanTimeStrategy getTimeStrategy();
+}
+package com.diligrp.cashier.pipeline.core;
+
+import com.diligrp.cashier.pipeline.exception.PaymentPipelineException;
+import com.diligrp.cashier.shared.ErrorCode;
+import com.diligrp.cashier.shared.util.JsonUtils;
+import com.diligrp.cashier.shared.util.ObjectUtils;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+
+public abstract class PaymentPipeline<T extends PaymentPipeline.PipelineParams> implements IPipeline<T> {
+    // 通道所属商户
+    private final long mchId;
+    // 通道ID
+    private final long pipelineId;
+    // 通道名称
+    private final String name;
+    // 通道服务URI
+    private final String uri;
+    // 通道参数配置
+    private final T params;
+
+    public PaymentPipeline(long mchId, long pipelineId, String name, String uri, String params) throws Exception {
+        this.mchId = mchId;
+        this.pipelineId = pipelineId;
+        this.name = name;
+        this.uri = uri;
+
+        Constructor<T> constructor = paramClass().getConstructor(String.class);
+        try {
+            this.params = constructor.newInstance(params);
+        } catch (InvocationTargetException tex) {
+            throw (Exception) tex.getCause();
+        }
+    }
+
+    @Override
+    public long mchId() {
+        return this.mchId;
+    }
+
+    @Override
+    public long pipelineId() {
+        return this.pipelineId;
+    }
+
+    @Override
+    public String name() {
+        return this.name;
+    }
+
+    @Override
+    public String uri() {
+        return this.uri;
+    }
+
+    @Override
+    public T params() {
+        return params;
+    }
+
+    protected void checkParam(String label, String value) {
+        if (ObjectUtils.isEmpty(value)) {
+            throw new PaymentPipelineException(ErrorCode.ILLEGAL_ARGUMENT_ERROR, String.format("支付通道缺少参数配置: %s", label));
+        }
+    }
+
+    protected static abstract class PipelineParams {
+        public PipelineParams(String params) {
+            parseParams(params);
+        }
+
+        protected void parseParams(String params) {
+            if (ObjectUtils.isNotEmpty(params)) {
+                JsonUtils.fromJsonString(this, params);
+            }
+        }
+    }
+
+    public static class NoneParams extends PipelineParams {
+        public NoneParams(String params) {
+            super(params);
+        }
+
+        @Override
+        protected void parseParams(String params) {
+        }
+    }
+}
+package com.diligrp.cashier.pipeline.core;
+
+public interface ScanTimeStrategy {
+    // 预支付订单延迟扫描时间
+    long nextPrepayScanTime(int times);
+
+    // 支付订单延迟扫描时间
+    long nextPaymentScanTime(int times);
+
+    // 退款订单延迟扫描时间
+    long nextRefundScanTime(int times);
+}
+package com.diligrp.cashier.pipeline.core;
+
+import com.diligrp.cashier.pipeline.client.WechatDirectHttpClient;
+import com.diligrp.cashier.pipeline.client.WechatHttpClient;
+import com.diligrp.cashier.shared.util.AssertUtils;
+
+/**
+ * 微信支付通道抽象模型-直联模式
+ */
+public class WechatDirectPipeline extends WechatPipeline {
+    private final ScanTimeStrategy strategy;
+
+    // 直联模式下的微信客户端
+    private WechatDirectHttpClient client;
+
+    public WechatDirectPipeline(long mchId, long pipelineId, String name, String uri, String params) throws Exception {
+        super(mchId, pipelineId, name, uri, params);
+        this.strategy = new DefaultTimeStrategy();
+    }
+
+    @Override
+    public ScanTimeStrategy getTimeStrategy() {
+        return this.strategy;
+    }
+
+    public void configure(String mchId, String appId, String appSecret, String serialNo, String privateKeyStr,
+                          String wechatSerialNo, String wechatPublicKey, String apiV3KeyStr) {
+        super.configure(mchId, appId, appSecret, serialNo, privateKeyStr, wechatSerialNo, wechatPublicKey, apiV3KeyStr);
+        client = new WechatDirectHttpClient(uri(), wechatConfig);
+    }
+
+    @Override
+    public WechatHttpClient getClient() {
+        AssertUtils.notNull(client, "微信支付通道客户端未配置");
+        return client;
+    }
+}
+package com.diligrp.cashier.pipeline.core;
+
+import com.diligrp.cashier.pipeline.client.WechatHttpClient;
+import com.diligrp.cashier.pipeline.client.WechatPartnerHttpClient;
+import com.diligrp.cashier.shared.util.AssertUtils;
+
+/**
+ * 微信支付通道抽象模型-服务商模式
+ */
+public class WechatPartnerPipeline extends WechatPipeline {
+
+    private final ScanTimeStrategy strategy;
+
+    // 服务商模式下的微信客户端
+    private WechatPartnerHttpClient client;
+
+    public WechatPartnerPipeline(long mchId, long pipelineId, String name, String uri, String params) throws Exception {
+        super(mchId, pipelineId, name, uri, params);
+        this.strategy = new DefaultTimeStrategy();
+    }
+
+    @Override
+    public ScanTimeStrategy getTimeStrategy() {
+        return this.strategy;
+    }
+
+    public void configure(String mchId, String appId, String appSecret, String serialNo, String privateKeyStr,
+                          String publicKeyNo, String publicKeyStr, String apiV3KeyStr) {
+        super.configure(mchId, appId, appSecret, serialNo, privateKeyStr, publicKeyNo, publicKeyStr, apiV3KeyStr);
+        client = new WechatPartnerHttpClient(uri(), wechatConfig);
+    }
+
+    @Override
+    public WechatHttpClient getClient() {
+        AssertUtils.notNull(client, "微信支付通道客户端未配置");
+        return client;
+    }
+}
+package com.diligrp.cashier.pipeline.core;
+
+import com.diligrp.cashier.pipeline.Constants;
+import com.diligrp.cashier.pipeline.client.WechatHttpClient;
+import com.diligrp.cashier.pipeline.domain.*;
+import com.diligrp.cashier.pipeline.domain.wechat.WechatCertificate;
+import com.diligrp.cashier.pipeline.domain.wechat.WechatConfig;
+import com.diligrp.cashier.pipeline.exception.PaymentPipelineException;
+import com.diligrp.cashier.pipeline.type.ChannelType;
+import com.diligrp.cashier.pipeline.util.WechatConstants;
+import com.diligrp.cashier.pipeline.util.WechatSignatureUtils;
+import com.diligrp.cashier.shared.ErrorCode;
+import com.diligrp.cashier.shared.security.RsaCipher;
+import com.diligrp.cashier.shared.util.AssertUtils;
+import com.diligrp.cashier.shared.util.RandomUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.crypto.spec.SecretKeySpec;
+import java.nio.charset.StandardCharsets;
+import java.security.PrivateKey;
+
+/**
+ * 微信支付通道抽象模型
+ */
+public abstract class WechatPipeline extends OnlinePipeline<WechatPipeline.WechatParams> {
+
+    private static final Logger LOG = LoggerFactory.getLogger(WechatPipeline.class);
+
+    // 微信支付通道配置
+    protected WechatConfig wechatConfig;
+
+    public WechatPipeline(long mchId, long pipelineId, String name, String uri, String params) throws Exception {
+        super(mchId, pipelineId, name, uri, params);
+        WechatParams config = params();
+        AssertUtils.notEmpty(config.notifyUri, String.format("微信支付缺少参数配置: notifyBaseUri"));
+    }
+
+    /**
+     * 微信支付通道配置
+     *
+     * @param mchId - 微信商户号
+     * @param appId - 微信小程序ID
+     * @param appSecret - 小程序密钥
+     * @param serialNo - 商户公钥序列号
+     * @param privateKeyStr - BASE64编码的商户私钥
+     * @param wechatSerialNo - 微信平台公钥序列号
+     * @param wechatPublicKey - BASE64编码的微信平台公钥
+     * @param apiV3KeyStr - BASE64编码的apiV3Key
+     */
+    public void configure(String mchId, String appId, String appSecret, String serialNo, String privateKeyStr,
+                          String wechatSerialNo, String wechatPublicKey, String apiV3KeyStr) {
+        checkParam("微信商户号", mchId);
+        checkParam("微信小程序ID", appId);
+        checkParam("小程序密钥", appSecret);
+        checkParam("商户公钥序列号", serialNo);
+        checkParam("商户私钥", privateKeyStr);
+        checkParam("微信平台公钥序列号", wechatSerialNo);
+        checkParam("微信平台公钥", wechatPublicKey);
+        checkParam("微信平台apiV3Key", apiV3KeyStr);
+
+        PrivateKey privateKey;
+        try {
+            privateKey = RsaCipher.getPrivateKey(privateKeyStr);
+        } catch (Exception e) {
+            throw new PaymentPipelineException(ErrorCode.ILLEGAL_ARGUMENT_ERROR, "商户私钥配置错误");
+        }
+
+        byte[] keyBytes = apiV3KeyStr.getBytes(StandardCharsets.UTF_8); // 需32位
+        if (keyBytes.length != WechatConstants.KEY_LENGTH_BYTE) {
+            throw new PaymentPipelineException(ErrorCode.ILLEGAL_ARGUMENT_ERROR, "微信支付平台apiV3Key配置错误");
+        }
+        SecretKeySpec apiV3Key = new SecretKeySpec(keyBytes, WechatConstants.AES_ALGORITHM);
+
+        wechatConfig = new WechatConfig(mchId, appId, appSecret, serialNo, privateKey, apiV3Key);
+        try {
+            wechatConfig.putCertificate(WechatCertificate.of(wechatSerialNo, RsaCipher.getPublicKey(wechatPublicKey)));
+        } catch (Exception ex) {
+            throw new PaymentPipelineException(ErrorCode.ILLEGAL_ARGUMENT_ERROR, "微信支付平台公钥配置错误");
+        }
+    }
+
+    /**
+     * 扫码预支付下单 - 客户扫商户收款码
+     */
+    @Override
+    public NativePrepayResponse sendNativePrepayRequest(NativePrepayRequest request) {
+        try {
+            String notifyUri = String.format(Constants.WECHAT_PAYMENT_NOTIFY_URI, params().notifyUri, request.getPaymentId());
+            return getClient().sendNativePrepayRequest(request, notifyUri);
+        } catch (PaymentPipelineException | IllegalArgumentException pse) {
+            throw pse;
+        } catch (Exception ex) {
+            LOG.error("Send wechat native prepay request exception", ex);
+            throw new PaymentPipelineException(ErrorCode.SYSTEM_UNKNOWN_ERROR, "发起微信预支付失败");
+        }
+    }
+
+    /**
+     * 付款码支付 - 商户扫客户付款码
+     */
+    @Override
+    public OnlinePaymentResponse sendQrCodePaymentRequest(OnlinePaymentRequest request) {
+        return super.sendQrCodePaymentRequest(request);
+    }
+
+    /**
+     * 小程序预支付下单
+     */
+    public MiniProPrepayResponse sendMiniProPrepayRequest(MiniProPrepayRequest request) {
+        try {
+            String notifyUri = String.format(Constants.WECHAT_PAYMENT_NOTIFY_URI, params().notifyUri, request.getPaymentId());
+            String prepayId = getClient().sendMiniProPrepayRequest(request, notifyUri);
+
+            String timeStamp = String.valueOf(System.currentTimeMillis() / 1000);
+            String nonceStr = RandomUtils.randomString(32);
+            String packet = "prepay_id=" + prepayId;
+            String appId = getClient().getWechatConfig().getAppId();
+            String message = String.format("%s\n%s\n%s\n%s\n", appId, timeStamp, nonceStr, packet);
+            String paySign = WechatSignatureUtils.signature(message, getClient().getWechatConfig().getPrivateKey());
+            String signType = WechatConstants.RSA_ALGORITHM;
+            return MiniProPrepayResponse.of(request.getPaymentId(), prepayId, prepayId, timeStamp, nonceStr, signType, paySign);
+        } catch (PaymentPipelineException | IllegalArgumentException pse) {
+            throw pse;
+        } catch (Exception ex) {
+            LOG.error("Send wechat mini pro prepay request exception", ex);
+            throw new PaymentPipelineException(ErrorCode.SYSTEM_UNKNOWN_ERROR, "发起微信预支付失败");
+        }
+    }
+
+    /**
+     * 查询预支付订单状态
+     */
+    public OnlinePaymentResponse queryPrepayResponse(OnlinePrepayOrder order) {
+        try {
+            return getClient().queryPrepayResponse(order);
+        } catch (PaymentPipelineException | IllegalArgumentException pse) {
+            throw pse;
+        } catch (Exception ex) {
+            LOG.error("Query wechat prepay order request exception", ex);
+            throw new PaymentPipelineException(ErrorCode.SYSTEM_UNKNOWN_ERROR, "查询微信支付状态失败");
+        }
+    }
+
+    /**
+     * 关闭预支付订单
+     */
+    public void closePrepayOrder(OnlinePrepayOrder request) {
+        try {
+            getClient().closePrepayOrder(request);
+        } catch (PaymentPipelineException | IllegalArgumentException pse) {
+            throw pse;
+        } catch (Exception ex) {
+            LOG.error("Close wechat prepay order exception", ex);
+            throw new PaymentPipelineException(ErrorCode.SYSTEM_UNKNOWN_ERROR, "关闭微信预支付订单失败");
+        }
+    }
+
+    /**
+     * 退款申请
+     */
+    public OnlineRefundResponse sendRefundRequest(OnlineRefundRequest request) {
+        try {
+            String notifyUri = String.format(Constants.WECHAT_REFUND_NOTIFY_URI, params().notifyUri, request.getRefundId());
+            return getClient().sendRefundRequest(request, notifyUri);
+        } catch (PaymentPipelineException | IllegalArgumentException pse) {
+            throw pse;
+        } catch (Exception ex) {
+            LOG.error("Send wechat refund request exception", ex);
+            throw new PaymentPipelineException(ErrorCode.SYSTEM_UNKNOWN_ERROR, "发起微信退款失败");
+        }
+    }
+
+    /**
+     * 查询退款状态
+     */
+    public OnlineRefundResponse queryRefundResponse(OnlineRefundOrder request) {
+        try {
+            return getClient().queryRefundOrder(request);
+        } catch (PaymentPipelineException | IllegalArgumentException pse) {
+            throw pse;
+        } catch (Exception ex) {
+            LOG.error("Query wechat refund order exception", ex);
+            throw new PaymentPipelineException(ErrorCode.SYSTEM_UNKNOWN_ERROR, "查询微信退款失败");
+        }
+    }
+
+    public abstract WechatHttpClient getClient();
+
+    @Override
+    public ChannelType supportedChannel() {
+        return ChannelType.WXPAY;
+    }
+
+    @Override
+    public Class<WechatParams> paramClass() {
+        return WechatParams.class;
+    }
+
+    public static class WechatParams extends PipelineParams {
+        // 微信支付通知base地址，如: https://gateway.diligrp.com/pay-service
+        private String notifyUri;
+
+        public WechatParams(String params) {
+            super(params);
+        }
+
+        public String getNotifyUri() {
+            return notifyUri;
+        }
+
+        public void setNotifyUri(String notifyUri) {
+            this.notifyUri = notifyUri;
+        }
+    }
+}
+package com.diligrp.cashier.pipeline.dao;
+
+import com.diligrp.cashier.pipeline.model.PaymentPipelineDO;
+import com.diligrp.cashier.pipeline.model.WechatParam;
+import com.diligrp.cashier.shared.mybatis.MybatisMapperSupport;
+import org.springframework.stereotype.Repository;
+
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * 支付通道数据访问层
+ */
+@Repository("paymentPipelineDao")
+public interface IPaymentPipelineDao extends MybatisMapperSupport {
+
+    List<PaymentPipelineDO> listPaymentPipelines();
+
+    Optional<WechatParam> findWechatParam(Long pipelineId);
+}
+package com.diligrp.cashier.pipeline.domain;
+
+import java.time.LocalDateTime;
+
+public class MiniProPrepayRequest extends OnlinePaymentRequest {
+    // 小程序openId
+    private final String openId;
+
+    public MiniProPrepayRequest(String paymentId, long amount, String goods, String description, LocalDateTime when, String openId) {
+        super(paymentId, amount, goods, description, when);
+        this.openId = openId;
+    }
+
+    public String getOpenId() {
+        return openId;
+    }
+}
+package com.diligrp.cashier.pipeline.domain;
+
+/**
+ * 小程序预支付响应
+ */
+public class MiniProPrepayResponse extends OnlinePrepayResponse {
+    // 微信预支付ID
+    protected String prepayId;
+    // 时间戳
+    protected String timeStamp;
+    // 随机字符串
+    protected String nonceStr;
+    // 签名类型
+    protected String signType;
+    // 签名
+    protected String paySign;
+
+    public static MiniProPrepayResponse of(String paymentId, String outTradeNo, String prepayId, String timeStamp,
+                                           String nonceStr, String signType, String paySign) {
+        MiniProPrepayResponse response = new MiniProPrepayResponse();
+        response.paymentId = paymentId;
+        response.outTradeNo = outTradeNo;
+        response.prepayId = prepayId;
+        response.timeStamp = timeStamp;
+        response.nonceStr = nonceStr;
+        response.signType = signType;
+        response.paySign = paySign;
+
+        return response;
+    }
+
+    public String getPrepayId() {
+        return prepayId;
+    }
+
+    public String getTimeStamp() {
+        return timeStamp;
+    }
+
+    public String getNonceStr() {
+        return nonceStr;
+    }
+
+    public String getPacket() {
+        return "prepay_id=" + prepayId;
+    }
+
+    public String getSignType() {
+        return signType;
+    }
+
+    public String getPaySign() {
+        return paySign;
+    }
+}
+package com.diligrp.cashier.pipeline.domain;
+
+import java.time.LocalDateTime;
+
+public class NativePrepayRequest extends OnlinePaymentRequest {
+    public NativePrepayRequest(String paymentId, long amount, String goods, String description, LocalDateTime when) {
+        super(paymentId, amount, goods, description, when);
+    }
+}
+package com.diligrp.cashier.pipeline.domain;
+
+/**
+ * 扫码预支付响应
+ */
+public class NativePrepayResponse extends OnlinePrepayResponse {
+    // 二维码链接
+    protected String codeUri;
+
+    public static NativePrepayResponse of(String paymentId, String outTradeNo, String codeUri) {
+        NativePrepayResponse response = new NativePrepayResponse();
+        response.paymentId = paymentId;
+        response.outTradeNo = outTradeNo;
+        response.codeUri = codeUri;
+        return response;
+    }
+
+    public String getCodeUri() {
+        return codeUri;
+    }
+}
+package com.diligrp.cashier.pipeline.domain;
+
+import com.diligrp.cashier.shared.domain.ContainerSupport;
+
+import java.time.LocalDateTime;
+import java.util.Map;
+
+/**
+ * 预支付申请模型
+ */
+public class OnlinePaymentRequest extends ContainerSupport {
+    // 支付ID
+    protected String paymentId;
+    // 交易金额 - 分
+    protected long amount;
+    // 商品描述
+    protected String goods;
+    // 交易备注
+    protected String description;
+    // 交易时间
+    protected LocalDateTime when;
+
+    public OnlinePaymentRequest(String paymentId, long amount, String goods, String description, LocalDateTime when) {
+        this.paymentId = paymentId;
+        this.amount = amount;
+        this.goods = goods;
+        this.description = description;
+        this.when = when;
+    }
+
+    public String getPaymentId() {
+        return paymentId;
+    }
+
+    public long getAmount() {
+        return amount;
+    }
+
+    public String getGoods() {
+        return goods;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public LocalDateTime getWhen() {
+        return when;
+    }
+
+    public void putParams(Map<String, Object> params) {
+        if (params != null) {
+            putAll(params);
+        }
+    }
+}
+package com.diligrp.cashier.pipeline.domain;
+
+import com.diligrp.cashier.shared.domain.ContainerSupport;
+
+import java.time.LocalDateTime;
+
+/**
+ * 在线支付结果领域模型
+ */
+public class OnlinePaymentResponse extends ContainerSupport {
+    // 支付ID
+    private String paymentId;
+    // 支付通道订单号
+    private String outTradeNo;
+    // 支付方Id - 比如微信OpenId
+    private String payerId;
+    // 支付时间
+    private LocalDateTime when;
+    // 支付状态
+    private Integer state;
+    // 交易备注
+    private String message;
+
+    public static OnlinePaymentResponse of(String paymentId, String outTradeNo, String payerId,
+                                           LocalDateTime when, Integer state, String message) {
+        OnlinePaymentResponse response = new OnlinePaymentResponse();
+        response.paymentId = paymentId;
+        response.outTradeNo = outTradeNo;
+        response.payerId = payerId;
+        response.when = when;
+        response.state = state;
+        response.message = message;
+        return response;
+    }
+
+    public String getPaymentId() {
+        return paymentId;
+    }
+
+    public String getOutTradeNo() {
+        return outTradeNo;
+    }
+
+    public String getPayerId() {
+        return payerId;
+    }
+
+    public LocalDateTime getWhen() {
+        return when;
+    }
+
+    public Integer getState() {
+        return state;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+}
+package com.diligrp.cashier.pipeline.domain;
+
+import com.diligrp.cashier.shared.domain.ContainerSupport;
+
+public class OnlinePrepayOrder extends ContainerSupport {
+    // 支付ID
+    private final String paymentId;
+    // 通道订单号
+    private final String outTradeNo;
+
+    public OnlinePrepayOrder(String paymentId, String outTradeNo) {
+        this.paymentId = paymentId;
+        this.outTradeNo = outTradeNo;
+    }
+
+    public String getPaymentId() {
+        return paymentId;
+    }
+
+    public String getOutTradeNo() {
+        return outTradeNo;
+    }
+}
+package com.diligrp.cashier.pipeline.domain;
+
+/**
+ * 预支付响应
+ */
+public class OnlinePrepayResponse {
+    // 支付订单号
+    protected String paymentId;
+    // 通道订单号
+    protected String outTradeNo;
+
+    public String getPaymentId() {
+        return paymentId;
+    }
+
+    public String getOutTradeNo() {
+        return outTradeNo;
+    }
+}
+package com.diligrp.cashier.pipeline.domain;
+
+import com.diligrp.cashier.shared.domain.ContainerSupport;
+
+public class OnlineRefundOrder extends ContainerSupport {
+    // 退款ID
+    private final String refundId;
+    // 通道订单号
+    private final String outTradeNo;
+
+    public OnlineRefundOrder(String refundId, String outTradeNo) {
+        this.refundId = refundId;
+        this.outTradeNo = outTradeNo;
+    }
+
+    public String getRefundId() {
+        return refundId;
+    }
+
+    public String getOutTradeNo() {
+        return outTradeNo;
+    }
+}
+package com.diligrp.cashier.pipeline.domain;
+
+import com.diligrp.cashier.shared.domain.ContainerSupport;
+
+import java.time.LocalDateTime;
+
+/**
+ * 微信退款领域模型
+ */
+public class OnlineRefundRequest extends ContainerSupport {
+    // 退款单号
+    private String refundId;
+    // 原订单号
+    private String paymentId;
+    // 原通道订单号
+    private String outTradeNo;
+    // 原订单总金额
+    private Long maxAmount;
+    // 退款金额
+    private Long amount;
+    // 交易备注或退款理由
+    private String description;
+    // 交易时间
+    private LocalDateTime when;
+
+    public static OnlineRefundRequest of(String refundId, String paymentId, String outTradeNo, Long maxAmount,
+                                         Long amount, String description, LocalDateTime when) {
+        OnlineRefundRequest request = new OnlineRefundRequest();
+        request.refundId = refundId;
+        request.paymentId = paymentId;
+        request.outTradeNo = outTradeNo;
+        request.maxAmount = maxAmount;
+        request.amount = amount;
+        request.description = description;
+        request.when = when;
+        return request;
+    }
+
+    public String getRefundId() {
+        return refundId;
+    }
+
+    public String getPaymentId() {
+        return paymentId;
+    }
+
+    public String getOutTradeNo() {
+        return outTradeNo;
+    }
+
+    public Long getMaxAmount() {
+        return maxAmount;
+    }
+
+    public Long getAmount() {
+        return amount;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public LocalDateTime getWhen() {
+        return when;
+    }
+}
+package com.diligrp.cashier.pipeline.domain;
+
+import com.diligrp.cashier.shared.domain.ContainerSupport;
+
+import java.time.LocalDateTime;
+
+/**
+ * 退款结果领域模型
+ */
+public class OnlineRefundResponse extends ContainerSupport {
+    // 商户退款单号
+    private String refundId;
+    // 通道退款订单号
+    private String outTradeNo;
+    // 退款完成时间
+    private LocalDateTime when;
+    // 退款状态
+    private Integer state;
+    // 交易备注
+    private String message;
+
+    public static OnlineRefundResponse of(String refundId, String outTradeNo, LocalDateTime when,
+                                          Integer state, String message) {
+        OnlineRefundResponse response = new OnlineRefundResponse();
+        response.refundId = refundId;
+        response.outTradeNo = outTradeNo;
+        response.when = when;
+        response.state = state;
+        response.message = message;
+        return response;
+    }
+
+    public String getRefundId() {
+        return refundId;
+    }
+
+    public String getOutTradeNo() {
+        return outTradeNo;
+    }
+
+    public LocalDateTime getWhen() {
+        return when;
+    }
+
+    public Integer getState() {
+        return state;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+}
+package com.diligrp.cashier.pipeline.domain.card;
+
+/**
+ * 园区卡信息
+ */
+public class UserCardDTO {
+    // 客户ID
+    private Long customerId;
+    // 账号ID
+    private Long accountId;
+    // 卡号
+    private String cardNo;
+    // 持卡人名称
+    private String name;
+
+    public UserCardDTO() {
+    }
+
+    public UserCardDTO(Long accountId, String cardNo) {
+        this.accountId = accountId;
+        this.cardNo = cardNo;
+    }
+
+    public UserCardDTO(Long customerId, Long accountId, String cardNo, String name) {
+        this.customerId = customerId;
+        this.accountId = accountId;
+        this.cardNo = cardNo;
+        this.name = name;
+    }
+
+    public Long getCustomerId() {
+        return customerId;
+    }
+
+    public void setCustomerId(Long customerId) {
+        this.customerId = customerId;
+    }
+
+    public Long getAccountId() {
+        return accountId;
+    }
+
+    public void setAccountId(Long accountId) {
+        this.accountId = accountId;
+    }
+
+    public String getCardNo() {
+        return cardNo;
+    }
+
+    public void setCardNo(String cardNo) {
+        this.cardNo = cardNo;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+}
+package com.diligrp.cashier.pipeline.domain.wechat;
+
+public class AuthorizationSession {
+    // 用户唯一标识
+    private String openid;
+    // 会话密钥
+    private String session_key;
+    // 用户在开放平台的唯一标识
+    private String unionid;
+    // 错误码
+    private Integer errcode;
+    // 错误信息
+    private String errmsg;
+
+    public String getOpenid() {
+        return openid;
+    }
+
+    public void setOpenid(String openid) {
+        this.openid = openid;
+    }
+
+    public String getSession_key() {
+        return session_key;
+    }
+
+    public void setSession_key(String session_key) {
+        this.session_key = session_key;
+    }
+
+    public String getUnionid() {
+        return unionid;
+    }
+
+    public void setUnionid(String unionid) {
+        this.unionid = unionid;
+    }
+
+    public Integer getErrcode() {
+        return errcode;
+    }
+
+    public void setErrcode(Integer errcode) {
+        this.errcode = errcode;
+    }
+
+    public String getErrmsg() {
+        return errmsg;
+    }
+
+    public void setErrmsg(String errmsg) {
+        this.errmsg = errmsg;
+    }
+}
+package com.diligrp.cashier.pipeline.domain.wechat;
+
+import java.util.List;
+
+/**
+ * 微信支付平台证书响应接口模型
+ */
+public class CertificateResponse {
+    // 证书列表
+    private List<Certificate> data;
+
+    public List<Certificate> getData() {
+        return data;
+    }
+
+    public void setData(List<Certificate> data) {
+        this.data = data;
+    }
+
+    public static class Certificate {
+        // 证书序列号
+        private String serial_no;
+        // 证书有效时间
+        private String effective_time;
+        // 证书过期时间
+        private String expire_time;
+        // 证书内容
+        private EncryptCertificate encrypt_certificate;
+
+        public String getSerial_no() {
+            return serial_no;
+        }
+
+        public void setSerial_no(String serial_no) {
+            this.serial_no = serial_no;
+        }
+
+        public String getEffective_time() {
+            return effective_time;
+        }
+
+        public void setEffective_time(String effective_time) {
+            this.effective_time = effective_time;
+        }
+
+        public String getExpire_time() {
+            return expire_time;
+        }
+
+        public void setExpire_time(String expire_time) {
+            this.expire_time = expire_time;
+        }
+
+        public EncryptCertificate getEncrypt_certificate() {
+            return encrypt_certificate;
+        }
+
+        public void setEncrypt_certificate(EncryptCertificate encrypt_certificate) {
+            this.encrypt_certificate = encrypt_certificate;
+        }
+
+        public static class EncryptCertificate {
+            // 证书加密算法
+            private String algorithm;
+            // 随机字符串
+            private String nonce;
+            // 附加数据
+            private String associated_data;
+            // 证书密文
+            private String ciphertext;
+
+            public String getAlgorithm() {
+                return algorithm;
+            }
+
+            public void setAlgorithm(String algorithm) {
+                this.algorithm = algorithm;
+            }
+
+            public String getNonce() {
+                return nonce;
+            }
+
+            public void setNonce(String nonce) {
+                this.nonce = nonce;
+            }
+
+            public String getAssociated_data() {
+                return associated_data;
+            }
+
+            public void setAssociated_data(String associated_data) {
+                this.associated_data = associated_data;
+            }
+
+            public String getCiphertext() {
+                return ciphertext;
+            }
+
+            public void setCiphertext(String ciphertext) {
+                this.ciphertext = ciphertext;
+            }
+        }
+    }
+}
+package com.diligrp.cashier.pipeline.domain.wechat;
+
+/**
+ * 交易结果模型 - 直联模式
+ */
+public class DirectPaymentResponse {
+    // 微信订单号
+    private String transaction_id;
+    // 商户订单号
+    private String out_trade_no;
+    // 交易状态
+    private String trade_state;
+    // 交易状态描述
+    private String trade_state_desc;
+    // 支付完成时间
+    private String success_time;
+    // 支付方
+    private Payer payer;
+
+    public String getTransaction_id() {
+        return transaction_id;
+    }
+
+    public void setTransaction_id(String transaction_id) {
+        this.transaction_id = transaction_id;
+    }
+
+    public String getOut_trade_no() {
+        return out_trade_no;
+    }
+
+    public void setOut_trade_no(String out_trade_no) {
+        this.out_trade_no = out_trade_no;
+    }
+
+    public String getTrade_state() {
+        return trade_state;
+    }
+
+    public void setTrade_state(String trade_state) {
+        this.trade_state = trade_state;
+    }
+
+    public String getTrade_state_desc() {
+        return trade_state_desc;
+    }
+
+    public void setTrade_state_desc(String trade_state_desc) {
+        this.trade_state_desc = trade_state_desc;
+    }
+
+    public String getSuccess_time() {
+        return success_time;
+    }
+
+    public void setSuccess_time(String success_time) {
+        this.success_time = success_time;
+    }
+
+    public Payer getPayer() {
+        return payer;
+    }
+
+    public void setPayer(Payer payer) {
+        this.payer = payer;
+    }
+
+    public static class Payer {
+        // 用户标识OpenId
+        private String openid;
+
+        public String getOpenid() {
+            return openid;
+        }
+
+        public void setOpenid(String openid) {
+            this.openid = openid;
+        }
+    }
+}
+package com.diligrp.cashier.pipeline.domain.wechat;
+
+public class ErrorMessage {
+    private String code;
+
+    private String message;
+
+    public String getCode() {
+        return code;
+    }
+
+    public void setCode(String code) {
+        this.code = code;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+
+    public void setMessage(String message) {
+        this.message = message;
+    }
+}
+package com.diligrp.cashier.pipeline.domain.wechat;
+
+/**
+ * 交易结果模型 - 服务商模式
+ */
+public class PartnerPaymentResponse {
+    // 微信订单号
+    private String transaction_id;
+    // 商户订单号
+    private String out_trade_no;
+    // 交易状态
+    private String trade_state;
+    // 交易状态描述
+    private String trade_state_desc;
+    // 支付完成时间
+    private String success_time;
+    // 支付方
+    private Payer payer;
+
+    public String getTransaction_id() {
+        return transaction_id;
+    }
+
+    public void setTransaction_id(String transaction_id) {
+        this.transaction_id = transaction_id;
+    }
+
+    public String getOut_trade_no() {
+        return out_trade_no;
+    }
+
+    public void setOut_trade_no(String out_trade_no) {
+        this.out_trade_no = out_trade_no;
+    }
+
+    public String getTrade_state() {
+        return trade_state;
+    }
+
+    public void setTrade_state(String trade_state) {
+        this.trade_state = trade_state;
+    }
+
+    public String getTrade_state_desc() {
+        return trade_state_desc;
+    }
+
+    public void setTrade_state_desc(String trade_state_desc) {
+        this.trade_state_desc = trade_state_desc;
+    }
+
+    public String getSuccess_time() {
+        return success_time;
+    }
+
+    public void setSuccess_time(String success_time) {
+        this.success_time = success_time;
+    }
+
+    public Payer getPayer() {
+        return payer;
+    }
+
+    public void setPayer(Payer payer) {
+        this.payer = payer;
+    }
+
+    public static class Payer {
+        // 服务商下用户OpenId
+        private String sp_openid;
+        // 子商户下用户OpenId
+        private String sub_openid;
+
+        public String getSp_openid() {
+            return sp_openid;
+        }
+
+        public void setSp_openid(String sp_openid) {
+            this.sp_openid = sp_openid;
+        }
+
+        public String getSub_openid() {
+            return sub_openid;
+        }
+
+        public void setSub_openid(String sub_openid) {
+            this.sub_openid = sub_openid;
+        }
+    }
+}
+package com.diligrp.cashier.pipeline.domain.wechat;
+
+/**
+ * 退款结果模型
+ */
+public class RefundNotifyResponse {
+    // 微信退款单号
+    private String refund_id;
+    // 商户退款单号
+    private String out_refund_no;
+    // 原支付交易对应的商户订单号
+    private String out_trade_no;
+    // 退款状态 - 退款结果通知返回
+    private String refund_status;
+    // 退款完成时间
+    private String success_time;
+
+    public String getRefund_id() {
+        return refund_id;
+    }
+
+    public void setRefund_id(String refund_id) {
+        this.refund_id = refund_id;
+    }
+
+    public String getOut_refund_no() {
+        return out_refund_no;
+    }
+
+    public void setOut_refund_no(String out_refund_no) {
+        this.out_refund_no = out_refund_no;
+    }
+
+    public String getOut_trade_no() {
+        return out_trade_no;
+    }
+
+    public void setOut_trade_no(String out_trade_no) {
+        this.out_trade_no = out_trade_no;
+    }
+
+    public String getRefund_status() {
+        return refund_status;
+    }
+
+    public void setRefund_status(String refund_status) {
+        this.refund_status = refund_status;
+    }
+
+    public String getSuccess_time() {
+        return success_time;
+    }
+
+    public void setSuccess_time(String success_time) {
+        this.success_time = success_time;
+    }
+}
+package com.diligrp.cashier.pipeline.domain.wechat;
+
+/**
+ * 微信发货申请
+ *
+ * 解决买家微信付款成功，卖家微信商户号无法收到钱，需要去自己的微信后台操作一下【发货】
+ */
+public class UploadShippingRequest {
+    // 微信订单号
+    private String transactionId;
+    // 物流模式
+    private Integer logisticsType;
+    // 商品信息
+    private String goods;
+    // 支付人标识
+    private String openId;
+
+    public static UploadShippingRequest of(String transactionId, Integer logisticsType, String goods, String openId) {
+        UploadShippingRequest request = new UploadShippingRequest();
+        request.transactionId = transactionId;
+        request.logisticsType = logisticsType;
+        request.goods = goods;
+        request.openId = openId;
+        return request;
+    }
+
+    public String getTransactionId() {
+        return transactionId;
+    }
+
+    public Integer getLogisticsType() {
+        return logisticsType;
+    }
+
+    public String getGoods() {
+        return goods;
+    }
+
+    public String getOpenId() {
+        return openId;
+    }
+}
+package com.diligrp.cashier.pipeline.domain.wechat;
+
+/**
+ * 微信小程序接口调用凭证
+ */
+public class WechatAccessToken {
+    // 接口调用凭证
+    private String token;
+    // 凭证有效时间，单位：秒
+    private Integer expiresIn;
+
+    public static WechatAccessToken of(String token, Integer expiresIn) {
+        WechatAccessToken accessToken = new WechatAccessToken();
+        accessToken.token = token;
+        accessToken.expiresIn = expiresIn;
+        return accessToken;
+    }
+
+    public String getToken() {
+        return token;
+    }
+
+    public Integer getExpiresIn() {
+        return expiresIn;
+    }
+}
+package com.diligrp.cashier.pipeline.domain.wechat;
+
+import java.security.PublicKey;
+
+/**
+ * 微信支付平台证书
+ */
+public class WechatCertificate {
+    // 公钥序列号
+    private String serialNo;
+    // 公钥
+    private PublicKey publicKey;
+
+    public static WechatCertificate of(String serialNo, PublicKey publicKey) {
+        WechatCertificate certificate = new WechatCertificate();
+        certificate.serialNo = serialNo;
+        certificate.publicKey = publicKey;
+        return certificate;
+    }
+
+    public String getSerialNo() {
+        return serialNo;
+    }
+
+    public PublicKey getPublicKey() {
+        return publicKey;
+    }
+}
+package com.diligrp.cashier.pipeline.domain.wechat;
+
+import javax.crypto.spec.SecretKeySpec;
+import java.security.PrivateKey;
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * 微信支付直连模式配置
+ */
+public class WechatConfig {
+    // 微信商户号
+    private final String mchId;
+    // 微信AppId
+    private final String appId;
+    // appSecret，用于小程序支付
+    private final String appSecret;
+    // 商户公钥序列号
+    private final String serialNo;
+    // 商户私钥
+    private final PrivateKey privateKey;
+    // 商户ApiV3Key - Base64编码
+    private final SecretKeySpec apiV3Key;
+
+    // 微信支付平台证书 - 当旧证书即将过期时，新老证书将并行使用
+    // https://pay.weixin.qq.com/wiki/doc/apiv3_partner/apis/wechatpay5_1.shtml
+    // https://pay.weixin.qq.com/docs/merchant/apis/platform-certificate/api-v3-get-certificates/get.html
+    private final Map<String, WechatCertificate> certificates = new ConcurrentHashMap<>();
+
+    /**
+     * 微信支付通道配置
+     *
+     * @param mchId - 微信商户号
+     * @param appId - 微信小程序ID
+     * @param appSecret - 小程序密钥
+     * @param serialNo - 商户公钥号
+     * @param privateKey - 商户私钥
+     * @param apiV3Key - 微信apiV3Key
+     */
+    public WechatConfig(String mchId, String appId, String appSecret, String serialNo, PrivateKey privateKey, SecretKeySpec apiV3Key) {
+        this.mchId = mchId;
+        this.appId = appId;
+        this.appSecret = appSecret;
+        this.serialNo = serialNo;
+        this.privateKey = privateKey;
+        this.apiV3Key = apiV3Key;
+    }
+
+    public String getMchId() {
+        return mchId;
+    }
+
+    public String getAppId() {
+        return appId;
+    }
+
+    public String getAppSecret() {
+        return appSecret;
+    }
+
+    public String getSerialNo() {
+        return serialNo;
+    }
+
+    public PrivateKey getPrivateKey() {
+        return privateKey;
+    }
+
+    public SecretKeySpec getApiV3Key() {
+        return apiV3Key;
+    }
+
+    public void putCertificate(WechatCertificate certificate) {
+        if (certificate != null) {
+            certificates.put(certificate.getSerialNo(), certificate);
+        }
+    }
+
+    public Optional<WechatCertificate> getCertificate(String serialNo) {
+        return Optional.ofNullable(certificates.get(serialNo));
+    }
+}
+package com.diligrp.cashier.pipeline.domain.wechat;
+
+/**
+ * 微信支付结果通知模型
+ */
+public class WechatNotifyResponse {
+    // 通知ID
+    private String id;
+    // 通知类型
+    private String event_type;
+    // 通知数据类型
+    private String resource_type;
+    // 通知数据
+    private Resource resource;
+
+    public String getId() {
+        return id;
+    }
+
+    public void setId(String id) {
+        this.id = id;
+    }
+
+    public String getEvent_type() {
+        return event_type;
+    }
+
+    public void setEvent_type(String event_type) {
+        this.event_type = event_type;
+    }
+
+    public String getResource_type() {
+        return resource_type;
+    }
+
+    public void setResource_type(String resource_type) {
+        this.resource_type = resource_type;
+    }
+
+    public Resource getResource() {
+        return resource;
+    }
+
+    public void setResource(Resource resource) {
+        this.resource = resource;
+    }
+
+    public static class Resource {
+        // 加密算法类型 - AEAD_AES_256_GCM
+        private String algorithm;
+        // 数据密文
+        private String ciphertext;
+        // 附加数据
+        private String associated_data;
+        // 原始类型
+        private String original_type;
+        // 随机串
+        private String nonce;
+
+        public String getAlgorithm() {
+            return algorithm;
+        }
+
+        public void setAlgorithm(String algorithm) {
+            this.algorithm = algorithm;
+        }
+
+        public String getCiphertext() {
+            return ciphertext;
+        }
+
+        public void setCiphertext(String ciphertext) {
+            this.ciphertext = ciphertext;
+        }
+
+        public String getAssociated_data() {
+            return associated_data;
+        }
+
+        public void setAssociated_data(String associated_data) {
+            this.associated_data = associated_data;
+        }
+
+        public String getOriginal_type() {
+            return original_type;
+        }
+
+        public void setOriginal_type(String original_type) {
+            this.original_type = original_type;
+        }
+
+        public String getNonce() {
+            return nonce;
+        }
+
+        public void setNonce(String nonce) {
+            this.nonce = nonce;
+        }
+    }
+}
+package com.diligrp.cashier.pipeline.exception;
+
+import com.diligrp.cashier.shared.exception.PlatformServiceException;
+
+public class PaymentPipelineException extends PlatformServiceException {
+
+    public PaymentPipelineException(String message) {
+        super(message);
+    }
+
+    public PaymentPipelineException(String code, String message) {
+        super(code, message);
+    }
+
+    public PaymentPipelineException(String message, Throwable ex) {
+        super(message, ex);
+    }
+}
+package com.diligrp.cashier.pipeline.model;
+
+import com.diligrp.cashier.shared.domain.BaseDO;
+
+public class PaymentPipelineDO extends BaseDO {
+    // 商户ID
+    private Long mchId;
+    // 通道ID
+    private Long pipelineId;
+    // 支付渠道
+    private Integer channelId;
+    // 通道类型
+    private Integer type;
+    // 通道名称
+    private String name;
+    // 通道uri
+    private String uri;
+    // 通道参数
+    private String param;
+    // 通道状态
+    private Integer state;
+
+    public Long getMchId() {
+        return mchId;
+    }
+
+    public void setMchId(Long mchId) {
+        this.mchId = mchId;
+    }
+
+    public Long getPipelineId() {
+        return pipelineId;
+    }
+
+    public void setPipelineId(Long pipelineId) {
+        this.pipelineId = pipelineId;
+    }
+
+    public Integer getChannelId() {
+        return channelId;
+    }
+
+    public void setChannelId(Integer channelId) {
+        this.channelId = channelId;
+    }
+
+    public Integer getType() {
+        return type;
+    }
+
+    public void setType(Integer type) {
+        this.type = type;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getUri() {
+        return uri;
+    }
+
+    public void setUri(String uri) {
+        this.uri = uri;
+    }
+
+    public String getParam() {
+        return param;
+    }
+
+    public void setParam(String param) {
+        this.param = param;
+    }
+
+    public Integer getState() {
+        return state;
+    }
+
+    public void setState(Integer state) {
+        this.state = state;
+    }
+}
+package com.diligrp.cashier.pipeline.model;
+
+import com.diligrp.cashier.shared.domain.BaseDO;
+
+public class WechatParam extends BaseDO {
+    // 通道ID
+    private Long pipelineId;
+    // 商户号, 服务商模式下为服务商商户号
+    private String mchId;
+    // 小程序ID
+    private String appId;
+    // 小程序密钥
+    private String appSecret;
+    // 商户公钥序列号
+    private String serialNo;
+    // 商户私钥
+    private String privateKey;
+    // 微信公钥序列号
+    private String wechatSerialNo;
+    // 微信公钥
+    private String wechatPublicKey;
+    // 微信apiV3Key
+    private String apiV3Key;
+    // 通道类型: 直连通道或服务商通道
+    private Integer type;
+
+    public Long getPipelineId() {
+        return pipelineId;
+    }
+
+    public void setPipelineId(Long pipelineId) {
+        this.pipelineId = pipelineId;
+    }
+
+    public String getMchId() {
+        return mchId;
+    }
+
+    public void setMchId(String mchId) {
+        this.mchId = mchId;
+    }
+
+    public String getAppId() {
+        return appId;
+    }
+
+    public void setAppId(String appId) {
+        this.appId = appId;
+    }
+
+    public String getAppSecret() {
+        return appSecret;
+    }
+
+    public void setAppSecret(String appSecret) {
+        this.appSecret = appSecret;
+    }
+
+    public String getSerialNo() {
+        return serialNo;
+    }
+
+    public void setSerialNo(String serialNo) {
+        this.serialNo = serialNo;
+    }
+
+    public String getPrivateKey() {
+        return privateKey;
+    }
+
+    public void setPrivateKey(String privateKey) {
+        this.privateKey = privateKey;
+    }
+
+    public String getWechatSerialNo() {
+        return wechatSerialNo;
+    }
+
+    public void setWechatSerialNo(String wechatSerialNo) {
+        this.wechatSerialNo = wechatSerialNo;
+    }
+
+    public String getWechatPublicKey() {
+        return wechatPublicKey;
+    }
+
+    public void setWechatPublicKey(String wechatPublicKey) {
+        this.wechatPublicKey = wechatPublicKey;
+    }
+
+    public String getApiV3Key() {
+        return apiV3Key;
+    }
+
+    public void setApiV3Key(String apiV3Key) {
+        this.apiV3Key = apiV3Key;
+    }
+
+    public Integer getType() {
+        return type;
+    }
+
+    public void setType(Integer type) {
+        this.type = type;
+    }
+}
+package com.diligrp.cashier.pipeline.service;
+
+import com.diligrp.cashier.pipeline.core.PaymentPipeline;
+import com.diligrp.cashier.pipeline.type.ChannelType;
+
+import java.util.List;
+
+/**
+ * 支付通道管理器接口
+ */
+public interface IPaymentPipelineManager {
+    /**
+     * 注册支付通道
+     */
+    <T extends PaymentPipeline<?>> void registerPaymentPipeline(T pipeline);
+
+    /**
+     * 获取商户配置的指定类型的支付通道
+     */
+    <T extends PaymentPipeline<?>> T findPipelineByMchId(long mchId, Class<T> type);
+
+    /**
+     * 获取商户配置的指定类型的支付通道
+     */
+    <T extends PaymentPipeline<?>> T findPipelineByMchId(long mchId, ChannelType channel, Class<T> type);
+
+    /**
+     * 获取商户配置的指定类型的支付通道
+     */
+    <T extends PaymentPipeline<?>> List<T> listPipelines(long mchId, Class<T> type);
+
+    /**
+     * 根据ID获取支付通道
+     */
+    <T extends PaymentPipeline<?>> T findPipelineById(long pipelineId, Class<T> type);
+}
+package com.diligrp.cashier.pipeline.service.impl;
+
+import com.diligrp.cashier.pipeline.core.*;
+import com.diligrp.cashier.pipeline.dao.IPaymentPipelineDao;
+import com.diligrp.cashier.pipeline.exception.PaymentPipelineException;
+import com.diligrp.cashier.pipeline.model.PaymentPipelineDO;
+import com.diligrp.cashier.pipeline.model.WechatParam;
+import com.diligrp.cashier.pipeline.service.IPaymentPipelineManager;
+import com.diligrp.cashier.pipeline.type.ChannelType;
+import com.diligrp.cashier.pipeline.type.WechatPipelineType;
+import com.diligrp.cashier.shared.ErrorCode;
+import com.diligrp.cashier.shared.service.LifeCycle;
+import jakarta.annotation.Resource;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Component;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+@Component("paymentPipelineManager")
+public class PaymentPipelineManagerImpl extends LifeCycle implements IPaymentPipelineManager {
+
+    private static final Logger LOG = LoggerFactory.getLogger(PaymentPipelineManagerImpl.class);
+
+    private final Map<Long, IPipeline<?>> pipelines = new HashMap<>();
+
+    @Resource
+    private IPaymentPipelineDao paymentPipelineDao;
+
+    protected void doStart() throws Exception {
+        List<PaymentPipelineDO> pipelines = paymentPipelineDao.listPaymentPipelines();
+        for (PaymentPipelineDO pipeline : pipelines) {
+            if (ChannelType.WXPAY.equalTo(pipeline.getChannelId())) {
+                Optional<WechatParam> paramOpt = paymentPipelineDao.findWechatParam(pipeline.getPipelineId());
+                if (paramOpt.isPresent()) {
+                    WechatParam param = paramOpt.get();
+                    if (WechatPipelineType.DIRECT.equalTo(param.getType())) {
+                        WechatPipeline paymentPipeline = new WechatDirectPipeline(pipeline.getMchId(), pipeline.getPipelineId(),
+                            pipeline.getName(), pipeline.getUri(), pipeline.getParam());
+                        paymentPipeline.configure(param.getMchId(), param.getAppId(), param.getAppSecret(), param.getSerialNo(),
+                            param.getPrivateKey(), param.getWechatSerialNo(), param.getWechatPublicKey(), param.getApiV3Key());
+                        registerPaymentPipeline(paymentPipeline);
+                    } else if (WechatPipelineType.PARTNER.equalTo(param.getType())) {
+                        WechatPipeline paymentPipeline = new WechatPartnerPipeline(pipeline.getMchId(), pipeline.getPipelineId(),
+                            pipeline.getName(), pipeline.getUri(), pipeline.getParam());
+                        paymentPipeline.configure(param.getMchId(), param.getAppId(), param.getAppSecret(), param.getSerialNo(),
+                            param.getPrivateKey(), param.getWechatSerialNo(), param.getWechatPublicKey(), param.getApiV3Key());
+                        registerPaymentPipeline(paymentPipeline);
+                    } else {
+                        LOG.warn("Ignore wechat payment pipeline: {}, because of invalid wechat pipeline type", pipeline.getName());
+                    }
+                } else {
+                    LOG.warn("Ignore wechat payment pipeline: {}, since wechat params not found", pipeline.getName());
+                }
+            } else if (ChannelType.DILIPAY.equalTo(pipeline.getChannelId())) { // 地利园区卡支付通道
+                DiliCardPipeline paymentPipeline = new DiliCardPipeline(pipeline.getMchId(), pipeline.getPipelineId(),
+                    pipeline.getName(), pipeline.getUri(), pipeline.getParam());
+                registerPaymentPipeline(paymentPipeline);
+            } else {
+                LOG.warn("Ignore payment pipeline configuration: {}", pipeline.getName());
+            }
+        }
+    }
+
+    @Override
+    public <T extends PaymentPipeline<?>> void registerPaymentPipeline(T pipeline) {
+        pipelines.put(pipeline.pipelineId(), pipeline);
+        LOG.info("{} payment pipeline registered", pipeline.name());
+    }
+
+    @Override
+    public <T extends PaymentPipeline<?>> T findPipelineByMchId(long mchId, Class<T> type) {
+        List<T> allPipelines = pipelines.values().stream().filter(p -> p.mchId() == mchId)
+            .filter(p -> type.isAssignableFrom(p.getClass())).map(type::cast).toList();
+        if (allPipelines.isEmpty()) {
+            throw new PaymentPipelineException(ErrorCode.OBJECT_NOT_FOUND, "该商户未配置此支付通道");
+        }
+        if (allPipelines.size() > 1) {
+            throw new PaymentPipelineException(ErrorCode.OBJECT_NOT_FOUND, "该商户未配置支付路由");
+        }
+        return allPipelines.get(0);
+    }
+
+    @Override
+    public <T extends PaymentPipeline<?>> T findPipelineByMchId(long mchId, ChannelType channel, Class<T> type) {
+        List<T> allPipelines = pipelines.values().stream().filter(p -> p.mchId() == mchId && p.supportedChannel() == channel)
+            .filter(p -> type.isAssignableFrom(p.getClass())).map(type::cast).toList();
+        if (allPipelines.isEmpty()) {
+            throw new PaymentPipelineException(ErrorCode.OBJECT_NOT_FOUND, "该商户未配置此支付通道");
+        }
+        if (allPipelines.size() > 1) {
+            throw new PaymentPipelineException(ErrorCode.OBJECT_NOT_FOUND, "该商户未配置支付路由");
+        }
+        return allPipelines.get(0);
+    }
+
+    @Override
+    public <T extends PaymentPipeline<?>> List<T> listPipelines(long mchId, Class<T> type) {
+        return pipelines.values().stream().filter(p -> p.mchId() == mchId)
+            .filter(p -> type.isAssignableFrom(p.getClass())).map(type::cast).collect(Collectors.toList());
+    }
+
+    @Override
+    public <T extends PaymentPipeline<?>> T findPipelineById(long pipelineId, Class<T> type) {
+        return pipelines.values().stream().filter(p -> p.pipelineId() == pipelineId && type.isAssignableFrom(p.getClass()))
+            .map(type::cast).findAny().orElseThrow(() -> new PaymentPipelineException(ErrorCode.OBJECT_NOT_FOUND, "系统不支持该支付通道"));
+    }
+}
+package com.diligrp.cashier.pipeline.type;
+
+import com.diligrp.cashier.pipeline.exception.PaymentPipelineException;
+import com.diligrp.cashier.shared.ErrorCode;
+import com.diligrp.cashier.shared.type.IEnumType;
+
+import java.util.Arrays;
+import java.util.Map;
+import java.util.Optional;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+/**
+ * 支持的渠道
+ */
+public enum ChannelType implements IEnumType {
+
+    NOP("未知渠道", 0),
+
+    WXPAY("微信渠道", 10),
+
+    ALIPAY("支付宝渠道", 11),
+
+    DILIPAY("地利渠道", 18), // 地利园区卡支付
+
+    ICBC("工商银行", 20),
+
+    ABC("农业银行", 21),
+
+    BOC("中国银行", 22),
+
+    CCB("建设银行", 23),
+
+    BCM("交通银行", 24),
+
+    CITIC("中信银行", 25),
+
+    CMB("招商银行", 27),
+
+    SJBANK("盛京银行", 28),
+
+    RCB("农商银行", 29),
+
+    HZBANK("杭州银行", 30);
+
+    private final String name;
+    private final int code;
+
+    ChannelType(String name, int code) {
+        this.name = name;
+        this.code = code;
+    }
+
+    public boolean equalTo(int code) {
+        return this.code == code;
+    }
+
+    public static Optional<ChannelType> getType(int code) {
+        Stream<ChannelType> TYPES = Arrays.stream(ChannelType.values());
+        return TYPES.filter(type -> type.getCode() == code).findFirst();
+    }
+
+    public static ChannelType getByCode(int code) {
+        return getType(code).orElseThrow(() -> new PaymentPipelineException(ErrorCode.ILLEGAL_ARGUMENT_ERROR, "系统不支持此支付渠道"));
+    }
+
+    public static String getName(int code) {
+        return getType(code).map(ChannelType::getName).orElse(null);
+    }
+
+    public static Optional<ChannelType> getBankChannel(String bankCode) {
+        Stream<ChannelType> TYPES = Arrays.stream(ChannelType.values());
+        return TYPES.filter(type -> type.name().equalsIgnoreCase(bankCode)).findFirst();
+    }
+
+    public static Map<Integer, String> getTypeNameMap() {
+        return Arrays.stream(ChannelType.values()).collect(Collectors.toMap(ChannelType::getCode, ChannelType::getName));
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public int getCode() {
+        return code;
+    }
+
+    @Override
+    public String toString() {
+        return name;
+    }
+}
+package com.diligrp.cashier.pipeline.type;
+
+import com.diligrp.cashier.shared.type.IEnumType;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+/**
+ * 支付状态列表
+ */
+public enum PaymentState implements IEnumType {
+
+    PENDING("待支付", 1),
+
+    PROCESSING("支付中", 2),
+
+    SUCCESS("支付成功", 4),
+
+    FAILED("支付失败", 6);
+
+    private final String name;
+    private final int code;
+
+    PaymentState(String name, int code) {
+        this.name = name;
+        this.code = code;
+    }
+
+    public boolean equalTo(int code) {
+        return this.code == code;
+    }
+
+    public static Optional<PaymentState> getState(int code) {
+        Stream<PaymentState> STATES = Arrays.stream(PaymentState.values());
+        return STATES.filter(state -> state.getCode() == code).findFirst();
+    }
+
+    public static String getName(int code) {
+        return getState(code).map(PaymentState::getName).orElse(null);
+    }
+
+    public static List<PaymentState> getStates() {
+        return Arrays.asList(PaymentState.values());
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public int getCode() {
+        return code;
+    }
+
+    @Override
+    public String toString() {
+        return name;
+    }
+}
+package com.diligrp.cashier.pipeline.type;
+
+import com.diligrp.cashier.shared.type.IEnumType;
+
+import java.util.Arrays;
+import java.util.Map;
+import java.util.Optional;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+/**
+ * 支持的支付通道
+ */
+public enum PipelineType implements IEnumType {
+    DIRECT_BANK("银企直连通道", 1),
+
+    ONLINE_BANK("聚合支付通道", 2),
+
+    WECHAT_PAY("微信支付通道", 10),
+
+    ALI_PAY("支付宝通道", 11);
+
+    private final String name;
+    private final int code;
+
+    PipelineType(String name, int code) {
+        this.name = name;
+        this.code = code;
+    }
+
+    public boolean equalTo(int code) {
+        return this.code == code;
+    }
+
+    public static Optional<PipelineType> getType(int code) {
+        Stream<PipelineType> TYPES = Arrays.stream(PipelineType.values());
+        return TYPES.filter(type -> type.getCode() == code).findFirst();
+    }
+
+    public static String getName(int code) {
+        return getType(code).map(PipelineType::getName).orElse(null);
+    }
+
+    public static Map<Integer, String> getTypeNameMap() {
+        return Arrays.stream(PipelineType.values()).collect(Collectors.toMap(PipelineType::getCode, PipelineType::getName));
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public int getCode() {
+        return code;
+    }
+
+    @Override
+    public String toString() {
+        return name;
+    }
+}
+package com.diligrp.cashier.pipeline.type;
+
+import com.diligrp.cashier.shared.type.IEnumType;
+
+import java.util.Arrays;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+/**
+ * 微信支付通道类型
+ */
+public enum WechatPipelineType implements IEnumType {
+    DIRECT("直连通道", 1),
+
+    PARTNER("服务商通道", 2);
+
+    private final String name;
+    private final int code;
+
+    WechatPipelineType(String name, int code) {
+        this.name = name;
+        this.code = code;
+    }
+
+    public boolean equalTo(int code) {
+        return this.code == code;
+    }
+
+    public static Optional<WechatPipelineType> getType(int code) {
+        Stream<WechatPipelineType> TYPES = Arrays.stream(WechatPipelineType.values());
+        return TYPES.filter(type -> type.getCode() == code).findFirst();
+    }
+
+    public static String getName(int code) {
+        return getType(code).map(WechatPipelineType::getName).orElse(null);
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public int getCode() {
+        return code;
+    }
+
+    @Override
+    public String toString() {
+        return name;
+    }
+}
+package com.diligrp.cashier.pipeline.util;
+
+/**
+ * 微信支付平台常量列表
+ */
+public class WechatConstants {
+    // 签名算法 - 请求时签名使用
+    public static final String SIGN_ALGORITHM = "SHA256WithRSA";
+    // 密钥算法 - 请求时签名使用
+    public static final String RSA_ALGORITHM = "RSA";
+    // 加密算法 - 证书和回调报文解密使用
+    public static final String AES_ALGORITHM = "AES";
+    // 加密算法 - 证书和回调报文解密使用
+    public static final String AESGCM_ALGORITHM = "AES/GCM/NoPadding";
+    // 密钥长度 - 证书和回调报文解密使用
+    public static final int KEY_LENGTH_BYTE = 32;
+    public static final int TAG_LENGTH_BIT = 128;
+
+    // HTTP常量
+    public static final String HTTP_GET = "GET";
+    public static final String HTTP_POST = "POST";
+
+    // 微信平台HTTP请求常量
+    public static final String HEADER_USER_AGENT = "User-Agent";
+    public static final String USER_AGENT = "DiliPay-HttpClient/2.4.0 Java/11.0.6";
+    public static final String HEADER_AUTHORIZATION = "Authorization";
+    public static final String HEADER_ACCEPT = "Accept";
+    public static final String ACCEPT_JSON = "application/json";
+
+    // 微信平台HTTP响应常量
+    public static final String HEADER_TIMESTAMP = "Wechatpay-Timestamp";
+    public static final String HEADER_NONCE = "Wechatpay-Nonce";
+    public static final String HEADER_SERIAL_NO = "Wechatpay-Serial";
+    public static final String HEADER_SIGNATURE = "Wechatpay-Signature";
+
+    public static String RFC3339_FORMAT = "yyyy-MM-dd'T'HH:mm:ss+08:00";
+    public static String NOTIFY_EVENT_TYPE = "TRANSACTION.SUCCESS";
+    public static String REFUND_EVENT_TYPE = "REFUND.SUCCESS";
+
+    // 支付状态常量列表
+    public static final String STATE_SUCCESS = "SUCCESS"; // 支付成功
+    public static final String STATE_REFUND = "REFUND"; // 转入退款
+    public static final String STATE_NOTPAY = "NOTPAY"; // 未支付
+    public static final String STATE_CLOSED = "CLOSED"; // 已关闭
+    public static final String STATE_REVOKED = "REVOKED"; // 已撤销（付款码支付）
+    public static final String STATE_USERPAYING = "USERPAYING"; // 用户支付中（付款码支付）
+    public static final String STATE_PAYERROR = "PAYERROR"; // 支付失败(其他原因，如银行返回失败)
+
+    // 退款状态常量列表
+    public static final String REFUND_SUCCESS = "SUCCESS"; // 退款成功
+    public static final String REFUND_CLOSED = "CLOSED"; // 退款关闭
+    public static final String REFUND_PROCESSING = "PROCESSING"; // 退款处理中
+    public static final String REFUND_ABNORMAL = "ABNORMAL"; // 退款异常
+
+    // 预支付订单有效期持续时间，超过这个时间将不能支付
+    public static final int PAY_DURATION_MINS = 8;
+}
+package com.diligrp.cashier.pipeline.util;
+
+import com.diligrp.cashier.shared.util.ObjectUtils;
+import com.diligrp.cashier.shared.util.RandomUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.crypto.Cipher;
+import javax.crypto.spec.GCMParameterSpec;
+import javax.crypto.spec.SecretKeySpec;
+import java.nio.charset.StandardCharsets;
+import java.security.PrivateKey;
+import java.security.PublicKey;
+import java.security.Signature;
+import java.util.Base64;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+/**
+ * 微信签名验签工具类
+ */
+public class WechatSignatureUtils {
+
+    private static final Logger LOG = LoggerFactory.getLogger(WechatSignatureUtils.class);
+
+    // 常用字符常量
+    private static String EMPTY_STR = "";
+    private static String ENTER_STR = "\n";
+    // 微信认证类型 - 请求时使用
+    private static final String TOKEN_FORMAT = "WECHATPAY2-SHA256-RSA2048 mchid=\"%s\",nonce_str=\"%s\",timestamp=\"%s\",serial_no=\"%s\",signature=\"%s\"";
+
+    /**
+     * 获取微信支付的认证信息和签名信息
+     *
+     * @param mchId - 服务商商户号
+     * @param method - 请求方法: GET/POST/PUT/**
+     * @param uri - 请求URL
+     * @param payload - POST请求消息体
+     * @param privateKey - Base64编码的私钥
+     * @param keySerialNo - 商户API证书(公钥)序列号
+     * @return 认证信息和签名信息，通过Http Header传输，格式 Authorization: 认证类型 签名信息
+     * @throws Exception 签名异常
+     */
+    public static String authorization(String mchId, String method, String uri, String payload,
+        PrivateKey privateKey, String keySerialNo) throws Exception {
+        String nonce = RandomUtils.randomString(32);
+        String timestamp = String.valueOf(System.currentTimeMillis() / 1000);
+        // No need handle uri here, the caller ensure the normal and valid URL
+        // URL url = new URL("https://www.diligrp.com/ddd?aaa=x"); url.getPath() = /ddd url.getQuery() = "aa=x"
+        String message = Stream.of(method, uri, timestamp, nonce, payload).map(o -> o == null ? EMPTY_STR : o)
+            .collect(Collectors.joining(ENTER_STR, EMPTY_STR, ENTER_STR));
+        LOG.debug("\n---Wechat Platform Sign Param---\n{}\n--------------------------------", message);
+        String signature = signature(message, privateKey);
+        return String.format(TOKEN_FORMAT, mchId, nonce, timestamp, keySerialNo, signature);
+    }
+
+    /**
+     * @see WechatSignatureUtils#authorization(String, String, String, String, PrivateKey, String)
+     */
+    public static String authorization(String mchId, String method, String uri, PrivateKey privateKey,
+        String keySerialNo) throws Exception {
+        return authorization(mchId, method, uri, null, privateKey, keySerialNo);
+    }
+
+    /**
+     * 微信支付签名
+     *
+     * @param message - 被签名字符串
+     * @param privateKey - 服务商私钥
+     * @return 签名数据
+     * @throws Exception 签名异常
+     */
+    public static String signature(String message, PrivateKey privateKey) throws Exception {
+        byte[] packet = message.getBytes(StandardCharsets.UTF_8);
+        Signature signature = Signature.getInstance(WechatConstants.SIGN_ALGORITHM);
+        signature.initSign(privateKey);
+        signature.update(packet);
+        return Base64.getEncoder().encodeToString(signature.sign());
+    }
+
+    /**
+     * 微信支付数据验签
+     *
+     * @param payload - POST请求消息体
+     * @param timestamp - 时间戳
+     * @param nonce - 随机字符串
+     * @param sign - 签名数据
+     * @param publicKey - 微信支付平台公钥
+     * @return 是否验签成功
+     * @throws Exception 验签异常
+     */
+    public static boolean verify(String payload, String timestamp, String nonce, String sign, PublicKey publicKey) throws Exception {
+        byte[] signBytes = Base64.getDecoder().decode(sign);
+        StringBuilder message = new StringBuilder();
+        message.append(timestamp).append("\n").append(nonce).append("\n").append(payload).append("\n");
+        byte[] packet = message.toString().getBytes(StandardCharsets.UTF_8);
+
+        Signature signature = Signature.getInstance(WechatConstants.SIGN_ALGORITHM);
+        signature.initVerify(publicKey);
+        signature.update(packet);
+        return signature.verify(signBytes);
+    }
+
+    /**
+     * 报文解密, 证书和微信回调时使用
+     *
+     * @param payload - Base64编码的待解密的消息
+     * @param nonce - 解密使用随机字符串
+     * @param extraData - 解密使用的附加数据包, 可为空
+     * @param apiV3Key - 微信平台apiV3Key
+     * @return 消息明文
+     * @throws Exception 解密异常
+     */
+    public static String decrypt(String payload, String nonce, String extraData, SecretKeySpec apiV3Key) throws Exception {
+        byte[] packet = Base64.getDecoder().decode(payload);
+        byte[] nonceBytes = nonce.getBytes(StandardCharsets.UTF_8);
+
+        Cipher cipher = Cipher.getInstance(WechatConstants.AESGCM_ALGORITHM);
+        GCMParameterSpec spec = new GCMParameterSpec(WechatConstants.TAG_LENGTH_BIT, nonceBytes);
+        cipher.init(Cipher.DECRYPT_MODE, apiV3Key, spec);
+        if (ObjectUtils.isNotEmpty(extraData)) {
+            cipher.updateAAD(extraData.getBytes(StandardCharsets.UTF_8));
+        }
+
+        return new String(cipher.doFinal(packet), StandardCharsets.UTF_8);
+    }
+}
+package com.diligrp.cashier.pipeline.util;
+
+import com.diligrp.cashier.pipeline.exception.PaymentPipelineException;
+import com.diligrp.cashier.pipeline.type.PaymentState;
+import com.diligrp.cashier.shared.ErrorCode;
+
+public final class WechatStateUtils {
+    public static PaymentState getPaymentState(String wechatState) {
+        PaymentState state = switch (wechatState) {
+            // 转入退款WechatConstants.STATE_REFUND也认为是支付成功，只有支付成功的才会转入STATE_REFUND状态
+            // 目前支付系统发生退款时，不会修改原来支付记录upay_trade_payment，只会修改upay_trade_order
+            case WechatConstants.STATE_SUCCESS, WechatConstants.STATE_REFUND -> PaymentState.SUCCESS;
+            case WechatConstants.STATE_NOTPAY -> PaymentState.PENDING;
+            case WechatConstants.STATE_USERPAYING -> PaymentState.PROCESSING;
+            case WechatConstants.STATE_CLOSED, WechatConstants.STATE_REVOKED, WechatConstants.STATE_PAYERROR -> PaymentState.FAILED;
+            default ->
+                throw new PaymentPipelineException(ErrorCode.INVALID_OBJECT_STATE, "未知的微信支付状态: " + wechatState);
+        };
+        return state;
+    }
+
+    public static boolean isPendingState(String wechatState) {
+        return switch (wechatState) {
+            case WechatConstants.STATE_NOTPAY, WechatConstants.STATE_USERPAYING -> true;
+            default -> false;
+        };
+    }
+
+    public static PaymentState getRefundState(String wechatState) {
+        return switch (wechatState) {
+            // 目前支付系统发生退款时，不会修改原来支付记录upay_trade_payment，只会修改upay_trade_order
+            case WechatConstants.REFUND_SUCCESS -> PaymentState.SUCCESS;
+            case WechatConstants.REFUND_PROCESSING -> PaymentState.PROCESSING;
+            case WechatConstants.REFUND_CLOSED, WechatConstants.REFUND_ABNORMAL -> PaymentState.FAILED;
+            default ->
+                throw new PaymentPipelineException(ErrorCode.INVALID_OBJECT_STATE, "未知的微信退款状态: " + wechatState);
+        };
+    }
+}
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+
+<mapper namespace="com.diligrp.cashier.pipeline.dao.IPaymentPipelineDao">
+    <resultMap id="PaymentPipelineMap" type="com.diligrp.cashier.pipeline.model.PaymentPipelineDO">
+        <id column="id" property="id"/>
+        <result column="mch_id" property="mchId"/>
+        <result column="pipeline_id" property="pipelineId"/>
+        <result column="channel_id" property="channelId"/>
+        <result column="type" property="type"/>
+        <result column="name" property="name"/>
+        <result column="uri" property="uri"/>
+        <result column="param" property="param"/>
+        <result column="state" property="state"/>
+        <result column="created_time" property="createdTime"/>
+        <result column="modified_time" property="modifiedTime"/>
+    </resultMap>
+
+    <resultMap id="WechatParamMap" type="com.diligrp.cashier.pipeline.model.WechatParam">
+        <id column="id" property="id"/>
+        <result column="pipeline_id" property="pipelineId"/>
+        <result column="mch_id" property="mchId"/>
+        <result column="app_id" property="appId"/>
+        <result column="app_secret" property="appSecret"/>
+        <result column="serial_no" property="serialNo"/>
+        <result column="private_key" property="privateKey"/>
+        <result column="wechat_serial_no" property="wechatSerialNo"/>
+        <result column="wechat_public_key" property="wechatPublicKey"/>
+        <result column="api_v3_key" property="apiV3Key"/>
+        <result column="type" property="type"/>
+        <result column="created_time" property="createdTime"/>
+    </resultMap>
+
+    <select id="listPaymentPipelines" resultMap="PaymentPipelineMap">
+        SELECT * FROM upay_payment_pipeline
+    </select>
+
+    <select id="findWechatParam" parameterType="long" resultMap="WechatParamMap">
+        SELECT * FROM upay_wechat_param WHERE pipeline_id = #{pipelineId}
+    </select>
+</mapper>
@@ -2,12 +2,12 @@ dependencies {
     //api 'org.springframework.boot:spring-boot-starter-data-mongodb'
     api libs.mybatis.starter
     api 'org.springframework.boot:spring-boot-starter-data-redis'
-    api "org.redisson:redisson-spring-boot-starter:${libs.versions.redissonVersion.get()}"
+    api libs.redisson.starter
     api 'org.springframework.boot:spring-boot-starter-amqp'
     api 'org.springframework.cloud:spring-cloud-starter-loadbalancer'
     api 'org.springframework.cloud:spring-cloud-starter-openfeign'
     api libs.cache.caffeine
-    api libs.collections4
+    api libs.common.collections4
  
     runtimeOnly libs.mysql.driver
 }
+package com.diligrp.cashier.trade;
+
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+@ComponentScan("com.diligrp.cashier.trade")
+public class TradeConfiguration {
+}
+package com.diligrp.cashier.trade.exception;
+
+import com.diligrp.cashier.shared.exception.PlatformServiceException;
+
+public class TradePaymentException extends PlatformServiceException {
+
+    public TradePaymentException(String message) {
+        super(message);
+    }
+
+    public TradePaymentException(String code, String message) {
+        super(code, message);
+    }
+
+    public TradePaymentException(String message, Throwable ex) {
+        super(message, ex);
+    }
+}
+package com.diligrp.cashier.trade.type;
+
+import com.diligrp.cashier.shared.ErrorCode;
+import com.diligrp.cashier.shared.type.IEnumType;
+import com.diligrp.cashier.trade.exception.TradePaymentException;
+
+import java.util.Arrays;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+/**
+ * 终端来源
+ */
+public enum CashierDesk implements IEnumType {
+
+    NOP("无收银台", 0),
+
+    PC("PC收银台", 1),
+
+    MINIPRO("小程序收银台", 2),
+
+    H5("H5收银台", 2),
+
+    APP("APP收银台", 3);
+
+    private final String name;
+    private final int code;
+
+    CashierDesk(String name, int code) {
+        this.name = name;
+        this.code = code;
+    }
+
+    public boolean equalTo(int code) {
+        return this.code == code;
+    }
+
+    public static Optional<CashierDesk> getType(int code) {
+        Stream<CashierDesk> TYPES = Arrays.stream(CashierDesk.values());
+        return TYPES.filter(type -> type.getCode() == code).findFirst();
+    }
+
+    public static CashierDesk getByCode(int code) {
+        return getType(code).orElseThrow(() -> new TradePaymentException(ErrorCode.ILLEGAL_ARGUMENT_ERROR, "系统暂不支持此收银台类型"));
+    }
+
+    public static void validateIfNonNull(Integer code) {
+        if (Objects.nonNull(code)) {
+            Stream<CashierDesk> TYPES = Arrays.stream(CashierDesk.values());
+            TYPES.filter(type -> type.getCode() == code).findFirst().orElseThrow(() -> new IllegalArgumentException("Invalid cashier desk"));
+        }
+    }
+
+    public static String getName(int code) {
+        return getType(code).map(CashierDesk::getName).orElse(null);
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public int getCode() {
+        return code;
+    }
+
+    @Override
+    public String toString() {
+        return name;
+    }
+}
+package com.diligrp.cashier.trade.type;
+
+import com.diligrp.cashier.shared.ErrorCode;
+import com.diligrp.cashier.shared.type.IEnumType;
+import com.diligrp.cashier.trade.exception.TradePaymentException;
+
+import java.util.Arrays;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+/**
+ * 聚合支付时实际使用的支付方式
+ */
+public enum OutPaymentType implements IEnumType {
+    NOP("其他方式", 0),
+
+    WXPAY("微信支付", 10),
+
+    ALIPAY("支付宝支付", 11),
+
+    UPAY("银联支付", 12),
+
+    APP("掌银支付", 13),
+
+    BANKCARD("银行卡支付", 20);
+
+    private final String name;
+    private final int code;
+
+    OutPaymentType(String name, int code) {
+        this.name = name;
+        this.code = code;
+    }
+
+    public boolean equalTo(int code) {
+        return this.code == code;
+    }
+
+    public static Optional<OutPaymentType> getType(int code) {
+        Stream<OutPaymentType> TYPES = Arrays.stream(OutPaymentType.values());
+        return TYPES.filter(type -> type.getCode() == code).findFirst();
+    }
+
+    public static OutPaymentType getByCode(int code) {
+        return getType(code).orElseThrow(() -> new TradePaymentException(ErrorCode.ILLEGAL_ARGUMENT_ERROR, "系统暂不支持该支付方式"));
+    }
+
+    public static String getName(int code) {
+        return getType(code).map(OutPaymentType::getName).orElse(null);
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public int getCode() {
+        return code;
+    }
+
+    @Override
+    public String toString() {
+        return name;
+    }
+}
+package com.diligrp.cashier.trade.type;
+
+import com.diligrp.cashier.shared.ErrorCode;
+import com.diligrp.cashier.shared.type.IEnumType;
+import com.diligrp.cashier.trade.exception.TradePaymentException;
+
+import java.util.Arrays;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+/**
+ * 支付方式
+ */
+public enum PaymentType implements IEnumType {
+    NATIVE("扫码支付", 1), // 客户扫商户收款码
+
+    QRCODE("付款码支付", 2), // 商户扫客户付款码
+
+    MINI_PRO("小程序支付", 3); // 目前特指微信小程序支付
+
+    private final String name;
+    private final int code;
+
+    PaymentType(String name, int code) {
+        this.name = name;
+        this.code = code;
+    }
+
+    public boolean equalTo(int code) {
+        return this.code == code;
+    }
+
+    public static Optional<PaymentType> getType(int code) {
+        Stream<PaymentType> TYPES = Arrays.stream(PaymentType.values());
+        return TYPES.filter(type -> type.getCode() == code).findFirst();
+    }
+
+    public static PaymentType getByCode(int code) {
+        return getType(code).orElseThrow(() -> new TradePaymentException(ErrorCode.ILLEGAL_ARGUMENT_ERROR, "系统不支持此类支付方式"));
+    }
+
+    public static String getName(int code) {
+        return getType(code).map(PaymentType::getName).orElse(null);
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public int getCode() {
+        return code;
+    }
+
+    @Override
+    public String toString() {
+        return name;
+    }
+}
+package com.diligrp.cashier.trade.type;
+
+import com.diligrp.cashier.assistant.service.impl.SnowflakeKeyManager;
+
+public enum SnowflakeKey implements SnowflakeKeyManager.SnowflakeKey {
+    TRADE_ID,
+
+    PAYMENT_ID
+}
+package com.diligrp.cashier.trade.type;
+
+import com.diligrp.cashier.shared.type.IEnumType;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+/**
+ * 交易状态列表
+ */
+public enum TradeState implements IEnumType {
+
+    PENDING("待处理", 1),
+
+    SUCCESS("交易成功", 4),
+
+    REFUND("交易退款", 5),
+
+    FAILED("交易失败", 6),
+
+    CLOSED("交易关闭", 7);
+
+    private final String name;
+    private final int code;
+
+    TradeState(String name, int code) {
+        this.name = name;
+        this.code = code;
+    }
+
+    public boolean equalTo(int code) {
+        return this.code == code;
+    }
+
+    public static Optional<TradeState> getState(int code) {
+        Stream<TradeState> STATES = Arrays.stream(TradeState.values());
+        return STATES.filter(state -> state.getCode() == code).findFirst();
+    }
+
+    public static String getName(int code) {
+        return getState(code).map(TradeState::getName).orElse(null);
+    }
+
+    public static List<TradeState> getStates() {
+        return Arrays.asList(TradeState.values());
+    }
+
+    /**
+     * 交易订单是否允许退款; 允许多次交易退款
+     *
+     * @param state - 交易订单状态
+     * @return 是否允许交易退款
+     */
+    public static boolean forRefund(int state) {
+        return state == TradeState.SUCCESS.getCode() || state == TradeState.REFUND.getCode();
+    }
+
+    /**
+     * 交易订单是否允许撤销
+     *
+     * @param state - 交易订单状态
+     * @return 是否允许撤销
+     */
+    public static boolean forCancel(int state) {
+        return state == TradeState.SUCCESS.getCode();
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public int getCode() {
+        return code;
+    }
+
+    @Override
+    public String toString() {
+        return name;
+    }
+}
+package com.diligrp.cashier.trade.type;
+
+import com.diligrp.cashier.shared.type.IEnumType;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+/**
+ * 交易类型列表
+ */
+public enum TradeType implements IEnumType {
+
+    TRADE("交易", 10),
+
+    REFUND("退款", 20);
+
+    private final String name;
+    private final int code;
+
+    TradeType(String name, int code) {
+        this.name = name;
+        this.code = code;
+    }
+
+    public boolean equalTo(int code) {
+        return this.code == code;
+    }
+
+    public static Optional<TradeType> getType(int code) {
+        Stream<TradeType> TYPES = Arrays.stream(TradeType.values());
+        return TYPES.filter(type -> type.getCode() == code).findFirst();
+    }
+
+    public static String getName(int code) {
+        return getType(code).map(TradeType::getName).orElse(null);
+    }
+
+    public static List<TradeType> getTypes() {
+        return Arrays.asList(TradeType.values());
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public int getCode() {
+        return code;
+    }
+
+    @Override
+    public String toString() {
+        return name;
+    }
+}
@@ -17,8 +17,9 @@ spring-cloud-nacos-discovery = {module = &#39;com.alibaba.cloud:spring-cloud-starter
 spring-cloud-nacos-config = {module = 'com.alibaba.cloud:spring-cloud-starter-alibaba-nacos-config', version.ref = 'springCloudAlibabaVersion'}
 mybatis-starter = {module = 'org.mybatis.spring.boot:mybatis-spring-boot-starter', version.ref = 'mybatisVersion'}
 mysql-driver = {module = 'mysql:mysql-connector-java', version.ref = 'mysqlDriverVersion'}
+redisson-starter = {module = 'org.redisson:redisson-spring-boot-starter', version.ref = 'redissonVersion'}
 cache-caffeine = {module = 'com.github.ben-manes.caffeine:caffeine', version.ref = 'caffeineVersion'}
-collections4 = {module = 'org.apache.commons:commons-collections4', version.ref = 'collections4Version'}
+common-collections4 = {module = 'org.apache.commons:commons-collections4', version.ref = 'collections4Version'}
  
 [plugins]
 spring-boot = {id = 'org.springframework.boot', version.ref = 'springBootVersion'}
+-- --------------------------------------------------------------------
+-- 商户表
+-- 说明：商户表用于维护接入支付的商户
+-- --------------------------------------------------------------------
+DROP TABLE IF EXISTS `upay_merchant`;
+CREATE TABLE `upay_merchant` (
+    `id` BIGINT NOT NULL AUTO_INCREMENT COMMENT '主键ID',
+    `mch_id` BIGINT NOT NULL COMMENT '商户ID',
+    `name` VARCHAR(60) NOT NULL COMMENT '商户名称',
+    `access_token` VARCHAR(40) NOT NULL COMMENT '访问令牌',
+    `param` JSON COMMENT '参数配置',
+    `address` VARCHAR(128) COMMENT '商户地址',
+    `linkman` VARCHAR(40) COMMENT '联系人',
+    `telephone` VARCHAR(20) COMMENT '电话号码',
+    `state` TINYINT UNSIGNED NOT NULL COMMENT '商户状态',
+    `created_time` DATETIME COMMENT '创建时间',
+    `modified_time` DATETIME COMMENT '修改时间',
+    PRIMARY KEY (`id`),
+    UNIQUE KEY `uk_merchant_mchId` (`mch_id`) USING BTREE
+) ENGINE=InnoDB COMMENT '支付商户';
+
+-- --------------------------------------------------------------------
+-- 支付订单数据模型
+-- --------------------------------------------------------------------
+DROP TABLE IF EXISTS `upay_trade_order`;
+CREATE TABLE `upay_trade_order` (
+    `id` BIGINT NOT NULL AUTO_INCREMENT COMMENT '主键ID',
+    `mch_id` BIGINT NOT NULL COMMENT '商户ID',
+    `trade_id` VARCHAR(40) NOT NULL COMMENT '交易ID',
+    `type` TINYINT UNSIGNED NOT NULL COMMENT '交易类型', -- 购买会员
+--     `channel_id` TINYINT UNSIGNED NOT NULL COMMENT '支付渠道',
+    `out_trade_no` VARCHAR(40) COMMENT '外部流水号', -- 商户流水号
+    `amount` BIGINT NOT NULL COMMENT '金额-分',
+    `max_amount` BIGINT NOT NULL COMMENT '初始金额-分',
+    `goods` VARCHAR(128) COMMENT '商品描述',
+    `order_timeout` INTEGER UNSIGNED NOT NULL COMMENT '超时间隔时间-秒',
+    `state` TINYINT UNSIGNED NOT NULL COMMENT '交易状态',
+    `description` VARCHAR(128) COMMENT '交易备注',
+    `attach` VARCHAR(255) COMMENT '附加数据',
+    `cashier_desk` TINYINT UNSIGNED NOT NULL COMMENT '收银台类型',
+    `version` INTEGER UNSIGNED NOT NULL COMMENT '数据版本号',
+    `created_time` DATETIME COMMENT '创建时间',
+    `modified_time` DATETIME COMMENT '修改时间',
+    PRIMARY KEY (`id`),
+    UNIQUE KEY `uk_trade_order_tradeId` (`trade_id`) USING BTREE,
+    KEY `idx_trade_order_outTradeNo` (`out_trade_no`, `mch_id`) USING BTREE,
+    KEY `idx_trade_order_createdTime` (`created_time`) USING BTREE
+) ENGINE=InnoDB COMMENT '支付订单';
+
+-- --------------------------------------------------------------------
+-- 支付申请数据模型
+-- --------------------------------------------------------------------
+DROP TABLE IF EXISTS `upay_online_payment`;
+CREATE TABLE `upay_online_payment` (
+    `id` BIGINT NOT NULL AUTO_INCREMENT COMMENT '主键ID',
+    `out_mch_id` VARCHAR(40) COMMENT '外部商户号',
+    `trade_id` VARCHAR(40) NOT NULL COMMENT '交易ID',
+    `type` TINYINT UNSIGNED NOT NULL COMMENT '交易类型',
+    `payment_id` VARCHAR(40) NOT NULL COMMENT '支付ID',
+    `channel_id` TINYINT UNSIGNED NOT NULL COMMENT '支付通道',
+    `pay_type` TINYINT UNSIGNED NOT NULL COMMENT '支付方式', -- NATIVE MINIPRO
+    `pipeline_id` BIGINT NOT NULL COMMENT '通道ID',
+    `goods` VARCHAR(128) NOT NULL COMMENT '商品描述',
+    `amount` BIGINT NOT NULL COMMENT '申请金额-分',
+    `object_id` VARCHAR(60) COMMENT '操作对象', -- prepareId，二维码，或退款时的原单号
+    `payer_id` VARCHAR(128) COMMENT '支付方', -- 比如微信openId，或json格式数据
+    `finish_time` DATETIME COMMENT '支付时间',
+    `out_trade_no` VARCHAR(40) COMMENT '通道流水号',
+    `out_pay_type` TINYINT UNSIGNED NOT NULL COMMENT '实际支付方式', -- 银行聚合支付时使用
+    `state` TINYINT UNSIGNED NOT NULL COMMENT '申请状态',
+    `notify_uri` VARCHAR(128) COMMENT '业务回调链接',
+    `description` VARCHAR(256) COMMENT '交易备注',
+    `version` INTEGER UNSIGNED NOT NULL COMMENT '数据版本号',
+    `created_time` DATETIME COMMENT '创建时间',
+    `modified_time` DATETIME COMMENT '修改时间',
+    PRIMARY KEY (`id`),
+    UNIQUE KEY `uk_online_payment_paymentId` (`payment_id`) USING BTREE,
+    KEY `idx_online_payment_tradeId` (`trade_id`) USING BTREE,
+    KEY `idx_online_payment_finishTime` (`finish_time`, `state`) USING BTREE,
+    KEY `idx_online_payment_outTradeNo` (`out_trade_no`) USING BTREE,
+    KEY `idx_online_payment_createdTime` (`created_time`) USING BTREE
+) ENGINE=InnoDB COMMENT '支付申请';
+
+-- --------------------------------------------------------------------
+-- 通道管理配置数据模型
+-- --------------------------------------------------------------------
+DROP TABLE IF EXISTS `upay_payment_pipeline`;
+CREATE TABLE `upay_payment_pipeline` (
+    `id` BIGINT NOT NULL AUTO_INCREMENT COMMENT '主键ID',
+    `mch_id` BIGINT NOT NULL COMMENT '商户ID',
+    `pipeline_id` BIGINT NOT NULL COMMENT '通道ID',
+    `channel_id` TINYINT UNSIGNED NOT NULL COMMENT '渠道', -- 建设银行、农业银行、微信、支付宝
+    `type` TINYINT UNSIGNED NOT NULL COMMENT '通道类型', -- 银企直连通道、聚合支付通道、微信支付通道、支付宝通道
+    `name` VARCHAR(40) NOT NULL COMMENT '通道名称',
+    `uri` VARCHAR(60) NOT NULL COMMENT '通道URI',
+    `param` JSON COMMENT '通道参数',
+    `state` TINYINT UNSIGNED NOT NULL COMMENT '通道状态',
+    `created_time` DATETIME COMMENT '创建时间',
+    `modified_time` DATETIME COMMENT '修改时间',
+    PRIMARY KEY (`id`),
+    UNIQUE KEY  `uk_payment_pipeline_pipelineId` (`pipeline_id`) USING BTREE
+) ENGINE=InnoDB COMMENT '通道管理配置';
+
+-- --------------------------------------------------------------------
+-- 微信支付通道参数配置数据模型
+-- --------------------------------------------------------------------
+DROP TABLE IF EXISTS `upay_wechat_param`;
+CREATE TABLE `upay_wechat_param` (
+    `id` BIGINT NOT NULL AUTO_INCREMENT COMMENT '主键ID',
+    `pipeline_id` BIGINT NOT NULL COMMENT '通道ID',
+    `mch_id` VARCHAR(20) NOT NULL COMMENT '商户号', -- 服务商模式下为服务商商户号
+    `app_id` VARCHAR(30) NOT NULL COMMENT '小程序ID',
+    `app_secret` VARCHAR(50) NOT NULL COMMENT '小程序密钥',
+    `serial_no` VARCHAR(50) NOT NULL COMMENT '商户公钥序列号',
+    `private_key` TEXT NOT NULL COMMENT '商户私钥',
+    `wechat_serial_no` VARCHAR(50) NOT NULL COMMENT '微信公钥序列号',
+    `wechat_public_key` TEXT NOT NULL COMMENT '微信公钥',
+    `api_v3_key` VARCHAR(50) NOT NULL COMMENT '微信apiV3Key',
+    `type` TINYINT UNSIGNED NOT NULL COMMENT '通道类型', -- 直连通道或服务商通道
+    `created_time` DATETIME COMMENT '创建时间',
+    PRIMARY KEY (`id`),
+    UNIQUE KEY  `uk_wechat_param_pipelineId` (`pipeline_id`) USING BTREE
+) ENGINE=InnoDB COMMENT '微信支付通道参数配置';
 \ No newline at end of file