YYGH-10-微信支付

微信支付的介绍

1.微信支付的支付申请

微信扫码支付是商户系统按微信支付协议生成支付二维码，用户再用微信“扫一扫”完成支付的模式。该模式适用于PC网站支付、实体店单品或订单支付、媒体广告支付等场景。

申请步骤：（了解）

第一步：注册公众号（类型须为：服务号）

请根据营业执照类型选择以下主体注册：个体工商户| 企业/公司| 政府| 媒体| 其他类型。

第二步：认证公众号

公众号认证后才可申请微信支付，认证费：300元/年。

第三步：提交资料申请微信支付

登录公众平台，点击左侧菜单【微信支付】，开始填写资料等待审核，审核时间为1-5个工作日内。

第四步：开户成功，登录商户平台进行验证

资料审核通过后，请登录联系人邮箱查收商户号和密码，并登录商户平台填写财付通备付金打的小额资金数额，完成账户验证。

第五步：在线签署协议

本协议为线上电子协议，签署后方可进行交易及资金结算，签署完立即生效。

2.开发文档

微信支付接口调用的整体思路：

按API要求组装参数，以XML方式发送（POST）给微信支付接口（URL）,微信支付接口也是以XML方式给予响应。程序根据返回的结果（其中包括支付URL）生成二维码或判断订单状态。

在线微信支付开发文档：

https://pay.weixin.qq.com/wiki/doc/api/index.html

1. appid：微信公众账号或开放平台APP的唯一标识

2. mch_id：商户号 (配置文件中的partner)

3. partnerkey：商户密钥

4. sign:数字签名, 根据微信官方提供的密钥和一套算法生成的一个加密信息, 就是为了保证交易的安全性

3.微信支付SDK

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

我们主要会用到微信支付SDK的以下功能：

1.获取随机字符串

WXPayUtil.*generateNonceStr()

2.MAP转换为XML字符串（自动添加签名）

WXPayUtil.*generateSignedXml*(param, partnerkey)

3.XML字符串转换为MAP

WXPayUtil.*xmlToMap*(result)

微信支付开发

二维码的显示

我们来分析一下支付的流程

1.用户在前台点击支付,前端将要支付的订单号传送给后端

2.MVC得到这个订单号,根据订单号查询出对应订单,利用https客户机向微信后台发送请求

3.微信后台请求传送回了二维码，在前端显示

service

