APIv3 版本的所有接口都需要； APIv2 版本的高级接口需要（如：退款、企业红包、企业付款等）

步骤：登录商户平台 => 选择 账户中心 => 安全中心 => API 安全 => 申请 API 证书

2.6、获取微信平台证书

 

 

项目实现

依赖

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0modelVersion>
    <packaging>jarpackaging>
 
    <groupId>org.examplegroupId>
    <artifactId>weixinZFartifactId>
    <version>1.0-SNAPSHOTversion>
 
    <properties>
        <maven.compiler.source>8maven.compiler.source>
        <maven.compiler.target>8maven.compiler.target>
    properties>
 
 
    <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>2.1.9.RELEASEversion>
        <relativePath/>
    parent>
 
    <dependencies>
 
        <dependency>
            <groupId>io.springfoxgroupId>
            <artifactId>springfox-swagger2artifactId>
            <version>2.7.0version>
        dependency>
 
        <dependency>
            <groupId>io.springfoxgroupId>
            <artifactId>springfox-swagger-uiartifactId>
            <version>2.7.0version>
        dependency>
 
        <dependency>
            <groupId>log4jgroupId>
            <artifactId>log4jartifactId>
            <version>1.2.14version>
        dependency>
 
        <dependency>
            <groupId>com.github.wechatpay-apiv3groupId>
            <artifactId>wechatpay-apache-httpclientartifactId>
            <version>0.3.0version>
        dependency>
        <dependency>
            <groupId>com.alipay.sdkgroupId>
            <artifactId>alipay-sdk-javaartifactId>
            <version>4.31.65.ALLversion>
        dependency>
 
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-dependenciesartifactId>
            <version>2.1.9.RELEASEversion>
            <type>pomtype>
            <scope>importscope>
        dependency>
 
        <dependency>
            <groupId>com.alibabagroupId>
            <artifactId>fastjsonartifactId>
        dependency>
 
        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
        dependency>
 
        <dependency>
            <groupId>com.baomidougroupId>
            <artifactId>mybatis-plus-boot-starterartifactId>
            <version>3.4.3version>
        dependency>
 
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>
 
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-configuration-processorartifactId>
            <optional>trueoptional>
        dependency>
 
        
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
            <scope>providedscope>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            
            <exclusions>
                <exclusion>
                    <groupId>org.junit.jupitergroupId>
                    <artifactId>junit-jupiter-engineartifactId>
                exclusion>
            exclusions>
        dependency>
        <dependency>
            <groupId>com.alibabagroupId>
            <artifactId>fastjsonartifactId>
            <version>1.2.60version>
            <scope>compilescope>
        dependency>
 
        <dependency>
            <groupId>com.google.code.gsongroupId>
            <artifactId>gsonartifactId>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-autoconfigureartifactId>
        dependency>
        
 
 
    dependencies>
 
    <build>
        <plugins>
            
            <plugin>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-maven-pluginartifactId>
                <version>2.1.9.RELEASEversion>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackagegoal>
                        goals>
                    execution>
                executions>
 
                <configuration>
                    <includeSystemScope>trueincludeSystemScope>
                    <mainClass>com.wx.WXapplicationmainClass>
                configuration>
            plugin>
 
        plugins>
    build>
 
 
project>

配置yml

server:
  port: 8090
 
spring:
  application:
    name: weixinZF
  datasource:
    #高版本驱动使用
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/payment_demo?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true
    #设定用户名和密码
    username: root
    password: root
 
  jackson:
    date-format: yyyy-MM-dd HH:mm:ss
    time-zone: GMT+8
 
