springboot对接微信支付的完整流程（附前后端代码）

gzh.appid=公众号appid

wxPay.mchId=商户号

wxPay.key= 支付 密钥

wxPay.notifyUrl=域名回调地址

/** 微信 支付统一下单接口*/

     public static final String unifiedOrderUrl = "https://api.mch.weixin.qq测试数据/pay/unifiedorder" ;

     public static String SUCCESSxml = "<xml> \r\n" +

             "\r\n" +

             "  <return_code><![CDATA[SUCCESS]]></return_code>\r\n" +

             "   <return_msg><![CDATA[OK]]></return_msg>\r\n" +

             " </xml> \r\n" +

             "" ;

     public static String ERRORxml =  "<xml> \r\n" +

             "\r\n" +

             "  <return_code><![CDATA[FAIL]]></return_code>\r\n" +

             "   <return_msg><![CDATA[invalid sign]]></return_msg>\r\n" +

             " </xml> \r\n" +

             "" ;

package com.jc.utils.util;

import org.apache测试数据mons.codec.digest.DigestUtils;

import org.apache测试数据mons.lang.StringUtils;

import org.apache.http.HttpEntity;

import org.apache.http.client.ClientProtocolException;

import org.apache.http.client.methods.CloseableHttpResponse;

import org.apache.http.client.methods.HttpPost;

import org.apache.http.conn.ssl.SSLConnectionSocketFactory;

import org.apache.http.entity.StringEntity;

import org.apache.http.impl.client.CloseableHttpClient;

import org.apache.http.impl.client.HttpClients;

import org.apache.http.ssl.SSLContexts;

import org.apache.http.util.EntityUtils;

import org.jdom2.Document;

import org.jdom2.Element;

import org.jdom2.input.SAXBuilder;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import javax.net.ssl.SSLContext;

import javax.servlet.http.HttpServletRequest;

import java.io.*;

import java.net.HttpURLConnection;

import java.net.URL;

import java.security.KeyStore;

import java.security.KeyStoreException;

import java.text.SimpleDateFormat;

import java.util.*;

public class CommUtils {

     private static Logger logger = LoggerFactory.getLogger(CommUtils. class );

     // 连接超时时间，默认10秒

     private static int socketTimeout = 60000 ;

     // 传输超时时间，默认30秒

     private static int connectTimeout= 60000 ;

     /**

      * Util工具类方法

      * 获取一定长度的随机字符串，范围0-9，a-z

      * @param length：指定字符串长度

      * @return 一定长度的随机字符串

      */

     public static String getRandomStringByLength( int length) {

         String base = "abcdefghijklmnopqrstuvwxyz0123456789" ;

         Random random = new Random();

         StringBuffer sb = new StringBuffer();

         for ( int i = 0 ; i < length; i++) {

             int number = random.nextInt(base.length());

             sb.append(base.charAt(number));

         }

         return sb.toString();

     }

     /**

      * 获取订单号

      * @return

      */

     public static String getOrderNo(){

         SimpleDateFormat ft = new SimpleDateFormat( "yyyyMMddHHmmss" );

         String time = ft.format( new Date());

         int mathCode = ( int ) ((Math.random() * 9 + 1 ) * 10000 ); // 5位随机数

         String resultCode = time+mathCode;

         return resultCode;

     }

     /**

      * Util工具类方法

      * 获取真实的ip地址

      * @param request

      * @return

      */

     public static String getIpAddr(HttpServletRequest request) {

         String ip = request.getHeader( "X-Forwarded-For" );

         if (StringUtils.isNotEmpty(ip) && ! "unKnown" .equalsIgnoreCase(ip)) {

             //多次反向代理后会有多个ip值，

             int index = ip.indexOf( "," );

             if (index != - 1 ) {

                 return ip.substring( 0 , index);

             } else {

                 return ip;

             }

         }

         ip = request.getHeader( "X-Real-IP" );

         if (StringUtils.isNotEmpty(ip) && ! "unKnown" .equalsIgnoreCase(ip)) {

             return ip;

         }

         return request.getRemoteAddr();

     }

     /**

      * 签名字符串

      * @param text 需要签名的字符串

      * @param key 密钥

      * @param input_charset 编码格式

      * @return 签名结果

      */

