查询单笔退款（通过商户退款单号）

1package com.java.demo;
2
3import com.google.gson.annotations.Expose;
4import com.google.gson.annotations.SerializedName;
5import com.java.utils.WXPayUtility; // 引用微信支付工具库 参考:https://pay.weixin.qq.com/doc/v3/merchant/4014931831
6import java.io.IOException;
7import java.io.UncheckedIOException;
8import java.security.PrivateKey;
9import java.security.PublicKey;
10import java.util.ArrayList;
11import java.util.HashMap;
12import java.util.List;
13import java.util.Map;
14import okhttp3.MediaType;
15import okhttp3.OkHttpClient;
16import okhttp3.Request;
17import okhttp3.RequestBody;
18import okhttp3.Response;
19
20/**
21 * 查询单笔退款（通过商户退款单号）
22 */
23public class QueryByOutRefundNo {
24  private static String HOST = "https://api.mch.weixin.qq.com";
25  private static String METHOD = "GET";
26  private static String PATH = "/v3/refund/domestic/refunds/{out_refund_no}";
27
28  public static void main(String[] args) {
29    // TODO: 请准备商户开发必要参数，参考：https://pay.weixin.qq.com/doc/v3/merchant/4013070756
30    QueryByOutRefundNo client = new QueryByOutRefundNo(
31        "填入 商户号",                  // 商户号，是由微信支付系统生成并分配给每个商户的唯一标识符，商户号获取方式参考https://pay.weixin.qq.com/doc/v3/merchant/4013070756
32        "填入 商户API证书序列号",       // 商户API证书序列号，如何获取请参考https://pay.weixin.qq.com/doc/v3/merchant/4013053053
33        "填入 商户API证书私钥文件路径", // 商户API证书私钥文件路径，本地文件路径
34        "填入 微信支付公钥ID",          // 微信支付公钥ID，如何获取请参考https://pay.weixin.qq.com/doc/v3/merchant/4013038816
35        "填入 微信支付公钥文件路径"     // 微信支付公钥文件路径，本地文件路径
36    );
37
38    QueryByOutRefundNoRequest request = new QueryByOutRefundNoRequest();
39    request.outRefundNo = "1217752501201407033233368018";
40    try {
41      Refund response = client.run(request);
42
43      // TODO: 请求成功，继续业务逻辑
44      System.out.println(response);
45    } catch (WXPayUtility.ApiException e) {
46      // TODO: 请求失败，根据状态码执行不同的逻辑
47      e.printStackTrace();
48    }
49  }
50
51  public Refund run(QueryByOutRefundNoRequest request) {
52    String uri = PATH.replace("{out_refund_no}", WXPayUtility.urlEncode(request.outRefundNo));
53
54    Request.Builder reqBuilder = new Request.Builder().url(HOST + uri);
55    reqBuilder.addHeader("Accept", "application/json");
56    reqBuilder.addHeader("Wechatpay-Serial", wechatPayPublicKeyId);
57    reqBuilder.addHeader("Authorization", WXPayUtility.buildAuthorization(mchid, certificateSerialNo, privateKey, METHOD, uri, null));
58    reqBuilder.method(METHOD, null);
59    Request httpRequest = reqBuilder.build();
60
61    // 发送HTTP请求
62    OkHttpClient client = new OkHttpClient.Builder().build();
63    try (Response httpResponse = client.newCall(httpRequest).execute()) {
64      String respBody = WXPayUtility.extractBody(httpResponse);
65      if (httpResponse.code() >= 200 && httpResponse.code() < 300) {
66        // 2XX 成功，验证应答签名
67        WXPayUtility.validateResponse(this.wechatPayPublicKeyId, this.wechatPayPublicKey,
68                                      httpResponse.headers(), respBody);
69
70        // 从HTTP应答报文构建返回数据
71        return WXPayUtility.fromJson(respBody, Refund.class);
72      } else {
73        throw new WXPayUtility.ApiException(httpResponse.code(), respBody, httpResponse.headers());
74      }
75    } catch (IOException e) {
76      throw new UncheckedIOException("Sending request to " + uri + " failed.", e);
77    }
78  }
79
80  private final String mchid;
81  private final String certificateSerialNo;
82  private final PrivateKey privateKey;
83  private final String wechatPayPublicKeyId;
84  private final PublicKey wechatPayPublicKey;
85
86  public QueryByOutRefundNo(String mchid, String certificateSerialNo, String privateKeyFilePath, String wechatPayPublicKeyId, String wechatPayPublicKeyFilePath) {
87    this.mchid = mchid;
88    this.certificateSerialNo = certificateSerialNo;
89    this.privateKey = WXPayUtility.loadPrivateKeyFromPath(privateKeyFilePath);
90    this.wechatPayPublicKeyId = wechatPayPublicKeyId;
91    this.wechatPayPublicKey = WXPayUtility.loadPublicKeyFromPath(wechatPayPublicKeyFilePath);
92  }
93
94  public enum Status {
95    @SerializedName("SUCCESS")
96    SUCCESS,
97    @SerializedName("CLOSED")
98    CLOSED,
99    @SerializedName("PROCESSING")
100    PROCESSING,
101    @SerializedName("ABNORMAL")
102    ABNORMAL
103  }
104
105  public enum Account {
106    @SerializedName("AVAILABLE")
107    AVAILABLE,
108    @SerializedName("UNAVAILABLE")
109    UNAVAILABLE
110  }
111
112  public enum PromotionType {
113    @SerializedName("COUPON")
114    COUPON,
115    @SerializedName("DISCOUNT")
116    DISCOUNT
117  }
118
119  public static class Refund {
120    @SerializedName("refund_id")
121    public String refundId;
122
123    @SerializedName("out_refund_no")
124    public String outRefundNo;
125
126    @SerializedName("transaction_id")
127    public String transactionId;
128
129    @SerializedName("out_trade_no")
130    public String outTradeNo;
131
132    @SerializedName("channel")
133    public Channel channel;
134
135    @SerializedName("user_received_account")
136    public String userReceivedAccount;
137
138    @SerializedName("success_time")
139    public String successTime;
140
141    @SerializedName("create_time")
142    public String createTime;
143
144    @SerializedName("status")
145    public Status status;
146
147    @SerializedName("funds_account")
148    public FundsAccount fundsAccount;
149
150    @SerializedName("amount")
151    public Amount amount;
152
153    @SerializedName("promotion_detail")
154    public List<Promotion> promotionDetail;
155  }
156
157  public static class GoodsDetail {
158    @SerializedName("merchant_goods_id")
159    public String merchantGoodsId;
160
161    @SerializedName("wechatpay_goods_id")
162    public String wechatpayGoodsId;
163
164    @SerializedName("goods_name")
165    public String goodsName;
166
167    @SerializedName("unit_price")
168    public Long unitPrice;
169
170    @SerializedName("refund_amount")
171    public Long refundAmount;
172
173    @SerializedName("refund_quantity")
174    public Integer refundQuantity;
175  }
176
177  public static class QueryByOutRefundNoRequest {
178    @SerializedName("out_refund_no")
179    @Expose(serialize = false)
180    public String outRefundNo;
181  }
182
183  public enum Channel {
184    @SerializedName("ORIGINAL")
185    ORIGINAL,
186    @SerializedName("BALANCE")
187    BALANCE,
188    @SerializedName("OTHER_BALANCE")
189    OTHER_BALANCE,
190    @SerializedName("OTHER_BANKCARD")
191    OTHER_BANKCARD
192  }
193
194  public static class Amount {
195    @SerializedName("total")
196    public Long total;
197
198    @SerializedName("refund")
199    public Long refund;
200
201    @SerializedName("from")
202    public List<FundsFromItem> from;
203
204    @SerializedName("payer_total")
205    public Long payerTotal;
206
207    @SerializedName("payer_refund")
208    public Long payerRefund;
209
210    @SerializedName("settlement_refund")
211    public Long settlementRefund;
212
213    @SerializedName("settlement_total")
214    public Long settlementTotal;
215
216    @SerializedName("discount_refund")
217    public Long discountRefund;
218
219    @SerializedName("currency")
220    public String currency;
221
222    @SerializedName("refund_fee")
223    public Long refundFee;
224  }
225
226  public static class FundsFromItem {
227    @SerializedName("account")
228    public Account account;
229
230    @SerializedName("amount")
231    public Long amount;
232  }
233
234  public enum FundsAccount {
235    @SerializedName("UNSETTLED")
236    UNSETTLED,
237    @SerializedName("AVAILABLE")
238    AVAILABLE,
239    @SerializedName("UNAVAILABLE")
240    UNAVAILABLE,
241    @SerializedName("OPERATION")
242    OPERATION,
243    @SerializedName("BASIC")
244    BASIC,
245    @SerializedName("ECNY_BASIC")
246    ECNY_BASIC
247  }
248
249  public static class Promotion {
250    @SerializedName("promotion_id")
251    public String promotionId;
252
253    @SerializedName("scope")
254    public PromotionScope scope;
255
256    @SerializedName("type")
257    public PromotionType type;
258
259    @SerializedName("amount")
260    public Long amount;
261
262    @SerializedName("refund_amount")
263    public Long refundAmount;
264
265    @SerializedName("goods_detail")
266    public List<GoodsDetail> goodsDetail;
267  }
268
269  public enum PromotionScope {
270    @SerializedName("GLOBAL")
271    GLOBAL,
272    @SerializedName("SINGLE")
273    SINGLE
274  }
275}