#SpringBoot整合Mybatis
mybatis-plus:
  #指定别名包
  type-aliases-package: com.jt.pojo
  #扫描指定路径下的映射文件
  mapper-locations: classpath:/mapper/*.xml
  #开启驼峰映射
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl  #sql日志
    map-underscore-to-camel-case: true
  # 一二级缓存默认开始 所以可以简化
#打印mysql日志
logging:
  level:
    com.jt.mapper: debug

数据库创建

订单表

CREATE TABLE `t_order_info` (
  `id` bigint(11) unsigned NOT NULL AUTO_INCREMENT COMMENT '订单id',
  `title` varchar(256) DEFAULT NULL COMMENT '订单标题',
  `order_no` varchar(50) DEFAULT NULL COMMENT '商户订单编号',
  `user_id` bigint(20) DEFAULT NULL COMMENT '用户id',
  `product_id` bigint(20) DEFAULT NULL COMMENT '支付产品id',
  `total_fee` int(11) DEFAULT NULL COMMENT '订单金额(分)',
  `code_url` varchar(50) DEFAULT NULL COMMENT '订单二维码连接',
  `order_status` varchar(10) DEFAULT NULL COMMENT '订单状态',
  `create_time` datetime DEFAULT current_timestamp() COMMENT '创建时间',
  `update_time` datetime DEFAULT current_timestamp() ON UPDATE current_timestamp() COMMENT '更新时间',
`payment_type` varchar(255) DEFAULT NULL COMMENT '支付类型（支付宝~微信）',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=39 DEFAULT CHARSET=utf8mb4 ROW_FORMAT=DYNAMIC;

记录表

CREATE TABLE `t_payment_info` (
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '支付记录id',
  `order_no` varchar(50) DEFAULT NULL COMMENT '商户订单编号',
  `transaction_id` varchar(50) DEFAULT NULL COMMENT '支付系统交易编号',
  `payment_type` varchar(20) DEFAULT NULL COMMENT '支付类型',
  `trade_type` varchar(20) DEFAULT NULL COMMENT '交易类型',
  `trade_state` varchar(50) DEFAULT NULL COMMENT '交易状态',
  `payer_total` int(11) DEFAULT NULL COMMENT '支付金额(分)',
  `content` text DEFAULT NULL COMMENT '通知参数',
  `create_time` datetime DEFAULT current_timestamp() COMMENT '创建时间',
  `update_time` datetime DEFAULT current_timestamp() ON UPDATE current_timestamp() COMMENT '更新时间',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=11 DEFAULT CHARSET=utf8mb4 ROW_FORMAT=DYNAMIC;

商品表

CREATE TABLE `t_product` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '商品id',
  `title` varchar(20) DEFAULT NULL COMMENT '商品名称',
  `price` int(11) DEFAULT NULL COMMENT '价格（分）',
  `create_time` datetime DEFAULT current_timestamp() COMMENT '创建时间',
  `update_time` datetime DEFAULT current_timestamp() ON UPDATE current_timestamp() COMMENT '更新时间',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8mb4 ROW_FORMAT=DYNAMIC;

退款表

CREATE TABLE `t_refund_info` (
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '退款单id',
  `order_no` varchar(50) DEFAULT NULL COMMENT '商户订单编号',
  `refund_no` varchar(50) DEFAULT NULL COMMENT '商户退款单编号',
  `refund_id` varchar(50) DEFAULT NULL COMMENT '支付系统退款单号',
  `total_fee` int(11) DEFAULT NULL COMMENT '原订单金额(分)',
  `refund` int(11) DEFAULT NULL COMMENT '退款金额(分)',
  `reason` varchar(50) DEFAULT NULL COMMENT '退款原因',
  `refund_status` varchar(10) DEFAULT NULL COMMENT '退款状态',
  `content_return` text DEFAULT NULL COMMENT '申请退款返回参数',
  `content_notify` text DEFAULT NULL COMMENT '退款结果通知参数',
  `create_time` datetime DEFAULT current_timestamp() COMMENT '创建时间',
  `update_time` datetime DEFAULT current_timestamp() ON UPDATE current_timestamp() COMMENT '更新时间',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8mb4 ROW_FORMAT=DYNAMIC;

配置微信相关支付参数

wxpay.properties

# 微信支付相关参数
# 商户号
wxpay.mch-id=11111111
# 商户API证书序列号
wxpay.mch-serial-no=1111111111111111
# 商户私钥文件
wxpay.private-key-path=apiclient_key.pem
# APIv3密钥
wxpay.api-v3-key=111111111111
# APPID
wxpay.appid=111111111111111
# 微信服务器地址
wxpay.domain=https://api.mch.weixin.qq.com
# 接收结果通知地址 使用内网穿透工具获取
wxpay.notify-domain=http://pw46ia.natappfree.cc

将私钥放置项目下

配置Util工具类

http请求客户端工具类

package com.wx.util;
 
import org.apache.http.Consts;
import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.*;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLContextBuilder;
import org.apache.http.conn.ssl.TrustStrategy;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
 
import javax.net.ssl.SSLContext;
import java.io.IOException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.text.ParseException;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
 
/**
 * http请求客户端
 */
