小程序微信支付

最新推荐文章于 2024-07-29 10:54:32 发布
最新推荐文章于 2024-07-29 10:54:32 发布
阅读量209 收藏 2
点赞数
分类专栏： 小程序中的微信支付 文章标签： java实现小程序中微信支付
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36837143/article/details/102935347
版权

前言：最近写小程序中微信支付!
其实支付很简单,不就是些请求接口然后返回结果最后回调处理业务逻辑!
官网：https://pay.weixin.qq.com/wiki/doc/api/wxa/wxa_api.php?chapter=7_7&index=5
话不多说:看代码

 /**
     * 开始
     * 进行支付
     * 参数自己配置上
     */
    @ApiOperation(value = "付款")
    @RequestMapping("/paymentOrder")
    public Object paymentOrder() {
        String nonceStr = CurrencyUtils.getRandomString(32);
        Map<Object, Object> resultObj = new TreeMap();
        try {
            Map<Object, Object> parame = new TreeMap<Object, Object>();
            //小程序id
            parame.put("appid", ResourceUtil.getConfigByName("wx.appId"));
            // 商家账号。
            parame.put("mch_id", ResourceUtil.getConfigByName("wx.mchId"));
            String randomStr = CurrencyUtils.getRandomNum(18).toUpperCase();
            // 随机字符串
            parame.put("nonce_str", randomStr);
            //商户订单编号：建议商品订单号设置 随机号+订单id，然后存在数据库，回调的时候根据随机号+订单id查询在做业务逻辑处理
            parame.put("out_trade_no", "123456");
            // 商品描述
            parame.put("body", "服务类型-支付");
            //支付金额 单位是分
            BigDecimal money =  new BigDecimal(1);//一块钱
            parame.put("total_fee", money.multiply(new BigDecimal(100)).intValue());
            // 回调地址
            parame.put("notify_url", ResourceUtil.getConfigByName("wx.notifyUrl"));
            // 交易类型APP
            parame.put("trade_type", ResourceUtil.getConfigByName("wx.tradeType"));
            //客户ip
            parame.put("spbill_create_ip", getClientIp());
            //微信客户的openid
            parame.put("openid", "xxxxxxxxxxx");
            //设置签名
            String sign = CurrencyUtils.arraySign(parame, ResourceUtil.getConfigByName("wx.paySignKey"));
            // 数字签证
            parame.put("sign", sign);
            //转成xml格式
            String xml = CurrencyUtils.convertMap2Xml(parame);
            logger.info("xml:" + xml);
            /*请求url ：https://api.mch.weixin.qq.com/pay/unifiedorder */
            Map<String, Object> resultUn = CurrencyUtils.xmlStrToMap(CurrencyUtils.requestOnce(ResourceUtil.getConfigByName("wx.uniformorder"), xml));
            // 响应报文
            String return_code = CurrencyUtils.getString("return_code", resultUn);
            String return_msg = CurrencyUtils.getString("return_msg", resultUn);
            if (return_code.equalsIgnoreCase("FAIL")) {
                return toResponsFail("支付失败," + return_msg);
            } else if (return_code.equalsIgnoreCase("SUCCESS")) {
                // 返回数据
                String result_code = CurrencyUtils.getString("result_code", resultUn);
                String err_code_des = CurrencyUtils.getString("err_code_des", resultUn);
                if (result_code.equalsIgnoreCase("FAIL")) {
                    return toResponsFail("支付失败," + err_code_des);
                } else if (result_code.equalsIgnoreCase("SUCCESS")) {
                    String prepay_id = MapUtils.getString("prepay_id", resultUn);
                    // 先生成paySign 参考https://pay.weixin.qq.com/wiki/doc/api/wxa/wxa_api.php?chapter=7_7&index=5
                    resultObj.put("appId", ResourceUtil.getConfigByName("wx.appId"));
                    resultObj.put("timeStamp", CurrencyUtils.timeToStr(System.currentTimeMillis() / 1000, CurrencyUtils.DATE_TIME_PATTERN));
                    resultObj.put("nonceStr", nonceStr);
                    resultObj.put("package", "prepay_id=" + prepay_id);
                    resultObj.put("signType", "MD5");
                    String paySign = CurrencyUtils.arraySign(resultObj, ResourceUtil.getConfigByName("wx.paySignKey"));
                    resultObj.put("paySign", paySign);
                    //业务处理
                  /*  order.setPayId(prepay_id);
                    order.setPayStatus(1);
                    aboutService.update(order);*/
                    return toResponsObject(0, "微信统一订单下单成功", resultObj);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            return toResponsFail("下单失败,error=" + e.getMessage());
        }
        return toResponsFail("下单失败");
    }

工具类有点多 暂时没有整理pom.xml文件 缺少包自己找

package com.platform.utils.excel;

import com.alibaba.druid.support.logging.Log;
import com.alibaba.druid.support.logging.LogFactory;
import com.platform.utils.ResourceUtil;
import com.platform.utils.StringUtils;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.conn.BasicHttpClientConnectionManager;
import org.apache.http.util.EntityUtils;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;

import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.security.MessageDigest;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * @Author: HUN
 * @Date: 2019/11/6 16:06
 * @Description:
 */
public class CurrencyUtils {
    private static Log logger = LogFactory.getLog(CurrencyUtils.class);
    /**
     * 获取随机字符串
     *
     * @param num
     * @return
     */
    public static String getRandomString(Integer num) {
        String base = "abcdefghijklmnopqrstuvwxyz0123456789";
        Random random = new Random();
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < num; i++) {
            int number = random.nextInt(base.length());
            sb.append(base.charAt(number));
        }
        return sb.toString();
    }

    /**
     * 获取随机字符串
     *
     * @param num
     * @return
     */
    public static String getRandomNum(Integer num) {
        String base = "0123456789";
        Random random = new Random();
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < num; i++) {
            int number = random.nextInt(base.length());
            sb.append(base.charAt(number));
        }
        return sb.toString();
    }

    /*  * 生成 MD5
     *
     * @param data 待处理数据
     * @return MD5结果
     */
    public static String getMessageDigest(String data) {
        StringBuilder sb = new StringBuilder();
        try {
            MessageDigest md = MessageDigest.getInstance("MD5");
            byte[] array = md.digest(data.getBytes("UTF-8"));

            for (byte item : array) {
                sb.append(Integer.toHexString((item & 0xFF) | 0x100).substring(1, 3));
            }
        } catch (Exception e) {
            return null;
        }
        return sb.toString().toUpperCase();
    }

    /**
     * 方法描述：根据签名加密请求参数
     * 创建时间：2017年6月8日  上午11:28:52
     * 作者： xubo
     *
     * @param
     * @return
     */
    public static String arraySign(Map<Object, Object> params, String paySignKey) {
        boolean encode = false;
        Set<Object> keysSet = params.keySet();
        Object[] keys = keysSet.toArray();
        Arrays.sort(keys);
        StringBuffer temp = new StringBuffer();
        boolean first = true;
        for (Object key : keys) {
            if (first) {
                first = false;
            } else {
                temp.append("&");
            }
            temp.append(key).append("=");
            Object value = params.get(key);
            String valueString = "";
            if (null != value) {
                valueString = value.toString();
            }
            if (encode) {
                try {
                    temp.append(URLEncoder.encode(valueString, "UTF-8"));
                } catch (UnsupportedEncodingException e) {
                    e.printStackTrace();
                }
            } else {
                temp.append(valueString);
            }
        }
        temp.append("&key=");
        temp.append(paySignKey);
        System.out.println(temp.toString());
        String packageSign = getMessageDigest(temp.toString());
        return packageSign;
    }

    //转成xml格式
    public static String convertMap2Xml(Map<Object, Object> paraMap) {
        StringBuffer xmlStr = new StringBuffer();
        if (paraMap != null) {
            xmlStr.append("<xml>");
            Set<Object> keySet = paraMap.keySet();
            Iterator<Object> keyIte = keySet.iterator();
            while (keyIte.hasNext()) {
                String key = (String) keyIte.next();
                String val = String.valueOf(paraMap.get(key));
                xmlStr.append("<");
                xmlStr.append(key);
                xmlStr.append(">");
                xmlStr.append(val);
                xmlStr.append("</");
                xmlStr.append(key);
                xmlStr.append(">");
            }
            xmlStr.append("</xml>");
        }
        return xmlStr.toString();
    }

    /**
     * 请求，只请求一次，不做重试
     *
     * @param url
     * @param data
     * @return
     * @throws Exception
     */
    public static String requestOnce(final String url, String data) throws Exception {
        BasicHttpClientConnectionManager connManager;
        connManager = new BasicHttpClientConnectionManager(
                RegistryBuilder.<ConnectionSocketFactory>create()
                        .register("http", PlainConnectionSocketFactory.getSocketFactory())
                        .register("https", SSLConnectionSocketFactory.getSocketFactory())
                        .build(),
                null,
                null,
                null
        );

        HttpClient httpClient = HttpClientBuilder.create()
                .setConnectionManager(connManager)
                .build();

        HttpPost httpPost = new HttpPost(url);

        RequestConfig requestConfig = RequestConfig.custom()
                .setSocketTimeout(5000)
                .setConnectTimeout(5000)
                .setConnectionRequestTimeout(10000).build();

        httpPost.setConfig(requestConfig);

        StringEntity postEntity = new StringEntity(data, "UTF-8");
        httpPost.addHeader("Content-Type", "text/xml");
        httpPost.addHeader("User-Agent", "wxpay sdk java v1.0 " + ResourceUtil.getConfigByName("wx.mchId"));
        httpPost.setEntity(postEntity);

        HttpResponse httpResponse = httpClient.execute(httpPost);
        HttpEntity httpEntity = httpResponse.getEntity();
        String reusltObj = EntityUtils.toString(httpEntity, "UTF-8");
        logger.info("请求结果:" + reusltObj);
        return reusltObj;
    }

    /**
     * 将xml格式的字符串转换成Map对象
     *
     * @param xmlStr xml格式的字符串
     * @return Map对象
     * @throws Exception 异常
     */
    public static Map<String, Object> xmlStrToMap(String xmlStr) throws Exception {
        if (StringUtils.isNullOrEmpty(xmlStr)) {
            return null;
        }
        Map<String, Object> map = new HashMap<String, Object>();
        // 将xml格式的字符串转换成Document对象
        Document doc = DocumentHelper.parseText(xmlStr);
        // 获取根节点
        Element root = doc.getRootElement();
        // 获取根节点下的所有元素
        List children = root.elements();
        // 循环所有子元素
        if (children != null && children.size() > 0) {
            for (int i = 0; i < children.size(); i++) {
                Element child = (Element) children.get(i);
                map.put(child.getName(), child.getTextTrim());
            }
        }
        return map;
    }

    /**
     *
     * @param key
     * @param map 从map中获取key的值
     * @return
     */
    public static String getString(String key, Map<String, Object> map) {
        if (map == null || key == null)
            throw new IllegalArgumentException();
        if (!map.containsKey(key))
            return null;
        Object value = map.get(key);
        if (value == null)
            return null;
        return value.toString();
    }


    /**
     * 时间格式(yyyy-MM-dd HH:mm:ss)
     */
    public final static String DATE_TIME_PATTERN = "yyyy-MM-dd HH:mm:ss";

    /**
     * 获取时间戳
     * @param time
     * @param pattern
     * @return
     */
    public static String timeToStr(Long time, String pattern) {
        SimpleDateFormat dateFormat = new SimpleDateFormat(pattern);
        if (time.toString().length() < 13) {
            time = time * 1000L;
        }
        Date date = new Date(time);
        String value = dateFormat.format(date);
        return value;
    }

    /**
     * @param requestCode
     * @param msg
     * @param data
     * @return Map<String,Object>
     * @throws
     * @Description:构建统一格式返回对象
     * @date 2016年9月2日
     * @author zhuliyun
     */
    public Map<String, Object> toResponsObject(int requestCode, String msg, Object data) {
        Map<String, Object> obj = new HashMap<String, Object>();
        obj.put("errno", requestCode);
        obj.put("errmsg", msg);
        if (data != null)
            obj.put("data", data);
        return obj;
    }

    /**
     * 错误的json格式
     * @param msg
     * @return
     */
    public Map<String, Object> toResponsFail(String msg) {
        return toResponsObject(1, msg, null);
    }
/**
     * 将Map对象通过反射机制转换成Bean对象
     *
     * @param map   存放数据的map对象
     * @param clazz 待转换的class
     * @return 转换后的Bean对象
     * @throws Exception 异常
     */
    public static Object mapToBean(Map<String, Object> map, Class clazz) throws Exception {
        Object obj = clazz.newInstance();
        if (map != null && map.size() > 0) {
            for (Map.Entry<String, Object> entry : map.entrySet()) {
                String propertyName = entry.getKey();
                Object value = entry.getValue();
                String setMethodName = "set" + propertyName.substring(0, 1).toUpperCase() + propertyName.substring(1);
                Field field = getClassField(clazz, propertyName);
                if (field != null) {
                    Class fieldTypeClass = field.getType();
                    value = convertValType(value, fieldTypeClass);
                    clazz.getMethod(setMethodName, field.getType()).invoke(obj, value);
                }
            }
        }
        return obj;
    }

    /**
     * 获取指定字段名称查找在class中的对应的Field对象(包括查找父类)
     *
     * @param clazz     指定的class
     * @param fieldName 字段名称
     * @return Field对象
     */
    private static Field getClassField(Class clazz, String fieldName) {
        if (Object.class.getName().equals(clazz.getName())) {
            return null;
        }
        Field[] declaredFields = clazz.getDeclaredFields();
        for (Field field : declaredFields) {
            if (field.getName().equals(fieldName)) {
                return field;
            }
        }

        Class superClass = clazz.getSuperclass();
        if (superClass != null) {// 简单的递归一下
            return getClassField(superClass, fieldName);
        }
        return null;
    }

    /**
     * 将Object类型的值，转换成bean对象属性里对应的类型值
     *
     * @param value          Object对象值
     * @param fieldTypeClass 属性的类型
     * @return 转换后的值
     */
    private static Object convertValType(Object value, Class fieldTypeClass) {
        Object retVal = null;
        if (Long.class.getName().equals(fieldTypeClass.getName())
                || long.class.getName().equals(fieldTypeClass.getName())) {
            retVal = Long.parseLong(value.toString());
        } else if (Integer.class.getName().equals(fieldTypeClass.getName())
                || int.class.getName().equals(fieldTypeClass.getName())) {
            retVal = Integer.parseInt(value.toString());
        } else if (Float.class.getName().equals(fieldTypeClass.getName())
                || float.class.getName().equals(fieldTypeClass.getName())) {
            retVal = Float.parseFloat(value.toString());
        } else if (Double.class.getName().equals(fieldTypeClass.getName())
                || double.class.getName().equals(fieldTypeClass.getName())) {
            retVal = Double.parseDouble(value.toString());
        } else {
            retVal = value;
        }
        return retVal;
    }




}

