对接微信支付之网页支付详解

￡神魔★判官ぃ 2022-04-05 04:43 379阅读 0赞

# 对接微信支付之网页支付详解 #

*  声明：转载请注明出处
 *  阅读对象：本文针对的是网页中的扫码支付
 *  温馨提示：微信支付坑比较多，阅读时请仔细一些，不要放过所有需要注意的内容 , 本人一路踩坑过来，希望大家引以为戒！
 *

#### 对接流程大致为以下几个步骤： ####

*  申请认证公众号 （若已有公众号则可跳过,  注意: 1. 公众号类型需要为服务号或者订阅号 2. 公众号需要认证， 认证费用300RMB）[点此跳转申请公众号][Link 1]
 *  申请网站备案 （若网站已备案则可跳过，注意：网站的备案内容需要和所出售商品直接关系）
 *  有以上两个条件后可以开始申请开通微信支付，具体的申请流程公众号平台都有，读者可自行去查阅。 注意：1.开通微信支付需要公司账户打款验证，要及时和财务沟通好，查看公司流水。2.开通成功后,会收到邮件 ,**邮件中的信息特别重要:示例如下**![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0phdmFCdWlsdA_size_16_color_FFFFFF_t_70]
 *  以上三条均申请完成即可开始配置开发环境。拿到邮件中的信息后，按照邮件中的指引配置好相关信息之后就可以开始开发了。注意：很重要的几个信息，1. API证书 2. API密钥 3. APPID
 *  可以开始开发了！！！

##### 支付类型： #####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0phdmFCdWlsdA_size_16_color_FFFFFF_t_70 1]

*  网页支付 一般选择 JSAPI和Native 这两种，[点此查看区别][Link 2]
 *  本文选择的是Native支付方式  
    呼~，终于开始编码了

--------------------

### 代码实现 ###

*  导入依赖

<dependency>
                    <groupId>com.github.wxpay</groupId>
                    <artifactId>wxpay-sdk</artifactId>
                    <version>0.0.3</version>
                </dependency>
                
                <dependency>
                    <groupId>dom4j</groupId>
                    <artifactId>dom4j</artifactId>
                    <version>1.6.1</version>
                </dependency>

*  编写配置实现类  
    业务层实现类  
    注意：这个实现类不要加@Service 注解,否则报错，因为springboot的@Service 是在项目启动时预创建对象，需要的是公共无参构造，以及所定义的成员变量也要注入。 总之别加就不会报错，使用没有影响，如果不相信可以加上试试，嘿嘿。