     public static String sign(String text, String key, String input_charset) {

         text = text + "&key=" + key;

         System.out.println(text);

         return DigestUtils.md5Hex(getContentBytes(text, input_charset));

     }

     /**

      * 签名字符串

      * @param text 需要签名的字符串

      * @param sign 签名结果

      * @param key 密钥

      * @param input_charset 编码格式

      * @return 签名结果

      */

     public static boolean verify(String text, String sign, String key, String input_charset) {

         text = text + key;

         String mysign = DigestUtils.md5Hex(getContentBytes(text, input_charset));

         if (mysign.equals(sign)) {

             return true ;

         } else {

             return false ;

         }

     }

     /**

      * @param content

      * @param charset

      * @return

      * @throws UnsupportedEncodingException

      */

     public static byte [] getContentBytes(String content, String charset) {

         if (charset == null || "" .equals(charset)) {

             return content.getBytes();

         }

         try {

             return content.getBytes(charset);

         } catch (UnsupportedEncodingException e) {

             throw new RuntimeException( "MD5签名过程中出现错误,指定的编码集不对,您目前指定的编码集是:" + charset);

         }

     }

     /**

      * 生成6位或10位随机数 param codeLength(多少位)

      * @return

      */

     public static String createCode( int codeLength) {

         String code = "" ;

         for ( int i = 0 ; i < codeLength; i++) {

             code += ( int ) (Math.random() * 9 );

         }

         return code;

     }

     @SuppressWarnings ( "unused" )

     private static boolean isValidChar( char ch) {

         if ((ch >= '0' && ch <= '9' ) || (ch >= 'A' && ch <= 'Z' ) || (ch >= 'a' && ch <= 'z' ))

             return true ;

         if ((ch >= 0x4e00 && ch <= 0x7fff ) || (ch >= 0x8000 && ch <= 0x952f ))

             return true ; // 简体中文汉字编码

         return false ;

     }

     /**

      * 除去数组中的空值和签名参数

      * @param sArray 签名参数组

      * @return 去掉空值与签名参数后的新签名参数组

      */

     public static Map<String, String> paraFilter(Map<String, String> sArray) {

         Map<String, String> result = new HashMap<>();

         if (sArray == null || sArray.size() <= 0 ) {

             return result;

         }

         for (String key : sArray.keySet()) {

             String value = sArray.get(key);

             if (value == null || value.equals( "" ) || key.equalsIgnoreCase( "sign" )

                     || key.equalsIgnoreCase( "sign_type" )) {

                 continue ;

             }

             result.put(key, value);

         }

         return result;

     }

     /**

      * 把数组所有元素排序，并按照[参数=参数值]的模式用[&]字符拼接成字符串

      * @param params 需要排序并参与字符拼接的参数组

      * @return 拼接后字符串

      */

     public static String createLinkString(Map<String, String> params) {

         List<String> keys = new ArrayList<>(params.keySet());

         Collections.sort(keys);

         String prestr = "" ;

         for ( int i = 0 ; i < keys.size(); i++) {

             String key = keys.get(i);

             String value = params.get(key);

             if (i == keys.size() - 1 ) { // 拼接时，不包括最后一个&字符

                 prestr = prestr + key + "=" + value;

             } else {

                 prestr = prestr + key + "=" + value + "&" ;

             }

         }

         return prestr;

     }

     /**

      *

      * @param requestUrl 请求地址

      * @param requestMethod 请求方法

      * @param outputStr 参数

      */

     public static String httpRequest(String requestUrl,String requestMethod,String outputStr){

         logger.warn( "请求报文：" +outputStr);

         StringBuffer buffer = null ;

         try {

             URL url = new URL(requestUrl);

             HttpURLConnection conn = (HttpURLConnection) url.openConnection();

             conn.setRequestMethod(requestMethod);

             conn.setDoOutput( true );

             conn.setDoInput( true );

             conn.connect();

             //往服务器端写内容

             if ( null !=outputStr){

                 OutputStream os=conn.getOutputStream();

                 os.write(outputStr.getBytes( "utf-8" ));

                 os.close();

             }

             // 读取服务器端返回的内容

             InputStream is = conn.getInputStream();

             InputStreamReader isr = new InputStreamReader(is, "utf-8" );

             BufferedReader br = new BufferedReader(isr);

             buffer = new StringBuffer();

             String line = null ;

             while ((line = br.readLine()) != null ) {

                 buffer.append(line);

             }

             br.close();

         } catch (Exception e){

             e.printStackTrace();

         }

         logger.warn( "返回报文：" +buffer.toString());

         return buffer.toString();

     }