//生成二维码
@Override
public Map createNative(Long orderId) {
    try {
        //先尝试在redis中获取数据
        Map payMap = (Map) redisTemplate.opsForValue().get(orderId.toString());
        if (payMap != null) {
            return payMap;
        }
        //1.根据orderId获取订单信息
        OrderInfo orderInfo = orderService.getById(orderId);
        //2.向支付记录表添加信息
        paymentService.savePaymentInfo(orderInfo, PaymentTypeEnum.WEIXIN.getStatus());
        //3.设置参数,调用微信生成二维码的接口
        //把参数转换成xml格式,使用商户key进行加密
        Map paramMap = getMap(orderInfo);
        //4.调用HttpClient
        HttpClient client = new HttpClient("https://api.mch.weixin.qq.com/pay/unifiedorder");
        //设置参数
        client.setXmlParam(WXPayUtil.generateSignedXml(paramMap, ConstantPropertiesUtils.PARTNERKEY));
        client.setHttps(true);
        client.post();
        //5.返回相关数据
        String xml = client.getContent();
        //转换成map集合
        Map<String, String> resultMap = WXPayUtil.xmlToMap(xml);
        //4、封装返回结果集
        Map map = new HashMap<>();
        map.put("orderId", orderId);
        map.put("totalFee", orderInfo.getAmount());
        map.put("resultCode", resultMap.get("result_code"));
        map.put("codeUrl", resultMap.get("code_url")); //二维码地址
        if (null != resultMap.get("result_code")) {
            //微信支付二维码2小时过期，可采取2小时未支付取消订单
            redisTemplate.opsForValue().set(orderId.toString(), map, 1000, TimeUnit.MINUTES);
        }
        return map;
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

controller

//生成微信支付扫描的二维码
@GetMapping("/createNative/{orderId}")
public Result createNative(@PathVariable Long orderId) {
    log.info("开始创建二维码" + orderId);
    Map aNative = weixinService.createNative(orderId);
    return Result.ok(aNative);
}

工具类

@Component
public class ConstantPropertiesUtils implements InitializingBean {
    
    @Value("${weixin.appid}")
    private String appid;

    @Value("${weixin.partner}")
    private String partner;

    @Value("${weixin.partnerkey}")
    private String partnerkey;

    public static String APPID;
    public static String PARTNER;
    public static String PARTNERKEY;
    @Override
    public void afterPropertiesSet() throws Exception {
        APPID = appid;
        PARTNER = partner;
        PARTNERKEY = partnerkey;
    }
}

import org.apache.http.Consts;
import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.*;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLContextBuilder;
import org.apache.http.conn.ssl.TrustStrategy;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.ssl.SSLContexts;
import org.apache.http.util.EntityUtils;

import javax.net.ssl.SSLContext;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.security.KeyStore;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.text.ParseException;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

/**
 * http请求客户端
 */
public class HttpClient {
   private String url;
   private Map<String, String> param;
   private int statusCode;
   private String content;
   private String xmlParam;
   private boolean isHttps;
   private boolean isCert = false;
   //证书密码 微信商户号（mch_id）
   private String certPassword;
   public boolean isHttps() {
      return isHttps;
   }
   public void setHttps(boolean isHttps) {
      this.isHttps = isHttps;
   }
   public boolean isCert() {
      return isCert;
   }
   public void setCert(boolean cert) {
      isCert = cert;
   }
   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 String getCertPassword() {
      return certPassword;
   }
   public void setCertPassword(String certPassword) {
      this.certPassword = certPassword;
   }
   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) {
            if(isCert) {
               FileInputStream inputStream = new FileInputStream(new File(ConstantPropertiesUtils.CERT));
               KeyStore keystore = KeyStore.getInstance("PKCS12");
               char[] partnerId2charArray = certPassword.toCharArray();
               keystore.load(inputStream, partnerId2charArray);
               SSLContext sslContext = SSLContexts.custom().loadKeyMaterial(keystore, partnerId2charArray).build();
               SSLConnectionSocketFactory sslsf =
                     new SSLConnectionSocketFactory(sslContext,
                           new String[] { "TLSv1" },
                           null,
                           SSLConnectionSocketFactory.BROWSER_COMPATIBLE_HOSTNAME_VERIFIER);
               httpClient = HttpClients.custom().setSSLSocketFactory(sslsf).build();
            } else {
               SSLContext sslContext = new SSLContextBuilder()
                     .loadTrustMaterial(null, new TrustStrategy() {
                        // 信任所有
                        public boolean isTrusted(X509Certificate[] chain,
                                           String authType)
                              throws CertificateException {
                           return true;
                        }
                     }).build();
               SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(
                     sslContext);
               httpClient = HttpClients.custom().setSSLSocketFactory(sslsf)
                     .build();
            }
         } else {
            httpClient = HttpClients.createDefault();
         }
         CloseableHttpResponse response = httpClient.execute(http);
         try {
            if (response != null) {
               if (response.getStatusLine() != null)
                  statusCode = response.getStatusLine().getStatusCode();
               HttpEntity entity = response.getEntity();
               // 响应内容
               content = EntityUtils.toString(entity, Consts.UTF_8);
            }
         } finally {
            response.close();
         }
      } catch (Exception e) {
         e.printStackTrace();
      } finally {
         httpClient.close();
      }
   }
   public int getStatusCode() {
      return statusCode;
   }
   public String getContent() throws ParseException, IOException {
      return content;
   }
}

前端

api/weixin.js

//查询订单状态
queryPayStatus(orderId) {
  return request({
    url: `${weixin_api_name}/queryPayStatus/${orderId}`,
    method: 'get'
  })
},
//生成微信支付的二维码
createNative(orderId) {
  return request({
    url: `${weixin_api_name}/createNative/${orderId}`,
    method: `get`,
  })
},

pages/order/show.vue

