对接微信JSAPI支付

– 微信支付 –

---

前提条件

• 微信支付商户号：必须有一个有效的微信支付商户号。
• 公众号或小程序：需要有一个经过认证的微信公众号或小程序，用于生成支付授权。
• 微信支付API证书：用于在服务器端调用微信支付API时进行身份验证

引入依赖

<!--微信支付-->
<dependency>
    <groupId>com.github.wechatpay-apiv3</groupId>
    <artifactId>wechatpay-java</artifactId>
    <version>0.2.12</version>
</dependency>

编写配置文件

• 这里默认已经获得微信支付需要的相关参数
• 下面直接进行代码Coding阶段

wx:
  # 微信小程序appid
  app-id: wxcb25xxxxxxxxxxxx
  # 商户号
  mch-id: 16xxxxxxxx
  # 证书序列号
  mch-serial-no: 59BAxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  # api密钥
  api-key: tonxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  # 回调接口地址(订单不做回调可以不用配)
  notify-url: https://15x.xx.xxx.xx/pay/payCallBack
  # 证书地址
  key-path: /apiclient_key.pem
  cert-path: /apiclient_cert.pem
  cert-p12-path: /apiclient_cert.p12
  msgDataFormat: JSON

编写配置WxProperties

/**
 * @Author：Ccoo
 * @Date：2024/3/21 20:40
 */
@Component
@ConfigurationProperties(prefix = "wx")
@Data
@ToString
public class WxProperties {
    /**
     * 设置微信小程序的appid
     */
    private String appId;

    /**
     * 微信支付分配的商户号
     */
    private String mchId;

    /**
     * 密钥文件的路径
     */
    private String keyPath;

    /**
     * 商户证书的路径
     */
    private String certPath;

    /**
     * 商户密钥，用于签名和验证
     */
    private String apiKey;

    /**
     * 接收微信支付异步通知的URL
     */
    private String notifyUrl;

    /**
     * 商户API证书序列号
     */
    private String mchSerialNo;

    /**
     * 消息格式，XML或者JSON
     */
    private String msgDataFormat;
}

编写配置WechatAutoConfiguration

import com.wechat.pay.java.core.RSAAutoCertificateConfig;
import com.wechat.pay.java.core.notification.NotificationConfig;
import com.wechat.pay.java.core.notification.NotificationParser;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import com.wechat.pay.java.service.payments.jsapi.JsapiServiceExtension;
import org.springframework.core.io.Resource;
import org.springframework.core.io.ResourceLoader;
import com.wechat.pay.java.core.Config;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.security.cert.*;

@Slf4j
@Configuration
@RequiredArgsConstructor
public class WechatAutoConfiguration {


	private final WxProperties wxProperties;
	private final ResourceLoader resourceLoader;

	private static final String CLASS_PATH = "classpath:";

	/**
	 * 自动更新证书
	 *
	 * @return RSAAutoCertificateConfig
	 */
	@Bean
	public Config config() throws IOException {
		String merchantSerialNumber = getCertificateSerialNumber(wxProperties.getCertPath());
		String privateKey = readResourceAsString(wxProperties.getKeyPath());

		return new RSAAutoCertificateConfig.Builder()
				.merchantId(wxProperties.getMchId())
				.privateKey(privateKey)
				.merchantSerialNumber(merchantSerialNumber)
				.apiV3Key(wxProperties.getApiKey())
				.build();
	}

	/**
	 * 微信支付对象
	 *
	 * @param config Config
	 * @return JsapiServiceExtension
	 */
	@Bean
	public JsapiServiceExtension jsapiServiceExtension(Config config) {
		return new JsapiServiceExtension.Builder().config(config).build();
	}

	/**
	 * 微信回调对象
	 *
	 * @param config Config
	 * @return NotificationParser
	 */
	@Bean
	public NotificationParser notificationParser(Config config) {
		return new NotificationParser((NotificationConfig) config);
	}

