微信二维码支付

最新推荐文章于 2024-06-05 01:29:18 发布
最新推荐文章于 2024-06-05 01:29:18 发布
阅读量4.6k 收藏 46
点赞数 17
分类专栏： Java 微信
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42218313/article/details/113533707
版权
Java 同时被 2 个专栏收录
38 篇文章 0 订阅
订阅专栏
微信
2 篇文章 0 订阅
订阅专栏

一、创建微服务

1、导入依赖

<!--微信支付-->
<dependency>
    <groupId>com.github.wxpay</groupId>
    <artifactId>wxpay-sdk</artifactId>
    <version>0.0.3</version>
</dependency>
<!--httpclient支持-->
    <dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
</dependency>

2、需要的工具类

HttpClient：http/https相关操作

public class HttpClient {
    private String url;
    private Map<String, String> 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 HttpClient(String url, Map<String, String> param) {
        this.url = url;
        this.param = param;
    }

    public HttpClient(String url) {
        this.url = url;
    }

    public void setParameter(Map<String, String> map) {
        param = map;
    }

    public void addParameter(String key, String value) {
        if (param == null)
            param = new HashMap<String, String>();
        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("?");
                }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<NameValuePair> nvps = new LinkedList<NameValuePair>();
            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() {
                            // 信任所有
                            @Override
                            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;
    }
}

3、配置文件：application.yml

server:
  port: 18090
spring:
  application:
    name: pay
  main:
    allow-bean-definition-overriding: true
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:7001/eureka
  instance:
    prefer-ip-address: true
feign:
  hystrix:
    enabled: true
#hystrix 配置
hystrix:
  command:
    default:
      execution:
        timeout:
          #如果enabled设置为false，则请求超时交给ribbon控制
          enabled: true
        isolation:
          strategy: SEMAPHORE

#微信支付信息配置
weixin:
  #应用ID
  appid: wx8397f8696b538317
  #商户号
  partner: 1473426802
  #密钥
  partnerkey: T6m9iK73b0kn9g5v426MKfHQH7X8rKwb
  #支付回调地址 通知地址
  notifyurl: https://www.cnblogs.com/chawaner/

4、SpringBoot启动类

/**
 * @Author TeaBowl
 * @Date 2021/2/1 10:47
 * @Version 1.0
 */
@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})
@EnableEurekaClient
public class WeiXinPayApplication {
    public static void main(String[] args) {
        SpringApplication.run(WeiXinPayApplication.class,args);
    }
}

5、控制层

/**
 * @Author TeaBowl
 * @Date 2021/2/1 12:01
 * @Version 1.0
 */
@RestController
@RequestMapping(value = "/weixin/pay")
public class WeiXinPayController {

    @Autowired
    private WeixinPayService weixinPayService;

    /**
     * 创建二维码
     * @param parameterMap：用户订单信息
     * @return
     */
    @RequestMapping(value = "/create/native")
    public Result createNative(@RequestParam Map<String,String> parameterMap){
        Map<String,String> resultMap = weixinPayService.createnative(parameterMap);
        return new Result(true, StatusCode.OK,"创建二维码预付订单成功！",resultMap);
    }
}

6、应用层

/**
 * @Author TeaBowl
 * @Date 2021/2/1 11:01
 * @Version 1.0
 */
public interface WeixinPayService {
    /**
     * 创建二维码
     * @param parameterMap：用户订单信息
     * @return
     */
    Map createnative(Map<String,String> parameterMap);
}

/**
 * @Author TeaBowl
 * @Date 2021/2/1 11:00
 * @Version 1.0
 */
@Service
public class WeixinPayServiceImpl implements WeixinPayService {

    //应用ID
    @Value("${weixin.appid}")
    private String appid;
    //商户号
    @Value("${weixin.partner}")
    private String partner;
    //密钥
    @Value("${weixin.partnerkey}")
    private String partnerkey;
    //通知地址
    @Value("${weixin.notifyurl}")
    private String notifyurl;

