Comece com o AWS SDK for Java 2.x - AWS SDK for Java 2.x
Etapa 1: configurar para este tutorialEtapa 2: criar o projetoEtapa 3: escrever o códigoEtapa 4: compilar e executar o aplicativoPróximas etapas

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Comece com o AWS SDK for Java 2.x

O AWS SDK for Java 2.x fornece Java APIs para Amazon Web Services (AWS). Usando oSDK, você pode criar aplicativos Java que funcionam com Amazon S3, Amazon EC2 DynamoDB, e muito mais.

Este tutorial mostra como usar o Apache Maven para definir dependências SDK para o Java 2.x e, em seguida, escrever um código que se conecte Amazon S3 ao upload de um arquivo.

Siga estas etapas para concluir este tutorial:

Etapa 1: configurar para este tutorial

Antes de iniciar este tutorial, é necessário instalar o seguinte:

  • Permissão para acessar Amazon S3

  • Um ambiente de desenvolvimento Java configurado para acessar Serviços da AWS usando login único ao AWS IAM Identity Center

Use as instruções em Visão geral da configuração para se preparar para este tutorial. Depois de configurar seu ambiente de desenvolvimento com acesso de logon único para Java SDK e ter uma sessão ativa do portal de AWS acesso, continue com a Etapa 2 deste tutorial.

Etapa 2: criar o projeto

Para criar o projeto para este tutorial, você executa um comando do Maven que solicita informações sobre como configurar o projeto. Depois que todas as informações forem inseridas e confirmadas, o Maven conclui a construção do projeto criando um pom.xml e cria arquivos Java stub.

  1. Abra uma janela de terminal ou prompt de comando e navegue até um diretório de sua escolha, por exemplo, sua pasta Desktop ou Home.

  2. Insira o seguinte comando no terminal e pressione Enter.

    mvn archetype:generate \
  -DarchetypeGroupId=software.amazon.awssdk \
  -DarchetypeArtifactId=archetype-app-quickstart \
  -DarchetypeVersion=2.27.21

  3. Insira o valor listado na segunda coluna para cada solicitação.

    Prompt Valor a informar
    Define value for property 'service': s3
    Define value for property 'httpClient': apache-client
    Define value for property 'nativeImage': false
    Define value for property 'credentialProvider' identity-center
    Define value for property 'groupId': org.example
    Define value for property 'artifactId': getstarted
    Define value for property 'version' 1.0-SNAPSHOT: <Enter>
    Define value for property 'package' org.example: <Enter>

  4. Depois que o último valor é inserido, o Maven lista as escolhas que você fez. Confirme informando Y ou reinsira valores informando N.

O Maven cria a pasta do projeto chamada getstarted com base no valor de artifactId que você informou. Dentro da pasta getstarted, encontre um arquivo README.md que você possa revisar, um arquivo pom.xml e um diretório src.

O Maven cria a árvore de diretórios a seguir.

getstarted
├── README.md
├── pom.xml
└── src
    ├── main
    │   ├── java
    │   │   └── org
    │   │       └── example
    │   │           ├── App.java
    │   │           ├── DependencyFactory.java
    │   │           └── Handler.java
    │   └── resources
    │       └── simplelogger.properties
    └── test
        └── java
            └── org
                └── example
                    └── HandlerTest.java

10 directories, 7 files

O exemplo a seguir mostra o conteúdo do arquivo de projeto pom.xml.

