Paso 1: Configuración para este tutorial Paso 2: Crear el proyecto Paso 3: Escribir el código Paso 4: Compilar y ejecutar la aplicación Siguientes pasos

Introducción al AWS SDK for Java 2.x

El AWS SDK for Java 2.x proporciona la API de Java para Amazon Web Services (AWS). Con el SDK, le resultará fácil crear aplicaciones Java que funcionen con Amazon S3, Amazon EC2, DynamoDB y otras.

En este tutorial, se muestra cómo usar Apache Maven para definir las dependencias del SDK para Java 2.x y, a continuación, escribir el código al que se conecta Amazon S3 para cargar un archivo.

Para completar el tutorial, siga estos pasos:

Paso 1: Configuración para este tutorial
Paso 2: Crear el proyecto
Paso 3: Escribir el código
Paso 4: Compilar y ejecutar la aplicación

Paso 1: Configuración para este tutorial

Antes de empezar este tutorial, necesitará:

Permiso de acceso a Amazon S3
Un entorno de desarrollo de Java que está configurado para acceder a los Servicios de AWS mediante un inicio de sesión único a AWS IAM Identity Center

Use las instrucciones de Descripción general de la configuración para configurar para este tutorial. Cuando haya configurado su entorno de desarrollo con acceso de inicio de sesión único para el SDK de Java y tenga una sesión activa en el portal de acceso a AWS, continúe con el paso 2 de este tutorial.

Paso 2: Crear el proyecto

Para crear el proyecto de este tutorial, ejecute un comando de Maven que le pida información sobre cómo configurar el proyecto. Una vez introducidas y confirmadas todas las entradas, Maven termina de construir el proyecto creando un archivo pom.xml y archivos stub de Java.

Abra una ventana de terminal o línea de comandos y acceda a un directorio de su elección, como su carpeta Desktop o Home.

Introduzca el siguiente comando en el terminal y pulse Enter.


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

Introduzca el valor que aparece en la segunda columna para cada pregunta.

Prompt	Valor para introducir
`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>`

Después de introducir el último valor, Maven muestra una lista de sus elecciones. Confirme introduciendo Y o vuelva a introducir los valores respondiendo con N

Maven crea la carpeta del proyecto llamada getstarted basándose en el valor artifactId que haya introducido. En la carpeta getstarted, busque un archivo README.md que pueda revisar, un archivo pom.xml y un directorio src.

Maven crea el árbol de directorios siguiente.


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

A continuación se muestra el contenido del archivo de proyecto pom.xml.

La sección dependencyManagement contiene una dependencia con el AWS SDK for Java 2.x y la sección dependencies una dependencia para Amazon S3. El proyecto usa Java 1.8 debido al valor 1.8 de las maven.compiler.target propiedades maven.compiler.source.


<?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.20.43</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>

Paso 3: Escribir el código

En el código siguiente se muestra la clase App creada por Maven. El método main es el punto de entrada a la aplicación, que crea una instancia de la Handler clase y, a continuación, llama a su 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");
    }
}

La clase DependencyFactory creada por Maven contiene el método de fábrica s3Client que crea y devuelve una instancia de S3Client. La instancia S3Client usa una instancia del cliente HTTP basado en Apache. Esto se debe a que especificó apache-client cuando Maven preguntó qué cliente HTTP usar.

La DependencyFactory muestra en el siguiente código.


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();
    }
}

La clase Handler contiene la lógica principal del programa. Cuando se crea una instancia de Handler en la clase App, DependencyFactory proporciona el cliente de servicios S3Client. El código utiliza la instancia de S3Client para llamar al servicio Amazon S3.

Maven genera la siguiente clase Handler con un comentario TODO. El siguiente paso del tutorial reemplaza el TODO por 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 completar la lógica, reemplace todo el contenido de la clase Handler por el código siguiente. El método sendRequest se rellena y se añaden las importaciones necesarias.

En primer lugar, el código crea un nuevo bucket de S3 con la última parte del nombre generado utilizando System.currentTimeMillis() para que el nombre del depósito sea único.

Tras crear el bucket en el método createBucket(), el programa carga un objeto mediante el método putObject de S3Client. El contenido del objeto es una cadena simple creada con el método RequestBody.fromString.

Por último, el programa elimina el objeto seguido del bucket del 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");
    }
}

Paso 4: Compilar y ejecutar la aplicación

Una vez creado el proyecto y que contenga la clase Handler completa, compile y ejecute la aplicación.

Asegúrese de que tiene una sesión activa del Centro de identidades de IAM. Para ello, ejecute el comando aws sts get-caller-identity de la AWS Command Line Interface y compruebe la respuesta. Si no tiene una sesión activa, consulte esta sección para obtener instrucciones.
Abra una ventana de terminal o símbolo del sistema y desplácese hasta el directorio del proyecto getstarted.
Para compilar su proyecto, utilice el comando siguiente:
```
mvn clean package
```
Para ejecutar la aplicación, utilice el comando siguiente.
```
mvn exec:java -Dexec.mainClass="org.example.App"
```

Para ver el bucket y el objeto nuevos creados por el programa, siga los pasos descritos a continuación.

En Handler.java, comente la línea cleanUp(s3Client, bucket, key) del método sendRequest y guarde el archivo.
Recompile el proyecto ejecutando mvn clean package.
Vuelva a ejecutar mvn exec:java -Dexec.mainClass="org.example.App" para cargar el objeto de texto una vez más.
Inicie sesión en la consola de S3 para ver el nuevo objeto en el bucket recién creado.

Después de ver el archivo, elimine el objeto y, a continuación, elimine el bucket.

Success

Si su proyecto de Maven se creó y ejecutó sin errores, ¡enhorabuena! Ha creado correctamente su primera aplicación Java mediante SDK para Java 2.x.

Limpieza

Para limpiar los recursos que ha creado en este tutorial, haga lo siguiente:

Si aún no lo ha hecho, en la consola de S3, elimine todos los objetos y buckets creados al ejecutar la aplicación.
Elimine la carpeta del proyecto (getstarted).

Siguientes pasos

Ahora que ya ha aprendido lo básico, puede aprender lo siguiente:

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Guía para desarrolladores. AWS SDK for Java 2.x

Configuración