图片上传接口

1curl -X POST \
2  https://api.mch.weixin.qq.com/v3/merchant-service/images/upload \
3  -H "Authorization: WECHATPAY2-SHA256-RSA2048 mchid=\"1900000001\",..." \
4  -H "Accept: application/json" \
5  -H "Content-Type: multipart/form-data" \
6  -F file=@"/path/to/file" \
7  -F meta="{
8    "filename" : "filea.jpg",
9    "sha256" : "hjkahkjsjkfsjk78687dhjahdajhk"
10  }"

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 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 * 图片上传接口
25 */
26public class CreateImages {
27  private static String HOST = "https://api.mch.weixin.qq.com";
28  private static String METHOD = "POST";
29  private static String PATH = "/v3/merchant-service/images/upload";
30
31  public static void main(String[] args) {
32    // TODO: 请准备商户开发必要参数，参考：https://pay.weixin.qq.com/doc/v3/partner/4013080340
33    CreateImages client = new CreateImages(
34      "19xxxxxxxx",                    // 商户号，是由微信支付系统生成并分配给每个商户的唯一标识符，商户号获取方式参考 https://pay.weixin.qq.com/doc/v3/partner/4013080340
35      "1DDE55AD98Exxxxxxxxxx",         // 商户API证书序列号，如何获取请参考 https://pay.weixin.qq.com/doc/v3/partner/4013058924
36      "/path/to/apiclient_key.pem",     // 商户API证书私钥文件路径，本地文件路径
37      "PUB_KEY_ID_xxxxxxxxxxxxx",      // 微信支付公钥ID，如何获取请参考 https://pay.weixin.qq.com/doc/v3/partner/4013038589
38      "/path/to/wxp_pub.pem"           // 微信支付公钥文件路径，本地文件路径
39    );
40
41    CreateImagesRequest request = new CreateImagesRequest();
42    request.file = "file_bytes".getBytes();
43    request.meta = new ImageMetaInfo();
44request.meta.filename = "filea.jpg";
45request.meta.sha256 = "hjkahkjsjkfsjk78687dhjahdajhk";
46    try {
47      CreateImagesResponse response = client.run(request);
48        // TODO: 请求成功，继续业务逻辑
49        System.out.println(response);
50    } catch (WXPayUtility.ApiException e) {
51        // TODO: 请求失败，根据状态码执行不同的逻辑
52        e.printStackTrace();
53    }
54  }
55
56  public CreateImagesResponse run(CreateImagesRequest request) {
57    String uri = PATH;
58     // 构建multipart/form-data请求体
59     String metaJson = WXPayUtility.toJson(request.meta);
60     RequestBody metaPart = RequestBody.create(MediaType.parse("application/json"), metaJson);
61     //  todo: you_file_name替换为meta里面的文件名字段
62     String contentType = WXPayUtility.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", WXPayUtility.buildAuthorization(mchid, 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 = WXPayUtility.extractBody(httpResponse);
81      if (httpResponse.code() >= 200 && httpResponse.code() < 300) {
82        // 2XX 成功，验证应答签名
83        WXPayUtility.validateResponse(this.wechatPayPublicKeyId, this.wechatPayPublicKey,
84            httpResponse.headers(), respBody);
85
86        // 从HTTP应答报文构建返回数据
87        return WXPayUtility.fromJson(respBody, CreateImagesResponse.class);
88      } else {
89        throw new WXPayUtility.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 mchid;
97  private final String certificateSerialNo;
98  private final PrivateKey privateKey;
99  private final String wechatPayPublicKeyId;
100  private final PublicKey wechatPayPublicKey;
101
102  public CreateImages(String mchid, String certificateSerialNo, String privateKeyFilePath, String wechatPayPublicKeyId, String wechatPayPublicKeyFilePath) {
103    this.mchid = mchid;
104    this.certificateSerialNo = certificateSerialNo;
105    this.privateKey = WXPayUtility.loadPrivateKeyFromPath(privateKeyFilePath);
106    this.wechatPayPublicKeyId = wechatPayPublicKeyId;
107    this.wechatPayPublicKey = WXPayUtility.loadPublicKeyFromPath(wechatPayPublicKeyFilePath);
108  }
109
110  public static class CreateImagesRequest {
111    @SerializedName("file")
112    public byte[] file;
113  
114    @SerializedName("meta")
115    public ImageMetaInfo meta;
116  }
117  
118  public static class CreateImagesResponse {
119    @SerializedName("media_id")
120    public String mediaId;
121  }
122  
123  public static class ImageMetaInfo {
124    @SerializedName("filename")
125    public String filename;
126  
127    @SerializedName("sha256")
128    public String sha256;
129  }
130  
131}
132

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	"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/v3/partner/4013080340
18	config, err := wxpay_utility.CreateMchConfig(
19		"19xxxxxxxx",                 // 商户号，是由微信支付系统生成并分配给每个商户的唯一标识符，商户号获取方式参考 https://pay.weixin.qq.com/doc/v3/partner/4013080340
20		"1DDE55AD98Exxxxxxxxxx",      // 商户API证书序列号，如何获取请参考 https://pay.weixin.qq.com/doc/v3/partner/4013058924
21		"/path/to/apiclient_key.pem", // 商户API证书私钥文件路径，本地文件路径
22		"PUB_KEY_ID_xxxxxxxxxxxxx",   // 微信支付公钥ID，如何获取请参考 https://pay.weixin.qq.com/doc/v3/partner/4013038589
23		"/path/to/wxp_pub.pem",       // 微信支付公钥文件路径，本地文件路径
24	)
25	if err != nil {
26		fmt.Println(err)
27		return
28	}
29
30	request := &CreateImagesRequest{
31		File: wxpay_utility.Bytes([]byte("file data")),
32		Meta: &ImageMetaInfo{
33			Filename: wxpay_utility.String("filea.jpg"),
34			Sha256:   wxpay_utility.String("hjkahkjsjkfsjk78687dhjahdajhk"),
35		},
36	}
37
38	response, err := CreateImages(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 CreateImages(config *wxpay_utility.MchConfig, request *CreateImagesRequest) (response *CreateImagesResponse, err error) {
50	const (
51		host   = "https://api.mch.weixin.qq.com"
52		method = "POST"
53		path   = "/v3/merchant-service/images/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_utility.BuildAuthorization(config.MchId(), 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_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_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 := &CreateImagesResponse{}
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_utility.NewApiException(
146			httpResponse.StatusCode,
147			httpResponse.Header,
148			respBody,
149		)
150	}
151}
152
153type CreateImagesRequest struct {
154	File *[]byte        `json:"file,omitempty"`
155	Meta *ImageMetaInfo `json:"meta,omitempty"`
156}
157
158type CreateImagesResponse struct {
159	MediaId *string `json:"media_id,omitempty"`
160}
161
162type ImageMetaInfo struct {
163	Filename *string `json:"filename,omitempty"`
164	Sha256   *string `json:"sha256,omitempty"`
165}
166