尚医通-微信支付

最新推荐文章于 2024-09-26 08:12:49 发布
最新推荐文章于 2024-09-26 08:12:49 发布
阅读量454 收藏 3
点赞数
分类专栏： 尚医通 文章标签： 微信 java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39007838/article/details/128147783
版权

流程梳理

image-20221202102602753

依赖和工具类

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

<dependency>
    <groupId>com.example</groupId>
    <artifactId>common_utils</artifactId>
    <version>0.0.1-SNAPSHOT</version>
</dependency>

配置文件

#??????????appid
weixin.appid=wx74862e0dfcf69954
#?????
weixin.partner=1558950191
#???key
weixin.partnerkey=T6m9iK73b0kn9g5v426MKfHQH7X8rKwb
#??????
weixin.cert=/Users/zhouzhou/IdeaProjects/yygh_parent/cert/apiclient_cert.p12

常量读取

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

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

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

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

    public static String APPID;
    public static String PARTNER;
    public static String PARTNERKEY;
    public static String CERT;

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

http 请求封装

/**
 * 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 IOException {
        return content;
    }
}

生成二维码

后端实现

根据订单号生成

/**
     * 根据订单号下单，生成支付链接
     */
    @Override
    public Map createNative(Long orderId) {
        try {
            Map payMap = (Map) redisTemplate.opsForValue().get(orderId.toString());
            if(null != payMap) return payMap;

            //根据id获取订单信息
            OrderInfo order = orderService.getById(orderId);
            // 保存交易记录
            paymentService.savePaymentInfo(order, PaymentTypeEnum.WEIXIN.getStatus());
            //1、设置参数
            Map paramMap = new HashMap();
            paramMap.put("appid", ConstantPropertiesUtils.APPID);
            paramMap.put("mch_id", ConstantPropertiesUtils.PARTNER);
            paramMap.put("nonce_str", WXPayUtil.generateNonceStr());
            String body = order.getReserveDate() + "就诊" + order.getDepname();
            paramMap.put("body", body);
            paramMap.put("out_trade_no", order.getOutTradeNo());
            //paramMap.put("total_fee", order.getAmount().multiply(new BigDecimal("100")).longValue()+"");
            paramMap.put("total_fee", "1"); // 为了测试 设置为 0.01 元
            paramMap.put("spbill_create_ip", "127.0.0.1");
            paramMap.put("notify_url", "http://guli.shop/api/order/weixinPay/weixinNotify");
            paramMap.put("trade_type", "NATIVE");
            //2、HTTPClient来根据URL访问第三方接口并且传递参数
            HttpClient client = new HttpClient("https://api.mch.weixin.qq.com/pay/unifiedorder");

            //client设置参数
            client.setXmlParam(WXPayUtil.generateSignedXml(paramMap, ConstantPropertiesUtils.PARTNERKEY));
            client.setHttps(true);
            client.post();
            //3、返回第三方的数据
            String xml = client.getContent();
            Map<String, String> resultMap = WXPayUtil.xmlToMap(xml);

            //4、封装返回结果集
            Map map = new HashMap<>();
            System.out.println(map);
            map.put("orderId", orderId);
            map.put("totalFee", order.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);
        }

    }

值得说的是，这里加入了 redis ，避免统一订单号多次生成二维码，和短信验证码登录这块的思路是一致的

再就是二维码调用流程，这块基本上是固定的，思路和调用短信服务差不多，都是调用第三方服务api

前端实现

npm install vue-qriously

全局引入

import VueQrious from 'vue-qriously'
Vue.use(VueQrious)

dialog中展示

<el-dialog
      :visible.sync="dialogPayVisible"
      style="text-align: left"
      :append-to-body="true"
      width="500px"
      @close="closeDialog"
    >
      <div class="container">
        <div class="operate-view" style="height: 350px">
          <div class="wrapper wechat">
            <div>
              <!-- 显示支付二维码 -->
              <qriously :value="payObj.codeUrl" :size="220" />
              <!-- <img src="images/weixin.jpg" alt="" /> -->

              <div
                style="
                  text-align: center;
                  line-height: 25px;
                  margin-bottom: 40px;
                "
              >
                请使用微信扫一扫<br />
                扫描二维码支付
              </div>
            </div>
          </div>
        </div>
      </div>
    </el-dialog>