回调接口
注意你请求时记回调设置要用域名或者网穿透。否则微信不会回调。

/**
     * 微信订单回调接口
     *
     * @return
     */
    @ApiOperation(value = "直接微信订单回调接口")
    @RequestMapping(value = "/notify", method = RequestMethod.POST, produces = "text/html;charset=UTF-8")
    @ResponseBody
    public void notify(HttpServletRequest request, HttpServletResponse response) {
        try {
            request.setCharacterEncoding("UTF-8");
            response.setCharacterEncoding("UTF-8");
            response.setContentType("text/html;charset=UTF-8");
            response.setHeader("Access-Control-Allow-Origin", "*");
            InputStream in = request.getInputStream();
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            byte[] buffer = new byte[1024];
            int len = 0;
            while ((len = in.read(buffer)) != -1) {
                out.write(buffer, 0, len);
            }
            out.close();
            in.close();
            //xml数据
            String reponseXml = new String(out.toByteArray(), "utf-8");
            WechatRefundApiResult result = (WechatRefundApiResult) CurrencyUtils.xmlStrToBean(reponseXml, WechatRefundApiResult.class);
            String result_code = result.getResult_code();
            if (result_code.equalsIgnoreCase("FAIL")) {
                //订单编号
                String out_trade_no = result.getOut_trade_no();
                logger.error("订单" + out_trade_no + "支付失败");
                response.getWriter().write(setXml("SUCCESS", "OK"));
            } else if (result_code.equalsIgnoreCase("SUCCESS")) {
                //订单编号
                String out_trade_no = result.getOut_trade_no();
                logger.error("订单" + out_trade_no + "支付成功");
                // 业务处理
                //....
                response.getWriter().write(setXml("SUCCESS", "OK"));
            }
        } catch (Exception e) {
            e.printStackTrace();
            return;
        }
    }
        //返回微信服务
    public static String setXml(String return_code, String return_msg) {
        return "<xml><return_code><![CDATA[" + return_code + "]]></return_code><return_msg><![CDATA[" + return_msg + "]]></return_msg></xml>";
    }