import com.github.wxpay.sdk.WXPayConfig;
    import com.juehua.single.constant.PayConstant;
    import com.juehua.single.model.qingshiyuanpay.ExceptionUtil;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Service;
    
    import java.io.ByteArrayInputStream;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.InputStream;
    
    /** * 微信 配置实现类 * Created by Jason on 2018/11/20. */
    public class WXPayConfigImpl implements WXPayConfig{ 
    
        private byte[] certData;
        private static WXPayConfigImpl INSTANCE;
        private static String cert_path;
        private static String notify_url;
    
        private WXPayConfigImpl(String certPath,String notifyUrl) throws Exception{ 
            ExceptionUtil.checkEmpty(certPath,"Sorry,Don't found your cert!"); // 校验证书路径
            ExceptionUtil.checkEmpty(notifyUrl,"Notify url can not null!");    // 校验回路径
    		
    		 // 读取API证书
            File file = new File(certPath);
            InputStream certStream = new FileInputStream(file);
            this.certData = new byte[(int) file.length()];
            certStream.read(this.certData);
            certStream.close();
        }
    
        /** * 获取实现类对象 * @param certPath * @param notifyUrl * @return * @throws Exception */
        public static WXPayConfigImpl getInstance(String certPath,String notifyUrl) throws Exception{ 
            notify_url = notifyUrl;
            cert_path = certPath;
            if (INSTANCE == null) { 
                synchronized (WXPayConfigImpl.class) { 
                    if (INSTANCE == null) { 
                        INSTANCE = new WXPayConfigImpl(cert_path,notify_url);
                    }
                }
            }
            return INSTANCE;
        }
    
        /** * 获取证书字节流 * @return */
        public InputStream getCertStream() { 
            ByteArrayInputStream certBis;
            certBis = new ByteArrayInputStream(this.certData);
            return certBis;
        }
    
        public String getAppID() { 
            return PayConstant.APPID;
        }
    
        public String getMchID() { 
            return PayConstant.MCHID;
        }
    
        public String getKey() { 
            return PayConstant.APIKEY;
        }
    
        public String getNotifyUrl() { 
            return notify_url;
        }
    
        public String getTradeType() { 
            return PayConstant.TRADE_TYPE;
        }
        // 请求连接超时时长
        public int getHttpConnectTimeoutMs() { 
            return PayConstant.HTTP_CONNECT_TIMEOUT;
        }
        // 请求读取超时时长
        public int getHttpReadTimeoutMs() { 
            return PayConstant.HTTP_READ_TIMEOUT;
        }
    
        public String getPrimaryDomain() { 
            return PayConstant.PRIMARY_DEMAIN;
        }
    
        public String getAlternateDomain() { 
            return PayConstant.ALTERNATE_DEMAIN;
        }
    
        public int getReportWorkerNum() { 
            return PayConstant.REPORT_WORKER_NUM;
        }
    
        public int getReportBatchSize() { 
            return PayConstant.REPORT_BATCH_SIZE;
        }
    
        public String getSpbillCreateIp() { 
            return PayConstant.BILL_CREATE_IP;
        }
    }

*  支付常量类，可以将配置信息写在这个常量里

/** * 支付接口相关常量 * Created by Jason on 2018/11/15. */
    public final class PayConstant { 
    
        public static String ORDER_NAME = "XXX技术服务费";
        public static String BODY = "备注";
    
        /** * 以下常量是 微信 支付相关 */
        // 公众号
        public static String APPID ="你的公众号appid";
        // 商户号
        public static String MCHID ="你的商户号";
        // API 安全密钥
        public static String APIKEY ="你配置的API安全密钥";
        // 支付类型 NATIVE
        public static String TRADE_TYPE="NATIVE";
        // 链接超时时长
        public static Integer HTTP_CONNECT_TIMEOUT=2000;
        // 请求读取超时时长
        public static Integer HTTP_READ_TIMEOUT = 10000;
    
        public static String PRIMARY_DEMAIN = "api.mch.weixin.qq.com";
    
        public static String ALTERNATE_DEMAIN = "api2.mch.weixin.qq.com";
    
        public static Integer REPORT_WORKER_NUM = 1;
    
        public static Integer REPORT_BATCH_SIZE= 2;
    
        public static String BILL_CREATE_IP="192.168.1.1";
    }

*  微信支付业务 省时间没有分接口和实现类 直接写了