js调用

//生成支付二维码
    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();
      });
    },

这里需要注意的是，生成二维码后，添加一个定时器，查询支付状态

查询支付状态

@ApiOperation(value = "查询支付状态")
    @GetMapping("/queryPayStatus/{orderId}")
    public Result queryPayStatus(
            @ApiParam(name = "orderId", value = "订单id", required = true)
            @PathVariable("orderId") Long orderId) {
        //调用查询接口
        Map<String, String> resultMap = weixinPayService.queryPayStatus(orderId, PaymentTypeEnum.WEIXIN.name());
        if (resultMap == null) {//出错
            return Result.fail().message("支付出错");
        }
        if ("SUCCESS".equals(resultMap.get("trade_state"))) {//如果成功
            //更改订单状态，处理支付结果
            String out_trade_no = resultMap.get("out_trade_no");
            paymentService.paySuccess(out_trade_no, PaymentTypeEnum.WEIXIN.getStatus(), resultMap);
            return Result.ok().message("支付成功");
        }
        return Result.ok().message("支付中");
    }

Service 实现

/**
     * 支付成功
     */
    @Override
    public void paySuccess(String outTradeNo, Integer paymentType, Map<String, String> paramMap) {
        PaymentInfo paymentInfo = this.getPaymentInfo(outTradeNo, paymentType);
        if (null == paymentInfo) {
            throw new HospitalException(ResultCodeEnum.PARAM_ERROR);
        }
        if (!Objects.equals(paymentInfo.getPaymentStatus(), PaymentStatusEnum.UNPAID.getStatus())) {
            return;
        }
        //修改支付状态
        PaymentInfo paymentInfoUpd = new PaymentInfo();
        paymentInfoUpd.setPaymentStatus(PaymentStatusEnum.PAID.getStatus());
        paymentInfoUpd.setTradeNo(paramMap.get("transaction_id"));
        paymentInfoUpd.setCallbackTime(new Date());
        paymentInfoUpd.setCallbackContent(paramMap.toString());
        this.updatePaymentInfo(outTradeNo, paymentInfoUpd);
        //修改订单状态
        OrderInfo orderInfo = orderService.getById(paymentInfo.getOrderId());
        orderInfo.setOrderStatus(OrderStatusEnum.PAID.getStatus());
        orderService.updateById(orderInfo);
        // 调用医院接口，通知更新支付状态
        SignInfoVo signInfoVo
                = hospFeignClient.getSignInfoVo(orderInfo.getHoscode());
        if (null == signInfoVo) {
            throw new HospitalException(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 HospitalException(result.getString("message"), ResultCodeEnum.FAIL.getCode());
        }
    }

/**
     * 获取支付记录
     */
    private PaymentInfo getPaymentInfo(String outTradeNo, Integer paymentType) {
        QueryWrapper<PaymentInfo> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("out_trade_no", outTradeNo);
        queryWrapper.eq("payment_type", paymentType);
        return baseMapper.selectOne(queryWrapper);
    }

    /**
     * 更改支付记录
     */
    private void updatePaymentInfo(String outTradeNo, PaymentInfo paymentInfoUpd) {
        QueryWrapper<PaymentInfo> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("out_trade_no", outTradeNo);
        baseMapper.update(paymentInfoUpd, queryWrapper);
    }

效果演示

image-20221202111003523

点击支付后出现二维码

扫码后成功返回，不扫码会一直定时器调用支付状态查询接口，这块我其实感觉抛出错误的话，界面展示不是很人性化

取消预约

取消订单分两种情况：

1、未支付取消订单，直接通知医院更新取消预约状态

2、已支付取消订单，先退款给用户，然后通知医院更新取消预约状态

image-20221202114201264 
@ApiOperation(value = "取消预约")
@GetMapping("auth/cancelOrder/{orderId}")
public Result cancelOrder(
        @ApiParam(name = "orderId", value = "订单id", required = true)
        @PathVariable("orderId") Long orderId) {
    return Result.ok(orderService.cancelOrder(orderId));
}

service 实现

@Override
    public Boolean cancelOrder(Long orderId) {
        OrderInfo orderInfo = this.getById(orderId);
        //1. 当前时间大于退号时间，不能取消预约
        DateTime quitTime = new DateTime(orderInfo.getQuitTime());
        if (quitTime.isBeforeNow()) {
            throw new HospitalException(ResultCodeEnum.CANCEL_ORDER_NO);
        }
      	// 2.向医院系统发送取消预约的请求
        SignInfoVo signInfoVo = hospFeignClient.getSignInfoVo(orderInfo.getHoscode());
        if (null == signInfoVo) {
            throw new HospitalException(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 HospitalException(result.getString("message"), ResultCodeEnum.FAIL.getCode());
        } else {
            //3. 如果成功 判断是否支付 已经支付则退款
            if (orderInfo.getOrderStatus().intValue() == OrderStatusEnum.PAID.getStatus().intValue()) {
            //已支付 退款
                boolean isRefund = weixinService.refund(orderId);
                if (!isRefund) {
                    throw new HospitalException(ResultCodeEnum.CANCEL_ORDER_FAIL);
                }
            }
            //4.更改订单状态
            orderInfo.setOrderStatus(OrderStatusEnum.CANCLE.getStatus());
            this.updateById(orderInfo);
            //5.发送mq信息更新预约数 我们与下单成功更新预约数使用相同的mq信息，不设置可预约数与剩余预约数，接收端可预约数加1即可
            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);
        }
        return true;
    }

这块的逻辑还是比较复杂的，主要看两个地方

  • 微信退款的实现
  • mq的整合

微信退款的实现

简单列一下实现方法，比较固定，和前面生成二维码接口类似

@Override
    public Boolean refund(Long orderId) {
        try {
            PaymentInfo paymentInfoQuery = paymentService.getPaymentInfo(orderId, PaymentTypeEnum.WEIXIN.getStatus());

            RefundInfo refundInfo = refundInfoService.saveRefundInfo(paymentInfoQuery);
            if (refundInfo.getRefundStatus().intValue() == RefundStatusEnum.REFUND.getStatus().intValue()) {
                return true;
            }
            Map<String, String> paramMap = new HashMap<>(8);
            paramMap.put("appid", ConstantPropertiesUtils.APPID);       //公众账号ID
            paramMap.put("mch_id", ConstantPropertiesUtils.PARTNER);   //商户编号
            paramMap.put("nonce_str", WXPayUtil.generateNonceStr());
            paramMap.put("transaction_id", paymentInfoQuery.getTradeNo()); //微信订单号
            paramMap.put("out_trade_no", paymentInfoQuery.getOutTradeNo()); //商户订单编号
            paramMap.put("out_refund_no", "tk" + paymentInfoQuery.getOutTradeNo()); //商户退款单号
//       paramMap.put("total_fee",paymentInfoQuery.getTotalAmount().multiply(new BigDecimal("100")).longValue()+"");
//       paramMap.put("refund_fee",paymentInfoQuery.getTotalAmount().multiply(new BigDecimal("100")).longValue()+"");
            paramMap.put("total_fee", "1");
            paramMap.put("refund_fee", "1");
            String paramXml = WXPayUtil.generateSignedXml(paramMap, ConstantPropertiesUtils.PARTNERKEY);
            HttpClient client = new HttpClient("https://api.mch.weixin.qq.com/secapi/pay/refund");
            client.setXmlParam(paramXml);
            client.setHttps(true);
            client.setCert(true);
            client.setCertPassword(ConstantPropertiesUtils.PARTNER);
            client.post();
//3、返回第三方的数据
            String xml = client.getContent();
            Map<String, String> resultMap = WXPayUtil.xmlToMap(xml);
            if (null != resultMap && WXPayConstants.SUCCESS.equalsIgnoreCase(resultMap.get("result_code"))) {
                refundInfo.setCallbackTime(new Date());
                refundInfo.setTradeNo(resultMap.get("refund_id"));
                refundInfo.setRefundStatus(RefundStatusEnum.REFUND.getStatus());
                refundInfo.setCallbackContent(JSONObject.toJSONString(resultMap));
                refundInfoService.updateById(refundInfo);
                return true;
            }
            return false;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

mq的整合

这块还是复用之前的方式，具体可以看我上一篇博客 尚医通-预约下单中rabbitmq的使用_周周写不完的代码的博客-CSDN博客

简单看一下订单生成和订单取消是如何复用一套逻辑的

先看订单生成

OrderMqVo orderMqVo = new OrderMqVo();
orderMqVo.setScheduleId(scheduleId);
orderMqVo.setReservedNumber(reservedNumber);
orderMqVo.setAvailableNumber(availableNumber);

对比下订单取消

OrderMqVo orderMqVo = new OrderMqVo();
orderMqVo.setScheduleId(orderInfo.getScheduleId());

看下 监听器

if (null != orderMqVo.getAvailableNumber()) {
    //下单成功更新预约数
    Schedule schedule = scheduleService.getScheduleId(orderMqVo.getScheduleId());
    schedule.setReservedNumber(orderMqVo.getReservedNumber());
    schedule.setAvailableNumber(orderMqVo.getAvailableNumber());
    scheduleService.update(schedule);
} else {
    //取消预约更新预约数
    Schedule schedule = scheduleService.getScheduleId(orderMqVo.getScheduleId());
    int availableNumber = schedule.getAvailableNumber().intValue() + 1;
    schedule.setAvailableNumber(availableNumber);
    scheduleService.update(schedule);
}

可以看到 订单取消不会设置 AvailableNumber，只设置了 id

周周写不完的代码
关注
专栏目录
尚医通 （二十三）微信支付
Knight
02-24 380
尚医通 （二十三）微信支付
尚医通 (三十六) --------- 微信支付
在森林里麋了鹿
12-14 819
微信支付实现
​​​​尚硅谷—尚医通—前台用户系统—预约挂号—订单支付（生成二维码）（163-167）
张老师的博客
07-22 782
一.需求分析： 1）业务需求流程图： 2） 3） 4） 二.生成微信支付 二维码接口： 1）微信支付 介绍： a： b：申请步骤： c：下发 几个值： d：官网 开发文档： 2）开发：（两分钟内有效：r...
Day118.尚医通：订单列表、详情、微信支付、查询交易状态
a111042555的博客
08-03 1887
尚医通
尚医通 166-77 处理支付结果
qq_44798321的博客
08-29 260
一、controller 1、调用微信接口查询订单支付状态 判断支付结果 1、失败 返货结果 2、在支付 返回结果 3、成功： 调用服务层 修改订单状态 以及订单信息 如 可预约人数 //查询订单状态 queryPayStatus/${orderId} //生成支付二维码 @ApiOperation("查询订单状态") @GetMapping("queryPayStatus/{orderId}") public Result queryPayStatus(@
尚医通项目150-170：预约挂号、微信支付功能
qq_43568982的博客
07-09 1506
尚医通项目
Java大型企业级练手项目——尚医通【视频+文档+代码】
wshyb0314的博客
01-04 1494
项目后端技术栈，采用主流的SpringBoot+SpringCloud微服务架构，广泛使用了目前流行的NoSQL技术，使用Redis缓存数据，使用MongoDB实现高并发读写，整合消息中间件RabbitMQ提高订单的并发量，同时还整合了定时任务，实现就医提醒功能，综合应用了阿里云OSS，短信服务以及微信登录、微信支付，同时增加了微信退款功能。如果你已经学完 SpringBoot、微服务的大致的知识，可以把这个项目作为第一个微服务的练手项目，学习技术的整合运用、接触更多的业务场景。
尚医通【预约挂号系统】总结
m0_67391270的博客
07-30 3189
尚医通即为网上预约挂号系统，网上预约挂号是近年来开展的一项便民就医服务，旨在缓解看病难、挂号难的就医难题，许多患者为看一次病要跑很多次医院，最终还不一定能保证看得上医生。网上预约挂号全面提供的预约挂号业务从根本上解决了这一就医难题。随时随地轻松挂号！不用排长队！后台页面包括数据管理数据字典（字典树形展示、导入、导出）医药管理医院设置（列表、添加、修改、删除）医药列表（列表、详情、排班、下线）会员管理会员列表（列表、查看、锁定）认证审批列表订单管理订单列表（列表、详情）统计管理预约统计。...
尹成学院区块链 Go 学习大纲-取得大纲试看视频联系微信yinchengak48
尹成的技术博客
08-21 4747
所处阶段 主讲内容 技术要点 学习目标 第一阶段Go语言开发入门实战 1.Go语言介绍及开发环境搭建 1.Go语言是什么 2.Go语言优势 3.Go语言适合来做什么 4.Go语言安装和设置 5.标准命令概述 6.第一个Go语言程序 课程设计理念： 夯实基础，Go语言作为...
尚医通项目总结
weixin_45524836的博客
03-21 4260
1项目总结 1.1项目功能总结（后台管理系统） 1、医院设置管理 （1）医院设置列表、添加、锁定、删除 （2）医院列表、详情、排班、下线 2、数据管理 （1）数据字典树形显示、导入、导出 3、用户管理 （1）用户列表、查看、锁定 （2）认证用户审批 4、订单管理 （1）订单列表、详情 5、统计管理 （1）预约统计 1.2项目功能总结（前台用户系统） 1、首页数据显示 （1）医院列表 2、医院详情显示 （1）医院科室显示 3、用户登录功能 （1）手机号登录（短信验证码发送） （2）微信扫描登录
【SpringBoot应用篇】接入微信支付
输入技术、输出想法
06-23 2837
微信支付
微信退款API证书-P12、本地测试及Windows、Linux系统配置证书
m0_60563637的博客
07-13 6746
微信退款API证书-P12类型证书的申请安装、本地测试及Windows、Linux系统配置证书
22-08-18 西安 尚医通（07）挂号流程、就医提醒，预约统计、rabbitmq的使用、定时任务、Echarts
m0_56799642的博客
08-19 1667
mq在这里充当了异步调用的作用，可以提高下单的响应速度
微信支付实战（2）
qq_38807606的博客
12-04 1124
1. 首先先申请一个测试账号 地址如下： 微信公众平台 登录后会给一个 appId和secret appID ********* appsecret ********* 取自官网上 demo 里 README.md 文件 ： 此SDK是对 微信支付开发者文档做了 封装： 微信支付开发者文档： https://pay.weixin.qq.com/wiki/doc/api/index.html 微信支付 Java SDK ------ 对[微信支付开发者文档](https://pay..
Day113.尚医通：微信登录二维码、登录回调接口
a111042555的博客
07-29 2998
尚医通
基于微信的原创音乐小程序的设计与实现+ssm论文源码调试讲解
最新发布
u014445459的博客
09-26 1129
Java主要采用CORBA技术和安全模型，可以在互联网应用的数据保护。它还提供了对EJB（Enterrise JavaBeans）的全面支持，java servlet AI，JS（java server ages），和XML技术。JAVA语言功能：面向对象：面向对象是Java编程语言的标志之一，是一种软件开发方法。最重要的是将所有东西变成对象，然后以某种方式编程。编程时，代码和数据写在每个对象上。面向对象编程方法的出现使得人们在编程过程中的设计思考和操作变得非常简单，同时也提高了程序的安全性。
工厂模式的介绍及实现
户伟伟的博客
09-25 96
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
uni-app微信支付
08-19
Uni-app是一个跨平台的开发框架，可以在一个代码库中同时开发iOS、Android和Web应用。而微信支付是一种移动支付方式，可以在微信内进行支付操作。 在Uni-app中实现微信支付，可以按照以下步骤进行操作： 1. 在Uni-app项目中导入并安装uni-wxpay插件，该插件是对微信支付的封装。 2. 配置微信支付的相关参数，在项目的manifest.json文件中添加以下代码： ```json "app-plus": { "payment": { "wechatpay": { "appid": "Your_WeChat_AppID", "mch_id": "Your_WeChat_Mch_ID", "apiKey": "Your_WeChat_API_Key" } } }, ``` 其中，"appid"是你的微信小程序AppID，"mch_id"是你的商户号，"apiKey"是你的API密钥。 3. 在需要使用微信支付的页面中，使用uni-wxpay插件提供的API进行支付操作。具体的API包括： - `uni.requestPayment()`：发起支付请求。 - `uni.onPaymentSuccess()`：监听支付成功事件。 - `uni.onPaymentFail()`：监听支付失败事件。 通过调用`uni.requestPayment()`方法，传入相关参数（如订单号、支付金额等），即可调起微信支付界面。在支付成功或失败后，会触发相应的事件回调函数。 需要注意的是，为了能够使用微信支付，你需要先在微信公众平台或开放平台上注册并获取相关的AppID、商户号和API密钥。 希望以上信息对你有帮助！如有更多问题，请随时提问。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值