Visão geral Alterações de alto nível Dependências do Maven Migração do construtor do cliente Migração do método do cliente Migração de objetos de modelo TransferManagerBuilder migração de configuração Alteração de comportamento

Migre o Transfer Manager da versão 1 para a versão 2 do AWS SDK para Java

Este guia de migração aborda as principais diferenças entre o Transfer Manager v1 e o S3 Transfer Manager v2, incluindo alterações no construtor, mapeamentos de métodos e exemplos de código para operações comuns. Depois de analisar essas diferenças, você pode migrar com êxito seu código existente do Transfer Manager para aproveitar o desempenho aprimorado e as operações assíncronas na v2.

Sobre a ferramenta de migração do AWS SDK

O AWS SDK para Java fornece uma ferramenta de migração automatizada que pode migrar grande parte da API do Transfer Manager v1 para a v2. No entanto, a ferramenta de migração não oferece suporte a vários recursos do Transfer Manager v1. Nesses casos, você precisa migrar manualmente o código do Transfer Manager usando as orientações deste tópico.

Ao longo deste guia, o status da migração mostra se a ferramenta de migração pode migrar automaticamente um construtor, método ou recurso:

Compatível: a ferramenta de migração pode transformar automaticamente esse código
Não suportado: você precisa migrar o código manualmente

Mesmo para itens marcados como “Suportados”, revise os resultados da migração e faça um teste completo. A migração do Transfer Manager envolve mudanças arquitetônicas significativas de operações síncronas para assíncronas.

Visão geral

O S3 Transfer Manager v2 introduz mudanças significativas na API do Transfer Manager. O S3 Transfer Manager v2 é baseado em operações assíncronas e oferece melhor desempenho, especialmente quando você usa o cliente Amazon S3 baseado em CRT. AWS

Principais diferenças

Package: com.amazonaws.services.s3.transfer → software.amazon.awssdk.transfer.s3
Nome da classe: TransferManager → S3TransferManager
Dependência do cliente: Cliente Amazon S3 síncrono → Cliente Amazon S3 assíncrono () S3AsyncClient
Arquitetura: Operações síncronas → Operações assíncronas com CompletableFuture
Desempenho: aprimorado com suporte ao cliente AWS baseado em CRT

Alterações de alto nível

Aspecto	V1	V2
Dependência do Maven	`aws-java-sdk-s3`	`s3-transfer-manager`
Pacote	`com.amazonaws.services.s3.transfer`	`software.amazon.awssdk.transfer.s3`
Classe principal	`TransferManager`	`S3TransferManager`
Cliente Amazon S3	`AmazonS3`(sincronizar)	`S3AsyncClient`(assíncrono)
Tipos de devolução	Operações de bloqueio	`CompletableFuture<T>`

Dependências do Maven

V1 V2

V1	V2
`<dependencyManagement> <dependencies> <dependency> <groupId>com.amazonaws</groupId> <artifactId>aws-java-sdk-bom</artifactId> <version>>1.12.787¹</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement> <dependencies> <dependency> <groupId>com.amazonaws</groupId> <artifactId>aws-java-sdk-s3</artifactId> </dependency> </dependencies>`	<dependencyManagement> <dependencies> <dependency> <groupId>software.amazon.awssdk</groupId> <artifactId>bom</artifactId> <version>2.31.68²</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement> <dependencies> <dependency> <groupId>software.amazon.awssdk</groupId> <artifactId>s3-transfer-manager</artifactId> </dependency> <!-- Optional: For enhanced performance with AWS CRT --> <dependency> <groupId>software.amazon.awssdk.crt</groupId> <artifactId>aws-crt</artifactId> <version>0.38.5³</version> </dependency> </dependencies>


<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>com.amazonaws</groupId>
            <artifactId>aws-java-sdk-bom</artifactId>
            <version>>1.12.787¹</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>
<dependencies>
    <dependency>
        <groupId>com.amazonaws</groupId>
        <artifactId>aws-java-sdk-s3</artifactId>
    </dependency>
</dependencies>


<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>bom</artifactId>
            <version>2.31.68²</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>
<dependencies>
    <dependency>
        <groupId>software.amazon.awssdk</groupId>
        <artifactId>s3-transfer-manager</artifactId>
    </dependency>
    <!-- Optional: For enhanced performance with AWS CRT -->
    <dependency>
        <groupId>software.amazon.awssdk.crt</groupId>
        <artifactId>aws-crt</artifactId>
        <version>0.38.5³</version>
    </dependency>
</dependencies>

¹ Versão mais recente. ² Versão mais recente. ³ Versão mais recente.

Migração do construtor do cliente

Construtores compatíveis (migração automática)

Construtor V1	Equivalente a V2	Status da migração
`new TransferManager()`	`S3TransferManager.create()`	Compatível
`TransferManagerBuilder. defaultTransferManager()`	`S3TransferManager.create()`	Compatível
`TransferManagerBuilder. standard().build()`	`S3TransferManager.builder().build()`	Compatível
`new TransferManager(AWSCredentials)`	`S3TransferManager.builder() .s3Client(S3AsyncClient.builder() .credentialsProvider(...).build()) .build()`	Compatível
`new TransferManager( AWSCredentialsProvider)`	`S3TransferManager.builder() .s3Client(S3AsyncClient.builder() .credentialsProvider(...).build()) .build()`	Compatível

Construtores sem suporte (é necessária a migração manual)

Construtor V1	Equivalente a V2	Notas de migração
`new TransferManager(AmazonS3)`	É necessária uma migração manual	Crie um `S3AsyncClient` separadamente
`new TransferManager(AmazonS3, ExecutorService)`	É necessária uma migração manual	Crie `S3AsyncClient` e configure um executor
`new TransferManager(AmazonS3, ExecutorService, boolean)`	É necessária uma migração manual	`shutDownThreadPools`parâmetro não suportado

Exemplos de migração manual

Código V1:


AmazonS3 s3Client = AmazonS3ClientBuilder.defaultClient();
TransferManager transferManager = new TransferManager(s3Client);

Código V2:


// Create an `S3AsyncClient` with similar configuration
S3AsyncClient s3AsyncClient = S3AsyncClient.builder()
    .credentialsProvider(DefaultCredentialsProvider.create())
    .build();

// Provide the configured `S3AsyncClient` to the S3 transfer manager builder.
S3TransferManager transferManager = S3TransferManager.builder()
    .s3Client(s3AsyncClient)
    .build();

Migração do método do cliente

Atualmente, a ferramenta de migração oferece suporte aos resumeUpload métodos básicos copy downloadupload,uploadDirectory,downloadDirectory,resumeDownload,, e básicos.

Métodos de transferência principais

Método V1	Método V2	Alteração do tipo de devolução	Status da migração
`upload(String, String, File)`	`uploadFile(UploadFileRequest)`	`Upload` → `FileUpload`	Compatível
`upload(PutObjectRequest)`	`upload(UploadRequest)`	`Upload` → `Upload`	Compatível
`download(String, String, File)`	`downloadFile(DownloadFileRequest)`	`Download` → `FileDownload`	Compatível
`download(GetObjectRequest, File)`	`downloadFile(DownloadFileRequest)`	`Download` → `FileDownload`	Compatível
`copy(String, String, String, String)`	`copy(CopyRequest)`	`Copy` → `Copy`	Compatível
`copy(CopyObjectRequest)`	`copy(CopyRequest)`	`Copy` → `Copy`	Compatível
`uploadDirectory(String, String, File, boolean)`	`uploadDirectory( UploadDirectoryRequest)`	`MultipleFileUpload` → `DirectoryUpload`	Compatível
`downloadDirectory(String, String, File)`	`downloadDirectory( DownloadDirectoryRequest)`	`MultipleFileDownload` → `DirectoryDownload`	Compatível

Métodos de transferência retomáveis

Método V1	Método V2	Status da migração
`resumeUpload(PersistableUpload)`	`resumeUploadFile(ResumableFileUpload)`	Compatível
`resumeDownload(PersistableDownload)`	`resumeDownloadFile(ResumableFileDownload)`	Compatível

Métodos de ciclo de vida

Método V1	Método V2	Status da migração
`shutdownNow()`	`close()`	Compatível
`shutdownNow(boolean)`	Ajuste manualmente o código usando o `close()` método	Não suportado

Métodos de cliente V1 não suportados

Método V1	Alternativa V2	Observações
`abortMultipartUploads(String, Date)`	Use o cliente Amazon S3 de baixo nível	Não suportado
`getAmazonS3Client()`	Salvar uma referência separadamente	Não suportado; não há melhor na v2
`getConfiguration()`	Salvar uma referência separadamente	Não suportado; não há melhor na v2
`uploadFileList(...)`	Faça várias `uploadFile()` chamadas	Não suportado
`copy`métodos com um `TransferStateChangeListener` parâmetro	Usar o `TransferListener`	Veja o exemplo de migração manual
`download`métodos com um `S3ProgressListener` parâmetro	Usar o `TransferListener`	Veja o exemplo de migração manual
`downloadDirectory`métodos com 4 ou mais parâmetros		Veja o exemplo de migração manual
`upload`método com um `ObjectMetadataProvider` parâmetro	Definir metadados na solicitação	Veja o exemplo de migração manual
`uploadDirectory`métodos com `*Provider` parâmetro	Definir tags na solicitação	Veja o exemplo de migração manual

`copy`métodos com um `TransferStateChangeListener` parâmetro

copy(CopyObjectRequest copyObjectRequest, AmazonS3 srcS3, TransferStateChangeListener stateChangeListener)
copy(CopyObjectRequest copyObjectRequest, TransferStateChangeListener stateChangeListener)


// V1 ----------------------------------------------------------------------------------------------
// Initialize source S3 client
AmazonS3 s3client = AmazonS3ClientBuilder.standard()
                .withRegion("us-west-2")
                .build();
                
// Initialize Transfer Manager
TransferManager tm = TransferManagerBuilder.standard()
                .withS3Client(srcS3)
                .build();

CopyObjectRequest copyObjectRequest = new CopyObjectRequest(
                "amzn-s3-demo-source-bucket",
                "source-key",         
                "amzn-s3-demo-destination-bucket", 
                "destination-key"    
        );

TransferStateChangeListener stateChangeListener = new TransferStateChangeListener() {
            @Override
            public void transferStateChanged(Transfer transfer, TransferState state) {
              //Implementation of the TransferStateChangeListener
            }
        };

Copy copy = tm.copy(copyObjectRequest, srcS3, stateChangeListener);


// V2 ----------------------------------------------------------------------------------------------
S3AsyncClient s3AsyncClient = S3AsyncClient.builder()
                .region(Region.US_WEST_2)          
                .build();

S3TransferManager transferManager = S3TransferManager.builder()
                .s3Client(s3AsyncClient)
                .build();

// Create transfer listener (equivalent to TransferStateChangeListener in v1)                                
TransferListener transferListener = new TransferListener() {
            @Override
            public void transferInitiated(Context.TransferInitiated context) {
               //Implementation
               System.out.println("Transfer initiated");
            }

            @Override
            public void bytesTransferred(Context.BytesTransferred context) {
                //Implementation
                System.out.println("Bytes transferred");
            }

            @Override
            public void transferComplete(Context.TransferComplete context) {
                //Implementation
                System.out.println("Transfer completed!");
            }

            @Override
            public void transferFailed(Context.TransferFailed context) {
                //Implementation
                System.out.println("Transfer failed");
            }
        };

CopyRequest copyRequest = CopyRequest.builder()
                              .copyObjectRequest(req -> req
                                  .sourceBucket("amzn-s3-demo-source-bucket")
                                  .sourceKey("source-key")
                                  .destinationBucket("amzn-s3-demo-destination-bucket")
                                  .destinationKey("destination-key")
                               )
                                .addTransferListener(transferListener) // Configure the transferListener into the request
                                .build();
  
Copy copy = transferManager.copy(copyRequest);

`download`métodos com um `S3ProgressListener` parâmetro

download(GetObjectRequest getObjectRequest, File file, S3ProgressListener progressListener)
download(GetObjectRequest getObjectRequest, File file, S3ProgressListener progressListener, long timeoutMillis)
download(GetObjectRequest getObjectRequest, File file, S3ProgressListener progressListener, long timeoutMillis, boolean resumeOnRetry)


// V1 ----------------------------------------------------------------------------------------------
S3ProgressListener progressListener = new S3ProgressListener() {
        @Override
        public void progressChanged(com.amazonaws.event.ProgressEvent progressEvent) {
            long bytes = progressEvent.getBytesTransferred();
            ProgressEventType eventType = progressEvent.getEventType();
            // Use bytes and eventType as needed
        }

        @Override
        public void onPersistableTransfer(PersistableTransfer persistableTransfer) {

        }
    };

Download download1 = tm.download(getObjectRequest, file, progressListener); 
Download download2 = tm.download(getObjectRequest, file, progressListener, timeoutMillis)
Download download3 = tm.download(getObjectRequest, file, progressListener, timeoutMillis, true)

// V2 ----------------------------------------------------------------------------------------------
TransferListener transferListener = new TransferListener() {
    @Override
    public void transferInitiated(Context.InitializedContext context) {
        // Equivalent to ProgressEventType.TRANSFER_STARTED_EVENT
        System.out.println("Transfer initiated");
    }

    @Override
    public void bytesTransferred(Context.BytesTransferred context) {
        // Equivalent to ProgressEventType.REQUEST_BYTE_TRANSFER_EVENT
        long bytes = context.bytesTransferred();
        System.out.println("Bytes transferred: " + bytes);
    }

    @Override
    public void transferComplete(Context.TransferComplete context) {
        // Equivalent to ProgressEventType.TRANSFER_COMPLETED_EVENT
        System.out.println("Transfer completed");
    }

    @Override
    public void transferFailed(Context.TransferFailed context) {
        // Equivalent to ProgressEventType.TRANSFER_FAILED_EVENT
        System.out.println("Transfer failed: " + context.exception().getMessage());
    }
};
DownloadFileRequest downloadFileRequest = 
                         DownloadFileRequest.builder()
                             .getObjectRequest(getObjectRequest)
                             .destination(file.toPath())
                             .addTransferListener(transferListener)
                             .build();

// For download1
FileDownload download = transferManager.downloadFile(downloadFileRequest);

// For download2
CompletedFileDownload completedFileDownload = download.completionFuture()
                                                  .get(timeoutMillis, TimeUnit.MILLISECONDS);

// For download3, the v2 SDK does not have a direct equiavalent to the `resumeOnRetry` method of v1.
// If a download is interrupted, you need to start a new download request.

`downloadDirectory`métodos com 4 ou mais parâmetros

downloadDirectory(String bucketName, String keyPrefix, File destinationDirectory, boolean resumeOnRetry)
downloadDirectory(String bucketName, String keyPrefix, File destinationDirectory, boolean resumeOnRetry, KeyFilter filter)
downloadDirectory(String bucketName, String keyPrefix, File destinationDirectory, KeyFilter filter)


// V1 ----------------------------------------------------------------------------------------------
KeyFilter filter = new KeyFilter() {
            @Override
            public boolean shouldInclude(S3ObjectSummary objectSummary) {
                //Filter implementation
            }
        };
MultipleFileDownload multipleFileDownload = tm.downloadDirectory(bucketName, keyPrefix, destinationDirectory, filter);

// V2 ----------------------------------------------------------------------------------------------
// The v2 SDK does not have a direct equiavalent to the `resumeOnRetry` method of v1.
// If a download is interrupted, you need to start a new download request.
DownloadFilter filter = new DownloadFilter() {
            @Override
            public boolean test(S3Object s3Object) {
                // Filter implementation.
            }
        };

DownloadDirectoryRequest downloadDirectoryRequest = 
                              DownloadDirectoryRequest.builder()
                                  .bucket(bucketName)
                                  .filter(filter)
                                  .listObjectsV2RequestTransformer(builder -> builder.prefix(keyPrefix))
                                  .destination(destinationDirectory.toPath())
                                  .build();
                                                                            
DirectoryDownload directoryDownload = transferManager.downloadDirectory(downloadDirectoryRequest);

`upload`método com `ObjectMetadata` parâmetro

upload(String bucketName, String key, InputStream input, ObjectMetadata objectMetadata)


// V1 ----------------------------------------------------------------------------------------------ObjectMetadata metadata = new ObjectMetadata();
ObjectMetadata metadata = new ObjectMetadata();

metadata.setContentType("text/plain");        // System-defined metadata
metadata.setContentLength(22L);               // System-defined metadata
metadata.addUserMetadata("myKey", "myValue"); // User-defined metadata

PutObjectRequest putObjectRequest = new PutObjectRequest(bucketName, key, inputStream, metadata);

Upload upload = transferManager.upload("amzn-s3-demo-bucket", "my-key", inputStream, metadata);

// V2 ----------------------------------------------------------------------------------------------
/* When you use an InputStream to upload in V2, you should specify the content length 
   and use `RequestBody.fromInputStream()`. 
   If you don't provide the content length, the entire stream will be buffered in memory. 
   If you can't determine the content length, we recommend using the CRT-based S3 client.
*/
Map<String, String> userMetadata = new HashMap<>();
userMetadata.put("x-amz-meta-myKey", "myValue");

PutObjectRequest putObjectRequest = 
                        PutObjectRequest.builder()
                            .bucket("amzn-s3-demo-bucket1")
                            .key("k")
                            .contentType("text/plain") //System-defined metadata usually has separate methods in the builder.
                            .contentLength(22L)
                            .metadata(userMetadata) //metadata() is only for user-defined metadata.
                            .build();

UploadRequest uploadRequest = 
                        UploadRequest.builder()
                            .putObjectRequest(putObjectRequest)
                            .requestBody(AsyncRequestBody.fromInputStream(stream, 22L, executor))
                            .build();
                                                   
transferManager.upload(uploadRequest).completionFuture().join();

`uploadDirectory`com `ObjectMetadataProvider` parâmetro

uploadDirectory(String bucketName, String virtualDirectoryKeyPrefix, File directory, boolean includeSubdirectories, ObjectMetadataProvider metadataProvider)
uploadDirectory(String bucketName, String virtualDirectoryKeyPrefix, File directory, boolean includeSubdirectories, ObjectMetadataProvider metadataProvider, ObjectTaggingProvider taggingProvider)
uploadDirectory(String bucketName, String virtualDirectoryKeyPrefix, File directory, boolean includeSubdirectories, ObjectMetadataProvider metadataProvider, ObjectTaggingProvider taggingProvider, ObjectCannedAclProvider cannedAclProvider)


// V1 ----------------------------------------------------------------------------------------------
tm.uploadDirectory(bucketName, virtualDirectoryKeyPrefix, directory, includeSubdirectories, metadataProvider)
tm.uploadDirectory(bucketName, virtualDirectoryKeyPrefix, directory, includeSubdirectories, metadataProvider, taggingProvider)
tm.uploadDirectory(bucketName, virtualDirectoryKeyPrefix, directory, includeSubdirectories, metadataProvider, taggingProvider, cannedAclProvider)

// V2 ----------------------------------------------------------------------------------------------
UploadDirectoryRequest request = UploadDirectoryRequest.builder()
                                  .bucket(bucketName)
                                  .s3Prefix(virtualDirectoryKeyPrefix)
                                  .source(directory.toPath())
                                  .maxDepth(includeSubdirectories ? Integer.MAX_VALUE : 1)
                                  .uploadFileRequestTransformer(builder -> {
                                      // 1.Replace `ObjectMetadataProvider`, `ObjectTaggingProvider`, and `ObjectCannedAclProvider` with an
                                        // `UploadFileRequestTransformer` that can combine the functionality of all three *Provider implementations.
                                        // 2. Convert your v1 `ObjectMetadata` to v2 `PutObjectRequest` parameters.
                                        // 3. Convert your v1 `ObjectTagging` to v2 `Tagging`.
                                        // 4. Convert your v1 `CannedAccessControlList` to v2 `ObjectCannedACL`.
                                  })
                                  .build();
        
DirectoryUpload directoryUpload = transferManager.uploadDirectory(request);

Migração de objetos de modelo

Em AWS SDK for Java 2.x, muitos dos objetos do TransferManager modelo foram redesenhados e vários métodos getter e setter disponíveis nos objetos do modelo da v1 não são mais suportados.

Na v2, você pode usar a CompletableFuture<T> classe para realizar ações quando a transferência for concluída, com êxito ou com uma exceção. Você pode usar o join() método para aguardar a conclusão, se necessário.

Objetos de transferência principais

Classe V1	Classe V2	Status da migração
`TransferManager`	`S3TransferManager`	Compatível
`TransferManagerBuilder`	`S3TransferManager.Builder`	Compatível
`Transfer`	`Transfer`	Compatível
`AbortableTransfer`	`Transfer`	Compatível (sem classe separada)
`Copy`	`Copy`	Compatível
`Download`	`FileDownload`	Compatível
`Upload`	`Upload` / `FileUpload`	Compatível
`MultipleFileDownload`	`DirectoryDownload`	Compatível
`MultipleFileUpload`	`DirectoryUpload`	Compatível

Objetos de persistência

Classe V1	Classe V2	Status da migração
`PersistableDownload`	`ResumableFileDownload`	Compatível
`PersistableUpload`	`ResumableFileUpload`	Compatível
`PersistableTransfer`	`ResumableTransfer`	Compatível
`PauseResult<T>`	Objeto retomável direto	Não suportado

Objetos de resultado

Classe V1	Classe V2	Status da migração
`CopyResult`	`CompletedCopy`	Compatível
`UploadResult`	`CompletedUpload`	Compatível

Objetos de configuração

Classe V1	Classe V2	Status da migração
`TransferManagerConfiguration`	`MultipartConfiguration`(no cliente Amazon S3)	Compatível
`TransferProgress`	`TransferProgress` + `TransferProgressSnapshot`	Compatível
`KeyFilter`	`DownloadFilter`	Compatível

Objetos não compatíveis

Classe V1	Alternativa V2	Status da migração
`PauseStatus`	Não compatível	Não suportado
`UploadContext`	Não compatível	Não suportado
`ObjectCannedAclProvider`	`PutObjectRequest.builder().acl()`	Não suportado
`ObjectMetadataProvider`	`PutObjectRequest.builder().metadata()`	Não suportado
`ObjectTaggingProvider`	`PutObjectRequest.builder().tagging()`	Não suportado
`PresignedUrlDownload`	Não compatível	Não suportado

TransferManagerBuilder migração de configuração

Alterações de configuração

As alterações de configuração que você precisa definir para o gerenciador de transferência v2 dependem do cliente S3 que você usa. Você pode escolher entre o cliente S3 AWS baseado em CRT ou o cliente assíncrono S3 padrão baseado em Java. Para obter informações sobre as diferenças, consulte o Clientes S3 no AWS SDK for Java 2.x tópico.

Use the AWS CRT-based S3 client

Configuração	v1	v2 - Gerenciador de transferências usando o cliente S3 baseado em AWS CRT
(obtenha um construtor)	`TransferManagerBuilder tmBuilder = TransferManagerBuilder.standard();`	`S3TransferManager.Builder tmBuilder = S3TransferManager.builder();`
Cliente do S3	`tmBuilder.withS3Client(...); tmBuilder.setS3Client(...);`	`tmBuilder.s3Client(...);`
Executor	`tmBuilder.withExecutorFactory(...); tmBuilder.setExecutorFactory(...);`	`tmBuilder.executor(...);`
Encerrar grupos de threads	`tmBuilder.withShutDownThreadPools(...); tmBuilder.setShutdownThreadPools(...);`	Sem suporte. O executor fornecido não será desligado quando o `S3TransferManager` for fechado
Tamanho mínimo da parte de upload	`tmBuilder.withMinimumUploadPartSize(...); tmBuilder.setMinimumUploadPartSize(...);`	`S3AsyncClient s3 = S3AsyncClient.crtBuilder(). minimumPartSizeInBytes(...).build(); tmBuilder.s3Client(s3);`
Limite de multipart upload	`tmBuilder.withMinimumUploadPartSize(...); tmBuilder.setMinimumUploadPartSize(...);`	`S3AsyncClient s3 = S3AsyncClient.crtBuilder(). thresholdInBytes(...).build(); tmBuilder.s3Client(s3);`
Tamanho mínimo da parte de cópia	`tmBuilder.withMinimumUploadPartSize(...); tmBuilder.setMinimumUploadPartSize(...);`	`S3AsyncClient s3 = S3AsyncClient.crtBuilder(). minimumPartSizeInBytes(...).build(); tmBuilder.s3Client(s3);`
Limite de cópia de multipart	`tmBuilder.withMinimumUploadPartSize(...); tmBuilder.setMinimumUploadPartSize(...);`	`S3AsyncClient s3 = S3AsyncClient.crtBuilder(). thresholdInBytes(...).build(); tmBuilder.s3Client(s3);`
Desabilitar downloads paralelos	`tmBuilder.withDisableParallelDownloads(...); tmBuilder.setDisableParallelDownloads(...);`	Desative os downloads paralelos passando um cliente S3 padrão baseado em Java com várias partes desativadas (padrão) para o gerenciador de transferências. `S3AsyncClient s3 = S3AsyncClient.builder().build(); tmBuilder.s3Client(s3);`
Sempre calcule o multipart md5	`tmBuilder.withAlwaysCalculateMultipartMd5(...); tmBuilder.setAlwaysCalculateMultipartMd5(...);`	Sem compatibilidade.

Use Java-based S3 async client

Configuração	v1	v2 - Gerenciador de transferências usando o cliente assíncrono S3 baseado em Java
(obtenha um construtor)	`TransferManagerBuilder tmBuilder = TransferManagerBuilder.standard();`	`S3TransferManager.Builder tmBuilder = S3TransferManager.builder();`
Cliente do S3	`tmBuilder.withS3Client(...); tmBuilder.setS3Client(...);`	`tmBuilder.s3Client(...);`
Executor	`tmBuilder.withExecutorFactory(...); tmBuilder.setExecutorFactory(...);`	`tmBuilder.executor(...);`
Encerrar grupos de threads	`tmBuilder.withShutDownThreadPools(...); tmBuilder.setShutdownThreadPools(...);`	Sem suporte. O executor fornecido não será desligado quando o `S3TransferManager` for fechado
Tamanho mínimo da parte de upload	`tmBuilder.withMinimumUploadPartSize(...); tmBuilder.setMinimumUploadPartSize(...);`	`S3AsyncClient s3 = S3AsyncClient.builder() .multipartConfiguration(cfg -> cfg.minimumPartSizeInBytes(...)).build(); tmBuilder.s3Client(s3);`
Limite de multipart upload	`tmBuilder.withMinimumUploadPartSize(...); tmBuilder.setMinimumUploadPartSize(...);`	`S3AsyncClient s3 = S3AsyncClient.builder() .multipartConfiguration(cfg -> cfg.thresholdInBytes(...)).build(); tmBuilder.s3Client(s3);`
Tamanho mínimo da parte de cópia	`tmBuilder.withMinimumUploadPartSize(...); tmBuilder.setMinimumUploadPartSize(...);`	`S3AsyncClient s3 = S3AsyncClient.builder() .multipartConfiguration(cfg -> cfg.minimumPartSizeInBytes(...)).build(); tmBuilder.s3Client(s3);`
Limite de cópia de multipart	`tmBuilder.withMinimumUploadPartSize(...); tmBuilder.setMinimumUploadPartSize(...);`	`S3AsyncClient s3 = S3AsyncClient.builder() .multipartConfiguration(cfg -> cfg.thresholdInBytes(...)).build(); tmBuilder.s3Client(s3);`
Desabilitar downloads paralelos	`tmBuilder.withDisableParallelDownloads(...); tmBuilder.setDisableParallelDownloads(...);`	Desative os downloads paralelos passando um cliente S3 padrão baseado em Java com várias partes desativadas (padrão) para o gerenciador de transferências. `S3AsyncClient s3 = S3AsyncClient.builder().build(); tmBuilder.s3Client(s3);`
Sempre calcule o multipart md5	`tmBuilder.withAlwaysCalculateMultipartMd5(...); tmBuilder.setAlwaysCalculateMultipartMd5(...);`	Sem compatibilidade.

Alteração de comportamento

Operações assíncronas

V1 (bloqueio):


Upload upload = transferManager.upload("amzn-s3-demo-bucket", "key", file);
upload.waitForCompletion(); // Blocks until complete

V2 (assíncrono):


FileUpload upload = transferManager.uploadFile(UploadFileRequest.builder()
    .putObjectRequest(PutObjectRequest.builder()
        .bucket("amzn-s3-demo-bucket")
        .key("key")
        .build())
    .source(file)
    .build());

CompletedFileUpload result = upload.completionFuture().join(); // Blocks until complete
// Or handle asynchronously:
upload.completionFuture().thenAccept(result -> {
    System.out.println("Upload completed: " + result.response().eTag());
});

Tratamento de erros

V1: As transferências de diretório falham completamente se alguma subsolicitação falhar.

V2: As transferências de diretório são concluídas com êxito, mesmo que algumas sub-solicitações falhem. Verifique se há erros de forma explícita:


DirectoryUpload directoryUpload = transferManager.uploadDirectory(request);
CompletedDirectoryUpload result = directoryUpload.completionFuture().join();

// Check for failed transfers
if (!result.failedTransfers().isEmpty()) {
    System.out.println("Some uploads failed:");
    result.failedTransfers().forEach(failed -> 
        System.out.println("Failed: " + failed.exception().getMessage()));
}

Download paralelo por meio de buscas de intervalo de bytes

Quando o recurso de transferência paralela automática está ativado no SDK v2, o S3 Transfer Manager usa buscas de intervalo de bytes para recuperar partes específicas do objeto em paralelo (download de várias partes). A forma como um objeto é baixado com a v2 não depende de como o objeto foi originalmente carregado. Todos os downloads podem se beneficiar da alta taxa de transferência e da simultaneidade.

Por outro lado, com o Transfer Manager da v1, importa como o objeto foi originalmente carregado. O Gerenciador de Transferências v1 recupera as partes do objeto da mesma forma que as partes foram carregadas. Se um objeto foi originalmente carregado como um único objeto, o Gerenciador de Transferências v1 não poderá acelerar o processo de download usando sub-solicitações.

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Diferenças do cliente S3

Análise de URI do S3