     /**

      * POST请求

      * @param url           请求url

      * @param xmlParam      请求参数

      * @param apiclient     证书

      * @param mch_id        商户号

      * @return

      * @throws Exception

      */

     public static String post(String url, String xmlParam,String apiclient,String mch_id) throws Exception {

         logger.warn( "请求报文：" +xmlParam);

         StringBuilder sb = new StringBuilder();

         try {

             KeyStore keyStore = KeyStore.getInstance( "PKCS12" );

             FileInputStream instream = new FileInputStream( new File(apiclient));

             try {

                 keyStore.load(instream, mch_id.toCharArray());

             } finally {

                 instream.close();

             }

             // 证书

             SSLContext sslcontext = SSLContexts.custom()

                     .loadKeyMaterial(keyStore, mch_id.toCharArray()).build();

             // 只允许TLSv1协议

             SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(

                     sslcontext, new String[]{ "TLSv1" }, null , SSLConnectionSocketFactory.BROWSER_COMPATIBLE_HOSTNAME_VERIFIER);

             //创建基于证书的httpClient,后面要用到

             CloseableHttpClient client = HttpClients.custom().setSSLSocketFactory(sslsf).build();

             HttpPost httpPost = new HttpPost(url); //退款接口

             StringEntity reqEntity = new StringEntity(xmlParam, "UTF-8" );

             // 设置类型

             reqEntity.setContentType( "application/x-www-form-urlencoded" );

             httpPost.setEntity(reqEntity);

             CloseableHttpResponse response = client.execute(httpPost);

             try {

                 HttpEntity entity = response.getEntity();

                 System.out.println(response.getStatusLine());

                 if (entity != null ) {

                     BufferedReader bufferedReader = new BufferedReader( new InputStreamReader(entity.getContent(), "UTF-8" ));

                     String text = "" ;

                     while ((text = bufferedReader.readLine()) != null ) {

                         sb.append(text);

                     }

                 }

                 EntityUtils.consume(entity);

             } catch (Exception e) {

                 e.printStackTrace();

             } finally {

                 try {

                     response.close();

                 } catch (IOException e) {

                     e.printStackTrace();

                 }

             }

         } catch (KeyStoreException e) {

             e.printStackTrace();

         } catch (ClientProtocolException e) {

             e.printStackTrace();

         } catch (IOException e) {

             e.printStackTrace();

         } catch (Exception e) {

             e.printStackTrace();

         }

         logger.warn( "返回报文：" +sb.toString());

         return sb.toString();

     }

     public static String urlEncodeUTF8(String source){

         String result=source;

         try {

             result=java.net.URLEncoder.encode(source, "UTF-8" );

         } catch (UnsupportedEncodingException e) {

             // TODO Auto-generated catch block

             e.printStackTrace();

         }

         return result;

     }

     /**

      * 解析xml,返回第一级元素键值对。如果第一级元素有子节点，则此节点的值是子节点的xml数据。

      * @param strxml

      * @return

      * @throws org.jdom2.JDOMException

      * @throws IOException

      */

     public static Map doXMLParse(String strxml) throws Exception {

         if ( null == strxml || "" .equals(strxml)) {

             return null ;

         }

         Map m = new HashMap();

         InputStream in = String2Inputstream(strxml);

         SAXBuilder builder = new SAXBuilder();

         Document doc = builder.build(in);

         Element root = doc.getRootElement();

         List list = root.getChildren();

         Iterator it = list.iterator();

         while (it.hasNext()) {

             Element e = (Element) it.next();

             String k = e.getName();

             String v = "" ;

             List children = e.getChildren();

             if (children.isEmpty()) {

                 v = e.getTextNormalize();

             } else {

                 v = getChildrenText(children);

             }

             m.put(k, v);

         }

         in.close();

         return m;

     }

     /**

      * 获取子结点的xml

      * @param children

      * @return String

      */

