申请退款

1curl -X POST \
2  https://api.mch.weixin.qq.com/v3/ecommerce/refunds/apply \
3  -H "Authorization: WECHATPAY2-SHA256-RSA2048 mchid=\"1900000001\",..." \
4  -H "Accept: application/json" \
5  -H "Content-Type: application/json" \
6  -d '{
7    "sub_mchid" : "1900000109",
8    "sp_appid" : "wx8888888888888888",
9    "sub_appid" : "wx8888888888888888",
10    "transaction_id" : "1217752501201407033233368018",
11    "out_trade_no" : "1217752501201407033233368018",
12    "out_refund_no" : "1217752501201407033233368018",
13    "reason" : "商品已售完",
14    "amount" : {
15      "refund" : 888,
16      "from" : [
17        {
18          "account" : "AVAILABLE",
19          "amount" : 444
20        }
21      ],
22      "total" : 888,
23      "currency" : "CNY"
24    },
25    "notify_url" : "https://weixin.qq.com",
26    "refund_account" : "REFUND_SOURCE_SUB_MERCHANT",
27    "funds_account" : "AVAILABLE"
28  }'

1package com.java.demo;
2
3import com.java.utils.WXPayUtility; // 引用微信支付工具库，参考：https://pay.weixin.qq.com/doc/v3/partner/4014985777
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 CreateRefund {
26  private static String HOST = "https://api.mch.weixin.qq.com";
27  private static String METHOD = "POST";
28  private static String PATH = "/v3/ecommerce/refunds/apply";
29
30  public static void main(String[] args) {
31    // TODO: 请准备商户开发必要参数，参考：https://pay.weixin.qq.com/doc/v3/partner/4013080340
32    CreateRefund client = new CreateRefund(
33      "19xxxxxxxx",                    // 商户号，是由微信支付系统生成并分配给每个商户的唯一标识符，商户号获取方式参考 https://pay.weixin.qq.com/doc/v3/partner/4013080340
34      "1DDE55AD98Exxxxxxxxxx",         // 商户API证书序列号，如何获取请参考 https://pay.weixin.qq.com/doc/v3/partner/4013058924
35      "/path/to/apiclient_key.pem",     // 商户API证书私钥文件路径，本地文件路径
36      "PUB_KEY_ID_xxxxxxxxxxxxx",      // 微信支付公钥ID，如何获取请参考 https://pay.weixin.qq.com/doc/v3/partner/4013038589
37      "/path/to/wxp_pub.pem"           // 微信支付公钥文件路径，本地文件路径
38    );
39
40    CreateRefundRequest request = new CreateRefundRequest();
41    request.subMchid = "1900000109";
42    request.spAppid = "wx8888888888888888";
43    request.subAppid = "wx8888888888888888";
44    request.transactionId = "1217752501201407033233368018";
45    request.outTradeNo = "1217752501201407033233368018";
46    request.outRefundNo = "1217752501201407033233368018";
47    request.reason = "商品已售完";
48    request.amount = new RefundReqAmount();
49    request.amount.refund = 888L;
50    request.amount.from = new ArrayList<>();
51    {
52      FundsFromItem fromItem = new FundsFromItem();
53      fromItem.account = "AVAILABLE";
54      fromItem.amount = 444L;
55      request.amount.from.add(fromItem);
56    };
57    request.amount.total = 888L;
58    request.amount.currency = "CNY";
59    request.notifyUrl = "https://weixin.qq.com";
60    request.refundAccount = "REFUND_SOURCE_SUB_MERCHANT";
61    request.fundsAccount = "AVAILABLE";
62    try {
63      Refund4Create response = client.run(request);
64        // TODO: 请求成功，继续业务逻辑
65        System.out.println(response);
66    } catch (WXPayUtility.ApiException e) {
67        // TODO: 请求失败，根据状态码执行不同的逻辑
68        e.printStackTrace();
69    }
70  }
71
72  public Refund4Create run(CreateRefundRequest request) {
73    String uri = PATH;
74    String reqBody = WXPayUtility.toJson(request);
75
76    Request.Builder reqBuilder = new Request.Builder().url(HOST + uri);
77    reqBuilder.addHeader("Accept", "application/json");
78    reqBuilder.addHeader("Wechatpay-Serial", wechatPayPublicKeyId);
79    reqBuilder.addHeader("Authorization", WXPayUtility.buildAuthorization(mchid, certificateSerialNo,privateKey, METHOD, uri, reqBody));
80    reqBuilder.addHeader("Content-Type", "application/json");
81    RequestBody requestBody = RequestBody.create(MediaType.parse("application/json; charset=utf-8"), reqBody);
82    reqBuilder.method(METHOD, requestBody);
83    Request httpRequest = reqBuilder.build();
84
85    // 发送HTTP请求
86    OkHttpClient client = new OkHttpClient.Builder().build();
87    try (Response httpResponse = client.newCall(httpRequest).execute()) {
88      String respBody = WXPayUtility.extractBody(httpResponse);
89      if (httpResponse.code() >= 200 && httpResponse.code() < 300) {
90        // 2XX 成功，验证应答签名
91        WXPayUtility.validateResponse(this.wechatPayPublicKeyId, this.wechatPayPublicKey,
92            httpResponse.headers(), respBody);
93
94        // 从HTTP应答报文构建返回数据
95        return WXPayUtility.fromJson(respBody, Refund4Create.class);
96      } else {
97        throw new WXPayUtility.ApiException(httpResponse.code(), respBody, httpResponse.headers());
98      }
99    } catch (IOException e) {
100      throw new UncheckedIOException("Sending request to " + uri + " failed.", e);
101    }
102  }
103
104  private final String mchid;
105  private final String certificateSerialNo;
106  private final PrivateKey privateKey;
107  private final String wechatPayPublicKeyId;
108  private final PublicKey wechatPayPublicKey;
109
110  public CreateRefund(String mchid, String certificateSerialNo, String privateKeyFilePath, String wechatPayPublicKeyId, String wechatPayPublicKeyFilePath) {
111    this.mchid = mchid;
112    this.certificateSerialNo = certificateSerialNo;
113    this.privateKey = WXPayUtility.loadPrivateKeyFromPath(privateKeyFilePath);
114    this.wechatPayPublicKeyId = wechatPayPublicKeyId;
115    this.wechatPayPublicKey = WXPayUtility.loadPublicKeyFromPath(wechatPayPublicKeyFilePath);
116  }
117
118  public static class CreateRefundRequest {
119    @SerializedName("sub_mchid")
120    public String subMchid;
121  
122    @SerializedName("sp_appid")
123    public String spAppid;
124  
125    @SerializedName("sub_appid")
126    public String subAppid;
127  
128    @SerializedName("transaction_id")
129    public String transactionId;
130  
131    @SerializedName("out_trade_no")
132    public String outTradeNo;
133  
134    @SerializedName("out_refund_no")
135    public String outRefundNo;
136  
137    @SerializedName("reason")
138    public String reason;
139  
140    @SerializedName("amount")
141    public RefundReqAmount amount;
142  
143    @SerializedName("notify_url")
144    public String notifyUrl;
145  
146    @SerializedName("refund_account")
147    public String refundAccount;
148  
149    @SerializedName("funds_account")
150    public String fundsAccount;
151  }
152  
153  public static class Refund4Create {
154    @SerializedName("refund_id")
155    public String refundId;
156  
157    @SerializedName("out_refund_no")
158    public String outRefundNo;
159  
160    @SerializedName("create_time")
161    public String createTime;
162  
163    @SerializedName("amount")
164    public RefundAmount amount;
165  
166    @SerializedName("promotion_detail")
167    public List<PromotionDetail> promotionDetail;
168  
169    @SerializedName("refund_account")
170    public String refundAccount;
171  }
172  
173  public static class RefundReqAmount {
174    @SerializedName("refund")
175    public Long refund;
176  
177    @SerializedName("from")
178    public List<FundsFromItem> from;
179  
180    @SerializedName("total")
181    public Long total;
182  
183    @SerializedName("currency")
184    public String currency;
185  }
186  
187  public static class RefundAmount {
188    @SerializedName("refund")
189    public Long refund;
190  
191    @SerializedName("from")
192    public List<FundsFromItem> from;
193  
194    @SerializedName("payer_refund")
195    public Long payerRefund;
196  
197    @SerializedName("discount_refund")
198    public Long discountRefund;
199  
200    @SerializedName("currency")
201    public String currency;
202  
203    @SerializedName("advance")
204    public Long advance;
205  }
206  
207  public static class PromotionDetail {
208    @SerializedName("promotion_id")
209    public String promotionId;
210  
211    @SerializedName("scope")
212    public String scope;
213  
214    @SerializedName("type")
215    public String type;
216  
217    @SerializedName("amount")
218    public Long amount;
219  
220    @SerializedName("refund_amount")
221    public Long refundAmount;
222  }
223  
224  public static class FundsFromItem {
225    @SerializedName("account")
226    public String account;
227  
228    @SerializedName("amount")
229    public Long amount;
230  }
231  
232}