回调xml转实体类

public class WechatRefundApiResult {
	private String return_code;
	private String return_msg;
	
	private String result_code;
	private String err_code;
	private String err_code_des;
	private String appid;
	private String mch_id;
	private String device_info;
	private String nonce_str;
	private String sign;
	private String transaction_id;
	private String out_trade_no;
	private String out_refund_no;
	private String refund_id;
	private String refund_channel;
	private String refund_fee;
	private String settlement_refund_fee;
	private String total_fee;
	private String settlement_total_fee;
	private String fee_type;
	private String cash_fee;
	private String cash_refund_fee;
	private String refund_status;
	}

小程序代码
主要是这个方法：requestPayment
前台请求支付接口返回值放入 requestPayment方法中.然后小程序就会自动调出支付!
这里建议看官网!前台不是我写的。
在这里插入图片描述
到这里差不多完了代码就这么多!还有一种是扫码支付。但是思想是一样的，微信请求url不同,参数差不多,多了生产个二维码而已!具体就不介绍了。
讲讲有坑的地方，
1.订单号这个坑，当时我是碰到了，主要是生成订单后不支付，就占用了订单号，这时候客户去修改订单，有可能会变动金额，就支付不了，还有正式上线时，出现该订单已支付这种问题，其实就是测试订单时把改订单号已经使用了。所以建议随机号加id，存在订单中。
2.金额是分作为单位，
3.最难解决的是签名问题。建议看仔细官网签名生成规则!
4.最后回调调试。

