图片上传

1curl -X POST \
2  https://api.mch.weixin.qq.com/brand/card-member/media/image-upload \
3  -H "Authorization: WECHATPAY-BRAND-SHA256-RSA2048 brand_id=\"XXXX\",..." \
4  -H "Accept: application/json" \
5  -H "Wechatpay-Serial: PUB_KEY_ID_XXXX"  \
6  -H "Content-Type: multipart/form-data" \
7  -F file=@"/path/to/file" \
8  -F meta="{
9    "filename" : "file.jpg",
10    "file_digest" : "hjkahkjsjkfsjk78687dhjahdajhk"
11  }"

1package com.java.demo;
2
3import com.java.utils.WXPayBrandUtility; // 引用微信支付工具库，参考：https://pay.weixin.qq.com/doc/brand/4015826861
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 okhttp3.MultipartBody;
15import java.io.UncheckedIOException;
16import java.security.PrivateKey;
17import java.security.PublicKey;
18import java.util.ArrayList;
19import java.util.HashMap;
20import java.util.List;
21import java.util.Map;
22
23/**
24 * 图片上传API
25 */
26public class UploadImage {
27  private static String HOST = "https://api.mch.weixin.qq.com";
28  private static String METHOD = "POST";
29  private static String PATH = "/brand/card-member/media/image-upload";
30
31  public static void main(String[] args) {
32    // TODO: 请准备商户开发必要参数，参考：https://pay.weixin.qq.com/doc/brand/4015415289
33    UploadImage client = new UploadImage(
34      "xxxxxxxx",                    // 品牌ID，是由微信支付系统生成并分配给每个品牌方的唯一标识符，品牌ID获取方式参考 https://pay.weixin.qq.com/doc/brand/4015415289
35      "1DDE55AD98Exxxxxxxxxx",         // 品牌API证书序列号，如何获取请参考 https://pay.weixin.qq.com/doc/brand/4015407570
36      "/path/to/apiclient_key.pem",     // 品牌API证书私钥文件路径，本地文件路径
37      "PUB_KEY_ID_xxxxxxxxxxxxx",      // 微信支付公钥ID，如何获取请参考 https://pay.weixin.qq.com/doc/brand/4015453439
38      "/path/to/wxp_pub.pem"           // 微信支付公钥文件路径，本地文件路径
39    );
40
41    UploadImageRequest request = new UploadImageRequest();
42    request.file = "file_bytes".getBytes();
43    request.meta = new ImageMeta();
44request.meta.filename = "file.jpg";
45request.meta.fileDigest = "hjkahkjsjkfsjk78687dhjahdajhk";
46    try {
47      UploadImageResponse response = client.run(request);
48        // TODO: 请求成功，继续业务逻辑
49        System.out.println(response);
50    } catch (WXPayBrandUtility.ApiException e) {
51        // TODO: 请求失败，根据状态码执行不同的逻辑
52        e.printStackTrace();
53    }
54  }
55
56  public UploadImageResponse run(UploadImageRequest request) {
57    String uri = PATH;
58     // 构建multipart/form-data请求体
59     String metaJson = WXPayBrandUtility.toJson(request.meta);
60     RequestBody metaPart = RequestBody.create(MediaType.parse("application/json"), metaJson);
61     //  todo: you_file_name替换为meta里面的文件名字段
62     String contentType = WXPayBrandUtility.getContentTypeByFileName("your_file_name");
63     RequestBody filePart = RequestBody.create(MediaType.parse(contentType), request.file);
64     MultipartBody requestBody = new MultipartBody.Builder()
65             .setType(MultipartBody.FORM)
66             .addFormDataPart("meta", null, metaPart)
67             .addFormDataPart("file", "your_file_name", filePart)
68             .build();
69
70    Request.Builder reqBuilder = new Request.Builder().url(HOST + uri);
71    reqBuilder.addHeader("Accept", "application/json");
72    reqBuilder.addHeader("Wechatpay-Serial", wechatPayPublicKeyId);
73    reqBuilder.addHeader("Authorization", WXPayBrandUtility.buildAuthorization(brand_id, certificateSerialNo, privateKey, METHOD, uri, metaJson));
74    reqBuilder.method(METHOD, requestBody);
75    Request httpRequest = reqBuilder.build();
76
77    // 发送HTTP请求
78    OkHttpClient client = new OkHttpClient.Builder().build();
79    try (Response httpResponse = client.newCall(httpRequest).execute()) {
80      String respBody = WXPayBrandUtility.extractBody(httpResponse);
81      if (httpResponse.code() >= 200 && httpResponse.code() < 300) {
82        // 2XX 成功，验证应答签名
83        WXPayBrandUtility.validateResponse(this.wechatPayPublicKeyId, this.wechatPayPublicKey,
84            httpResponse.headers(), respBody);
85
86        // 从HTTP应答报文构建返回数据
87        return WXPayBrandUtility.fromJson(respBody, UploadImageResponse.class);
88      } else {
89        throw new WXPayBrandUtility.ApiException(httpResponse.code(), respBody, httpResponse.headers());
90      }
91    } catch (IOException e) {
92      throw new UncheckedIOException("Sending request to " + uri + " failed.", e);
93    }
94  }
95
96  private final String brand_id;
97  private final String certificateSerialNo;
98  private final PrivateKey privateKey;
99  private final String wechatPayPublicKeyId;
100  private final PublicKey wechatPayPublicKey;
101
102  public UploadImage(String brand_id, String certificateSerialNo, String privateKeyFilePath, String wechatPayPublicKeyId, String wechatPayPublicKeyFilePath) {
103    this.brand_id = brand_id;
104    this.certificateSerialNo = certificateSerialNo;
105    this.privateKey = WXPayBrandUtility.loadPrivateKeyFromPath(privateKeyFilePath);
106    this.wechatPayPublicKeyId = wechatPayPublicKeyId;
107    this.wechatPayPublicKey = WXPayBrandUtility.loadPublicKeyFromPath(wechatPayPublicKeyFilePath);
108  }
109
110  public static class UploadImageRequest {
111    @SerializedName("file")
112    public byte[] file;
113  
114    @SerializedName("meta")
115    public ImageMeta meta;
116  }
117  
118  public static class UploadImageResponse {
119    @SerializedName("media_url")
120    public String mediaUrl;
121  }
122  
123  public static class ImageMeta {
124    @SerializedName("filename")
125    public String filename;
126  
127    @SerializedName("file_digest")
128    public String fileDigest;
129  }
130  
131}
132