public class HttpClientUtils {
	private String url;
	private Map param;
	private int statusCode;
	private String content;
	private String xmlParam;
	private boolean isHttps;
 
	public boolean isHttps() {
		return isHttps;
	}
 
	public void setHttps(boolean isHttps) {
		this.isHttps = isHttps;
	}
 
	public String getXmlParam() {
		return xmlParam;
	}
 
	public void setXmlParam(String xmlParam) {
		this.xmlParam = xmlParam;
	}
 
	public HttpClientUtils(String url, Map param) {
		this.url = url;
		this.param = param;
	}
 
	public HttpClientUtils(String url) {
		this.url = url;
	}
 
	public void setParameter(Map map) {
		param = map;
	}
 
	public void addParameter(String key, String value) {
		if (param == null)
			param = new HashMap();
		param.put(key, value);
	}
 
	public void post() throws ClientProtocolException, IOException {
		HttpPost http = new HttpPost(url);
		setEntity(http);
		execute(http);
	}
 
	public void put() throws ClientProtocolException, IOException {
		HttpPut http = new HttpPut(url);
		setEntity(http);
		execute(http);
	}
 
	public void get() throws ClientProtocolException, IOException {
		if (param != null) {
			StringBuilder url = new StringBuilder(this.url);
			boolean isFirst = true;
			for (String key : param.keySet()) {
				if (isFirst) {
					url.append("?");
					isFirst = false;
				}else {
					url.append("&");
				}
				url.append(key).append("=").append(param.get(key));
			}
			this.url = url.toString();
		}
		HttpGet http = new HttpGet(url);
		execute(http);
	}
 
	/**
	 * set http post,put param
	 */
	private void setEntity(HttpEntityEnclosingRequestBase http) {
		if (param != null) {
			List nvps = new LinkedList();
			for (String key : param.keySet())
				nvps.add(new BasicNameValuePair(key, param.get(key))); // 参数
			http.setEntity(new UrlEncodedFormEntity(nvps, Consts.UTF_8)); // 设置参数
		}
		if (xmlParam != null) {
			http.setEntity(new StringEntity(xmlParam, Consts.UTF_8));
		}
	}
 
	private void execute(HttpUriRequest http) throws ClientProtocolException,
			IOException {
		CloseableHttpClient httpClient = null;
		try {
			if (isHttps) {
				SSLContext sslContext = new SSLContextBuilder()
						.loadTrustMaterial(null, new TrustStrategy() {
							// 信任所有
							public boolean isTrusted(X509Certificate[] chain,
									String authType)
									throws CertificateException {
								return true;
							}
						}).build();
				SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(
						sslContext);
				httpClient = HttpClients.custom().setSSLSocketFactory(sslsf)
						.build();
			} else {
				httpClient = HttpClients.createDefault();
			}
			CloseableHttpResponse response = httpClient.execute(http);
			try {
				if (response != null) {
					if (response.getStatusLine() != null)
						statusCode = response.getStatusLine().getStatusCode();
					HttpEntity entity = response.getEntity();
					// 响应内容
					content = EntityUtils.toString(entity, Consts.UTF_8);
				}
			} finally {
				response.close();
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			httpClient.close();
		}
	}
 
	public int getStatusCode() {
		return statusCode;
	}
 
	public String getContent() throws ParseException, IOException {
		return content;
	}
 
}

参数转换字符串工具类

package com.wx.util;
 
import javax.servlet.http.HttpServletRequest;
import java.io.BufferedReader;
import java.io.IOException;
 
 
public class HttpUtils {
 