甜晓枫
关注
专栏目录
小程序微信支付，微信小程序支付
12-29
小程序微信支付，微信小程序支付
微信支付-小程序支付
06-24
适用于微信小程序支付的时候,服务器端的预支付和支付接口,以及支付结果回调通知!
微信小程序---支付
weixin_47808575的博客
06-18 1346
获取订单编号再次请求后端接口，拿到wx.requestPayment()需要的参数。如果没有登录，走前端登录流程，不再赘述。跟自己的后端商议入参，然后获取订单编号。
微信小程序+JAVA实现微信支付
最新发布
student_zz的博客
07-29 5274
时隔两年再次回归 本文主要讲的是小程序实现微信支付功能，后台采用JAVA。 一.准备工作 1.小程序 2.微信商户号 1.商户号申请 这里对小程序的申请不做赘述。 如果没有微信商户号的同学，点击该链接https://pay.weixin.qq.com/，按照下属步骤进行商户号申请。 扫码之后点击"成为商家"，这里主要有个人个体工商户和企业，按照事实填写，然后按照步骤填写就行了。 主要需要营业执照，法人信息，公账信息等。 2.微信商户号关联小程序 点击"产品中心"的"开发配置"，点击"新增授权申请单"。
小程序微信支付实现
PHPer技术栈
07-14 934
前言： 最近在做小程序微信支付，开发中遇到的各种问题与大家分享，对小程序微信支付做一个简单的总结和梳理。 开发环境： - 使用语言：PHP # PHP世界上最好的语言 - 使用框架：zend framwork # 公司内部框架，实现原理不受框架约束 - 测试工具：微信开发者工具 # 简单、方便、好用 - 整理时间：2019-02-12 ...
asp.net版小程序微信支付接口文件
09-20
ASP.NET版的小程序微信支付接口文件是用于在ASP.NET平台上集成微信支付功能的关键组件，它使得开发者能够方便地在自己的小程序应用中实现安全、便捷的在线支付。此接口文件包括了必要的配置信息以及处理支付请求的...
【支付】微信小程序微信支付接入开发
03-29
本文主要讲述微信小程序接入微信支付开发过程中遇到的坑，分为两大块，小程序端和后台接口封装。本文主要内容如下： 一、后台接口封装； 二、小程序端整合； 三、总结 一、后台接口封装 本文介绍基于ThinkPHP5进行...
微信小程序微信支付接入开发实例详解
08-30
微信小程序微信支付接入开发是一个复杂的过程，涉及到前后端的交互以及微信支付平台的接口调用。下面将详细讲解这一过程。 一、后台接口封装 在后台接口封装阶段，主要是为了提供给微信小程序调用的支付接口。以...
uni-app商城-含小程序微信登陆、小程序微信支付
05-25
【uni-app商城-含小程序微信登陆、小程序微信支付】是一个基于uni-app框架开发的电子商务解决方案，旨在为开发者提供一个能够快速构建包含小程序登录和微信支付功能的多端应用。uni-app是一个由Egret Lab推出的跨...
php微信小程序支付代码
07-26
php微信小程序支付代码
小程序微信支付-用作记录
03-15
小程序微信支付
关于微信小程序获取小程序码并接受buffer流保存为图片的方法
10-16
主要介绍了关于微信小程序获取小程序码并接受buffer流保存为图片的方法，文中通过示例代码介绍的非常详细，对大家学习或者使用小程序具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
微信支付一篇就够了（app，小程序，公众号）
Mr_likes的博客
07-16 1633
当前开发的主流项目涉及到实体商品，虚拟商品等付费服务的基本都会用到微信支付，本篇对于对接微信商户平台的三大主流支付方式的Java对接方式列举一下。官方文档给到httpshttpshttpshttps微信官方提供了一套Java、.NET、PHP等三个版本的开发SDKhttps其实这几种支付方式所调用api接口参数和方式都大同小异，详细的参数介绍可以直接访问官方文档查看，下面直接列实战代码复制即用。......
微信支付签名遇到的坑
wpeng_1024的博客
06-29 2394
这两天做了下微信支付，其中也遇到不少问题，记录下，以免下次重复踩坑。         结合我们项目使用场景，我选择了扫码支付 模式二 (具体开发步骤见 官方文档  扫码支付模式二)         微信下单方法：               SortedMap param = new TreeMap(); //公众号ID param.put("appid", ap
Java操作mongodb小记
03-17 735
JSONArray jsonArr = JSONArray.fromObject(menuContent); JSONObject jsonObj = null; Mongo mongo = new Mongo(ResourceUtil.getConfigByName("MongoDB_IP"), Integer.valueOf(ResourceUtil.getConfigByName
java获取小程序中用户的unionId的三种方式
热门推荐
SCDN_CP的博客
03-26 1万+
前提条件： 想要获取uuid，必须几个小程序或者公众号在同一个主体之下，要不然没有uuid,只会生成用户的openid https://open.weixin.qq.com 第一种实现方式：使用weixin-java-miniapp实现微信小程序登录接口 个人认为代码最为整洁 maven 依赖 <!--微信开源封装sdk--> <dep...
springboot读取自定义配置文件
CaptainJava的博客
04-10 2744
前提： Application.java启动类要添加注解支持，如果使用的注解是 @SpringBootApplication 那没问题，如果不是的话，还需要添加如下注解来开启配置文件读取支持 @EnableAutoConfiguration //自动加载配置信息 实现方法： 一、 1、如果是读取application.properties文件中的值可以直接用@Value("${属...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值