     public static String getChildrenText(List children) {

         StringBuffer sb = new StringBuffer();

         if (!children.isEmpty()) {

             Iterator it = children.iterator();

             while (it.hasNext()) {

                 Element e = (Element) it.next();

                 String name = e.getName();

                 String value = e.getTextNormalize();

                 List list = e.getChildren();

                 sb.append( "<" + name + ">" );

                 if (!list.isEmpty()) {

                     sb.append(getChildrenText(list));

                 }

                 sb.append(value);

                 sb.append( "</" + name + ">" );

             }

         }

         return sb.toString();

     }

     public static InputStream String2Inputstream(String str) {

         return new ByteArrayInputStream(str.getBytes());

     }

}

package com.jch.mng.controller;

import com.jch.boot测试数据ponent.CommonInfo;

import com.jch.boot测试数据ponent.Result;

import com.jch.boot测试数据ponent.ServiceCommonInfo;

import com.jch.mng.dto.input.gzh.WxPayDto;

import com.jch.mng.service.WxPayService;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.web.bind.annotation.PostMapping;

import org.springframework.web.bind.annotation.RequestBody;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

/**

  * Created by xxs on 2021/7/30 10:54

  *

  * @Description 公众号微信支付

  * @Version 2.9

  */

@RestController

@RequestMapping ( "/wxPay" )

public class WxPayController {

     @Autowired

     private WxPayService payService;

     /**

     * @Author: xxs

     * @param dto

      * @param request

     * @Date: 2021/7/30 11:55

     * @Description:  公众号微信支付

     * @Version: 2.9

     * @Return: com.jch.boot测试数据ponent.Result<java.lang.String>

     */

     @PostMapping ( "/pay" )

     public Result<String> pay( @RequestBody WxPayDto dto, HttpServletRequest request) throws Exception {

         ServiceCommonInfo<Object> result = payService.pay(dto,request);

         return CommonInfo.controllerBack(result);

     }

     /**

     * @Author: xxs

     * @param request

      * @param response

     * @Date: 2021/7/30 11:55

     * @Description:  支付回调

     * @Version: 2.9

     * @Return: void

     */

     @PostMapping ( "/notify" )

     public void notify(HttpServletRequest request, HttpServletResponse response) throws Exception {

         payService.notify(request,response);

     }

}

package com.jch.mng.service;

import com.jch.boot测试数据ponent.ServiceCommonInfo;

import com.jch.mng.dto.input.gzh.WxPayDto;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

/**

  * Created by xxs on 2021/7/30 9:56

  *

  * @Description

  * @Version 2.9

  */

public interface WxPayService {

     ServiceCommonInfo<Object> pay(WxPayDto dto, HttpServletRequest request) throws Exception;

     void notify(HttpServletRequest request, HttpServletResponse response) throws Exception;

}

package com.jch.mng.service.impl;

import com.alibaba.fastjson.JSON;

import com.jc.utils.util.CommUtils;

import com.jch.boot测试数据ponent.ServiceCommonInfo;

import com.jch.mng.constant.WeChatConstants;

import com.jch.mng.dto.input.gzh.WxPayDto;

import com.jch.mng.service.WxPayService;

import com.jch.mng.utils.DoubleUtil;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.stereotype.Service;

import javax.servlet.ServletInputStream;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import java.io.BufferedOutputStream;

import java.io.BufferedReader;

import java.io.InputStreamReader;

import java.util.HashMap;

import java.util.Map;

/**

  * Created by xxs on 2021/7/30 9:56

  *

  * @Description

  * @Version 2.9

  */

@Service

public class WxPayServiceImpl implements WxPayService {

     public   String appId;

     public   String mch_id;

     public   String notify_url;

     public   String key;

     @Value ( "${gzh.appid}" )

     public void setAppId(String appId) {

         this .appId = appId;

     }

     @Value ( "${wxPay.mchId}" )

     public void setMch_id(String mch_id) {

         this .mch_id = mch_id;

     }

     @Value ( "${wxPay.notifyUrl}" )

     public void setNotify_url(String notify_url) {

         this .notify_url = notify_url;

     }

     @Value ( "${wxPay.key}" )

     public void setKey(String key) {

         this .key = key;

     }

     private static Logger logger = LoggerFactory.getLogger(WxPayServiceImpl. class );

     /**

     * @Author: xxs

     * @param dto

      * @param request

     * @Date: 2021/7/30 11:01

     * @Description:  微信支付

     * @Version: 2.9

     * @Return: com.jch.boot测试数据ponent.ServiceCommonInfo<java.lang.Object>

     */

