准备工作
第一步：注册公众号（类型须为：服务号）：请根据营业执照类型选择以下主体注册：个体工商户| 企业/公司| 政府| 媒体| 其他类型。
第二步：认证公众号：公众号认证后才可申请微信支付，认证费：300元/年。
第三步：提交资料申请微信支付：登录公众平台，点击左侧菜单【微信支付】，开始填写资料等待审核，审核时间为1-5个工作日内。
第四步：登录商户平台进行验证：资料审核通过后，请登录联系人邮箱查收商户号和密码，并登录商户平台填写财付通备付金打的小额资金数额，完成账户验证。
第五步：在线签署协议：本协议为线上电子协议，签署后方可进行交易及资金结算，签署完立即生效。
前期工作完成会下发重要信息
appid: 微信公众账号或开放平台APP的唯一标识
mch_id: 商户号，稍后用配置文件中的partner代替，见名知意
partnerkey: 商户密钥
sign: 数字签名，根据微信官方提供的密钥和一套算法生成的一个加密信息，就是为了保证交易的安全性
在支付过程中，主要会用到微信支付SDK的以下功能
获取随机字符串: WXPayUtil.generateNonceStr()
Map类型转换为xml字符串（自动添加签名）: WXPayUtil.generateSignedXml(map, partnerkey)
xml字符串转换为Map类型: WXPayUtil.xmlToMap(result)
在支付模块中导入微信支付依赖

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

配置文件添加微信支付信息，为了设置预付单的有效时间，还需要添加redis缓存信息
spring.redis.host=your_ip
spring.redis.port=6379
spring.redis.database= 0
spring.redis.timeout=1800000
spring.redis.lettuce.pool.max-active=20
spring.redis.lettuce.pool.max-wait=-1

最大阻塞等待时间(负数表示没限制)

spring.redis.lettuce.pool.max-idle=5
spring.redis.lettuce.pool.min-idle=0

关联的公众号appid

wx.appid=your_app_id

商户号

wx.partner=your_partner

商户key

wx.partnerkey=your_partner_key
编写常量类读取配置文件中微信支付信息
@Component
public class WxPayProperties implements InitializingBean {
@Value("${wx.appid}")
private String appId;
@Value("${wx.partner}")
private String partner;
@Value("${wx.partnerkey}")
private String partnerKey;

public static String WX_APP_ID;
public static String WX_PARTNER;
public static String WX_PARTNER_KEY;

@Override
public void afterPropertiesSet() throws Exception {

WX_APP_ID = appId;
WX_PARTNER = partner;
WX_PARTNER_KEY = partnerKey;

}
}
借用HttpClient工具类，内容基本不用改，可尝试优化下
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.TrustSelfSignedStrategy;
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 org.springframework.util.StringUtils;

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

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

public void addParameter(String key, String value) {
    if (param == null) param = new HashMap<>();
    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 completeUrl = new StringBuilder(this.url);
        boolean isFirst = true;
        for(Map.Entry<String, String> entry: param.entrySet()) {
            if(isFirst)  completeUrl.append("?");
            else completeUrl.append("&");
            completeUrl.append(entry.getKey()).append("=").append(entry.getValue());
            isFirst = false;
        }
        // 拼接成完整的url
        this.url = completeUrl.toString();
    }
    HttpGet http = new HttpGet(url);
    execute(http);
}

/** 设置post和put参数 */
private void setEntity(HttpEntityEnclosingRequestBase http) {
    if (param != null) {
        List<NameValuePair> nvps = new LinkedList<>();
        for(Map.Entry<String, String> entry: param.entrySet())
            nvps.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));   // 参数
        http.setEntity(new UrlEncodedFormEntity(nvps, Consts.UTF_8)); // 设置参数
    }
    if (!StringUtils.isEmpty(xmlParam)) http.setEntity(new StringEntity(xmlParam, Consts.UTF_8));
}