import com.github.wxpay.sdk.WXPay;
    import com.juehua.single.model.qingshiyuanpay.MD5Util;
    import org.dom4j.Document;
    import org.dom4j.DocumentException;
    import org.dom4j.DocumentHelper;
    import org.dom4j.Element;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.stereotype.Service;
    
    import java.util.*;
    import java.util.Map.Entry;
    
    /** * 微信支付业务 * Created by Jason on 2018/11/20. */
    public class WXPayService { 
        private static Logger logger = LoggerFactory.getLogger(WXPayService.class);
        private WXPay wxpay;
        private WXPayConfigImpl config;
        private static WXPayService INSTANCE;
    
    	
        private WXPayService(String certPath, String notifyUrl) throws Exception { 
            config = WXPayConfigImpl.getInstance(certPath,notifyUrl);
            wxpay = new WXPay(config);
        }
    
        public static WXPayService getInstance(String certPath,String notifyUrl) throws Exception { 
            if (INSTANCE == null) { 
                synchronized (WXPayConfigImpl.class) { 
                    if (INSTANCE == null) { 
                        INSTANCE = new WXPayService(certPath,notifyUrl);
                    }
                }
            }
            return INSTANCE;
        }
    
        /** * 微信下单业务 * * @param out_trade_no 订单号 * @param body 商家商品名 * @param money 总金额 * @param applyNo 商品编号 * @return */
        public String doUnifiedOrder(String out_trade_no, String body, Double money, String applyNo) { 
            String amt = String.valueOf(money * 100);
            HashMap<String, String> data = new HashMap<String, String>();
            data.put("body", body);
            data.put("out_trade_no", out_trade_no);
            data.put("device_info", "web");
            data.put("fee_type", "CNY");
            data.put("total_fee", amt.substring(0, amt.lastIndexOf(".")));
            data.put("spbill_create_ip", config.getSpbillCreateIp());
            data.put("notify_url", config.getNotifyUrl());
            data.put("trade_type", config.getTradeType());
            data.put("product_id", applyNo);
            System.out.println(String.valueOf(money * 100));
            // data.put("time_expire", "20170112104120");
    
            try { 
                Map<String, String> r = wxpay.unifiedOrder(data);
                logger.info("返回的参数是" + r);
                return r.get("code_url");
            } catch (Exception e) { 
                e.printStackTrace();
                logger.info(e.getMessage());
                return null;
            }
        }
    
        /** * 退款业务 */
        public void doRefund(String out_trade_no, String total_fee) { 
            logger.info("退款时的订单号为：" + out_trade_no + "退款时的金额为:" + total_fee);
            String amt = String.valueOf(Double.parseDouble(total_fee) * 100);
            HashMap<String, String> data = new HashMap<String, String>();
            data.put("out_trade_no", out_trade_no);
            data.put("out_refund_no", out_trade_no);
            data.put("total_fee", amt.substring(0, amt.lastIndexOf(".")));
            data.put("refund_fee", amt.substring(0, amt.lastIndexOf(".")));
            data.put("refund_fee_type", "CNY");
            data.put("op_user_id", config.getMchID());
    
            try { 
                Map<String, String> r = wxpay.refund(data);
                logger.info("退款操作返回的参数为" + r);
            } catch (Exception e) { 
                e.printStackTrace();
            }
    
        }
    
    
        /** * 微信验证签名 * * @return * @throws DocumentException */
        public boolean checkSign(String  strXML) throws DocumentException { 
            SortedMap<String, String> smap = new TreeMap<String, String>();
            Document doc = DocumentHelper.parseText(strXML);
            Element root = doc.getRootElement();
            for (Iterator iterator = root.elementIterator(); iterator.hasNext();) { 
                Element e = (Element) iterator.next();
                smap.put(e.getName(), e.getText());
            }
            return isWechatSign(smap,config.getKey());
        }
    
    
        private boolean isWechatSign(SortedMap<String, String> smap,String apiKey) { 
            StringBuffer sb = new StringBuffer();
            Set<Entry<String, String>> es = smap.entrySet();
            Iterator<Entry<String, String>> it = es.iterator();
            while (it.hasNext()) { 
                Entry<String, String> entry =  it.next();
                String k = (String) entry.getKey();
                String v = (String) entry.getValue();
                if (!"sign".equals(k) && null != v && !"".equals(v) && !"key".equals(k)) { 
                    sb.append(k + "=" + v + "&");
                }
            }
            sb.append("key=" + apiKey);
            /** 验证的签名 */
            String sign = MD5Util.MD5Encode(sb.toString(), "utf-8").toUpperCase();
            /** 微信端返回的合法签名 */
            String validSign = ((String) smap.get("sign")).toUpperCase();
            return validSign.equals(sign);
        }
    }