	/**
	 * 读取私钥文件，将文件流读取成 string
	 *
	 * @param path 文件路径
	 * @return 文件内容
	 * @throws IOException
	 */
	private String readResourceAsString(String path) throws IOException {
		Resource resource = resourceLoader.getResource(CLASS_PATH + path);
		try (InputStream inputStream = resource.getInputStream();
		     BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream))) {
			StringBuilder stringBuilder = new StringBuilder();
			String line;
			while ((line = reader.readLine()) != null) {
				stringBuilder.append(line);
			}
			return stringBuilder.toString();
		}
	}

	/**
	 * 获取证书序列号
	 *
	 * @param certPath 证书路径
	 * @return 证书序列号
	 * @throws IOException
	 */
	private String getCertificateSerialNumber(String certPath) throws IOException {
		Resource resource = resourceLoader.getResource(CLASS_PATH + certPath);
		try (InputStream inputStream = resource.getInputStream()) {
			X509Certificate certificate = getCertificate(inputStream);
			return certificate.getSerialNumber().toString(16).toUpperCase();
		}
	}

	/**
	 * 获取证书，将文件流转成证书文件
	 *
	 * @param inputStream 证书文件流
	 * @return {@link X509Certificate} 证书对象
	 */
	public static X509Certificate getCertificate(InputStream inputStream) {
		try {
			CertificateFactory cf = CertificateFactory.getInstance("X509");
			X509Certificate cert = (X509Certificate) cf.generateCertificate(inputStream);
			cert.checkValidity();
			return cert;
		} catch (CertificateExpiredException e) {
			throw new RuntimeException("证书已过期", e);
		} catch (CertificateNotYetValidException e) {
			throw new RuntimeException("证书尚未生效", e);
		} catch (CertificateException e) {
			throw new RuntimeException("无效的证书", e);
		}
	}
}

• 微信JSAPI支付官方文档

JSAPI下单 - JSAPI支付 | 微信支付商户文档中心

微信支付相关代码

Controller控制器代码

import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

/**
 * @author Ccoo
 * @since 2024-8-23
 */
@RestController
@RequestMapping("/wechat")
public class WeChatController {

	@Autowired
	private WeChatService wechatService;

	@ApiOperation("微信预支付")
	@PostMapping("/prePay")
	public R<?> createPreOrder(@RequestBody PrePayReq prePayReq) {
		return R.ok(wechatService.prepayWithRequest(prePayReq));
	}

	@ApiOperation("查询订单")
	@GetMapping("/queryOrder")
	public R<?> queryOrder(@RequestParam String outTradeNo) {
		return R.ok(wechatService.queryStatus(outTradeNo));
	}

	@ApiOperation("取消订单")
	@PostMapping("/closeOrder")
	public R<?> closeOrder(@RequestParam String outTradeNo) {
		//方法没有返回值，意味着成功时API返回204 No Content
		return R.ok(wechatService.closeOrder(outTradeNo));
	}
    
}

Service接口层代码

import com.itheima.mp.domain.R;
import com.itheima.mp.domain.wechat.PrePayReq;

/**
 * @author Ccoo
 * 2024/8/23
 */
public interface WeChatService {

	/**
	 * 微信预支付
	 * @param prePayReq 预支付请求
	 * @return 结果
	 */
	R<?> prepayWithRequest(PrePayReq prePayReq);

	/**
	 * 查询订单状态
	 * @param outTradeNo 订单号
	 * @return 结果
	 */
	R<?> queryStatus(String outTradeNo);

	/**
	 * 关闭订单
	 * @param outTradeNo 订单号
	 */
	R<?> closeOrder(String outTradeNo);

}

ServiceImpl实现层代码

import com.wechat.pay.java.core.exception.ServiceException;
import com.wechat.pay.java.service.payments.jsapi.JsapiServiceExtension;
import com.wechat.pay.java.service.payments.jsapi.model.*;
import com.wechat.pay.java.service.payments.model.Transaction;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.security.SecureRandom;

/**
 * @author Ccoo
 * 2024/8/23
 */
@Slf4j
@Service
@RequiredArgsConstructor
public class WeChatServiceImpl implements WeChatService {

	private final WxProperties wxProperties;
	private final JsapiServiceExtension jsapiService;