     @Override

     public ServiceCommonInfo<Object> pay(WxPayDto dto, HttpServletRequest request) throws Exception {

         logger.info( "公众号微信支付, 入参:{}" , JSON.toJSONString(dto));

         String openid = dto.getOpenid();

         String outTradeNo = dto.getOutTradeNo();

         String body = dto.getBody();

         Double totalFee = dto.getTotalFee();

         String nonce_str = CommUtils.getRandomStringByLength( 32 );

         String spbill_create_ip = CommUtils.getIpAddr(request);

         Map<String, String> packageParams = new HashMap<>();

         packageParams.put( "appid" , appId);

         packageParams.put( "mch_id" ,mch_id);

         packageParams.put( "nonce_str" , nonce_str);

         packageParams.put( "body" , body);

         packageParams.put( "out_trade_no" , outTradeNo);

         double t = DoubleUtil.parseDouble(totalFee); //保留两位小数

         int aDouble = Integer.parseInt( new java.text.DecimalFormat( "0" ).format(t* 100 ));

         packageParams.put( "total_fee" , aDouble+ "" );

         packageParams.put( "spbill_create_ip" , spbill_create_ip);

         packageParams.put( "notify_url" , notify_url);

         packageParams.put( "trade_type" , "JSAPI" );

         packageParams.put( "openid" , openid);

         packageParams = CommUtils.paraFilter(packageParams);

         String prestr = CommUtils.createLinkString(packageParams);

         String sign = CommUtils.sign(prestr, key, "utf-8" ).toUpperCase();

         logger.info( "统一下单请求签名：" + sign );

         String xml = "<xml version='1.0' encoding='gbk'>" + "<appid>" + appId + "</appid>"

                 + "<body><![CDATA[" + body + "]]></body>"

                 + "<mch_id>" + mch_id + "</mch_id>"

                 + "<nonce_str>" + nonce_str + "</nonce_str>"

                 + "<notify_url>" + notify_url+ "</notify_url>"

                 + "<openid>" + openid + "</openid>"

                 + "<out_trade_no>" + outTradeNo + "</out_trade_no>"

                 + "<spbill_create_ip>" + spbill_create_ip + "</spbill_create_ip>"

                 + "<total_fee>" + aDouble+ "" + "</total_fee>"

                 + "<trade_type>" + "JSAPI" + "</trade_type>"

                 + "<sign>" + sign + "</sign>"

                 + "</xml>" ;

         String result = CommUtils.httpRequest(WeChatConstants.unifiedOrderUrl, "POST" , xml);

         Map map = CommUtils.doXMLParse(result);

         Object return_code =  map.get( "return_code" );

         logger.info( "统一下单返回return_code：" + return_code );

         if (return_code == "SUCCESS"   || return_code.equals(return_code)){

             Map<String,String> resultMap= new HashMap<String, String>();

             String prepay_id = (String) map.get( "prepay_id" );

             resultMap.put( "appId" , appId);

             Long timeStamp = System.currentTimeMillis() / 1000 ;

             resultMap.put( "timeStamp" , timeStamp + "" );

             resultMap.put( "nonceStr" , nonce_str);

             resultMap.put( "package" , "prepay_id=" + prepay_id);

             resultMap.put( "signType" , "MD5" );

             logger.info( "参与paySign签名数据, 入参:{}" , JSON.toJSONString(resultMap));

             String linkString = CommUtils.createLinkString(resultMap);

             String paySign = CommUtils.sign(linkString, key, "utf-8" ).toUpperCase();

             logger.info( "获取到paySign:" +paySign);

             resultMap.put( "paySign" , paySign);

             return ServiceCommonInfo.success( "ok" , resultMap);

         }

         return ServiceCommonInfo.serviceFail( "支付失败" , null );

     }

     /**

     * @Author: xxs

     * @param request

      * @param response

     * @Date: 2021/7/31 15:17

     * @Description:  微信支付回调

     * @Version: 2.9

     * @Return: void

     */

     @Override