1package main
2
3import (
4	"demo/wxpay_utility"// 引用微信支付工具库 参考:https://pay.weixin.qq.com/doc/v3/merchant/4015119334
5	"encoding/json"
6	"fmt"
7	"net/http"
8	"net/url"
9	"strings"
10)
11
12func main() {
13	// TODO: 请准备商户开发必要参数，参考：https://pay.weixin.qq.com/doc/v3/merchant/4013070756
14	config, err := wxpay_utility.CreateMchConfig(
15		"填入 商户号",           // 商户号，是由微信支付系统生成并分配给每个商户的唯一标识符，商户号获取方式参考https://pay.weixin.qq.com/doc/v3/merchant/4013070756
16		"填入 商户API证书序列号",    // 商户API证书序列号，如何获取请参考https://pay.weixin.qq.com/doc/v3/merchant/4013053053
17		"填入 商户API证书私钥文件路径", // 商户API证书私钥文件路径，本地文件路径
18		"填入 微信支付公钥ID",      // 微信支付公钥ID，如何获取请参考https://pay.weixin.qq.com/doc/v3/merchant/4013038816
19		"填入 微信支付公钥文件路径",    // 微信支付公钥文件路径，本地文件路径
20	)
21	if err != nil {
22		fmt.Println(err)
23		return
24	}
25
26	request := &QueryByOutRefundNoRequest{
27		OutRefundNo: wxpay_utility.String("1217752501201407033233368018"),
28	}
29
30	response, err := QueryByOutRefundNo(config, request)
31	if err != nil {
32		fmt.Printf("请求失败: %+v\n", err)
33		// TODO: 请求失败，根据状态码执行不同的处理
34		return
35	}
36
37	// TODO: 请求成功，继续业务逻辑
38	fmt.Printf("请求成功: %+v\n", response)
39}
40
41func QueryByOutRefundNo(config *wxpay_utility.MchConfig, request *QueryByOutRefundNoRequest) (response *Refund, err error) {
42	const (
43		host   = "https://api.mch.weixin.qq.com"
44		method = "GET"
45		path   = "/v3/refund/domestic/refunds/{out_refund_no}"
46	)
47
48	reqUrl, err := url.Parse(fmt.Sprintf("%s%s", host, path))
49	if err != nil {
50		return nil, err
51	}
52	reqUrl.Path = strings.Replace(reqUrl.Path, "{out_refund_no}", url.PathEscape(*request.OutRefundNo), -1)
53	query := reqUrl.Query()
54	reqUrl.RawQuery = query.Encode()
55	httpRequest, err := http.NewRequest(method, reqUrl.String(), nil)
56	if err != nil {
57		return nil, err
58	}
59	httpRequest.Header.Set("Accept", "application/json")
60	httpRequest.Header.Set("Wechatpay-Serial", config.WechatPayPublicKeyId())
61	authorization, err := wxpay_utility.BuildAuthorization(config.MchId(), config.CertificateSerialNo(), config.PrivateKey(), method, reqUrl.RequestURI(), nil)
62	if err != nil {
63		return nil, err
64	}
65	httpRequest.Header.Set("Authorization", authorization)
66
67	client := &http.Client{}
68	httpResponse, err := client.Do(httpRequest)
69	if err != nil {
70		return nil, err
71	}
72
73	respBody, err := wxpay_utility.ExtractResponseBody(httpResponse)
74	if err != nil {
75		return nil, err
76	}
77
78	if httpResponse.StatusCode >= 200 && httpResponse.StatusCode < 300 {
79		// 2XX 成功，验证应答签名
80		err = wxpay_utility.ValidateResponse(
81			config.WechatPayPublicKeyId(),
82			config.WechatPayPublicKey(),
83			&httpResponse.Header,
84			respBody,
85		)
86		if err != nil {
87			return nil, err
88		}
89
90		if err := json.Unmarshal(respBody, response); err != nil {
91			return nil, err
92		}
93
94		return response, nil
95	} else {
96		return nil, &wxpay_utility.ApiException{
97			StatusCode: httpResponse.StatusCode,
98			Header:     httpResponse.Header,
99			Body:       respBody,
100		}
101	}
102}
103
104type Status string
105
106func (e Status) Ptr() *Status {
107	return &e
108}
109
110const (
111	STATUS_SUCCESS    Status = "SUCCESS"
112	STATUS_CLOSED     Status = "CLOSED"
113	STATUS_PROCESSING Status = "PROCESSING"
114	STATUS_ABNORMAL   Status = "ABNORMAL"
115)
116
117type Account string
118
119func (e Account) Ptr() *Account {
120	return &e
121}
122
123const (
124	ACCOUNT_AVAILABLE   Account = "AVAILABLE"
125	ACCOUNT_UNAVAILABLE Account = "UNAVAILABLE"
126)
127
128type PromotionType string
129
130func (e PromotionType) Ptr() *PromotionType {
131	return &e
132}
133
134const (
135	PROMOTIONTYPE_COUPON   PromotionType = "COUPON"
136	PROMOTIONTYPE_DISCOUNT PromotionType = "DISCOUNT"
137)
138
139type Refund struct {
140	RefundId            *string       `json:"refund_id,omitempty"`
141	OutRefundNo         *string       `json:"out_refund_no,omitempty"`
142	TransactionId       *string       `json:"transaction_id,omitempty"`
143	OutTradeNo          *string       `json:"out_trade_no,omitempty"`
144	Channel             *Channel      `json:"channel,omitempty"`
145	UserReceivedAccount *string       `json:"user_received_account,omitempty"`
146	SuccessTime         *string       `json:"success_time,omitempty"`
147	CreateTime          *string       `json:"create_time,omitempty"`
148	Status              *Status       `json:"status,omitempty"`
149	FundsAccount        *FundsAccount `json:"funds_account,omitempty"`
150	Amount              *Amount       `json:"amount,omitempty"`
151	PromotionDetail     []Promotion   `json:"promotion_detail,omitempty"`
152}
153
154type GoodsDetail struct {
155	MerchantGoodsId  *string `json:"merchant_goods_id,omitempty"`
156	WechatpayGoodsId *string `json:"wechatpay_goods_id,omitempty"`
157	GoodsName        *string `json:"goods_name,omitempty"`
158	UnitPrice        *int64  `json:"unit_price,omitempty"`
159	RefundAmount     *int64  `json:"refund_amount,omitempty"`
160	RefundQuantity   *int64  `json:"refund_quantity,omitempty"`
161}
162
163type QueryByOutRefundNoRequest struct {
164	OutRefundNo *string `json:"out_refund_no,omitempty"`
165}
166
167func (o *QueryByOutRefundNoRequest) MarshalJSON() ([]byte, error) {
168	type Alias QueryByOutRefundNoRequest
169	a := &struct {
170		OutRefundNo *string `json:"out_refund_no,omitempty"`
171		*Alias
172	}{
173		// 序列化时移除非 Body 字段
174		OutRefundNo: nil,
175		Alias:       (*Alias)(o),
176	}
177	return json.Marshal(a)
178}
179
180type Channel string
181
182func (e Channel) Ptr() *Channel {
183	return &e
184}
185
186const (
187	CHANNEL_ORIGINAL       Channel = "ORIGINAL"
188	CHANNEL_BALANCE        Channel = "BALANCE"
189	CHANNEL_OTHER_BALANCE  Channel = "OTHER_BALANCE"
190	CHANNEL_OTHER_BANKCARD Channel = "OTHER_BANKCARD"
191)
192
193type Amount struct {
194	Total            *int64          `json:"total,omitempty"`
195	Refund           *int64          `json:"refund,omitempty"`
196	From             []FundsFromItem `json:"from,omitempty"`
197	PayerTotal       *int64          `json:"payer_total,omitempty"`
198	PayerRefund      *int64          `json:"payer_refund,omitempty"`
199	SettlementRefund *int64          `json:"settlement_refund,omitempty"`
200	SettlementTotal  *int64          `json:"settlement_total,omitempty"`
201	DiscountRefund   *int64          `json:"discount_refund,omitempty"`
202	Currency         *string         `json:"currency,omitempty"`
203	RefundFee        *int64          `json:"refund_fee,omitempty"`
204}
205
206type FundsFromItem struct {
207	Account *Account `json:"account,omitempty"`
208	Amount  *int64   `json:"amount,omitempty"`
209}
210
211type FundsAccount string
212
213func (e FundsAccount) Ptr() *FundsAccount {
214	return &e
215}
216
217const (
218	FUNDSACCOUNT_UNSETTLED   FundsAccount = "UNSETTLED"
219	FUNDSACCOUNT_AVAILABLE   FundsAccount = "AVAILABLE"
220	FUNDSACCOUNT_UNAVAILABLE FundsAccount = "UNAVAILABLE"
221	FUNDSACCOUNT_OPERATION   FundsAccount = "OPERATION"
222	FUNDSACCOUNT_BASIC       FundsAccount = "BASIC"
223	FUNDSACCOUNT_ECNY_BASIC  FundsAccount = "ECNY_BASIC"
224)
225
226type Promotion struct {
227	PromotionId  *string         `json:"promotion_id,omitempty"`
228	Scope        *PromotionScope `json:"scope,omitempty"`
229	Type         *PromotionType  `json:"type,omitempty"`
230	Amount       *int64          `json:"amount,omitempty"`
231	RefundAmount *int64          `json:"refund_amount,omitempty"`
232	GoodsDetail  []GoodsDetail   `json:"goods_detail,omitempty"`
233}
234
235type PromotionScope string
236
237func (e PromotionScope) Ptr() *PromotionScope {
238	return &e
239}
240
241const (
242	PROMOTIONSCOPE_GLOBAL PromotionScope = "GLOBAL"
243	PROMOTIONSCOPE_SINGLE PromotionScope = "SINGLE"
244)

1curl -X GET \
2  https://api.mch.weixin.qq.com/v3/refund/domestic/refunds/1217752501201407033233368018 \
3  -H "Authorization: WECHATPAY2-SHA256-RSA2048 mchid=\"1900000001\",..." \
4  -H "Accept: application/json"