A seção dependencyManagement contém uma dependência do AWS SDK for Java 2.x e a seção dependencies tem uma dependência do Amazon S3. O projeto usa o Java 1.8 devido ao valor 1.8 nas propriedades maven.compiler.source e maven.compiler.target.

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>getstarted</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <maven.shade.plugin.version>3.2.1</maven.shade.plugin.version>
        <maven.compiler.plugin.version>3.6.1</maven.compiler.plugin.version>
        <exec-maven-plugin.version>1.6.0</exec-maven-plugin.version>
        <aws.java.sdk.version>2.27.21</aws.java.sdk.version> <-------- SDK version picked up from archetype version.
        <slf4j.version>1.7.28</slf4j.version>
        <junit5.version>5.8.1</junit5.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>software.amazon.awssdk</groupId>
                <artifactId>bom</artifactId>
                <version>${aws.java.sdk.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>
        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>s3</artifactId>  <-------- S3 dependency
            <exclusions>
                <exclusion>
                    <groupId>software.amazon.awssdk</groupId>
                    <artifactId>netty-nio-client</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>software.amazon.awssdk</groupId>
                    <artifactId>apache-client</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>sso</artifactId> <-------- Required for identity center authentication.
        </dependency>

        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>ssooidc</artifactId> <-------- Required for identity center authentication.
        </dependency>

        <dependency>
            <groupId>software.amazon.awssdk</groupId>
            <artifactId>apache-client</artifactId> <-------- HTTP client specified.
            <exclusions>
                <exclusion>
                    <groupId>commons-logging</groupId>
                    <artifactId>commons-logging</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4j.version}</version>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
            <version>${slf4j.version}</version>
        </dependency>

        <!-- Needed to adapt Apache Commons Logging used by Apache HTTP Client to Slf4j to avoid
        ClassNotFoundException: org.apache.commons.logging.impl.LogFactoryImpl during runtime -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>jcl-over-slf4j</artifactId>
            <version>${slf4j.version}</version>
        </dependency>

        <!-- Test Dependencies -->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>${junit5.version}</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>${maven.compiler.plugin.version}</version>
            </plugin>
        </plugins>
    </build>

</project>

Etapa 3: escrever o código

O código a seguir mostra a classe App criada pelo Maven. O método main é o ponto de entrada no aplicativo, que cria uma instância da classe Handler e, em seguida, chama seu método sendRequest.

package org.example;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class App {
    private static final Logger logger = LoggerFactory.getLogger(App.class);

    public static void main(String... args) {
        logger.info("Application starts");

        Handler handler = new Handler();
        handler.sendRequest();

        logger.info("Application ends");
    }
}

A classe DependencyFactory criada pelo Maven contém o método de fábrica s3Client, que cria e exibe uma instância do S3Client. A S3Client instância usa uma instância do cliente baseado em ApacheHTTP. Isso ocorre porque você especificou apache-client quando o Maven solicitou qual HTTP cliente usar.

O DependencyFactory pode ser visto no código a seguir.

package org.example;

import software.amazon.awssdk.http.apache.ApacheHttpClient;
import software.amazon.awssdk.services.s3.S3Client;

/**
 * The module containing all dependencies required by the {@link Handler}.
 */
public class DependencyFactory {

    private DependencyFactory() {}

    /**
     * @return an instance of S3Client
     */
    public static S3Client s3Client() {
        return S3Client.builder()
                       .httpClientBuilder(ApacheHttpClient.builder())
                       .build();
    }
}

A classe Handler contém a lógica principal do seu programa. Quando uma instância de Handler é criada na classe App, a classe DependencyFactory fornece o cliente de serviço do S3Client. Seu código usa a instância do S3Client para chamar o serviço do Amazon S3.

O Maven gera a seguinte classe Handler com um comentário TODO. A próxima etapa do tutorial substitui o TODO pelo código.

package org.example;

import software.amazon.awssdk.services.s3.S3Client;


public class Handler {
    private final S3Client s3Client;

    public Handler() {
        s3Client = DependencyFactory.s3Client();
    }

    public void sendRequest() {
        // TODO: invoking the api calls using s3Client.
    }
}

Para preencher a lógica, substitua todo o conteúdo da classe Handler pelo código a seguir. O método sendRequest é preenchido e as importações necessárias são adicionadas.

Primeiro, o código cria um novo bucket do S3 com a última parte do nome gerada usando System.currentTimeMillis() para tornar o nome do bucket exclusivo.

Depois de criar o bucket no método createBucket(), o programa carrega um objeto usando o método putObject deS3Client. O conteúdo do objeto é uma string simples criada com o método RequestBody.fromString.

Por fim, o programa exclui o objeto seguido pelo bucket no método cleanUp.

package org.example;

import software.amazon.awssdk.core.sync.RequestBody;
import software.amazon.awssdk.services.s3.S3Client;
import software.amazon.awssdk.services.s3.model.CreateBucketRequest;
import software.amazon.awssdk.services.s3.model.DeleteBucketRequest;
import software.amazon.awssdk.services.s3.model.DeleteObjectRequest;
import software.amazon.awssdk.services.s3.model.HeadBucketRequest;
import software.amazon.awssdk.services.s3.model.PutObjectRequest;
import software.amazon.awssdk.services.s3.model.S3Exception;