/** 执行get、post、put请求 */
private void execute(HttpUriRequest http) throws ClientProtocolException, IOException {
    CloseableHttpClient httpClient = null;
    try {
        if (isHttps) {
            if(isCert) {
                FileInputStream inputStream = new FileInputStream(WxPayProperties.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 {
                TrustSelfSignedStrategy strategy = new TrustSelfSignedStrategy() {
                    @Override
                    public boolean isTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
                        // 信任所有
                        return true;
                    }
                };
                SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(null, strategy).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 {
            assert response != null;
            response.close();
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        assert httpClient != null;
        httpClient.close();
    }
}


public int getStatusCode() {
    return statusCode;
}

public String getContent() throws ParseException, IOException {
    return content;
}

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 String getCertPassword() {
    return certPassword;
}

public void setCertPassword(String certPassword) {
    this.certPassword = certPassword;
}

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

}
用户微信支付（前后端工作）
后端生成微信支付二维码业务逻辑代码
@Service
public class WxPayServiceImpl implements WxPayService {

@Autowired
private RedisTemplate<String, Object> redisTemplate;
/** 生成微信支付二维码 */
@Override
public Map<String, Object> createNative(String orderId) {
    try {
        // 如果缓存中有，就直接返回
        Map<String, Object> payMap = (Map<String, Object>) redisTemplate.opsForValue().get(orderId);
        if(payMap != null) return payMap;
        // 根据实际的业务需求编写相应的代码
        // 省略业务代码.......
        // 设置参数，
        // 把参数转换xml格式，使用商户key进行加密
        Map<String, String> paramMap = new HashMap<>();
        paramMap.put("appid", WxPayProperties.WX_APP_ID);
        paramMap.put("mch_id", WxPayProperties.WX_PARTNER);
        // 随机字符串
        paramMap.put("nonce_str", WXPayUtil.generateNonceStr());
        String body = "请求体，应该是扫码支付时的文本信息";
        paramMap.put("body", body);
        // 实际开发中还是要保存当前字段到数据表中，供其他需求（如退款）使用
        paramMap.put("out_trade_no", "交易流水号，自定义即可，保证唯一性");
        paramMap.put("total_fee", "1"); // 支付的费用
        // 当前支付的IP地址
        paramMap.put("spbill_create_ip", "可以通过HttpServletRequest对象获取请求的IP地址");
        // 微信支付的回调地址
        paramMap.put("notify_url", "申请微信支付时填的回调地址");
        // 微信扫码支付
        paramMap.put("trade_type", "NATIVE");
        //4 调用微信生成二维码接口，httpclient调用，请求地址一般固定
        HttpClient client = new HttpClient("https://api.mch.weixin.qq.com/pay/unifiedorder");
        //设置xml参数（Map类型转换为xml）
        client.setXmlParam(WXPayUtil.generateSignedXml(paramMap, WxPayProperties.WX_PARTNER_KEY));
        // 是https协议
        client.setHttps(true);
        client.post();
        //5 返回相关数据
        String xml = client.getContent();
        // xml数据转换为Map类型
        Map<String, String> resultMap = WXPayUtil.xmlToMap(xml);
        //6 封装返回结果集
        Map<String, Object> 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(resultMap.get("result_code") != null) {
            // 保存到Redis缓存中
            redisTemplateString.opsForValue().set(orderId.toString(),map,120, TimeUnit.MINUTES);
        }
        return map;
    }catch (Exception e) {
        e.printStackTrace();
        return new HashMap<>();
    }
}

}
前端引入vue-qriously生成二维码
安装vue-qriously: npm install vue-qriously
在插件文件中导入
import VueQriously from 'vue-qriously'
Vue.use(VueQriously)
vue组件显示二维码，只展示二维码区域

请使用微信扫一扫
扫描二维码支付

    </div>
  </div>
</div>

后端编写微信支付状态接口，同样省略支付成功之后的业务需求代码
@Service
public class WxPayServiceImpl implements WxPayService {
/ * 查询支付状态 /

@Override
public Map<String, String> queryPayStatus(Long orderId) {
    try {
        // 封装提交参数
        Map<String, String> paramMap = new HashMap<>();
        paramMap.put("appid", WxPayProperties.WX_APP_ID);
        paramMap.put("mch_id", WxPayProperties.WX_PARTNER);
        // 实际开发中还是要保存当前字段到数据表中，供其他需求（如退款）使用
        paramMap.put("out_trade_no", "当前支付订单的流水号");
        paramMap.put("nonce_str", WXPayUtil.generateNonceStr());

        // 设置请求内容
        HttpClient client = new HttpClient("https://api.mch.weixin.qq.com/pay/orderquery");
        client.setXmlParam(WXPayUtil.generateSignedXml(paramMap, WxPayProperties.WX_PARTNER_KEY));
        client.setHttps(true);
        client.post();

        // 得到微信接口返回数据
        String xml = client.getContent();
        // 其中返回的数据中会有transaction_id字段的数据，这是交易流水号，供退款使用
        return WXPayUtil.xmlToMap(xml);
    }catch(Exception e) {
        e.printStackTrace();
        return new HashMap<>();
    }
}

}
注意支付（成功）之后返回的数据结果
用户申请退款
参考文档下载证书
在原有的配置文件中添加配置证书的路径（全路径）
wx.cert=absolute_path\apiclient_cert.p12
退款操作是根据支付记录发起的，所以支付和退款的交易单号必须保持一致
@Service
public class OrderServiceImpl implements OrderService {

@Autowired
private WxPayService wxPayService;
@Override
public boolean cancelOrder(Long orderId) {
    // 退款成功前关于订单、库存等其他业务的需求，需要根据实际开发场景编写，这里暂时忽略不写
    // ..........
    // 判断当前的订单是否可以取消
    if(OrderStatusEnum.PAID.getStatus().equals(orderInfo.getOrderStatus())) {
        // 调用退款方法
        boolean isRefund = wxPayService.refund(orderId);
        if(!isRefund) throw new YyghException(ResultCodeEnum.CANCEL_ORDER_FAIL);
        // 退款成功后业务需求代码省略不写
        // .........
    }
    return false;
}

}
主要的退款业务逻辑代码
@Service
public class WxPayServiceImpl implements WxPayService {

/** 微信退款 */
@Override
public boolean refund(Long orderId) {
    try {
        // 其他业务代码需求，省略不写
        // ......
        
        // 封装map参数
        Map<String, String> paramMap = new HashMap<>();
        paramMap.put("appid", WxPayProperties.WX_APP_ID);
        paramMap.put("mch_id", WxPayProperties.WX_PARTNER);
        paramMap.put("nonce_str", WXPayUtil.generateNonceStr());
        // 交易流水号（和支付成功之后的交易流水号保持一致）
        paramMap.put("transaction_id", paymentInfo.getTradeNo());
        // 商户订单号（和支付成功之后的交易流水号保持一致）
        paramMap.put("out_trade_no", paymentInfo.getOutTradeNo());
        // 商户退款单号
        paramMap.put("out_refund_no", "tk" + paymentInfo.getOutTradeNo());
        paramMap.put("total_fee", "1");
        paramMap.put("refund_fee", "1");
        // map类型数据转换为xml格式数据
        String paramXml = WXPayUtil.generateSignedXml(paramMap, WxPayProperties.WX_PARTNER_KEY);
        // 调用微信退款接口地址
        HttpClient client = new HttpClient("https://api.mch.weixin.qq.com/secapi/pay/refund");
        // 设置xml参数
        client.setXmlParam(paramXml);
        client.setHttps(true);
        // 设置退款证书信息
        client.setCert(true);
        client.setCertPassword(WxPayProperties.WX_PARTNER);
        client.post();
        
        // 返回结果数据（xml格式）
        String xml = client.getContent();
        // xml格式数据转换为map类型数据
        Map<String, String> resultMap = WXPayUtil.xmlToMap(xml);
        // 根据返回的退款结果做其他部分的需求，省略不写
        // ......
        return true;
    }catch (Exception e) {
        e.printStackTrace();
        return false;
    }
}

}

微信二维码支付

最大阻塞等待时间(负数表示没限制)

关联的公众号appid

商户号

商户key

热门文章

最新文章

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

微信二维码支付

最大阻塞等待时间(负数表示没限制)

关联的公众号appid

商户号

商户key

热门文章

最新文章

相关电子书

相关实验场景