	/**
	 * 微信预支付
	 * @param prePayReq 预支付请求
	 * @return 结果
	 * 商户系统先调用该接口在微信支付服务后台生成预支付交易单，
	 * 返回正确的预支付交易会话标识后再按Native、JSAPI、APP等不同场景生成交易串调起支付。
	 */
	@Override
	public R<?> prepayWithRequest(PrePayReq prePayReq) {

		// 判断参数是否为空
		if (prePayReq == null || prePayReq.getAmount() == null || prePayReq.getDescription() == null || prePayReq.getOpenid() == null) {
			return R.fail(HttpStatus.BAD_REQUEST, "参数错误");
		}

		PrepayRequest request = new PrepayRequest();
		String outTradeNo = System.currentTimeMillis() + String.format("%06d", new SecureRandom().nextInt(999999));

		// 1. 设置AppId
		request.setAppid(wxProperties.getAppId());
		// 2. 设置商户号
		request.setMchid(wxProperties.getMchId());
		// 3. 设置商品描述
		request.setDescription(prePayReq.getDescription());
		// 4. 设置商户订单号
		request.setOutTradeNo(outTradeNo);
		// 5. 设置支付回调地址
		request.setNotifyUrl(wxProperties.getNotifyUrl());
		// 6. 设置金额
		Amount amount = new Amount();
		amount.setTotal(prePayReq.getAmount());
		amount.setCurrency("CNY");
		request.setAmount(amount);
		// 7. 设置支付者信息
		Payer payer = new Payer();
		payer.setOpenid(prePayReq.getOpenid());
		request.setPayer(payer);

		try {
			// 请求微信服务器JSAPI下单
			PrepayWithRequestPaymentResponse response = jsapiService.prepayWithRequestPayment(request);
			return R.ok(response);
		} catch (ServiceException e) {
			return R.fail(e.getHttpStatusCode(), e.getErrorMessage());
		}

	}

	/**
	 * 查询订单
	 * @param outTradeNo 订单号
	 * @return 结果
	 * 商户可以通过查询订单接口主动查询订单状态，完成下一步的业务逻辑。
	 * 查询订单可通过微信支付订单号 (opens new window)和商户订单号 (opens new window)两种方式查询。
	 * 需要调用查询接口的情况：
	 * 1.当商户后台、网络、服务器等出现异常，商户系统最终未接收到支付通知。
	 * 2.调用支付接口后，返回系统错误或未知交易状态情况。
	 * 3.调用付款码支付API，返回USERPAYING的状态。
	 * 4.调用关单或撤销接口API之前，需确认支付状态。
	 */
	@Override
	public R<?> queryStatus(String outTradeNo) {

		// 判断参数是否为空
		if (outTradeNo == null || outTradeNo.isEmpty()) {
			return R.fail(HttpStatus.BAD_REQUEST, "参数错误");
		}

		QueryOrderByOutTradeNoRequest request = new QueryOrderByOutTradeNoRequest();
		// 1. 设置商户订单号
		request.setOutTradeNo(outTradeNo);
		// 2. 设置商户号
		request.setMchid(wxProperties.getMchId());

		try {
			// 请求微信服务器查询订单
			Transaction response = jsapiService.queryOrderByOutTradeNo(request);
			return R.ok(response);
		} catch (ServiceException e) {
			return R.fail(e.getHttpStatusCode(), e.getErrorMessage());
		}

	}

	/**
	 * 取消订单
	 * @param outTradeNo 订单号
	 * 关闭订单，以下情况需要调用关单接口：
	 * 商户订单支付失败需要生成新单号重新发起支付，要对原订单号调用关单，避免重复支付；
	 * 系统下单后，用户支付超时，系统退出不再受理，避免用户继续，请调用关单接口。
	 */
	@Override
	public R<?> closeOrder(String outTradeNo) {
		// 判断参数是否为空
		if (outTradeNo == null || outTradeNo.isEmpty()) {
			return R.fail(HttpStatus.BAD_REQUEST, "参数错误");
		}

		CloseOrderRequest request = new CloseOrderRequest();
		// 1. 设置商户订单号
		request.setOutTradeNo(outTradeNo);
		// 2. 设置商户号
		request.setMchid(wxProperties.getMchId());

		try {
			// 请求微信服务器关闭订单
			jsapiService.closeOrder(request);
			return R.ok();
		} catch (ServiceException e) {
			return R.fail(e.getHttpStatusCode(), e.getErrorMessage());
		}

	}

}