public class Handler {
    private final S3Client s3Client;

    public Handler() {
        s3Client = DependencyFactory.s3Client();
    }

    public void sendRequest() {
        String bucket = "bucket" + System.currentTimeMillis();
        String key = "key";

        createBucket(s3Client, bucket);

        System.out.println("Uploading object...");

        s3Client.putObject(PutObjectRequest.builder().bucket(bucket).key(key)
                        .build(),
                RequestBody.fromString("Testing with the {sdk-java}"));

        System.out.println("Upload complete");
        System.out.printf("%n");

        cleanUp(s3Client, bucket, key);

        System.out.println("Closing the connection to {S3}");
        s3Client.close();
        System.out.println("Connection closed");
        System.out.println("Exiting...");
    }

    public static void createBucket(S3Client s3Client, String bucketName) {
        try {
            s3Client.createBucket(CreateBucketRequest
                    .builder()
                    .bucket(bucketName)
                    .build());
            System.out.println("Creating bucket: " + bucketName);
            s3Client.waiter().waitUntilBucketExists(HeadBucketRequest.builder()
                    .bucket(bucketName)
                    .build());
            System.out.println(bucketName + " is ready.");
            System.out.printf("%n");
        } catch (S3Exception e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
    }

    public static void cleanUp(S3Client s3Client, String bucketName, String keyName) {
        System.out.println("Cleaning up...");
        try {
            System.out.println("Deleting object: " + keyName);
            DeleteObjectRequest deleteObjectRequest = DeleteObjectRequest.builder().bucket(bucketName).key(keyName).build();
            s3Client.deleteObject(deleteObjectRequest);
            System.out.println(keyName + " has been deleted.");
            System.out.println("Deleting bucket: " + bucketName);
            DeleteBucketRequest deleteBucketRequest = DeleteBucketRequest.builder().bucket(bucketName).build();
            s3Client.deleteBucket(deleteBucketRequest);
            System.out.println(bucketName + " has been deleted.");
            System.out.printf("%n");
        } catch (S3Exception e) {
            System.err.println(e.awsErrorDetails().errorMessage());
            System.exit(1);
        }
        System.out.println("Cleanup complete");
        System.out.printf("%n");
    }
}

Etapa 4: compilar e executar o aplicativo

Depois que o projeto for criado e contiver a classe Handler completa, crie e execute o aplicativo.

  1. Verifique se você tem uma sessão ativa do IAM Identity Center. Para fazer isso, execute o comando aws sts get-caller-identity da AWS Command Line Interface e verifique a resposta. Se você ainda não tiver uma sessão ativa, consulte esta seção para obter as instruções.

  2. Abra uma janela de terminal ou prompt de comando e navegue até o diretório getstarted do seu projeto.

  3. Use o comando a seguir para compilar seu projeto:

    mvn clean package

  4. Use o comando a seguir para executar o aplicativo.

    mvn exec:java -Dexec.mainClass="org.example.App"

Para visualizar o novo bucket e objeto que o programa cria, execute as etapas a seguir.

  1. Em Handler.java, comente a linha cleanUp(s3Client, bucket, key) no método sendRequest e salve o arquivo.

  2. Reconstrua o projeto executando mvn clean package.

  3. Execute mvn exec:java -Dexec.mainClass="org.example.App" novamente para carregar o objeto de texto mais uma vez.

  4. Faça login no console do S3 para ver o novo objeto no bucket recém-criado.

Depois de visualizar o arquivo, exclua o objeto e, em seguida, exclua o bucket.

Bem-sucedida

Se seu projeto Maven foi criado e executado sem erros, parabéns! Você construiu com sucesso seu primeiro aplicativo Java usando o SDK for Java 2.x.

Limpeza

Para limpar os recursos que foram criados durante este tutorial, faça o seguinte:

  • Se você ainda não tiver feito isso, no console do S3, exclua todos os objetos e buckets criados quando você executou o aplicativo.

  • Exclua a pasta do projeto (getstarted).

Próximas etapas

Agora que você entendeu o básico, poderá descobrir mais sobre o seguinte: