使用签名URL上传

1. 文件拥有者生成指定请求头和自定义元数据的PUT方法的签名URL。

   import com.aliyun.oss.*;
   import com.aliyun.oss.common.auth.*;
   import com.aliyun.oss.common.comm.SignVersion;
   import com.aliyun.oss.model.GeneratePresignedUrlRequest;
   import java.net.URL;
   import java.util.*;
   import java.util.Date;
   
   public class GetSignUrl {
       public static void main(String[] args) throws Throwable {
           // 以华东1（杭州）的外网Endpoint为例，其它Region请按实际情况填写。
           String endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
           // 从环境变量中获取访问凭证。运行本代码示例之前，请确保已设置环境变量OSS_ACCESS_KEY_ID和OSS_ACCESS_KEY_SECRET。
           EnvironmentVariableCredentialsProvider credentialsProvider = CredentialsProviderFactory.newEnvironmentVariableCredentialsProvider();
           // 填写Bucket名称，例如examplebucket。
           String bucketName = "zy-test1009";
           // 填写Object完整路径，例如exampleobject.txt。Object完整路径中不能包含Bucket名称。
           String objectName = "exampleobject1.txt";
           // 填写Bucket所在地域。以华东1（杭州）为例，Region填写为cn-hangzhou。
           String region = "cn-hangzhou";
   
           // 创建OSSClient实例。
           ClientBuilderConfiguration clientBuilderConfiguration = new ClientBuilderConfiguration();
           clientBuilderConfiguration.setSignatureVersion(SignVersion.V4);
           OSS ossClient = OSSClientBuilder.create()
                   .endpoint(endpoint)
                   .credentialsProvider(credentialsProvider)
                   .clientConfiguration(clientBuilderConfiguration)
                   .region(region)
                   .build();
   
           // 设置请求头。
           Map<String, String> headers = new HashMap<String, String>();
           /*// 指定Object的存储类型。
           headers.put(OSSHeaders.STORAGE_CLASS, StorageClass.Standard.toString());
           // 指定ContentType。
           headers.put(OSSHeaders.CONTENT_TYPE, "text/txt");*/
   
           // 设置用户自定义元数据。
           Map<String, String> userMetadata = new HashMap<String, String>();
           /*userMetadata.put("key1","value1");
           userMetadata.put("key2","value2");*/
   
           URL signedUrl = null;
           try {
               // 指定生成的签名URL过期时间，单位为毫秒。本示例以设置过期时间为1小时为例。
               Date expiration = new Date(new Date().getTime() + 3600 * 1000L);
   
               // 生成签名URL。
               GeneratePresignedUrlRequest request = new GeneratePresignedUrlRequest(bucketName, objectName, HttpMethod.PUT);
               // 设置过期时间。
               request.setExpiration(expiration);
   
               // 将请求头加入到request中。
               request.setHeaders(headers);
               // 添加用户自定义元数据。
               request.setUserMetadata(userMetadata);
   
               // 通过HTTP PUT请求生成签名URL。
               signedUrl = ossClient.generatePresignedUrl(request);
               // 打印签名URL。
               System.out.println("signed url for putObject: " + signedUrl);
   
           } catch (OSSException oe) {
               System.out.println("Caught an OSSException, which means your request made it to OSS, "
                       + "but was rejected with an error response for some reason.");
               System.out.println("Error Message:" + oe.getErrorMessage());
               System.out.println("Error Code:" + oe.getErrorCode());
               System.out.println("Request ID:" + oe.getRequestId());
               System.out.println("Host ID:" + oe.getHostId());
           } catch (ClientException ce) {
               System.out.println("Caught an ClientException, which means the client encountered "
                       + "a serious internal problem while trying to communicate with OSS, "
                       + "such as not being able to access the network.");
               System.out.println("Error Message:" + ce.getMessage());
           }
       }
   }       

2. 其他人使用PUT方法的签名URL上传文件。

   Java

   import org.apache.http.HttpEntity;
   import org.apache.http.client.methods.CloseableHttpResponse;
   import org.apache.http.client.methods.HttpPut;
   import org.apache.http.entity.FileEntity;
   import org.apache.http.impl.client.CloseableHttpClient;
   import org.apache.http.impl.client.HttpClients;
   import java.io.*;
   import java.net.URL;
   import java.util.*;
   
   public class SignUrlUpload {
       public static void main(String[] args) throws Throwable {
           CloseableHttpClient httpClient = null;
           CloseableHttpResponse response = null;
   
           // 将<signedUrl>替换为授权URL。
           URL signedUrl = new URL("<signedUrl>");
   
           // 填写本地文件的完整路径。如果未指定本地路径，则默认从示例程序所属项目对应本地路径中上传文件。
           String pathName = "C:\\Users\\demo.txt";
   
           // 设置请求头，这里的请求头信息需要与生成URL时的信息一致。
           Map<String, String> headers = new HashMap<String, String>();
           /*// 指定Object的存储类型。
           headers.put(OSSHeaders.STORAGE_CLASS, StorageClass.Standard.toString());
           // 指定ContentType。
           headers.put(OSSHeaders.CONTENT_TYPE, "text/txt");*/
   
           // 设置用户自定义元数据，这里的用户自定义元数据需要与生成URL时的信息一致。
           Map<String, String> userMetadata = new HashMap<String, String>();
           /*userMetadata.put("key1","value1");
           userMetadata.put("key2","value2");*/
   
           try {
               HttpPut put = new HttpPut(signedUrl.toString());
               System.out.println(put);
               HttpEntity entity = new FileEntity(new File(pathName));
               put.setEntity(entity);
               // 如果生成签名URL时设置了header参数，例如用户元数据，存储类型等，则调用签名URL上传文件时，也需要将这些参数发送至服务端。如果签名和发送至服务端的不一致，会报签名错误。
               for(Map.Entry header: headers.entrySet()){
                   put.addHeader(header.getKey().toString(),header.getValue().toString());
               }
               for(Map.Entry meta: userMetadata.entrySet()){
                   // 如果使用userMeta，sdk内部会为userMeta拼接"x-oss-meta-"前缀。当您使用其他方式生成签名URL进行上传时，userMeta也需要拼接"x-oss-meta-"前缀。
                   put.addHeader("x-oss-meta-"+meta.getKey().toString(), meta.getValue().toString());
               }
   
               httpClient = HttpClients.createDefault();
   
               response = httpClient.execute(put);
   
               System.out.println("返回上传状态码："+response.getStatusLine().getStatusCode());
               if(response.getStatusLine().getStatusCode() == 200){
                   System.out.println("使用网络库上传成功");
               }
               System.out.println(response.toString());
           } catch (Exception e){
               e.printStackTrace();
           } finally {
               response.close();
               httpClient.close();
           }
       }
   }       

   Python

   import requests
   from requests.auth import HTTPBasicAuth
   import os
   
   def upload_file(signed_url, file_path, headers=None, metadata=None):
       """
       使用预签名的URL上传文件到OSS。
   
       :param signed_url: 预签名的URL。
       :param file_path: 要上传的文件的完整路径。
       :param headers: 可选，自定义HTTP头部。
       :param metadata: 可选，自定义元数据。
       :return: None
       """
       if not headers:
           headers = {}
       if not metadata:
           metadata = {}
   
       # 更新headers，添加元数据前缀
       for key, value in metadata.items():
           headers[f'x-oss-meta-{key}'] = value
   
       try:
           with open(file_path, 'rb') as file:
               response = requests.put(signed_url, data=file, headers=headers)
               print(f"返回上传状态码：{response.status_code}")
               if response.status_code == 200:
                   print("使用网络库上传成功")
               else:
                   print("上传失败")
               print(response.text)
       except Exception as e:
           print(f"发生错误：{e}")
   
   if __name__ == "__main__":
       # 将<signedUrl>替换为授权URL。
       signed_url = "<signedUrl>"
       
       # 填写本地文件的完整路径。如果未指定本地路径，则默认从脚本所在目录中上传文件。
       file_path = "C:\\Users\\demo.txt"
   
       # 设置请求头，这里的请求头信息需要与生成URL时的信息一致。
       headers = {
           # "Content-Type": "text/txt",
           # "x-oss-storage-class": "Standard"
       }
   
       # 设置用户自定义元数据，这里的用户自定义元数据需要与生成URL时的信息一致。
       metadata = {
           # "key1": "value1",
           # "key2": "value2"
       }
   
       upload_file(signed_url, file_path, headers, metadata)
   

   Android-Java

   import android.os.AsyncTask;
   import android.util.Log;
   
   import java.io.DataOutputStream;
   import java.io.File;
   import java.io.FileInputStream;
   import java.io.IOException;
   import java.io.InputStream;
   import java.net.HttpURLConnection;
   import java.net.URL;
   import java.util.HashMap;
   import java.util.Map;
   import java.util.Map.Entry;
   
   public class SignUrlUploadActivity extends AppCompatActivity {
   
       private static final String TAG = "SignUrlUploadActivity";
   
       @Override
       protected void onCreate(Bundle savedInstanceState) {
           super.onCreate(savedInstanceState);
           setContentView(R.layout.activity_main);
   
           // 将<signedUrl>替换为授权URL。
           String signedUrl = "<signedUrl>";
   
           // 填写本地文件的完整路径。如果未指定本地路径，则默认从示例程序所属项目对应本地路径中上传文件。
           String pathName = "/storage/emulated/0/demo.txt";
   
           // 设置请求头，这里的请求头信息需要与生成URL时的信息一致。
           Map<String, String> headers = new HashMap<>();
           // headers.put("Content-Type", "text/txt");
           // headers.put("x-oss-storage-class", "Standard");
   
           // 设置用户自定义元数据，这里的用户自定义元数据需要与生成URL时的信息一致。
           Map<String, String> userMetadata = new HashMap<>();
           // userMetadata.put("key1", "value1");
           // userMetadata.put("key2", "value2");
   
           new UploadTask().execute(signedUrl, pathName, headers, userMetadata);
       }
   
       private class UploadTask extends AsyncTask<Object, Void, Integer> {
           @Override
           protected Integer doInBackground(Object... params) {
               String signedUrl = (String) params[0];
               String pathName = (String) params[1];
               Map<String, String> headers = (Map<String, String>) params[2];
               Map<String, String> userMetadata = (Map<String, String>) params[3];
   
               try {
                   URL url = new URL(signedUrl);
                   HttpURLConnection connection = (HttpURLConnection) url.openConnection();
                   connection.setRequestMethod("PUT");
                   connection.setDoOutput(true);
                   connection.setUseCaches(false);
   
                   // 设置请求头
                   for (Entry<String, String> header : headers.entrySet()) {
                       connection.setRequestProperty(header.getKey(), header.getValue());
                   }
   
                   // 设置用户自定义元数据
                   for (Entry<String, String> meta : userMetadata.entrySet()) {
                       connection.setRequestProperty("x-oss-meta-" + meta.getKey(), meta.getValue());
                   }
   
                   // 读取文件
                   File file = new File(pathName);
                   FileInputStream fileInputStream = new FileInputStream(file);
                   DataOutputStream dos = new DataOutputStream(connection.getOutputStream());
   
                   byte[] buffer = new byte[1024];
                   int count;
                   while ((count = fileInputStream.read(buffer)) != -1) {
                       dos.write(buffer, 0, count);
                   }
   
                   fileInputStream.close();
                   dos.flush();
                   dos.close();
   
                   // 获取响应
                   int responseCode = connection.getResponseCode();
                   Log.d(TAG, "返回上传状态码：" + responseCode);
                   if (responseCode == 200) {
                       Log.d(TAG, "使用网络库上传成功");
                   } else {
                       Log.d(TAG, "上传失败");
                   }
   
                   InputStream is = connection.getInputStream();
                   byte[] responseBuffer = new byte[1024];
                   StringBuilder responseStringBuilder = new StringBuilder();
                   while ((count = is.read(responseBuffer)) != -1) {
                       responseStringBuilder.append(new String(responseBuffer, 0, count));
                   }
                   Log.d(TAG, responseStringBuilder.toString());
   
                   return responseCode;
               } catch (IOException e) {
                   e.printStackTrace();
                   return -1;
               }
           }
   
           @Override
           protected void onPostExecute(Integer result) {
               super.onPostExecute(result);
               if (result == 200) {
                   Toast.makeText(SignUrlUploadActivity.this, "上传成功", Toast.LENGTH_SHORT).show();
               } else {
                   Toast.makeText(SignUrlUploadActivity.this, "上传失败", Toast.LENGTH_SHORT).show();
               }
           }
       }
   }
   

   Go

   package main
   
   import (
   	"bytes"
   	"fmt"
   	"io/ioutil"
   	"net/http"
   	"os"
   )
   
   func uploadFile(signedUrl string, filePath string, headers map[string]string, metadata map[string]string) error {
   	// 打开文件
   	file, err := os.Open(filePath)
   	if err != nil {
   		return err
   	}
   	defer file.Close()
   
   	// 读取文件内容
   	fileBytes, err := ioutil.ReadAll(file)
   	if err != nil {
   		return err
   	}
   
   	// 创建请求
   	req, err := http.NewRequest("PUT", signedUrl, bytes.NewBuffer(fileBytes))
   	if err != nil {
   		return err
   	}
   
   	// 设置请求头
   	for key, value := range headers {
   		req.Header.Set(key, value)
   	}
   
   	// 设置用户自定义元数据
   	for key, value := range metadata {
   		req.Header.Set(fmt.Sprintf("x-oss-meta-%s", key), value)
   	}
   
   	// 发送请求
   	client := &http.Client{}
   	resp, err := client.Do(req)
   	if err != nil {
   		return err
   	}
   	defer resp.Body.Close()
   
   	// 处理响应
   	fmt.Printf("返回上传状态码：%d\n", resp.StatusCode)
   	if resp.StatusCode == 200 {
   		fmt.Println("使用网络库上传成功")
   	} else {
   		fmt.Println("上传失败")
   	}
   	body, _ := ioutil.ReadAll(resp.Body)
   	fmt.Println(string(body))
   
   	return nil
   }
   
   func main() {
   	// 将<signedUrl>替换为授权URL。
   	signedUrl := "<signedUrl>"
   
   	// 填写本地文件的完整路径。如果未指定本地路径，则默认从示例程序所属项目对应本地路径中上传文件。
   	filePath := "C:\\Users\\demo.txt"
   
   	// 设置请求头，这里的请求头信息需要与生成URL时的信息一致。
   	headers := map[string]string{
   		// "Content-Type": "text/txt",
   		// "x-oss-storage-class": "Standard",
   	}
   
   	// 设置用户自定义元数据，这里的用户自定义元数据需要与生成URL时的信息一致。
   	metadata := map[string]string{
   		// "key1": "value1",
   		// "key2": "value2",
   	}
   
   	err := uploadFile(signedUrl, filePath, headers, metadata)
   	if err != nil {
   		fmt.Printf("发生错误：%v\n", err)
   	}
   }
   

   JavaScript

   const fs = require('fs');
   const axios = require('axios');
   
   async function uploadFile(signedUrl, filePath, headers = {}, metadata = {}) {
       try {
           // 更新headers，添加元数据前缀
           for (const [key, value] of Object.entries(metadata)) {
               headers[`x-oss-meta-${key}`] = value;
           }
   
           // 读取文件流
           const fileStream = fs.createReadStream(filePath);
   
           // 发送PUT请求
           const response = await axios.put(signedUrl, fileStream, {
               headers: headers
           });
   
           console.log(`返回上传状态码：${response.status}`);
           if (response.status === 200) {
               console.log("使用网络库上传成功");
           } else {
               console.log("上传失败");
           }
           console.log(response.data);
       } catch (error) {
           console.error(`发生错误：${error.message}`);
       }
   }
   
   // 主函数
   (async () => {
       // 将<signedUrl>替换为授权URL。
       const signedUrl = "<signedUrl>";
   
       // 填写本地文件的完整路径。如果未指定本地路径，则默认从脚本所在目录中上传文件。
       const filePath = "C:\\Users\\demo.txt";
   
       // 设置请求头，这里的请求头信息需要与生成URL时的信息一致。
       const headers = {
           // "Content-Type": "text/txt",
           // "x-oss-storage-class": "Standard"
       };
   
       // 设置用户自定义元数据，这里的用户自定义元数据需要与生成URL时的信息一致。
       const metadata = {
           // "key1": "value1",
           // "key2": "value2"
       };
   
       await uploadFile(signedUrl, filePath, headers, metadata);
   })();
   

   C++

   #include <iostream>
   #include <fstream>
   #include <curl/curl.h>
   #include <map>
   #include <string>
   
   // 回调函数，用于处理HTTP响应
   size_t WriteCallback(void* contents, size_t size, size_t nmemb, std::string* output) {
       size_t totalSize = size * nmemb;
       output->append((char*)contents, totalSize);
       return totalSize;
   }
   
   void uploadFile(const std::string& signedUrl, const std::string& filePath, const std::map<std::string, std::string>& headers, const std::map<std::string, std::string>& metadata) {
       CURL* curl;
       CURLcode res;
       std::string readBuffer;
   
       curl_global_init(CURL_GLOBAL_DEFAULT);
       curl = curl_easy_init();
   
       if (curl) {
           // 设置URL
           curl_easy_setopt(curl, CURLOPT_URL, signedUrl.c_str());
   
           // 设置请求方法为PUT
           curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
   
           // 打开文件
           FILE* file = fopen(filePath.c_str(), "rb");
           if (!file) {
               std::cerr << "无法打开文件: " << filePath << std::endl;
               return;
           }
   
           // 设置文件大小
           fseek(file, 0, SEEK_END);
           long fileSize = ftell(file);
           rewind(file);
   
           // 设置文件读取回调
           curl_easy_setopt(curl, CURLOPT_READDATA, file);
           curl_easy_setopt(curl, CURLOPT_INFILESIZE_LARGE, (curl_off_t)fileSize);
   
           // 设置请求头
           struct curl_slist* chunk = nullptr;
           for (const auto& header : headers) {
               std::string headerStr = header.first + ": " + header.second;
               chunk = curl_slist_append(chunk, headerStr.c_str());
           }
           for (const auto& meta : metadata) {
               std::string metaStr = "x-oss-meta-" + meta.first + ": " + meta.second;
               chunk = curl_slist_append(chunk, metaStr.c_str());
           }
           curl_easy_setopt(curl, CURLOPT_HTTPHEADER, chunk);
   
           // 设置响应处理回调
           curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
           curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);
   
           // 执行请求
           res = curl_easy_perform(curl);
   
           // 检查响应
           if (res != CURLE_OK) {
               std::cerr << "curl_easy_perform() failed: " << curl_easy_strerror(res) << std::endl;
           } else {
               long responseCode;
               curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &responseCode);
               std::cout << "返回上传状态码: " << responseCode << std::endl;
               if (responseCode == 200) {
                   std::cout << "使用网络库上传成功" << std::endl;
               } else {
                   std::cout << "上传失败" << std::endl;
               }
               std::cout << readBuffer << std::endl;
           }
   
           // 清理
           fclose(file);
           curl_slist_free_all(chunk);
           curl_easy_cleanup(curl);
       }
   
       curl_global_cleanup();
   }
   
   int main() {
       // 将<signedUrl>替换为授权URL。
       std::string signedUrl = "<signedUrl>";
   
       // 填写本地文件的完整路径。如果未指定本地路径，则默认从示例程序所属项目对应本地路径中上传文件。
       std::string filePath = "C:\\Users\\demo.txt";
   
       // 设置请求头，这里的请求头信息需要与生成URL时的信息一致。
       std::map<std::string, std::string> headers = {
           // {"Content-Type", "text/txt"},
           // {"x-oss-storage-class", "Standard"}
       };
   
       // 设置用户自定义元数据，这里的用户自定义元数据需要与生成URL时的信息一致。
       std::map<std::string, std::string> metadata = {
           // {"key1", "value1"},
           // {"key2", "value2"}
       };
   
       uploadFile(signedUrl, filePath, headers, metadata);
   
       return 0;
   }
   

   curl

   curl -X PUT \
        -H "Content-Type: text/txt" \
        -H "x-oss-meta-key1: value1" \
        -H "x-oss-meta-key2: value2" \
        -T "C:\\Users\\demo.txt" \
        "https://exampleobject.oss-cn-hangzhou.aliyuncs.com/exampleobject.txt?x-oss-date=20241112T083238Z&x-oss-expires=3599&x-oss-signature-version=OSS4-HMAC-SHA256&x-oss-credential=LTAI5************%2F20241112%2Fcn-hangzhou%2Foss%2Faliyun_v4_request&x-oss-signature=ed5a939feb8d79a389572719f7e2939939936d0**********"
   

使用签名URL分片上传文件需要配置分片大小并逐片生成签名URL，示例代码如下：

import com.aliyun.oss.*;
import com.aliyun.oss.common.auth.*;
import com.aliyun.oss.common.comm.SignVersion;
import com.aliyun.oss.common.utils.CRC64;
import com.aliyun.oss.model.*;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPut;
import org.apache.http.entity.BufferedHttpEntity;
import org.apache.http.entity.InputStreamEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.DefaultHttpRequestRetryHandler;
import org.apache.http.impl.client.HttpClients;
import java.io.*;
import java.net.URL;
import java.util.*;
import java.util.Date;

public class MultipartUrl {
    public static void main(String[] args) throws Throwable {
        // 以华东1（杭州）的外网Endpoint为例，其它Region请按实际情况填写。
        String endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
        // 从环境变量中获取访问凭证。运行本代码示例之前，请确保已设置环境变量OSS_ACCESS_KEY_ID和OSS_ACCESS_KEY_SECRET。
        EnvironmentVariableCredentialsProvider credentialsProvider = CredentialsProviderFactory.newEnvironmentVariableCredentialsProvider();
        // 填写Bucket名称，例如examplebucket。
        String bucketName = "examplebucket";
        // 填写Object完整路径，例如exampleobject.txt。Object完整路径中不能包含Bucket名称。
        String objectName = "exampleobject.txt";
        // 填写本地文件的完整路径。如果未指定本地路径，则默认从示例程序所属项目对应本地路径中上传文件。
        String pathName = "D:\\localpath\\examplefile.txt";
        // 指定生成的签名URL过期时间，单位为毫秒。本示例以设置过期时间为1小时为例。
        long expireTime = 3600*1000L;
        // 填写Bucket所在地域。以华东1（杭州）为例，Region填写为cn-hangzhou。
        String region = "cn-hangzhou";

        // 创建OSSClient实例。
        ClientBuilderConfiguration clientBuilderConfiguration = new ClientBuilderConfiguration();
        clientBuilderConfiguration.setSignatureVersion(SignVersion.V4);
        OSS ossClient = OSSClientBuilder.create()
                .endpoint(endpoint)
                .credentialsProvider(credentialsProvider)
                .clientConfiguration(clientBuilderConfiguration)
                .region(region)
                .build();

        // 创建InitiateMultipartUploadRequest对象。
        InitiateMultipartUploadRequest initRequest = new InitiateMultipartUploadRequest(bucketName, objectName);

        // 初始化分片。
        InitiateMultipartUploadResult upResult = ossClient.initiateMultipartUpload(initRequest);
        // 返回uploadId。uploadId是分片上传事件的唯一标识。您可以根据该uploadId发起相关的操作，例如取消分片上传、查询分片上传等。
        String uploadId = upResult.getUploadId();

        // partETags是PartETag的集合。PartETag由分片的ETag和分片号组成。
        List<PartETag> partETags =  new ArrayList<PartETag>();
        // 每个分片的大小，用于计算文件有多少个分片。单位为字节。
        long partSize = 1 * 100 * 1024L;   //100kb。

        // 填写本地文件的完整路径。如果未指定本地路径，则默认从示例程序所属项目对应本地路径中上传文件。
        File sampleFile = new File(pathName);
        long fileLength = sampleFile.length();
        // 如果希望设置为1个分片，可以将分片大小设置为文件大小。
        // long fileLength = sampleFile.length();
        int partCount = (int) (fileLength / partSize);
        if (fileLength % partSize != 0) {
            partCount++;
        }

        // 设置签名URL的请求头。
        Map<String, String> headers = new HashMap<String, String>();
        /*// 指定Object的存储类型。
        headers.put(OSSHeaders.STORAGE_CLASS, StorageClass.Standard.toString());
        // 指定ContentType。
        headers.put(OSSHeaders.CONTENT_TYPE, "text/txt");*/


        // 遍历分片获取分片签名，并上传分片。
        // 您还可以一次返回所有分片的签名URL，然后依次上传。此处以返回单个签名URL，并通过签名URL上传单个分片为例。
        for (int i = 0; i < partCount; i++) {
            long startPos = i * partSize;
            long curPartSize = (i + 1 == partCount) ? (fileLength - startPos) : partSize;

            /*// 设置md5校验，只支持对单个分片进行md5校验
            FileInputStream inStream = new FileInputStream(pathName);
            // 跳过已经上传的分片。
            inStream.skip(startPos);
            BoundedInputStream entity = new BoundedInputStream(inStream, partSize);
            String md5 = BinaryUtil.toBase64String(DigestUtils.md5(entity));
            headers.put("Content-MD5", md5);*/

            String signUrl = getSignUrl(ossClient, bucketName, objectName, HttpMethod.PUT, expireTime, i + 1, uploadId, headers);

            // 通过签名URL上传文件，以HttpClients为例说明。
            putObjectWithHttp(signUrl, pathName, startPos, curPartSize, headers);
        }

        // 假设合并分片时，与上传分片不在同一个系统。此时，您需要先列举分片，然后再合并分片。
        // 列举已上传的分片。
        ListPartsRequest listPartsRequest = new ListPartsRequest(bucketName, objectName, uploadId);
        PartListing partListing = ossClient.listParts(listPartsRequest);

        // 遍历分片，并填充partETags。
        for (PartSummary part : partListing.getParts()) {
            PartETag partETag = new PartETag(part.getPartNumber(), part.getETag());
            partETags.add(partETag);
        }

        // 合并分片。
        CompleteMultipartUploadRequest completeMultipartUploadRequest =
                new CompleteMultipartUploadRequest(bucketName, objectName, uploadId, partETags);
        // String md5 = BinaryUtil.toBase64String(BinaryUtil.calculateMd5("aaa".getBytes()));
        // 设置禁止覆盖同名文件。
        // completeMultipartUploadRequest.addHeader("x-oss-forbid-overwrite", "true");

        // 完成分片上传。
        CompleteMultipartUploadResult completeMultipartUploadResult = ossClient.completeMultipartUpload(completeMultipartUploadRequest);
        System.out.println("合并分片成功，上传分片完成。");


        // 校验整体上传文件是否完整
        CRC64 crc = new CRC64();
        InputStream inStream = new FileInputStream(pathName);
        byte[] bytes = new byte[1024];
        int cnt;
        while ((cnt = inStream.read(bytes)) != -1) {
            crc.update(bytes, 0, cnt);
        }

        if(crc.getValue() == completeMultipartUploadResult.getServerCRC()){
            System.out.println("上传文件完整");
        } else {
            System.out.println("上传文件不完整，请做异常处理");
        }
    }

    public static void putObjectWithHttp(String signedUrl, String pathName, long startPos, long partSize, Map<String, String> headers) throws IOException {
        CloseableHttpClient httpClient = null;
        CloseableHttpResponse response = null;
        try {
            HttpPut put = new HttpPut(signedUrl);

            FileInputStream inStream = new FileInputStream(pathName);
            // 跳过已经上传的分片。
            inStream.skip(startPos);
            InputStreamEntity entity = new InputStreamEntity(inStream, partSize);
            BufferedHttpEntity byteArrayEntity = new BufferedHttpEntity(entity);
            put.setEntity(byteArrayEntity);

            // 如果生成签名URL时设置了header参数，例如用户元数据，存储类型等，则调用签名URL上传文件时，也需要将这些参数发送至服务端。如果签名和发送至服务端的不一致，会报签名错误。
            for(Map.Entry header: headers.entrySet()){
                put.addHeader(header.getKey().toString(),header.getValue().toString());
            }

            // 加入重试，设置为重试3次。这里仅为举例，业务代码根据需要自行设置重试
            httpClient = HttpClients.custom().setRetryHandler(new DefaultHttpRequestRetryHandler(3, true)).build();

            response = httpClient.execute(put);

            System.out.println("返回上传状态码："+response.getStatusLine().getStatusCode());
            if(response.getStatusLine().getStatusCode() == 200){
                System.out.println("使用网络库上传成功");
            }
            System.out.println(response.toString());
        } catch (Exception e){
            e.printStackTrace();
        } finally {
            if(response != null){
                response.close();
            }
            if(httpClient != null){
                httpClient.close();
            }
        }
    }

    public static String getSignUrl(OSS ossClient, String bucketName, String objectName, HttpMethod method, long expireTime, int partNum, String uploadId, Map<String, String> headers){
        // 指定生成的签名URL过期时间，单位为毫秒。
        Date expiration = new Date(new Date().getTime() + expireTime);

        // 生成签名URL。
        GeneratePresignedUrlRequest request = new GeneratePresignedUrlRequest(bucketName, objectName, method);
        // 设置过期时间。
        request.setExpiration(expiration);

        // 将请求头加入到request中。
        request.setHeaders(headers);

        request.addQueryParameter("partNumber", String.valueOf(partNum));

        request.addQueryParameter("uploadId", uploadId);


        // 通过HTTP Method请求生成签名URL。
        URL signedUrl = ossClient.generatePresignedUrl(request);
        // 打印签名URL。
        System.out.println("signed url: " + signedUrl);
        return signedUrl.toString();
    }
}

上传时不会失败。

上传时使用的是预签名地址，该URL只要是在有效期里（取Token的有效期和预签名有效期最小值），都可以使用。

不需要配置。

请求头和自定义元数据为非必要参数，如果不设置请求头和自定义元数据可以将示例中相关代码去掉。