*  控制层 我的方式是先生成支付二维码图片，然后进行图片渲染，你们可以直接返回二维码图片流给前端。我为啥不用？ 因为我的是客户端，采用swing自己编写的浏览器，和传统的浏览器还是有区别。
 *  讲解一下，前端发送请求过来，具体携带的参数，因人而异。携带的是前端生成的订单号，以及商品的数量。 Controller 接收到请求后，拿到参数，计算价格 商品数量\*商品单价，然后下单对接微信平台，下单成功会返回一个二维码的url，然后自行生成二维码。将二维码返回给页面，用户扫码支付后，微信平台会回调你所填写的异步回调通知接口，验证签名之后，解析平台给你返回的参数。
 *  解析微信平台回调你的接口时所返回的数据，这个单独拿出来说一下。这是比较坑的，返回的是一个数据流！！！！ 没错，没有任何参数，只是一个流。我们需要把流解析为xml，然后我们把xml解析成map，将map转为json，将json转为你自己定义的对象（这个看你自己了，需要就转），拿到数据，做你的业务就行了。

import com.alibaba.druid.support.json.JSONUtils;
    import com.alibaba.druid.util.StringUtils;
    import com.github.wxpay.sdk.WXPayUtil;
    import com.google.zxing.WriterException;
    import com.juehua.single.constant.DicConstant;
    import com.juehua.single.constant.PayConstant;
    import com.juehua.single.controller.BaseController;
    import com.juehua.single.model.qingshiyuanpay.ExceptionUtil;
    import com.juehua.single.model.qingshiyuanpay.UnifiedOrderRespose;
    import com.juehua.single.po.biz.BizOrder;
    import com.juehua.single.po.sys.SysInfo;
    import com.juehua.single.qrcode.DateCompareUtil;
    import com.juehua.single.qrcode.QRCodeUtil;
    import com.juehua.single.service.biz.BizOrderService;
    import com.juehua.single.service.biz.BizServiceService;
    import com.juehua.single.service.bse.BseDicService;
    import com.juehua.single.service.impl.alipay.AlipayViewServiceImpl;
    import com.juehua.single.service.impl.wxpay.WXPayService;
    import com.juehua.single.service.sys.SysInfoService;
    import lombok.extern.slf4j.Slf4j;
    import net.sf.json.JSONObject;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Controller;
    import org.springframework.transaction.annotation.Transactional;
    import org.springframework.web.bind.annotation.RequestMapping;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.File;
    import java.io.IOException;
    import java.text.SimpleDateFormat;
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    /** * 微信支付接口开发控制器 * Created by Jason on 2018/11/20. */
    
    @Controller
    @Slf4j
    @RequestMapping("/portal")
    public final class WXPayController extends BaseController{ 
    // ----------------这些是个人业务 因人而异 --------------
    	@Autowired
    	private AlipayViewServiceImpl alipayViewServiceImpl;
    
    	@Autowired
    	private BizOrderService bizOrderService;
    
    	@Autowired
    	private BseDicService bseDicService;
    
    	@Autowired
    	private BizServiceService bizServiceService;
    	@Autowired
    	private SysInfoService sysInfoService;
    // -------------- 这些是在配置文件中配置的 使用@Value注解注入 ----------------
    	@Value("${juehua.request.address}")
    	private String reqPath;	   //资源请求路径
    
    	@Value("${weixin.qrcode.path}")
    	private String qrcodePath; //生成的二维码地址
    
    	@Value("${weixin.cert.path}")
    	private String certPath; //注入证书路径
    
    	@Value("${weixin.notify.url}")
    	private String notifyUrl; //回调地址(异步)
    
    	@Value("${img.server.port}")
    	private String imgPort; //图片服务器端口
    
    	/** * 映射微信支付 * * @param orderId 商户单号 * @param amount 购买商品总数量 * @param map freemaker 返回渲染数据 * @return */
    	@RequestMapping("/wxpay")
    	public String wxPay(String orderId, Integer amount, String orgId, Map<String, Object> map) throws Exception { 
    		// 计算总费用 这里调用你的计算你的
    		Double total_fee = alipayViewServiceImpl.wxCalculatePrice(amount);
    		if (total_fee > 0) { 
    			WXPayService wxPayService = WXPayService.getInstance(certPath, notifyUrl);
    			String codeUrl = wxPayService.doUnifiedOrder(orderId, "清视元", total_fee, "产品id");
    
    			// 订单保存到数据库 这是我的，具体需要看你们自己的业务
    			BizOrder bizOrder = new BizOrder();
    			bizOrder.setAmount(amount);
    			bizOrder.setAppid(PayConstant.APPID);
    			bizOrder.setMacId(orderId);
    			bizOrder.setTotalFee(String.valueOf(total_fee));
    			bizOrder.setOrgId(Long.parseLong(orgId));
    			BizOrder bo = bizOrderService.insertOrder(bizOrder);
    			if (bo == null)
    				throw new NullPointerException("Don't save order!");
    // ---------------------这是我的方式，有点无奈，你们可以用第二种写法 方便
    			// 写法1 生成二维码图片保存到服务器，然后渲染页面
    			// 后台生成二维码图片(本地与服务器系统不同)
    			String imgName = orderId+".jpg";
    			log.info("图片名称为："+imgName);
    			// 物理路径
    			String imgPath = qrcodePath + File.separator + imgName;
    			log.info("图片存放路径为："+imgPath);
    			// 相对路径(通过请求获得)
    			String reqImgPath = reqPath + ":" + imgPort + File.separator + "qrcode" + File.separator + imgName;
    			log.info("图片请求路径为："+reqImgPath);
    			QRCodeUtil.createQrCode(imgPath, codeUrl, 900, "JPEG");
    			boolean isLocal = isLocalPath(reqPath);
    			map.put("reqPath", reqPath);     // 请求路径
    			map.put("orderId", orderId);     // 订单号
    			map.put("goodsType", "技术服务"); // 商品类型
    			map.put("amount", amount);       // 商品数量
    			map.put("total_fee", total_fee); // 金额总数
    			if (isLocal) {  // 本地路径
    				map.put("codeUrl", imgPath);// 返回二维码图片路径 路径1
    			}else
    				map.put("reqImgPath",reqImgPath);// 路径2
    
    			delOldQrCode(qrcodePath); // 删除旧二维码
    		}
    
    		return "wxpay";
    	}
    
    	/** * 是否是本地路径 * @param reqPath 请求路径 * @return */
    	private boolean isLocalPath(String reqPath) { 
    		log.info("检测到的请求路径为："+reqPath);
    		if (reqPath != null) { 
    			return reqPath.contains("localhost");
    		}
    		throw new NullPointerException("request is null!");
    	}
    
    	/** * 二维码生成写法2 * 渲染二维码 * @param content 二维码内容 返回的二维码链接 页面img src =“/qrcode” * * @param response 响应页面 */
    	@RequestMapping("/qrcode")
    	public void showQrCode(String content,HttpServletResponse response) { 
    		try { 
    			QRCodeUtil.createQrCodeStream(content,900,"JPEG",response);
    		} catch (IOException e) { 
    			e.printStackTrace();
    		} catch (WriterException e) { 
    			e.printStackTrace();
    		}
    	}
    
    
    
    	/** * 微信支付成功回调接口 * * @param map 返回给页面 * @param request 接收请求 * @param response 响应 * @return * @throws Exception */
    	@RequestMapping("/callback")
    	public void callback(Map<String, Object> map, HttpServletRequest request,
    						   HttpServletResponse response) throws Exception { 
    		map.put("reqPath", reqPath); // 返回给freemaker 渲染页面
    
    		log.info("用户支付成功,回调！");
    		String inputLine;
    		String notityXml = "";
    		request.setCharacterEncoding("UTF-8");
    		response.setCharacterEncoding("UTF-8");
    		response.setContentType("text/html;charset=UTF-8");
    		response.setHeader("Access-Control-Allow-Origin", "*");
    		// 微信给返回的东西
    		try { 
    			while ((inputLine = request.getReader().readLine()) != null) { 
    				notityXml += inputLine;
    			}
    			request.getReader().close();
    		} catch (Exception e) { 
    			e.printStackTrace();
    			log.info("xml获取失败");
    			response.getWriter().write(setXml("FAIL", "xml获取失败"));
    		}
    		if (StringUtils.isEmpty(notityXml)) { 
    			log.info("xml为空");
    			response.getWriter().write(setXml("FAIL", "xml为空"));
    		}
    
    		WXPayService wxService = WXPayService.getInstance(certPath, notifyUrl);
    		if (!wxService.checkSign(notityXml)) { 
    			response.getWriter().write(setXml("FAIL", "验签失败"));
    		}
    		log.info("xml的值为：" + notityXml);
    		Map<String, String> xmlMap = WXPayUtil.xmlToMap(notityXml); // 解析成map
    		String json = JSONUtils.toJSONString(xmlMap); // map 转成json
    // JSON json = xmlSerializer.read(notityXml);
    		log.info(json);
    		JSONObject jsonObject = JSONObject.fromObject(json);
    		UnifiedOrderRespose returnPay = (UnifiedOrderRespose) JSONObject.toBean(jsonObject, UnifiedOrderRespose.class);
    		log.info(("转换后对象为：" + returnPay.toString()));
    		log.info(("订单号：" + returnPay.getOut_trade_no() + "总金额：" + returnPay.getTotal_fee()));
    		if (returnPay.getReturn_code().equals("SUCCESS") && returnPay.getOut_trade_no() != null
    				&& !returnPay.getOut_trade_no().isEmpty()) { 
    			double fee = Double.parseDouble(returnPay.getTotal_fee());
    			returnPay.setTotal_fee(String.valueOf(fee / 100));
    			log.info("微信的支付状态为SUCCESS");
    			// 支付成功业务
    			synchronized (WXPayController.class) {  // 加入同步锁
    				Thread.sleep(1000); //睡一秒,防止并发倒致数据不一致
    				addServiceCount(returnPay,response);// 这里写你自己的业务
    			}
    			// 返回false的原因有可能是：订单已完成支付,或者订单已退款
    		}else
    			response.getWriter().write(setXml("FAIL","ORDER IS FINISH"));
    
    		}
    
    	/** * 充值服务次数 * 加同步锁 处理并发 * @param returnPay * @return * @throws Exception */
    	private synchronized void addServiceCount(UnifiedOrderRespose returnPay,HttpServletResponse response) throws Exception { 
    		
    		return false;
    	}
    
    	/** * 计算商品数量 * 商品数量只能为整数,采取四舍五入制 * @param total_fee 总金额 * @param price 商品单价 * @return */
    	private int getAmount(String total_fee,String price) { 
    		ExceptionUtil.checkEmpty(total_fee,"总金额不能为空");
    		ExceptionUtil.checkEmpty(price,"单价不能为空");
    
    		double v1 = Double.parseDouble(total_fee);
    		double v = Double.parseDouble(price);
    		double amount = v1/v;
    		log.info("商品数量为:"+amount);
    		long num = Math.round(amount);
    		if (num < 1)
    			throw new IllegalArgumentException("服务充值基数不能小于0");
    		else
    			return (int)num;
    	}
    
    	/** * 支付成功,回调成功,返回xml类型的数据 * @param returnCode * @param msg * @return * @throws Exception */
    	private String setXml(String returnCode, String msg) throws Exception { 
    		Map<String,String> xmlMap = new HashMap<>();
    		xmlMap.put("return_code",returnCode);
    		xmlMap.put("return_msg",msg);
    		String data = WXPayUtil.mapToXml(xmlMap);
    		return data;
    	}
    
    	/** * 删除旧二维码 */
    	private void delOldQrCode(String qrcodePath) { 
    		ExceptionUtil.checkEmpty(qrcodePath,"二维码存放路径不能为空!");
    
    		String compareRule = "yyyyMMdd"; // 日期比较格式
    		SimpleDateFormat simpleDateFormat = new SimpleDateFormat(compareRule);
    		String nowDate = simpleDateFormat.format(compareRule);
    
    		try { 
    			File qrcodeDir = new File(qrcodePath);
    			if (qrcodeDir.isDirectory()) {  // 如果目录存在
    				File[] files = qrcodeDir.listFiles();
    				for (File file:files) { 
    					if (file.exists()&&file.isFile()) { 
    						String date = file.getName().substring(0, 8);
    						boolean bool = DateCompareUtil.compareDate(date, nowDate, compareRule);
    						if (!bool) { 
    							file.delete(); // 删除二维码
    						}
    					}
    				}
    			}
    		} catch (Exception e) { 
    			log.error("获取二维码图片路径为空");
    		}
    
    	}
    }

