查询单笔退款（按商户退款单号）

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"

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

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