pay() {
  this.dialogPayVisible = true
  weixinApi.createNative(this.orderId).then(response => {
    this.payObj = response.data
    if(this.payObj.codeUrl === '') {
      this.dialogPayVisible = false
      this.$message.error("支付错误")
    } else {
      this.timer = setInterval(() => {
        this.queryPayStatus(this.orderId)
      }, 3000);
    }
  })
},
queryPayStatus(orderId) {
  weixinApi.queryPayStatus(orderId).then(response => {
    if (response.message === '支付中') {
      return
    }
    clearInterval(this.timer);
    window.location.reload()
  })
},
closeDialog() {
  if(this.timer) {
    clearInterval(this.timer);
  }

这样我们就可以在前端看到支付要用的二维码了,当我们选择支付之后就回在微信后台得到数据

监测交易状态

可能有人注意到了

  this.timer = setInterval(() => {
    this.queryPayStatus(this.orderId)
  }, 3000);

我这里有一组这样的代码

这个是每3s查询一次交易状态,如果交易成功直接跳转,在后台是这样做的

controller

//查询支付状态
@GetMapping("/queryPayStatus/{orderId}")
public Result queryPayStatus(@PathVariable Long orderId) {
    log.info("查询支付订单状态");
    //调用微信接口实现支付状态查询
    Map<String, String> resultMap = weixinService.queryPayStatus(orderId);
    //判断
    if (resultMap == null) {
        return Result.fail().message("支付出错");
    }
    if ("SUCCESS".equals(resultMap.get("trade_state"))) {
        //支付成功,更新订单状态
        String tradeNo = resultMap.get("out_trade_no");
        paymentService.paySuccess(tradeNo,resultMap);
        return Result.ok().message("支付成功");
    }
    return Result.ok().message("支付中");
}

WeixinServiceImpl

@Override
public Map<String, String> queryPayStatus(Long orderId) {
    try {
        //1.根据orderId获取订单信息
        OrderInfo orderInfo = orderService.getById(orderId);

        //2.封装提交参数
        Map paramMap = new HashMap();
        paramMap.put("appid", ConstantPropertiesUtils.APPID);
        paramMap.put("mch_id", ConstantPropertiesUtils.PARTNER);
        paramMap.put("out_trade_no", orderInfo.getOutTradeNo());
        paramMap.put("nonce_str", WXPayUtil.generateNonceStr());

        //3.设置请求内容
        HttpClient client = new HttpClient("https://api.mch.weixin.qq.com/pay/orderquery");
        client.setXmlParam(WXPayUtil.generateSignedXml(paramMap, ConstantPropertiesUtils.PARTNERKEY));
        client.setHttps(true);
        client.post();
        //3、返回第三方的数据，转成Map
        String xml = client.getContent();
        Map<String, String> resultMap = WXPayUtil.xmlToMap(xml);
        //4、返回
        return resultMap;
    } catch (Exception e) {
        return null;
    }
}

PaymentServiceImpl

    //更新订单状态
    @Override
    public void paySuccess(String tradeNo, Map<String, String> resultMap) {
        //1.根据订单编号得到支付记录
        QueryWrapper<PaymentInfo> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("out_trade_no", tradeNo);
        queryWrapper.eq("payment_type", PaymentTypeEnum.WEIXIN.getStatus());
        PaymentInfo paymentInfo = baseMapper.selectOne(queryWrapper);

        //2.更新支付信息
        paymentInfo.setPaymentStatus(PaymentStatusEnum.PAID.getStatus());
        paymentInfo.setCallbackTime(new Date());
        paymentInfo.setTradeNo(resultMap.get("transaction_id"));
        paymentInfo.setCallbackContent(resultMap.toString());
        baseMapper.updateById(paymentInfo);

        //3.根据订单号得到订单信息
        log.info(String.valueOf(paymentInfo.getOrderId()));
        OrderInfo orderInfo = orderService.getById(paymentInfo.getOrderId());
        orderInfo.setOrderStatus(OrderStatusEnum.PAID.getStatus());

        //4.更新订单信息
        orderService.updateById(orderInfo);

        //5.调用医院接口,更新支付信息
        hospApi(orderInfo);

    }

    /**
     * 获取支付记录
     *
     * @param orderId
     * @param paymentType
     * @return
     */
    @Override
    public PaymentInfo getPaymentInfo(Long orderId, Integer paymentType) {
        QueryWrapper queryWrapper = new QueryWrapper();
        queryWrapper.eq("order_id", orderId);
        queryWrapper.eq("payment_type", paymentType);
        return baseMapper.selectOne(queryWrapper);
    }

    private void hospApi(OrderInfo orderInfo) {
        SignInfoVo signInfoVo = hospitalFeignClient.getSignInfoVo(orderInfo.getHoscode());
        if (null == signInfoVo) {
            throw new YyghException(ResultCodeEnum.PARAM_ERROR);
        }
        Map<String, Object> reqMap = new HashMap<>();
        reqMap.put("hoscode", orderInfo.getHoscode());
        reqMap.put("hosRecordId", orderInfo.getHosRecordId());
        reqMap.put("timestamp", HttpRequestHelper.getTimestamp());
        String sign = HttpRequestHelper.getSign(reqMap, signInfoVo.getSignKey());
        reqMap.put("sign", sign);
        JSONObject result = HttpRequestHelper.sendRequest(reqMap, signInfoVo.getApiUrl() + "/order/updatePayStatus");
        if (result.getInteger("code") != 200) {
            throw new YyghException(result.getString("message"), ResultCodeEnum.FAIL.getCode());
        }
    }

微信退款

微信退款的流程:

1.前台页面传来要退款的订单id

2.后台根据这个id得到对应的订单,将这个订单的信息在取消预约的表中保存一份,状态为退款中

3.向微信后台发送请求,得到如果退款成功,更新订单状态,

4.利用rabbitmq

后端

@Override
public Boolean cancelOrder(Long orderId) {
    //1.根据订单id得到订单信息
    OrderInfo orderInfo = orderService.getById(orderId);
    //2.判断是否取消
    DateTime quitTime = new DateTime(orderInfo.getQuitTime());
    //校验时间,对比最后时间与现在
    /*if (quitTime.isBeforeNow()) {
        throw new YyghException(ResultCodeEnum.CANCEL_ORDER_NO);
    }*/
    //3.调用医院接口实现预约取消
    SignInfoVo signInfoVo = hospitalFeignClient.getSignInfoVo(orderInfo.getHoscode());
    if (null == signInfoVo) {
        throw new YyghException(ResultCodeEnum.PARAM_ERROR);
    }

    Map<String, Object> reqMap = new HashMap<>();
    reqMap.put("hoscode", orderInfo.getHoscode());
    reqMap.put("hosRecordId", orderInfo.getHosRecordId());
    reqMap.put("timestamp", HttpRequestHelper.getTimestamp());
    String sign = HttpRequestHelper.getSign(reqMap, signInfoVo.getSignKey());
    reqMap.put("sign", sign);

    JSONObject result = HttpRequestHelper.sendRequest(reqMap, signInfoVo.getApiUrl() + "/order/updateCancelStatus");

    //根据医院接口返回数据
    if (result.getInteger("code") != 200) {
        throw new YyghException(ResultCodeEnum.PARAM_ERROR);
    } else {
        //判断当前订单是否已支付
        if (orderInfo.getOrderStatus().intValue() == OrderStatusEnum.PAID.getStatus().intValue()) {
            Boolean refund = this.refund(orderId);
            if (!refund) {
                throw new YyghException(ResultCodeEnum.CANCEL_ORDER_FAIL);
            }
            //更新订单状态
            orderInfo.setOrderStatus(OrderStatusEnum.CANCLE.getStatus());
            orderService.updateById(orderInfo);

            //剩余数量+1
            //发送mq信息更新预约数 我们与下单成功更新预约数使用相同的mq信息，不设置可预约数与剩余预约数，接收端可预约数减1即可
            rabbitMq(orderInfo);
        }
        return true;
    }
}

private void rabbitMq(OrderInfo orderInfo) {
    OrderMqVo orderMqVo = new OrderMqVo();
    orderMqVo.setScheduleId(orderInfo.getScheduleId());
    //短信提示
    MsmVo msmVo = new MsmVo();
    msmVo.setPhone(orderInfo.getPatientPhone());
    msmVo.setTemplateCode("SMS_194640722");
    String reserveDate = new DateTime(orderInfo.getReserveDate()).toString("yyyy-MM-dd") + (orderInfo.getReserveTime()==0 ? "上午": "下午");
    Map<String,Object> param = new HashMap<String,Object>(){{
        put("title", orderInfo.getHosname()+"|"+ orderInfo.getDepname()+"|"+ orderInfo.getTitle());
        put("reserveDate", reserveDate);
        put("name", orderInfo.getPatientName());
    }};
    msmVo.setParam(param);
    orderMqVo.setMsmVo(msmVo);
    rabbitService.sendMessage(MqConst.EXCHANGE_DIRECT_ORDER, MqConst.ROUTING_ORDER, orderMqVo);
}

前端

//取消预约
cancelOrder() {
  this.$confirm('确定取消预约吗?', '提示', {
    confirmButtonText: '确定',
    cancelButtonText: '取消',
    type: 'warning'
  }).then(() => { // promise
    // 点击确定，远程调用
    return weixinApi.cancelOrder(this.orderId)
  }).then((response) => {
    this.$message.success('取消成功')
    this.init()
  }).catch(() => {
    this.$message.info('已取消取消预约')
  })
},