1package main
2
3import (
4	"bytes"
5	"demo/wxpay_utility" // 引用微信支付工具库，参考 https://pay.weixin.qq.com/doc/v3/partner/4015119446
6	"encoding/json"
7	"fmt"
8	"net/http"
9	"net/url"
10	"time"
11)
12
13func main() {
14	// TODO: 请准备商户开发必要参数，参考：https://pay.weixin.qq.com/doc/v3/partner/4013080340
15	config, err := wxpay_utility.CreateMchConfig(
16		"19xxxxxxxx",                 // 商户号，是由微信支付系统生成并分配给每个商户的唯一标识符，商户号获取方式参考 https://pay.weixin.qq.com/doc/v3/partner/4013080340
17		"1DDE55AD98Exxxxxxxxxx",      // 商户API证书序列号，如何获取请参考 https://pay.weixin.qq.com/doc/v3/partner/4013058924
18		"/path/to/apiclient_key.pem", // 商户API证书私钥文件路径，本地文件路径
19		"PUB_KEY_ID_xxxxxxxxxxxxx",   // 微信支付公钥ID，如何获取请参考 https://pay.weixin.qq.com/doc/v3/partner/4013038589
20		"/path/to/wxp_pub.pem",       // 微信支付公钥文件路径，本地文件路径
21	)
22	if err != nil {
23		fmt.Println(err)
24		return
25	}
26
27	request := &CreateRefundRequest{
28		SubMchid:             wxpay_utility.String("1900000109"),
29		SpAppid:              wxpay_utility.String("wx8888888888888888"),
30		SubAppid:             wxpay_utility.String("wx8888888888888888"),
31		TransactionId:        wxpay_utility.String("1217752501201407033233368018"),
32		OutTradeNo:           wxpay_utility.String("1217752501201407033233368018"),
33		OutRefundNo:          wxpay_utility.String("1217752501201407033233368018"),
34		Reason:               wxpay_utility.String("商品已售完"),
35		Amount: &RefundReqAmount{
36			Refund: wxpay_utility.Int64(888),
37			From: []FundsFromItem{FundsFromItem{
38				Account: wxpay_utility.String("AVAILABLE"),
39				Amount:  wxpay_utility.Int64(444),
40			}},
41			Total:    wxpay_utility.Int64(888),
42			Currency: wxpay_utility.String("CNY"),
43		},
44		NotifyUrl:     wxpay_utility.String("https://weixin.qq.com"),
45		RefundAccount: wxpay_utility.String("REFUND_SOURCE_SUB_MERCHANT"),
46		FundsAccount:  wxpay_utility.String("AVAILABLE"),
47	}
48
49	response, err := CreateRefund(config, request)
50	if err != nil {
51		fmt.Printf("请求失败: %+v\n", err)
52		// TODO: 请求失败，根据状态码执行不同的处理
53		return
54	}
55
56	// TODO: 请求成功，继续业务逻辑
57	fmt.Printf("请求成功: %+v\n", response)
58}
59
60func CreateRefund(config *wxpay_utility.MchConfig, request *CreateRefundRequest) (response *Refund4Create, err error) {
61	const (
62		host   = "https://api.mch.weixin.qq.com"
63		method = "POST"
64		path   = "/v3/ecommerce/refunds/apply"
65	)
66
67	reqUrl, err := url.Parse(fmt.Sprintf("%s%s", host, path))
68	if err != nil {
69		return nil, err
70	}
71	reqBody, err := json.Marshal(request)
72	if err != nil {
73		return nil, err
74	}
75	httpRequest, err := http.NewRequest(method, reqUrl.String(), bytes.NewReader(reqBody))
76	if err != nil {
77		return nil, err
78	}
79	httpRequest.Header.Set("Accept", "application/json")
80	httpRequest.Header.Set("Wechatpay-Serial", config.WechatPayPublicKeyId())
81	httpRequest.Header.Set("Content-Type", "application/json")
82	authorization, err := wxpay_utility.BuildAuthorization(config.MchId(), config.CertificateSerialNo(), config.PrivateKey(), method, reqUrl.RequestURI(), reqBody)
83	if err != nil {
84		return nil, err
85	}
86	httpRequest.Header.Set("Authorization", authorization)
87
88	client := &http.Client{}
89	httpResponse, err := client.Do(httpRequest)
90	if err != nil {
91		return nil, err
92	}
93	respBody, err := wxpay_utility.ExtractResponseBody(httpResponse)
94	if err != nil {
95		return nil, err
96	}
97	if httpResponse.StatusCode >= 200 && httpResponse.StatusCode < 300 {
98		// 2XX 成功，验证应答签名
99		err = wxpay_utility.ValidateResponse(
100			config.WechatPayPublicKeyId(),
101			config.WechatPayPublicKey(),
102			&httpResponse.Header,
103			respBody,
104		)
105		if err != nil {
106			return nil, err
107		}
108		response := &Refund4Create{}
109		if err := json.Unmarshal(respBody, response); err != nil {
110			return nil, err
111		}
112
113		return response, nil
114	} else {
115		return nil, wxpay_utility.NewApiException(
116			httpResponse.StatusCode,
117			httpResponse.Header,
118			respBody,
119		)
120	}
121}
122
123type CreateRefundRequest struct {
124	SubMchid             *string          `json:"sub_mchid,omitempty"`
125	SpAppid              *string          `json:"sp_appid,omitempty"`
126	SubAppid             *string          `json:"sub_appid,omitempty"`
127	TransactionId        *string          `json:"transaction_id,omitempty"`
128	OutTradeNo           *string          `json:"out_trade_no,omitempty"`
129	OutRefundNo          *string          `json:"out_refund_no,omitempty"`
130	Reason               *string          `json:"reason,omitempty"`
131	Amount               *RefundReqAmount `json:"amount,omitempty"`
132	NotifyUrl            *string          `json:"notify_url,omitempty"`
133	RefundAccount        *string          `json:"refund_account,omitempty"`
134	FundsAccount         *string          `json:"funds_account,omitempty"`
135}
136
137type Refund4Create struct {
138	RefundId        *string           `json:"refund_id,omitempty"`
139	OutRefundNo     *string           `json:"out_refund_no,omitempty"`
140	CreateTime      *time.Time        `json:"create_time,omitempty"`
141	Amount          *RefundAmount     `json:"amount,omitempty"`
142	PromotionDetail []PromotionDetail `json:"promotion_detail,omitempty"`
143	RefundAccount   *string           `json:"refund_account,omitempty"`
144}
145
146type RefundReqAmount struct {
147	Refund   *int64          `json:"refund,omitempty"`
148	From     []FundsFromItem `json:"from,omitempty"`
149	Total    *int64          `json:"total,omitempty"`
150	Currency *string         `json:"currency,omitempty"`
151}
152
153type RefundAmount struct {
154	Refund         *int64          `json:"refund,omitempty"`
155	From           []FundsFromItem `json:"from,omitempty"`
156	PayerRefund    *int64          `json:"payer_refund,omitempty"`
157	DiscountRefund *int64          `json:"discount_refund,omitempty"`
158	Currency       *string         `json:"currency,omitempty"`
159	Advance        *int64          `json:"advance,omitempty"`
160}
161
162type PromotionDetail struct {
163	PromotionId  *string `json:"promotion_id,omitempty"`
164	Scope        *string `json:"scope,omitempty"`
165	Type         *string `json:"type,omitempty"`
166	Amount       *int64  `json:"amount,omitempty"`
167	RefundAmount *int64  `json:"refund_amount,omitempty"`
168}
169
170type FundsFromItem struct {
171	Account *string `json:"account,omitempty"`
172	Amount  *int64  `json:"amount,omitempty"`
173}