     public void notify(HttpServletRequest request, HttpServletResponse response) throws Exception {

         logger.info( "进入支付回调啦啦啦啦*-*" );

         String resXml = "" ;

         BufferedReader br = new BufferedReader( new InputStreamReader((ServletInputStream) request.getInputStream()));

         String line = null ;

         StringBuilder sb = new StringBuilder();

         while ((line = br.readLine()) != null ) {

             sb.append(line);

         }

         br.close();

         String notityXml = sb.toString();

         logger.info( "支付回调返回数据：" +notityXml);

         Map map = CommUtils.doXMLParse(notityXml);

         Object returnCode = map.get( "return_code" );

         Object result_code = map.get( "result_code" );

         if ( "SUCCESS" .equals(returnCode) && "SUCCESS" .equals(result_code)) {

             Map<String, String> validParams = CommUtils.paraFilter(map);  //回调验签时需要去除sign和空值参数

             String validStr = CommUtils.createLinkString(validParams); //把数组所有元素，按照[参数=参数值]的模式用[&]字符拼接成字符串

             String sign = CommUtils.sign(validStr, key , "utf-8" ).toUpperCase(); //拼装生成服务器端验证的签名

             logger.info( "支付回调生成签名：" +sign);

             String transaction_id = (String) map.get( "transaction_id" );

             String order_no = (String) map.get( "out_trade_no" );

             String time_end = (String) map.get( "time_end" );

             String total_fee = (String) map.get( "total_fee" );

             //签名验证,并校验返回的订单金额是否与商户侧的订单金额一致

             if (sign.equals(map.get( "sign" ))) {

                 logger.info( "支付回调验签通过" );

                 //通知微信服务器已经支付成功

                 resXml = WeChatConstants.SUCCESSxml;

             } else {

                 logger.info( "微信支付回调失败!签名不一致" );

             }

         } else {

             resXml = WeChatConstants.ERRORxml;

         }

         System.out.println(resXml);

         logger.info( "微信支付回调返回数据：" +resXml);

         logger.info( "微信支付回调数据结束" );

         BufferedOutputStream out = new BufferedOutputStream(response.getOutputStream());

         out.write(resXml.getBytes());

         out.flush();

         out.close();

     }

}

<!DOCTYPE html>

<html lang= "en" >

<head>

     <meta charset= "UTF-8" >

     <title>Title</title>

     <meta content= "width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=0;" name= "viewport" />

</head>

<body>

     body: <input type= "text" class= "inp-body" ><br>

     outTradeNo: <input type= "text" class= "inp-outTradeNo" ><br>

     totalFee: <input type= "text" class= "inp-totalFee" ><br>

     openid: <input type= "text" class= "inp-openid" ><br>

     <button onclick= "handleWxPay()" >支付</button>

</body>

</html>

<script src= "https://cdnjs.cloudflare测试数据/ajax/libs/jquery/3.5.1/jquery.min.js" ></script>

<script>

     function handleWxPay(){

         let obj = {

             "body" :$( ".inp-body" ).val(),

             "outTradeNo" :$( ".inp-outTradeNo" ).val(),

             "totalFee" :$( ".inp-totalFee" ).val(),

             "openid" :$( ".inp-openid" ).val(),

         }

         $.ajax({

             type: "POST" ,

             url: "微信支付接口地址" ,

             data:JSON.stringify(obj),

             beforeSend: function (request) {

                 request.setRequestHeader( "Content-Type" , "application/json" );

             },

             success: result=> {

                 let obj = JSON.parse(result.data)

                 onBridgeReady(obj)

             }

         });

     }

     function onBridgeReady(obj){

         WeixinJSBridge.invoke(

             'getBrandWCPayRequest' , obj,

             function (res){

                 alert(JSON.stringify(res))

                 if (res.err_msg == "get_brand_wcpay_request:ok" ){

                     // 使用以上方式判断前端返回,微信团队郑重提示：

                     //res.err_msg将在用户支付成功后返回ok，但并不保证它绝对可靠。

                 }

             });

     }

</script>

<dependency>

             <groupId>org.springframework.boot</groupId>

             <artifactId>spring-boot-starter-thymeleaf</artifactId>

         </dependency>

package com.jch.mng.controller;

import org.springframework.stereotype.Controller;

import org.springframework.web.bind.annotation.RequestMapping;

import javax.servlet.http.HttpServletResponse;

/**

  * Created by xxs on 2021/7/31 12:29

  *

  * @Description

  * @Version 2.9

  */

@Controller

public class TestPageController {

     @RequestMapping ( "/wxPayTest" )

     public String test(HttpServletResponse response)  {

         return "wxPay" ;

     }

}