    /**
     * 将通知参数转化为字符串
     * @param request
     * @return
     */
    public static String readData(HttpServletRequest request) {
        BufferedReader br = null;
        try {
            StringBuilder result = new StringBuilder();
            br = request.getReader();
            for (String line; (line = br.readLine()) != null; ) {
                if (result.length() > 0) {
                    result.append("\n");
                }
                result.append(line);
            }
            return result.toString();
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

订单号工具类：我们需要为我们的订单生成一个编号

package com.wx.util;
 
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Random;
 
/**
 * 订单号工具类
 *
 * @author qy
 * @since 1.0
 */
public class OrderNoUtils {
 
    /**
     * 获取订单编号
     * @return
     */
    public static String getOrderNo() {
        return "ORDER_" + getNo();
    }
 
    /**
     * 获取退款单编号
     * @return
     */
    public static String getRefundNo() {
        return "REFUND_" + getNo();
    }
 
    /**
     * 获取编号
     * @return
     */
    public static String getNo() {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
        String newDate = sdf.format(new Date());
        String result = "";
        Random random = new Random();
        for (int i = 0; i < 3; i++) {
            result += random.nextInt(10);
        }
        return newDate + result;
    }
 
}

微信验签应答工具类

package com.wx.util;
 
 
import com.wechat.pay.contrib.apache.httpclient.auth.Verifier;
import org.apache.http.HttpEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.time.DateTimeException;
import java.time.Duration;
import java.time.Instant;
 
import static com.wechat.pay.contrib.apache.httpclient.constant.WechatPayHttpHeaders.*;
 
/**
 * @author xy-peng
 */
public class WechatPay2ValidatorForRequest {
 
    protected static final Logger log = LoggerFactory.getLogger(WechatPay2ValidatorForRequest.class);
    /**
     * 应答超时时间，单位为分钟
     */
    protected static final long RESPONSE_EXPIRED_MINUTES = 5;
    protected final Verifier verifier;
    protected final String requestId;
    protected final String body;
 
 
    public WechatPay2ValidatorForRequest(Verifier verifier, String requestId, String body) {
        this.verifier = verifier;
        this.requestId = requestId;
        this.body = body;
    }
 
    protected static IllegalArgumentException parameterError(String message, Object... args) {
        message = String.format(message, args);
        return new IllegalArgumentException("parameter error: " + message);
    }
 
    protected static IllegalArgumentException verifyFail(String message, Object... args) {
        message = String.format(message, args);
        return new IllegalArgumentException("signature verify fail: " + message);
    }
 
    public final boolean validate(HttpServletRequest request) throws IOException {
        try {
            //处理请求参数
            validateParameters(request);
 
            //构造验签名串
            String message = buildMessage(request);
 
            String serial = request.getHeader(WECHAT_PAY_SERIAL);
            String signature = request.getHeader(WECHAT_PAY_SIGNATURE);
 
            //验签
            if (!verifier.verify(serial, message.getBytes(StandardCharsets.UTF_8), signature)) {
                throw verifyFail("serial=[%s] message=[%s] sign=[%s], request-id=[%s]",
                        serial, message, signature, requestId);
            }
        } catch (IllegalArgumentException e) {
            log.warn(e.getMessage());
            return false;
        }
 
        return true;
    }
 
    protected final void validateParameters(HttpServletRequest request) {
 
        // NOTE: ensure HEADER_WECHAT_PAY_TIMESTAMP at last
        String[] headers = {WECHAT_PAY_SERIAL, WECHAT_PAY_SIGNATURE, WECHAT_PAY_NONCE, WECHAT_PAY_TIMESTAMP};
 
        String header = null;
        for (String headerName : headers) {
            header = request.getHeader(headerName);
            if (header == null) {
                throw parameterError("empty [%s], request-id=[%s]", headerName, requestId);
            }
        }
 
        //判断请求是否过期
        String timestampStr = header;
        try {
            Instant responseTime = Instant.ofEpochSecond(Long.parseLong(timestampStr));
            // 拒绝过期请求
            if (Duration.between(responseTime, Instant.now()).abs().toMinutes() >= RESPONSE_EXPIRED_MINUTES) {
                throw parameterError("timestamp=[%s] expires, request-id=[%s]", timestampStr, requestId);
            }
        } catch (DateTimeException | NumberFormatException e) {
            throw parameterError("invalid timestamp=[%s], request-id=[%s]", timestampStr, requestId);
        }
    }
 
    protected final String buildMessage(HttpServletRequest request) throws IOException {
        String timestamp = request.getHeader(WECHAT_PAY_TIMESTAMP);
        String nonce = request.getHeader(WECHAT_PAY_NONCE);
        return timestamp + "\n"
                + nonce + "\n"
                + body + "\n";
    }
 
    protected final String getResponseBody(CloseableHttpResponse response) throws IOException {
        HttpEntity entity = response.getEntity();
        return (entity != null && entity.isRepeatable()) ? EntityUtils.toString(entity) : "";
    }
 
}

创建统一结果R类

package com.wx.vo;
 
import lombok.Data;
import lombok.experimental.Accessors;
 
import java.util.HashMap;
import java.util.Map;
 
@Data
@Accessors(chain = true)
public class R {
 
    private Integer code; //响应码
    private String message; //响应消息
    private Map data = new HashMap<>();
 
    public static R ok(){
        R r = new R();
        r.setCode(200);
        r.setMessage("成功");
        return r;
    }
 
    public static R error(){
        R r = new R();
        r.setCode(201);
        r.setMessage("失败");
        return r;
    }
 
    public R data(String key, Object value){
        this.data.put(key, value);
        return this;
    }
 
}

定义实体类

package com.wx.entity;
 
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import lombok.Data;
 
import java.util.Date;
 
@Data
public class BaseEntity {
 
    //定义主键策略：跟随数据库的主键自增
    @TableId(value = "id", type = IdType.AUTO)
    private String id; //主键
 
    private Date createTime;//创建时间
 
    private Date updateTime;//更新时间
}

package com.wx.entity;
 
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
 
@Data
@TableName("t_order_info")
public class OrderInfo  extends BaseEntity{
 
    private String title;//订单标题
 
    private String orderNo;//商户订单编号
 
    private Long userId;//用户id
 
    private Long productId;//支付产品id
 
    private Integer totalFee;//订单金额(分)
 
    private String codeUrl;//订单二维码连接
 
    private String orderStatus;//订单状态
}

package com.wx.entity;
 
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
 
@Data
@TableName("t_payment_info")
public class PaymentInfo extends BaseEntity{
 
    private String orderNo;//商品订单编号
 
    private String transactionId;//支付系统交易编号
 
    private String paymentType;//支付类型
 
    private String tradeType;//交易类型
 
    private String tradeState;//交易状态
 
    private Integer payerTotal;//支付金额(分)
 
    private String content;//通知参数
}

package com.wx.entity;
 
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
 
@Data
@TableName("t_product")
public class Product extends BaseEntity{
 
    private String title; //商品名称
 
    private Integer price; //价格（分）
}

package com.wx.entity;
 
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
 
@Data
@TableName("t_refund_info")
public class RefundInfo extends BaseEntity{
 
    private String orderNo;//商品订单编号
 
    private String refundNo;//退款单编号
 
    private String refundId;//支付系统退款单号
 
    private Integer totalFee;//原订单金额(分)
 
    private Integer refund;//退款金额(分)
 
    private String reason;//退款原因
 
    private String refundStatus;//退款单状态
 
    private String contentReturn;//申请退款返回参数
 
    private String contentNotify;//退款结果通知参数
}

定义枚举

为了开发方便，我们预先在项目中定义一些枚举。枚举中定义的内容包括接口地址，支付状态等信息

API接口地址，封装了微信支付的所有接口

package com.wx.enums.wxpay;
 
import lombok.AllArgsConstructor;
import lombok.Getter;
 
/**
 * api接口地址
 */
@AllArgsConstructor
@Getter
public enum WxApiType {
 
	/**
	 * Native下单
	 */
	NATIVE_PAY("/v3/pay/transactions/native"),
 
	/**
	 * Native下单
	 */
	NATIVE_PAY_V2("/pay/unifiedorder"),
 
	/**
	 * 查询订单
	 */
	ORDER_QUERY_BY_NO("/v3/pay/transactions/out-trade-no/%s"),
 
	/**
	 * 关闭订单
	 */
	CLOSE_ORDER_BY_NO("/v3/pay/transactions/out-trade-no/%s/close"),
 
	/**
	 * 申请退款
	 */
	DOMESTIC_REFUNDS("/v3/refund/domestic/refunds"),
 
	/**
	 * 查询单笔退款
	 */
	DOMESTIC_REFUNDS_QUERY("/v3/refund/domestic/refunds/%s"),
 
	/**
	 * 申请交易账单
	 */
	TRADE_BILLS("/v3/bill/tradebill"),
 
	/**
	 * 申请资金账单
	 */
	FUND_FLOW_BILLS("/v3/bill/fundflowbill");
 
 
	/**
	 * 类型
	 */
	private final String type;
}

封装了通知接口地址

package com.wx.enums.wxpay;
 
import lombok.AllArgsConstructor;
import lombok.Getter;
 
/**
 * 封装了通知接口地址
 */
@AllArgsConstructor
@Getter
public enum WxNotifyType {
 
	/**
	 * 支付通知
	 */
	NATIVE_NOTIFY("/api/wx-pay/native/notify"),
 
	/**
	 * 支付通知
	 */
	NATIVE_NOTIFY_V2("/api/wx-pay-v2/native/notify"),
 
 
	/**
	 * 退款结果通知
	 */
	REFUND_NOTIFY("/api/wx-pay/refunds/notify");
 
	/**
	 * 类型
	 */
	private final String type;
}

退款类型

package com.wx.enums.wxpay;
 
import lombok.AllArgsConstructor;
import lombok.Getter;
 
/**
 * 退款
 */
@AllArgsConstructor
@Getter
public enum WxRefundStatus {
 
    /**
     * 退款成功
     */
    SUCCESS("SUCCESS"),
 
    /**
     * 退款关闭
     */
    CLOSED("CLOSED"),
 
    /**
     * 退款处理中
     */
    PROCESSING("PROCESSING"),
 
    /**
     * 退款异常
     */
    ABNORMAL("ABNORMAL");
 
    /**
     * 类型
     */
    private final String type;
}

支付类型

package com.wx.enums.wxpay;
 
import lombok.AllArgsConstructor;
import lombok.Getter;
 
/**
 * 支付订单状态
 */
@AllArgsConstructor
@Getter
public enum WxTradeState {
 
    /**
     * 支付成功
     */
    SUCCESS("SUCCESS"),
 
    /**
     * 未支付
     */
    NOTPAY("NOTPAY"),
 
    /**
     * 已关闭
     */
    CLOSED("CLOSED"),
 
    /**
     * 转入退款
     */
    REFUND("REFUND");
 
    /**
     * 类型
     */
    private final String type;
}

支付状态

package com.wx.enums;
 
import lombok.AllArgsConstructor;
import lombok.Getter;
 
@AllArgsConstructor
@Getter
public enum OrderStatus {
    /**
     * 未支付
     */
    NOTPAY("未支付"),
 
 
    /**
     * 支付成功
     */
    SUCCESS("支付成功"),
 
    /**
     * 已关闭
     */
    CLOSED("超时已关闭"),
 
    /**
     * 已取消
     */
    CANCEL("用户已取消"),
 
    /**
     * 退款中
     */
    REFUND_PROCESSING("退款中"),
 
    /**
     * 已退款
     */
    REFUND_SUCCESS("已退款"),
 
    /**
     * 退款异常
     */
    REFUND_ABNORMAL("退款异常");
 
    /**
     * 类型
     */
    private final String type;
}

付款类型

package com.wx.enums;
 
import lombok.AllArgsConstructor;
import lombok.Getter;
 
@AllArgsConstructor
@Getter
public enum PayType {
    /**
     * 微信
     */
    WXPAY("微信"),
 
 
    /**
     * 支付宝
     */
    ALIPAY("支付宝");
 
    /**
     * 类型
     */
    private final String type;
}

定义MyBatis-Plus的配置文件