二维码生成工具类

import com.google.zxing.*;
    import com.google.zxing.client.j2se.BufferedImageLuminanceSource;
    import com.google.zxing.common.BitMatrix;
    import com.google.zxing.common.HybridBinarizer;
    import com.google.zxing.qrcode.QRCodeReader;
    import com.google.zxing.qrcode.QRCodeWriter;
    import com.google.zxing.qrcode.decoder.ErrorCorrectionLevel;
    
    import javax.imageio.ImageIO;
    import javax.servlet.http.HttpServletResponse;
    import java.awt.*;
    import java.awt.image.BufferedImage;
    import java.io.*;
    import java.util.Hashtable;
    
    /** * 二维码生成工具类 * Created by jason on 2018/11/28 0028. */
    public final class QRCodeUtil { 
    
    	/** * 生成包含字符串信息的二维码图片 * @param filePath 文件输出流路径 * @param content 二维码携带信息 * @param qrCodeSize 二维码图片大小 * @param imageFormat 二维码的格式 * @throws WriterException * @throws IOException */
    	public static boolean createQrCode(String  filePath, String content, int qrCodeSize, String imageFormat) throws WriterException, IOException { 
    		//设置二维码纠错级别ＭＡＰ
    		Hashtable<EncodeHintType, ErrorCorrectionLevel> hintMap = new Hashtable<EncodeHintType, ErrorCorrectionLevel>();
    		hintMap.put(EncodeHintType.ERROR_CORRECTION, ErrorCorrectionLevel.L);  // 矫错级别
    		QRCodeWriter qrCodeWriter = new QRCodeWriter();
    		//创建比特矩阵(位矩阵)的QR码编码的字符串
    		BitMatrix byteMatrix = qrCodeWriter.encode(content, BarcodeFormat.QR_CODE, qrCodeSize, qrCodeSize, hintMap);
    		// 使BufferedImage勾画QRCode (matrixWidth 是行二维码像素点)
    		int matrixWidth = byteMatrix.getWidth();
    		BufferedImage image = new BufferedImage(matrixWidth-200, matrixWidth-200, BufferedImage.TYPE_INT_RGB);
    		image.createGraphics();
    		Graphics2D graphics = (Graphics2D) image.getGraphics();
    		graphics.setColor(Color.WHITE);
    		graphics.fillRect(0, 0, matrixWidth, matrixWidth);
    		// 使用比特矩阵画并保存图像
    		graphics.setColor(Color.BLACK);
    		for (int i = 0; i < matrixWidth; i++){ 
    			for (int j = 0; j < matrixWidth; j++){ 
    				if (byteMatrix.get(i, j)){ 
    					graphics.fillRect(i-100, j-100, 1, 1);
    				}
    			}
    		}
    		OutputStream outputStream=new FileOutputStream(new File(filePath));
    		return ImageIO.write(image, imageFormat, outputStream);
    	}
    
    	/** * 创建二维码输入流 可以直接将二维码以流的形式返回给页面 * @param content 二维码内容 * @param qrCodeSize 二维码尺寸 * @param imageFormat 图片格式 * @param response 响应给页面 */
    	public static void createQrCodeStream(String content, int qrCodeSize, String imageFormat, HttpServletResponse response) throws IOException, WriterException { 
    		//设置二维码纠错级别ＭＡＰ
    		Hashtable<EncodeHintType, ErrorCorrectionLevel> hintMap = new Hashtable<EncodeHintType, ErrorCorrectionLevel>();
    		hintMap.put(EncodeHintType.ERROR_CORRECTION, ErrorCorrectionLevel.L);  // 矫错级别
    		QRCodeWriter qrCodeWriter = new QRCodeWriter();
    		//创建比特矩阵(位矩阵)的QR码编码的字符串
    		BitMatrix byteMatrix = qrCodeWriter.encode(content, BarcodeFormat.QR_CODE, qrCodeSize, qrCodeSize, hintMap);
    		// 使BufferedImage勾画QRCode (matrixWidth 是行二维码像素点)
    		int matrixWidth = byteMatrix.getWidth();
    		BufferedImage image = new BufferedImage(matrixWidth-200, matrixWidth-200, BufferedImage.TYPE_INT_RGB);
    		image.createGraphics();
    		Graphics2D graphics = (Graphics2D) image.getGraphics();
    		graphics.setColor(Color.WHITE);
    		graphics.fillRect(0, 0, matrixWidth, matrixWidth);
    		// 使用比特矩阵画并保存图像
    		graphics.setColor(Color.BLACK);
    		for (int i = 0; i < matrixWidth; i++){ 
    			for (int j = 0; j < matrixWidth; j++){ 
    				if (byteMatrix.get(i, j)){ 
    					graphics.fillRect(i-100, j-100, 1, 1);
    				}
    			}
    		}
    		// 返回给页面
    		OutputStream outputStream= response.getOutputStream();
    		// 关流
    		try { 
    			ImageIO.write(image, imageFormat, outputStream);
    		} finally { 
    			outputStream.close();
    		}
    	}
    
    	/** * 读二维码并输出携带的信息 */
    	public static void readQrCode(InputStream inputStream) throws IOException{ 
    		//从输入流中获取字符串信息
    		BufferedImage image = ImageIO.read(inputStream);
    		//将图像转换为二进制位图源
    		LuminanceSource source = new BufferedImageLuminanceSource(image);
    		BinaryBitmap bitmap = new BinaryBitmap(new HybridBinarizer(source));
    		QRCodeReader reader = new QRCodeReader();
    		Result result = null ;
    		try { 
    			result = reader.decode(bitmap);
    		} catch (ReaderException e) { 
    			e.printStackTrace();
    		}
    		System.out.println(result.getText());
    	}
    
    
    	/** * 测试代码 * @throws WriterException */
    	public static void main(String[] args) throws IOException, WriterException { 
    
    // createQrCode("E:\\qrcode.jpg","china is good",900,"JPEG");
    // readQrCode(new FileInputStream(new File("E:\\qrcode.jpg")));
    	}
    }

核心代码就告一段落了，摘取你要的，用不到的方法以及代码可以删去。后续会把原代码发上来。  
**注意：** 生成二维码成功后，扫码支付成功后腾讯会回调你的接口callback。  
还有一个坑，腾讯如论回调成功还是失败 都会重复回调，所以我加了同步锁，订单状态改变后，就不再执行任何操作，去除重复回调！

后续会更新对接支付宝支付

累死了，码了一晚上，希望大家多多支持。不懂得下方评论，大神可直接忽略。

[Link 1]: https://mp.weixin.qq.com/cgi-bin/loginpage?t=wxm2-login&lang=zh_CN
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0phdmFCdWlsdA_size_16_color_FFFFFF_t_70]: /images/20220405/006b93ca8b4746b8867f235f3aae74f3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0phdmFCdWlsdA_size_16_color_FFFFFF_t_70 1]: /images/20220405/9543332f67224a89ba50afacc0feaba6.png
[Link 2]: https://pay.weixin.qq.com/wiki/doc/api/index.html