    /**
     * 创建二维码
     *
     * @param parameterMap：用户订单信息
     * @return
     */
    @Override
    public Map createnative(Map<String, String> parameterMap) {
        try {
            //远程调用
            //创建一个Map集合存放请求参数
            Map<String, String> paramMap = new HashMap<>();
            //添加数据
            //应用ID
            paramMap.put("appid", appid);
            //商户号
            paramMap.put("mch_id", partner);
            //随机字符串
            paramMap.put("nonce_str", WXPayUtil.generateNonceStr());
            //商品描述
            paramMap.put("body", "茶碗儿购物是真的好");
            //订单号
            paramMap.put("out_trade_no", parameterMap.get("outtradeno"));
            //交易总金额，单位为：分
            paramMap.put("total_fee", parameterMap.get("totalfee"));
            //终端IP
            paramMap.put("spbill_create_ip", "127.0.0.1");
            //通知地址，添URL地址
            paramMap.put("notify_url", notifyurl);
            //交易类型，NATIVE
            paramMap.put("trade_type", "NATIVE");

            //签名
            //paramMap.put("sign","");
            //Map转为XML数据，可以自带签名
            //将请求参数集合，转为带有签名的XML数据格式
            String xmlStr = WXPayUtil.generateSignedXml(paramMap, partnerkey);

            //URL地址，微信支付接口链接
            String url = "https://api.mch.weixin.qq.com/pay/unifiedorder";

            //提交方式:HTTPS
            //创建HttpClient对象,对url请求地址进行操作
            HttpClient httpClient = new HttpClient(url);
            //设置提交方式为HTTPS
            httpClient.setHttps(true);

            //提交参数,参数以XML数据格式提交
            httpClient.setXmlParam(xmlStr);

            //执行请求
            //发送XML数据，使用post请求
            httpClient.post();

            //获取返回的数据,此时返回的数据为XML数据格式
            String content = httpClient.getContent();
            System.out.println("content:" + content);

            //返回数据转成Map
            Map<String, String> resultMap = WXPayUtil.xmlToMap(content);
            return resultMap;

        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

二、测试

1、浏览器输入请求地址：http://localhost:18090/weixin/pay/create/native?outtradeno=198999&totalfee=101

2、参数解释：

​ outtradeno：订单号

​ totalfee：总金额

3、浏览器请求结果

{
    "flag": true,
    "code": 20000,
    "message": "创建二维码预付订单成功！",
    "data": {
        "nonce_str": "pUPI4MeBq1ikJbOJ",
        "code_url": "weixin://wxpay/bizpayurl?pr=qJVBnYYzz",
        "appid": "wx8397f8696b538317",
        "sign": "7BCED5501AD892D5490A109DADE3383F",
        "trade_type": "NATIVE",
        "return_msg": "OK",
        "result_code": "SUCCESS",
        "mch_id": "1473426802",
        "return_code": "SUCCESS",
        "prepay_id": "wx011403161517455f3f2880f7e02e920000"
    }
}

三、生成二维码

1、使用qrious.js写一个页面pay.html，用于生成二维码

<html>
<head>
<title>二维码入门小demo</title>
<!--1.引入js  2. 创建一个img标签 用来存储显示二维码的图片 3.创建js对象 4.设置js对象的配置项-->
<script src="qrious.js"> </script>
</head>
<body>
<img id="myqrious" >
</body>
<script>
   var qrious = new QRious({
   		 element:document.getElementById("myqrious"),// 指定的是图片所在的DOM对象
   		 size:250,//指定图片的像素大小
		 level:'H',//指定二维码的容错级别(H:可以恢复30%的数据)
		 value:'weixin://wxpay/bizpayurl?pr=qJVBnYYzz'//指定二维码图片代表的真正的值
   })
</script>
</html>

2、打开pay.html，显示一个二维码，微信扫码支付

四、查询支付状态

1、控制层添加方法(controller)

/**
 * 微信支付状态查询
 * @param outtradeno:商户订单号，由微信服务器生成
 * @return
 */
@GetMapping(value = "/status/query")
public Result queryStatus(String outtradeno){
    //查询微信支付状态
    Map map = weixinPayService.queryStatus(outtradeno);
    return new Result(true, StatusCode.OK,"微信支付状态查询成功！",map);
}

2、应用层添加方法(service、serviceImpl)

/**
 * 查询微信支付状态
 * @param outtradeno：商户订单号，由微信服务器生成
 * @return
 */
 Map queryStatus(String outtradeno);

/**
     * 查询微信支付状态
     * @param outtradeno：商户订单号，由微信服务器生成
     * @return
     */
    @Override
    public Map queryStatus(String outtradeno) {
        try {
            //远程调用
            //创建一个Map集合存放请求参数
            Map<String, String> paramMap = new HashMap<>();
            //添加数据
            //应用ID
            paramMap.put("appid", appid);
            //商户号
            paramMap.put("mch_id", partner);
            //随机字符串
            paramMap.put("nonce_str", WXPayUtil.generateNonceStr());
            //订单号
            paramMap.put("out_trade_no", outtradeno);

            //签名
            //paramMap.put("sign","");
            //Map转为XML数据，可以自带签名
            //将请求参数集合，转为带有签名的XML数据格式
            String xmlStr = WXPayUtil.generateSignedXml(paramMap, partnerkey);

            //URL地址，微信查询订单接口链接
            String url = "https://api.mch.weixin.qq.com/pay/orderquery";

            //提交方式:HTTPS
            //创建HttpClient对象,对url请求地址进行操作
            HttpClient httpClient = new HttpClient(url);
            //设置提交方式为HTTPS
            httpClient.setHttps(true);

            //提交参数,参数以XML数据格式提交
            httpClient.setXmlParam(xmlStr);

            //执行请求
            //发送XML数据，使用post请求
            httpClient.post();

            //获取返回的数据,此时返回的数据为XML数据格式
            String content = httpClient.getContent();
            //System.out.println("content:" + content);

            //返回数据转成Map
            Map<String, String> resultMap = WXPayUtil.xmlToMap(content);
            return resultMap;

        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

3、浏览器输入请求地址：http://localhost:18090/weixin/pay/status/query?outtradeno=198999

参数解释：outtradeno：订单号

{
    "flag": true,
    "code": 20000,
    "message": "微信支付状态查询成功！",
    "data": {
        "nonce_str": "9FMEOJb0nhdJzGOQ",
        "device_info": "",
        "out_trade_no": "198999",
        "trade_state": "NOTPAY",
        "appid": "wx8397f8696b538317",
        "total_fee": "101",
        "sign": "1C86209F252D64254542EFC5481FD0D0",
        "trade_state_desc": "订单未支付",
        "return_msg": "OK",
        "result_code": "SUCCESS",
        "mch_id": "1473426802",
        "return_code": "SUCCESS"
    }
}

因为上面测试支付二维码时候，我没支付，所以查询订单支付状态显示“订单未支付”。

五、支付结果回调

1、控制层添加方法

/**
     * 支付结果通知回调方法
     * @param request
     * @return
     */
    @RequestMapping(value = "/notify/url")
    public String notifyurl(HttpServletRequest request) throws Exception {
        //获取网络输入流，也就是网络输入流格式的通知结果
        ServletInputStream inputStream = request.getInputStream();

        //创建一个OutputStream输出流->输入文件
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

        //定义缓冲区
        byte[] buffer = new byte[1024];

        //初始化一个数据长度
        int len = 0;

        //往缓冲区里读文件，数据长度 不等于-1说明有数据
        while ((len = inputStream.read(buffer))!=-1){
            //缓冲区中的数据  写入到   输出流对象中
            //从0开始读到长度最后一位
            byteArrayOutputStream.write(buffer,0,len);
        }

        //将byteArrayOutputStream字节流转为字节数组
        //这就是微信支付结果的字节数组
        byte[] byteArray = byteArrayOutputStream.toByteArray();

        //字节数组  转为  xml字符串
        String xmlResult = new String(byteArray, "Utf-8");
        System.out.println("xmlResult:\n"+xmlResult);

        //xml字符串  转为  Map
        Map<String, String> resultMap = WXPayUtil.xmlToMap(xmlResult);
        System.out.println("resultMap:\n"+resultMap);

        //返回结果
        String result = "<xml><return_code><![CDATA[SUCCESS]]></return_code><return_msg><![CDATA[OK]]></return_msg></xml>";
        return result;
    }

2、配置文件中修改回调地址为动态调用

#微信支付信息配置
weixin:
  #应用ID
  appid: wx8397f8696b538317
  #商户号
  partner: 1473426802
  #密钥
  partnerkey: T6m9iK73b0kn9g5v426MKfHQH7X8rKwb
  #支付回调地址 通知地址
  #外网域名：http://19453k43d4.51vip.biz:32375
  notifyurl: http://19453k43d4.51vip.biz:32375/weixin/pay/notify/url

3、创建二维码

浏览器输入请求：http://19453k43d4.51vip.biz:32375/weixin/pay//create/native?outtradeno=1999&totalfee=1

{
    "flag": true,
    "code": 20000,
    "message": "创建二维码预付订单成功！",
    "data": {
        "nonce_str": "pUPI4MeBq1ikJbOJ",
        "code_url": "weixin://wxpay/bizpayurl?pr=qJVBnYYzd",
        "appid": "wx8397f8696b538317",
        "sign": "7BCED5501AD892D5490A109DADE3383F",
        "trade_type": "NATIVE",
        "return_msg": "OK",
        "result_code": "SUCCESS",
        "mch_id": "1473426802",
        "return_code": "SUCCESS",
        "prepay_id": "wx011403161517455f3f2880f7e02e920000"
    }
}

4、修改pay.html中的value为上步的code_url

<html>
<head>
<title>二维码入门小demo</title>
<!--1.引入js  2. 创建一个img标签 用来存储显示二维码的图片 3.创建js对象 4.设置js对象的配置项-->
<script src="qrious.js"> </script>
</head>
<body>
<img id="myqrious" >
</body>
<script>
   var qrious = new QRious({
   		 element:document.getElementById("myqrious"),// 指定的是图片所在的DOM对象
   		 size:250,//指定图片的像素大小
		 level:'H',//指定二维码的容错级别(H:可以恢复30%的数据)
		 value:'weixin://wxpay/bizpayurl?pr=qJVBnYYzd'//指定二维码图片代表的真正的值
   })
</script>
</html>

5、双击打开pay.html，生成一个二维码，扫码支付后；

浏览器输入请求地址:http://19453k43d4.51vip.biz:32375/weixin/pay/status/query?outtradeno=1999

{
"flag": true,
"code": 20000,
"message": "微信支付状态查询成功！",
    "data": {
        "transaction_id": "4200000517202002187004756359",
        "nonce_str": "ZxVmHMCc1mVr8rxR",
        "trade_state": "SUCCESS",
        "bank_type": "OTHERS",
        "openid": "oNpSGwaqHv74waDX0BLPNrFiYIUo",
        "sign": "3DC6A5346C914DE745DBBB7796039BC1",
        "return_msg": "OK",
        "fee_type": "CNY",
        "mch_id": "1473426802",
        "cash_fee": "1",
        "out_trade_no": "1999",
        "cash_fee_type": "CNY",
        "appid": "wx8397f8696b538317",
        "total_fee": "1",
        "trade_state_desc": "支付成功",
        "trade_type": "NATIVE",
        "result_code": "SUCCESS",
        "attach": "",
        "time_end": "20200218153715",
        "is_subscribe": "N",
        "return_code": "SUCCESS"
    }
}

6、查看控制台输出，有一个支付结果通知

六、MQ消息中间件监听

微信服务返回的支付状态，发送给MQ消息中间件

1、在支付系统中导入依赖

<!--加入ampq-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

2、配置文件application.yml中添加信息

 rabbitmq:
 	host: 服务器地址
 	port: 端口
	username: 用户名
	password: 密码
#位置支付交换机和队列
mq:
  pay:
    exchange:
      order: exchange.order
    queue:
      order: queue.order
    routing:
      key: queue.order

实际开发中登录“服务器地址:15672”手动创建交换机和队列

3、创建队列绑定交换机配置

/**
 * @Author TeaBowl
 * @Date 2021/2/3 11:26
 * @Version 1.0
 */
@Configuration
public class MQConfig {

    /**
     * 读取配置文件中的信息
     */
    @Autowired
    private  Environment env;

    /**
     * 创建队列
     * @return
     */
    @Bean
    public Queue OrderQueue (){
        //参数：队列名
        return new Queue(env.getProperty("mq.pay.queue.order"));
    }

    /**
     * 创建交换机
     * @return
     */
    @Bean
    public Exchange OrderExchange (){
        //参数：交换机名、是否持久化、是否自动删除
        return new DirectExchange(env.getProperty("mq.pay.exchange.order"),true,false);
    }

    /**
     * 队列绑定交换机
     * @param orderQueue:队列
     * @param orderExchange:交换机
     * @return
     */
    @Bean
    public Binding orderQueueExchange(Queue orderQueue,Exchange orderExchange){
        //队列绑定交换机  
        return BindingBuilder.bind(orderQueue).to(orderExchange).with(env.getProperty("mq.pay.routing.key")).noargs();
    }

}

4、controller中注入MQ操作对象

//注入MQ操作对象
@Autowired
private RabbitTemplate rabbitTemplate;

5、修改controller中支付结果通知回调方法

/**
     * 支付结果通知回调方法
     * @param request
     * @return
     */
    @RequestMapping(value = "/notify/url")
    public String notifyurl(HttpServletRequest request) throws Exception {
        //获取网络输入流，也就是网络输入流格式的通知结果
        ServletInputStream inputStream = request.getInputStream();

        //创建一个OutputStream输出流->输入文件
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

        //定义缓冲区
        byte[] buffer = new byte[1024];

        //初始化一个数据长度
        int len = 0;

        //往缓冲区里读文件，数据长度 不等于-1说明有数据
        while ((len = inputStream.read(buffer))!=-1){
            //缓冲区中的数据  写入到   输出流对象中
            //从0开始读到长度最后一位
            byteArrayOutputStream.write(buffer,0,len);
        }

        //将byteArrayOutputStream字节流转为字节数组
        //这就是微信支付结果的字节数组
        byte[] byteArray = byteArrayOutputStream.toByteArray();

        //字节数组  转为  xml字符串
        String xmlResult = new String(byteArray, "Utf-8");
        System.out.println("xmlResult:\n"+xmlResult);

        //xml字符串  转为  Map
        Map<String, String> resultMap = WXPayUtil.xmlToMap(xmlResult);
        System.out.println("resultMap:\n"+resultMap);

        //发送支付结果给MQ
        rabbitTemplate.convertAndSend("exchange.order","queue.order", JSON.toJSONString(resultMap));

        //返回结果
        String result = "<xml><return_code><![CDATA[SUCCESS]]></return_code><return_msg><![CDATA[OK]]></return_msg></xml>";
        return result;
    }

订单系统监听MQ消息

1、在订单系统中导入依赖

<!--加入ampq-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

2、配置文件application.yml中添加信息

 rabbitmq:
    host: 服务器地址
    port: 端口
    username: 用户名
    password: 密码
#位置支付交换机和队列
mq:
  pay:
    #交换机
    exchange:
      order: exchange.order
    #队列
    queue:
      order: queue.order
    routing:
      key: queue.order

3、创建监听MQ信息配置

/**
 * @Author TeaBowl
 * @Date 2021/2/3 12:02
 * @Version 1.0
 * 监听MQ信息
 */
@Component
@RabbitListener(queues = "${mq.pay.queue.order}")   //监听队列
public class OrderMessageListener {
    /**
     * 支付结果监听
     * @param message:支付结果
     */
    @RabbitHandler
    public void getMeaaage(String message){
        //支付结果回调通知，Json格式转为Map
        Map<String, String> resultMap = JSON.parseObject(message, Map.class);
        System.out.println("监听到的支付结果信息:\n"+resultMap);

        //从MQ消息中间件中获取 支付操作的通信状态
        //通信标识：return_code      状态：SUCCESS/FAIL
        String return_code = resultMap.get("return_code");

        //如果支付操作的通信成功
        if (return_code.equals("SUCCESS")){
            //从MQ消息中间件中获取 支付操作的业务结果
            //业务结果：result_code     状态：SUCCESS/FAIL
            String result_code = resultMap.get("result_code");

            //商户订单号：out_trade_no
            String out_trade_no = resultMap.get("out_trade_no");

            //如果支付操作的业务结果为成功    修改订单状态
            if (result_code.equals("SUCCESS")){
                //从MQ消息中间件中获取信息
                //微信支付订单号：transaction_id
                String transaction_id = resultMap.get("transaction_id");
            }else {
                //如果支付失败，关闭支付，取消订单，回滚库存

            }
        }
    }
}

4、创建二维码实

a. 浏览器请求地址：http://19453k43d4.51vip.biz:32375/weixin/pay/create/native?outtradeno=1769&totalfee=1

{
    "flag": true,
    "code": 20000,
    "message": "创建二维码预付订单成功！",
    "data": {
        "nonce_str": "QlLrzt4vdsKNck1d",
        "code_url": "weixin://wxpay/bizpayurl?pr=MjNPE2Dzz",
        "appid": "wx8397f8696b538317",
        "sign": "CD80E7E68014CF70C36535E231E0FF14",
        "trade_type": "NATIVE",
        "return_msg": "OK",
        "result_code": "SUCCESS",
        "mch_id": "1473426802",
        "return_code": "SUCCESS",
        "prepay_id": "wx03125509016851a5fca270399354320000"
    }
}

b. 修改pay.html中的支付地址为code_url地址

<html>
<head>
<title>二维码入门小demo</title>
<!--1.引入js  
2. 创建一个img标签 用来存储显示二维码的图片 
3.创建js对象 4.设置js对象的配置项-->
<script src="qrious.js"> </script>
</head>
<body>
	<img id="myqrious" >
</body>
	<script>
	   var qrious = new QRious({
			 element:document.getElementById("myqrious"),// 指定的是图片所在的DOM对象
			 size:250,//指定图片的像素大小
			 level:'H',//指定二维码的容错级别(H:可以恢复30%的数据)
			 value:'weixin://wxpay/bizpayurl?pr=MjNPE2Dzz'//指定二维码图片代表的真正的值
	   })
	</script>
</html>

c. 二维码图片

5、扫码支付后。查看浏览器RabbitMQ后台：“服务器地址:15672/#/queues”
查看消息：

七、修改订单状态

1、在订单工程中进行修改

应用层接口（OrderService）中，添加接口

/**
 * 修改订单状态
 * @param outtradeno：用户订单号
 * @param paytime：支付时间
 * @param transactionid：交易流水号
 */
void updataStatus(String outtradeno,String paytime,String transactionid) throws  Exception;

应用层接口实现类（OrderServiceImpl）中，添加方法实现

/**
     * 修改订单状态
     * @param outtradeno：用户订单号
     * @param paytime：支付时间
     * @param transactionid：交易流水号
     */
    @Override
    public void updataStatus(String outtradeno, String paytime, String transactionid) throws Exception {
        //使用时间转换工具，转换时间格式
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
        Date payTimeInfo = simpleDateFormat.parse(paytime);

        //根据用户订单号，查询订单      order订单信息封装类
        Order order = orderMapper.selectByPrimaryKey(outtradeno);
        //修改订单信息
        //设置交易时间
        order.setPayTime(payTimeInfo);
        //设置支付状态：0未支付，1已支付，2支付失败
        order.setPayStatus("1");
        //设置交易流水号
        order.setTransactionId(transactionid);

        //信息更新到数据库订单表中
        orderMapper.updateByPrimaryKeySelective(order);
    }

2、删除订单，回滚库存

在订单支付后，如果支付失败，订单数据表中的订单信息就没必要保留了，商品库存也需要回滚到原来的数量；
为了方便二次查询，订单并不是真的删除了，而是修改了状态，这叫逻辑删除。

应用层接口（OrderService）中，添加接口

/**
 * 支付失败，删除[修改状态]订单，回滚库存
 * @param outtradeno：用户订单号
 */
void deleteOrder(String outtradeno);

应用层接口实现类（OrderServiceImpl）中，添加方法实现

/**
     * 支付失败，删除[修改状态]订单，回滚库存
     * @param outtradeno：用户订单号
     */
    @Override
    public void deleteOrder(String outtradeno) {
        //根据用户订单号，查询订单      order订单信息封装类
        Order order = orderMapper.selectByPrimaryKey(outtradeno);

        //修改状态
        //设置更新时间
        order.setUpdateTime(new Date());
        //设置支付状态：0未支付，1已支付，2支付失败
        order.setPayStatus("2");
        //信息更新到数据库订单表中
        orderMapper.updateByPrimaryKeySelective(order);

        //回滚库存->调用商品微服务     暂略
    }

3、对接监听

修改MQ信息监听配置OrderMessageListener

注入订单应用的操作对象

@Autowired
private OrderService orderService;

修改支付结果监听方法

/**
     * 支付结果监听
     * @param message:支付结果
     */
    @RabbitHandler
    public void getMeaaage(String message) throws Exception {
        //支付结果回调通知，Json格式转为Map
        Map<String, String> resultMap = JSON.parseObject(message, Map.class);
        System.out.println("监听到的支付结果信息:\n"+resultMap);

        //从MQ消息中间件中获取 支付操作的通信状态
        //通信标识：return_code      状态：SUCCESS/FAIL
        String return_code = resultMap.get("return_code");

        //如果支付操作的通信成功
        if (return_code.equals("SUCCESS")){
            //从MQ消息中间件中获取 支付操作的业务结果
            //业务结果：result_code     状态：SUCCESS/FAIL
            String result_code = resultMap.get("result_code");

            //商户订单号：out_trade_no
            String out_trade_no = resultMap.get("out_trade_no");

            //如果支付操作的业务结果为成功    修改订单状态
            if (result_code.equals("SUCCESS")){
                //修改订单状态
                //参数：用户订单号、支付完成时间、交易流水号
                orderService.updataStatus(out_trade_no,resultMap.get("time_end"),resultMap.get("transaction_id"));
            }else {
                //如果支付失败，关闭支付，取消订单，回滚库存
                //关闭支付  暂略

                //支付失败，删除[修改状态]订单，回滚库存
                orderService.deleteOrder(out_trade_no);
            }
        }
    }

4、测试

创建二维码信息，浏览器输入请求：http://localhost:18090/weixin/pay/create/native?outtradeno=1355321180126445568&totalfee=1

{
    "flag": true,
    "code": 20000,
    "message": "创建二维码预付订单成功！",
    "data": {
        "nonce_str": "Dc7zjYlcdvPxienu",
        "code_url": "weixin://wxpay/bizpayurl?pr=s2V4HM3zz",
        "appid": "wx8397f8696b538317",
        "sign": "7D75E71E44AD669496C14684A66D8501",
        "trade_type": "NATIVE",
        "return_msg": "OK",
        "result_code": "SUCCESS",
        "mch_id": "1473426802",
        "return_code": "SUCCESS",
        "prepay_id": "wx04014823728571d0a1350cf856a41e0000"
    }
}

修改pay.html的支付地址

<html>
<head>
<title>二维码入门小demo</title>
<!--1.引入js  
2. 创建一个img标签 用来存储显示二维码的图片 
3.创建js对象 4.设置js对象的配置项-->
<script src="qrious.js"> </script>
</head>
<body>
	<img id="myqrious" >
</body>
	<script>
	   var qrious = new QRious({
			 element:document.getElementById("myqrious"),// 指定的是图片所在的DOM对象
			 size:250,//指定图片的像素大小
			 level:'H',//指定二维码的容错级别(H:可以恢复30%的数据)
			 value:'weixin://wxpay/bizpayurl?pr=s2V4HM3zz'//指定二维码图片代表的真正的值
	   })
	</script>
</html>

双击pay.html生成二维码

扫码支付成功后，已经监听到了信息

数据库中的订单表，也根据监听到的消息进行了改变

八、延时队列配置

创建订单后，延长支付时间

1、订单系统中，创建延时队列配置类

/**
 * @Author TeaBowl
 * @Date 2021/2/4 11:11
 * @Version 1.0
 * 延时队列配置
 * Queue1->Queue2
 */
@Configuration
public class QueueConfig {
    /**
     * 创建Queue1
     * 延时队列会过期，过期后将数据发送给Queue2
     * 死信：就是超过有效时间仍没有读取的数据，就是放弃读取的数据
     */
    @Bean
    public Queue orderDelayQueue() {
        return QueueBuilder
                //设置队列名
                .durable("orderDelayQueue")
                /**
                 * 死信交换机->新交换机
                 * Queue1消息超时，进入死信队列，绑定死信交换机x-dead-letter-exchange
                 * 参数：死信交换机、被绑定的新交换机
                 */
                .withArgument("x-dead-letter-exchange","orderListenerExchange")
                /**
                 * 死信路由Key->新路由Key
                 * Queue1绑定死信交换机后,路由key就是x-dead-letter-routing-key
                 * orderListenerQueue是新的路由key,名称就是队列Queue2的名称
                 */
                .withArgument("x-dead-letter-routing-key","orderListenerQueue")
                .build();

    }

    /**
     * 创建Queue2
     * Queue1过期后，进入死信交换机x-dead-letter-exchange
     * Queue1数据绑定新的交换机orderListenerExchange
     * 路由到队列Queue2
     * @return
     */
    @Bean
    public Queue orderListenerQueue() {
        //参数：队列名、是否持久化
        return new Queue("orderListenerQueue",true);
    }

    /**
     * 创建交换机
     * @return
     */
    @Bean
    public Exchange orderListenerExchange(){
        return new DirectExchange("orderListenerExchange");
    }

    /**
     * 队列Queue2绑定新交换机
     * @param orderListenerQueue：队列Queue2
     * @param orderListenerExchange：新的交换机
     * @return
     */
    @Bean
    public Binding orderListenerBinding(Queue orderListenerQueue,Exchange orderListenerExchange){
        return  BindingBuilder
                //新队列
                .bind(orderListenerQueue)
                //新交换机
                .to(orderListenerExchange)
                //新路由key
                .with("orderListenerQueue")
                .noargs();
    }

}

2、修改订单应用层实现类OrderServiceImpl

注入MQ操作对象

@Autowired
private RabbitTemplate rabbitTemplate;

修改添加订单方法

/**
     * 增加Order  添加订单实现  就是把购物车里的商品信息生成一个订单
     * 订单表:tb_order     统计信息（订单里的商品）
     * 明细表:tb_order_item    商品详细信息
     * 订单添加1次，明细添加多次
     *
     * @param order：前端接收的订单信息
     */
    @Override
    public void add(Order order) {
        /**
         * 未实现
         *      1.价格校验
         *      2.当前购物车和订单捆绑了，没有拆开
         */

        //生成订单id
        order.setId(String.valueOf(idWorker.nextId()));

        /**
         * 获取订单明细——>购物车集合
         * 获取登录名：order.getUsername()
         * orderItems:明细对象集合
         */
        List<OrderItem> orderItems = new ArrayList<>();

        /**
         * 获取勾选的商品ID，需要下单的商品，将要下单的商品ID从购物车中移除
         * 勾选了的id集合:order.getSkuIds()
         */
        for (Long skuId : order.getSkuIds()) {
            //根据商品id，查询要下单的商品
            orderItems.add((OrderItem) redisTemplate.boundHashOps("Cart_" + order.getUsername()).get(skuId));
            //根据商品id，从购物车中删除要下单的商品
            redisTemplate.boundHashOps("Cart_" + order.getUsername()).delete(skuId);
        }


        //初始化总数量
        int totalNum = 0;
        //初始化总金额
        int totalMoney = 0;

        //封装Map<String,Integer> 封装库存递减数据
        Map<String, Integer> decrmap = new HashMap<>();

        //循环明细  orderItems：购物车里的所有商品
        for (OrderItem orderItem : orderItems) {
            //获取总数量     orderItem：购物车里，其中一种商品
            //totalNum：购物车里，商品的总数量
            totalNum += orderItem.getNum();
            //totalMoney：购物车里，商品的总金额
            totalMoney += orderItem.getMoney();

            //设置订单明细id
            orderItem.setId(String.valueOf(idWorker.nextId()));
            //设置订单明细所属的订单         order.getId():订单id
            orderItem.setOrderId(order.getId());
            //是否退货  0:未退货，1：已退货
            orderItem.setIsReturn("0");

            //封装递减数据    参数：商品ID、订单中的商品数量
            decrmap.put(orderItem.getSkuId().toString(),orderItem.getNum());
        }

        //1、添加订单
        //创建订单时间：当前时间
        order.setCreateTime(new Date());
        //修改订单时间：当前时间
        order.setUpdateTime(order.getCreateTime());
        //订单来源
        // 1:web，2：app，3：微信公众号，4：微信小程序  5 H5手机页面
        order.setSourceType("1");
        //订单状态
        //0:未完成,1:已完成，2：已退货
        order.setOrderStatus("0");
        //支付状态
        //0:未支付，1：已支付，2：支付失败
        order.setPayStatus("0");
        //订单是否删除    0:未删除，1：已删除
        order.setIsDelete("0");


        /**
         * 订单里，购买商品的总数量=每个商品的总数量之和
         * 1.获取订单明细——>购物车集合
         * 2.循环订单明细,获取每个商品的购买数量
         * 3.所有商品的数量求和
         */
        order.setTotalNum(totalNum);
        //订单里，商品的总金额=每个商品的总金额之和
        order.setTotalMoney(totalMoney);
        //实付金额，实付金额金额=每个商品的总金额之和
        //存在优惠时，金额会变动，此处无优惠，商品总金额=实付金额
        order.setPayMoney(totalMoney);

        //2、添加明细
        //添加订单信息
        orderMapper.insertSelective(order);
        //循环添加订单明细信息
        for (OrderItem orderItem : orderItems) {
            //根据订单，循环添加订单明细信息
            orderItemMapper.insertSelective(orderItem);
        }

        /**
         * 库存递减
         * decrmap:要减掉的数据
         */
        skuFeign.decrCount(decrmap);

        //为用户添加积分活跃度,+1
        userFeign.addPoints(1);

        //设置延时消息发送时间
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("创建订单时间："+simpleDateFormat.format(new Date()));

        //添加订单
        rabbitTemplate.convertAndSend("orderDelayQueue", (Object) order.getId(),
                new MessagePostProcessor() {
                    @Override
                    public Message postProcessMessage(Message message) throws AmqpException {
                        //设置延时读取    10s
                        message.getMessageProperties().setExpiration("10000");
                        return message;
                    }
                });

    }

3、创建过期消息监听

/**
 * @Author TeaBowl
 * @Date 2021/2/4 12:35
 * @Version 1.0
 * 过期消息监听,监听队列Queue2
 */
@Component
@RabbitListener(queues = "orderListenerQueue")
public class DelayMessageListener {
    /**
     * 延时队列监听
     * @param message
     */
    @RabbitHandler
    public void getDelayMessage(String message){
        //设置延时消息发送时间
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.print("监听到消息的时间：\n"+simpleDateFormat.format(new Date()));
        System.out.println("监听到的消息：\n"+message);
    }
}

结果：

茶碗儿
关注
  • 17
    点赞
  • 踩
  • 46
    收藏
    觉得还不错? 一键收藏
  • 11
    评论
专栏目录
前端在线微信扫码支付的小功能
m1948429907的博客
02-16 4017
前两天写了一个微信扫码支付的小功能，采用vue+antDesign，在此记录一下. 功能大概如下 输入信息 微信扫码支付 结果页面 ·输入信息 通过下拉选择框的联动，输入信息后点击下一步调取api并进入支付页面（前台使用antDesign表单验证非空） ·微信扫码支付 通过api获取二维码的url（一般格式为‘weixin://wxpay/bizpayurl?pr=5svmAQaoz’）,拿到路径后通过vue-qr转换成图片。同时进入支付页面后每隔一秒调取一次查询支付状态的api，当返回为‘SUCC
微信扫码支付
爱笑的boy的博客
02-06 1048
微信扫码支付
关于微信支付 二维码扫码支付
weixin_57504427的博客
05-11 267
微信支付 weixin_pay
【前端】微信小程序前端开发通过weixin://wxpay/bizpayurl生成支付二维码
最新发布
06-05 2万+
【前端】微信小程序前端开发通过weixin://wxpay/bizpayurl生成支付二维码
对接微信二维码支付流程
臻实
10-11 651
对接微信二维码支付
微信二维码支付自动发卡系统源码-易语言
06-12
微信二维码支付自动发卡系统是一种基于易语言开发的网络应用，主要用于实现线上支付与自动发放数字产品卡密的功能。易语言是一种中文编程语言，旨在降低编程难度，让不懂英文的用户也能进行软件开发。该系统的核心是...
支付宝微信二维码支付整合
11-15
支付宝微信二维码支付整合
2012腾讯微信二维码支付合作方案1.0.ppt
08-25
2012腾讯微信二维码支付合作方案1.0.ppt
ecshop微信二维码支付插件
07-25
标题中的“ecshop微信二维码支付插件”是指在ECSHOP电商系统中集成微信扫码支付功能的一个扩展模块。ECSHOP是一款流行的开源电子商务平台，而微信二维码支付则是腾讯公司提供的在线支付方式，允许用户通过扫描二维码...
微信二维码支付项目完整项目
01-09
微信二维码支付项目是一个实际应用中的典型案例，涉及到移动支付、二维码技术、微信支付接口以及服务器端与客户端的交互等多个IT领域的知识点。在这个项目中，我们主要会接触到以下几个关键技术和流程： 1. **微信...
weixin-pay:微信支付
04-22
weixin-pay 微信支付 for node.js Installation npm install weixin-pay Usage 创建统一支付订单 var WXPay = require('weixin-pay'); var wxpay = WXPay({ appid: 'xxxxxxxx', mch_id: '1234567890', partner_key: 'xxxxxxxxxxxxxxxxx', //微信商户平台API密钥 pfx: fs.readFileSync('./wxpay_cert.p12'), //微信商户平台证书 }); wxpay.createUnifiedOrder({ body: '扫码支付测试', out_trade_no: '20140703'+Math.random().toString().substr(2, 10), total
微信支付功能封装，适用所有公众号、微信小程序支付wxpay-master.zip
09-25
微信支付功能封装，适用所有公众号、微信小程序支付wxpay-master.zip
js生成二维码
CherryCola_zjl的博客
03-04 1922
import QRCode from '../utils/weapp-qrcode.js' // 初始化 let qrcode = new QRCode('canvas', { text: &quot;1&quot;, width: qrcodeWidth, height: qrcodeWidth, colorDark: &quot;#000&quot;, colorLigh...
微信公众号实现扫码支付
热门推荐
yin4302008的专栏
06-17 3万+
今天给大家讲讲微信扫码支付，如果之前未接触过微信支付的朋友可以看看我之前发的文章(基于weixin-java-tools集成微信小程序支付功能)，其实微信支付和微信扫码流程都是一样的，只是调用统一下单传入参数及返回参数有区别。 1.微信支付统一下单URL地址：https://api.mch.weixin.qq.com/pay/unifiedorder 这里只...
微信支付接口开发之－－微信扫码支付
fighting_tl的博客
07-06 2万+
1、模式一   实现步骤 1）、生成支付链接或是二维码 链接格式如下： weixin://wxpay/bizpayurl?appid=wxa842e8005c427e2d&mch_id=1314710101&nonce_str=3c6d11d09c2f4d49a7c18386cf8f3a14&product_id=123456789&sign=4AC5113048BD
微信扫码支付开发小结
elesos.com
12-29 2227
https://pay.weixin.qq.com/wiki/doc/api/native.php?chapter=6_1 商户根据微信支付的规则，为不同商品生成不同的二维码，展示在各种场景，用于用户扫描购买。 支付完成后会提示用户支付成功（如图6.5），商户后台得到支付成功的通知，然后进行发货处理。 开发扫码支付可分为两种模式,可根据支付场景选择
微信扫码支付（模式一）详解
weixin_44027022的博客
09-10 2万+
最近在写微信扫码支付（模式一），特此记录一下开发过程中的问题。 一、二维码生成： 1.1、二维码所需参数列表： 1.2、生成二维码内容链接，如下： weixin：//wxpay/bizpayurl?sign=XXXXX&appid=XXXXX&mch_id=XXXXX&product_id=XXXXXX&time_stamp=XXXXXX&nonce_s...
浏览器自动将参数中的url转码问题
weixin_34392906的博客
06-04 6305
遇到一个问题， 开始的url如下： http://localhost:6666/pages/wxpay.html? code_url=weixin://wxpay/biz 请求转发到谷歌浏览器打开后变成了 http://localhost:6666/pages/wxpay.html?code_url=weixin:%2F%2Fwxpay%2Fbizpayurl%3Fpr%3 也就是说，...
微信二维码支付测试点
05-29
微信二维码支付是一种通过微信扫描二维码来完成支付的方式，测试点包括以下几个方面： 1. 生成二维码：测试生成二维码的速度和准确性，确保能够正确生成可用的微信支付二维码。 2. 扫码支付：测试用户使用微信扫描...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 11
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值