部分实体类

统一响应实体类

package com.itheima.mp.domain;

import java.io.Serializable;

/**
 * 响应信息主体
 *
 * @author Ccoo
 */
public class R<T> implements Serializable
{
    private static final long serialVersionUID = 1L;

    /** 成功 */
    public static final int SUCCESS = 200;

    /** 失败 */
    public static final int FAIL = 500;

    private int code;

    private String msg;

    private T data;

    public static <T> R<T> ok()
    {
        return restResult(null, SUCCESS, "操作成功");
    }
    public static <T> R<T> ok(String msg)
    {
        return restResult(null, SUCCESS, msg);
    }

    public static <T> R<T> ok(T data)
    {
        return restResult(data, SUCCESS, "操作成功");
    }

    public static <T> R<T> ok(T data, String msg)
    {
        return restResult(data, SUCCESS, msg);
    }

    public static <T> R<T> fail()
    {
        return restResult(null, FAIL, "操作失败");
    }

    public static <T> R<T> fail(String msg)
    {
        return restResult(null, FAIL, msg);
    }

    public static <T> R<T> fail(T data)
    {
        return restResult(data, FAIL, "操作失败");
    }

    public static <T> R<T> fail(T data, String msg)
    {
        return restResult(data, FAIL, msg);
    }

    public static <T> R<T> fail(int code, String msg)
    {
        return restResult(null, code, msg);
    }

    private static <T> R<T> restResult(T data, int code, String msg)
    {
        R<T> apiResult = new R<>();
        apiResult.setCode(code);
        apiResult.setData(data);
        apiResult.setMsg(msg);
        return apiResult;
    }

    public int getCode()
    {
        return code;
    }

    public void setCode(int code)
    {
        this.code = code;
    }

    public String getMsg()
    {
        return msg;
    }

    public void setMsg(String msg)
    {
        this.msg = msg;
    }

    public T getData()
    {
        return data;
    }

    public void setData(T data)
    {
        this.data = data;
    }
}

预支付订单请求实体类

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

/**
 * @author Ccoo
 * 2024/8/24
 */
@Data
@ApiModel(description = "订单预支付实体类")
public class PrePayReq {

	@ApiModelProperty("商品描述")
	private String description;

	@ApiModelProperty("订单金额")
	private Integer amount;

	@ApiModelProperty("用户标识")
	private String openid;

}

响应状态码枚举类

/**
 * 返回状态码
 * 
 * @author ruoyi
 */
public class HttpStatus
{
    /**
     * 操作成功
     */
    public static final int SUCCESS = 200;

    /**
     * 对象创建成功
     */
    public static final int CREATED = 201;

    /**
     * 请求已经被接受
     */
    public static final int ACCEPTED = 202;

    /**
     * 操作已经执行成功，但是没有返回数据
     */
    public static final int NO_CONTENT = 204;

    /**
     * 资源已被移除
     */
    public static final int MOVED_PERM = 301;

    /**
     * 重定向
     */
    public static final int SEE_OTHER = 303;

    /**
     * 资源没有被修改
     */
    public static final int NOT_MODIFIED = 304;

    /**
     * 参数列表错误（缺少，格式不匹配）
     */
    public static final int BAD_REQUEST = 400;

    /**
     * 未授权
     */
    public static final int UNAUTHORIZED = 401;

    /**
     * 访问受限，授权过期
     */
    public static final int FORBIDDEN = 403;

    /**
     * 资源，服务未找到
     */
    public static final int NOT_FOUND = 404;

    /**
     * 不允许的http方法
     */
    public static final int BAD_METHOD = 405;

    /**
     * 资源冲突，或者资源被锁
     */
    public static final int CONFLICT = 409;

    /**
     * 不支持的数据，媒体类型
     */
    public static final int UNSUPPORTED_TYPE = 415;

    /**
     * 系统内部错误
     */
    public static final int ERROR = 500;

    /**
     * 接口未实现
     */
    public static final int NOT_IMPLEMENTED = 501;

    /**
     * 系统警告消息
     */
    public static final int WARN = 601;
}