1package main
2
3import (
4	"bytes"
5	"demo/wxpay_brand_utility" // 引用微信支付工具库，参考 https://pay.weixin.qq.com/doc/brand/4015826866
6	"encoding/json"
7	"fmt"
8	"mime"
9	"mime/multipart"
10	"net/http"
11	"net/textproto"
12	"net/url"
13	"path/filepath"
14)
15
16func main() {
17	// TODO: 请准备商户开发必要参数，参考：https://pay.weixin.qq.com/doc/brand/4015415289
18	config, err := wxpay_brand_utility.CreateBrandConfig(
19		"xxxxxxxx",                   // 品牌ID，是由微信支付系统生成并分配给每个品牌方的唯一标识符，品牌ID获取方式参考 https://pay.weixin.qq.com/doc/brand/4015415289
20		"1DDE55AD98Exxxxxxxxxx",      // 品牌API证书序列号，如何获取请参考 https://pay.weixin.qq.com/doc/brand/4015407570
21		"/path/to/apiclient_key.pem", // 品牌API证书私钥文件路径，本地文件路径
22		"PUB_KEY_ID_xxxxxxxxxxxxx",   // 微信支付公钥ID，如何获取请参考 https://pay.weixin.qq.com/doc/brand/4015453439
23		"/path/to/wxp_pub.pem",       // 微信支付公钥文件路径，本地文件路径
24	)
25	if err != nil {
26		fmt.Println(err)
27		return
28	}
29
30	request := &UploadImageRequest{
31		File: wxpay_brand_utility.Bytes([]byte("file data")),
32		Meta: &ImageMeta{
33			Filename:   wxpay_brand_utility.String("file.jpg"),
34			FileDigest: wxpay_brand_utility.String("hjkahkjsjkfsjk78687dhjahdajhk"),
35		},
36	}
37
38	response, err := UploadImage(config, request)
39	if err != nil {
40		fmt.Printf("请求失败: %+v\n", err)
41		// TODO: 请求失败，根据状态码执行不同的处理
42		return
43	}
44
45	// TODO: 请求成功，继续业务逻辑
46	fmt.Printf("请求成功: %+v\n", response)
47}
48
49func UploadImage(config *wxpay_brand_utility.BrandConfig, request *UploadImageRequest) (response *UploadImageResponse, err error) {
50	const (
51		host   = "https://api.mch.weixin.qq.com"
52		method = "POST"
53		path   = "/brand/card-member/media/image-upload"
54	)
55
56	reqUrl, err := url.Parse(fmt.Sprintf("%s%s", host, path))
57	if err != nil {
58		return nil, err
59	}
60	// 构造 multipart/form-data 请求体
61	body := &bytes.Buffer{}
62	writer := multipart.NewWriter(body)
63
64	// todo: your_file_name替换为meta里面的文件名字段
65	fileHeader := make(textproto.MIMEHeader)
66	fileHeader.Set("Content-Disposition", fmt.Sprintf(`form-data; name="file"; filename="%s"`, "your_file_name"))
67	ext := filepath.Ext("your_file_name")
68	contentType := mime.TypeByExtension(ext)
69	if contentType == "" {
70		contentType = "application/octet-stream"
71	}
72	fileHeader.Set("Content-Type", contentType)
73	fileWriter, err := writer.CreatePart(fileHeader)
74	if err != nil {
75		return nil, err
76	}
77	_, err = fileWriter.Write(*request.File)
78	if err != nil {
79		return nil, err
80	}
81
82	// meta 字段
83	metaJSON, err := json.Marshal(request.Meta)
84	if err != nil {
85		return nil, err
86	}
87	metaWriter, err := writer.CreateFormField("meta")
88	if err != nil {
89		return nil, err
90	}
91	_, err = metaWriter.Write(metaJSON)
92	if err != nil {
93		return nil, err
94	}
95
96	err = writer.Close()
97	if err != nil {
98		return nil, err
99	}
100	httpRequest, err := http.NewRequest(method, reqUrl.String(), body)
101	if err != nil {
102		return nil, err
103	}
104	httpRequest.Header.Set("Accept", "application/json")
105	httpRequest.Header.Set("Wechatpay-Serial", config.WechatPayPublicKeyId())
106	httpRequest.Header.Set("Content-Type", writer.FormDataContentType())
107	// 签名时使用 meta JSON
108	metaJson, err := json.Marshal(request.Meta)
109	if err != nil {
110		return nil, err
111	}
112	authorization, err := wxpay_brand_utility.BuildAuthorization(config.BrandId(), config.CertificateSerialNo(), config.PrivateKey(), method, reqUrl.RequestURI(), metaJson)
113	if err != nil {
114		return nil, err
115	}
116	httpRequest.Header.Set("Authorization", authorization)
117
118	client := &http.Client{}
119	httpResponse, err := client.Do(httpRequest)
120	if err != nil {
121		return nil, err
122	}
123	respBody, err := wxpay_brand_utility.ExtractResponseBody(httpResponse)
124	if err != nil {
125		return nil, err
126	}
127	if httpResponse.StatusCode >= 200 && httpResponse.StatusCode < 300 {
128		// 2XX 成功，验证应答签名
129		err = wxpay_brand_utility.ValidateResponse(
130			config.WechatPayPublicKeyId(),
131			config.WechatPayPublicKey(),
132			&httpResponse.Header,
133			respBody,
134		)
135		if err != nil {
136			return nil, err
137		}
138		response := &UploadImageResponse{}
139		if err := json.Unmarshal(respBody, response); err != nil {
140			return nil, err
141		}
142
143		return response, nil
144	} else {
145		return nil, wxpay_brand_utility.NewApiException(
146			httpResponse.StatusCode,
147			httpResponse.Header,
148			respBody,
149		)
150	}
151}
152
153type UploadImageRequest struct {
154	File *[]byte    `json:"file,omitempty"`
155	Meta *ImageMeta `json:"meta,omitempty"`
156}
157
158type UploadImageResponse struct {
159	MediaUrl *string `json:"media_url,omitempty"`
160}
161
162type ImageMeta struct {
163	Filename   *string `json:"filename,omitempty"`
164	FileDigest *string `json:"file_digest,omitempty"`
165}
166