Fase 1: prepararsi per il tutorial Fase 2: creare il progetto Fase 3: scrivere il codice Fase 4: creare ed eseguire l’applicazione Fasi successive

Creazione di una semplice applicazione utilizzando AWS SDK for Java 2.x

Questo tutorial mostra come utilizzare Apache Maven per definire le dipendenze per l'SDK for Java 2.x e quindi scrivere codice che si connette a per caricare un file. Amazon S3

Segui questi passaggi per completare questo tutorial:

Fase 1: Configurazione per questo tutorial
Fase 2: Creare il progetto
Fase 3: Scrivere il codice
Fase 4: Compilare ed eseguire l'applicazione

Fase 1: prepararsi per il tutorial

Prima di iniziare questo tutorial, servirà quanto segue:

Autorizzazione all'accesso Amazon S3
Un ambiente di sviluppo Java configurato per accedere Servizi AWS tramite Single Sign-On a AWS IAM Identity Center

Usa le istruzioni riportate in questa guida Panoramica della configurazione per prepararti a questo tutorial. Dopo aver configurato l'ambiente di sviluppo con l'accesso Single Sign-On per Java SDK e aver avuto una sessione attiva sul portale di AWS accesso, continua con la Fase 2 di questo tutorial.

Fase 2: creare il progetto

Per creare il progetto per questo tutorial, si esegue un comando Maven che richiede input su come configurare il progetto. Dopo aver inserito e confermato tutti gli input, Maven completa la creazione del progetto creando un pom.xml file Java stub.

Apri un terminale o una finestra del prompt dei comandi e accedi a una directory a tua scelta, ad esempio il Desktop o la cartella Home.

Immettete il seguente comando nel terminale e premete. Enter


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

Immettete il valore elencato nella seconda colonna per ogni prompt.

Prompt	Valore da immettere
`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>`

Dopo aver inserito l'ultimo valore, Maven elenca le scelte effettuate. Conferma inserendo Yo reinserisci i valori inserendo. N

Maven crea la cartella di progetto denominata getstarted in base al artifactId valore inserito. All'interno della getstarted cartella, trova un README.md file che puoi rivedere, un pom.xml file e una src directory.

Maven crea la seguente struttura di cartelle.


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

Di seguito viene mostrato il contenuto del file di progetto pom.xml.

La dependencyManagement sezione contiene una dipendenza da AWS SDK for Java 2.x e la dependencies sezione ha una dipendenza per Amazon S3. Il progetto utilizza Java 1.8 a causa del valore 1.8 delle proprietà 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>

Fase 3: scrivere il codice

Il codice seguente mostra la App classe creata da Maven. Il metodo main è il punto di ingresso nell’applicazione, che crea un’istanza della classe Handler e quindi ne richiama il metodo 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 DependencyFactory classe creata da Maven contiene il metodo s3Client factory che crea e restituisce un'istanza. S3Client L’istanza S3Client utilizza un’istanza del client HTTP basato su Apache. Questo avviene perché si specifica apache-client quando Maven chiede quale client HTTP usare.

DependencyFactoryÈ mostrato nel codice seguente.


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 classe Handler contiene la logica principale del programma. Quando viene creata un’istanza di Handler nella classe App, DependencyFactory fornisce il servizio client S3Client. Il codice utilizza l'S3Clientistanza per chiamare il servizio Amazon S3.

Maven genera la seguente classe Handler con un commento TODO. Il passaggio successivo del tutorial sostituisce il codice TODOwith.


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.
    }
}

Per compilare la logica, sostituisci l’intero contenuto della classe Handler con il codice seguente. Il metodo sendRequest viene compilato e vengono aggiunte le importazioni necessarie.

Il codice crea innanzitutto un nuovo bucket S3 con l'ultima parte del nome generata utilizzando per rendere System.currentTimeMillis() unico il nome del bucket.

Dopo aver creato il bucket nel createBucket() metodo, il programma carica un oggetto utilizzando il metodo di. putObjectS3Client Il contenuto dell'oggetto è una semplice stringa creata con il RequestBody.fromString metodo.

Infine, il programma elimina l'oggetto seguito dal bucket nel cleanUp metodo.


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

Fase 4: creare ed eseguire l’applicazione

Dopo che il progetto è stato creato e contiene la Handler classe completa, create ed eseguite l'applicazione.

Assicurati di avere una sessione IAM Identity Center attiva. Per farlo, esegui il AWS Command Line Interface comando aws sts get-caller-identity e controlla la risposta. Se non hai una sessione attiva, consulta questa sezione per le istruzioni.
Apri un terminale o una finestra del prompt dei comandi e vai alla directory del progetto getstarted.
Usa il seguente comando per creare il tuo progetto:
```
mvn clean package
```
Utilizzate il seguente comando per eseguire l'applicazione.
```
mvn exec:java -Dexec.mainClass="org.example.App"
```

Per visualizzare il nuovo bucket e l'oggetto creati dal programma, effettuate le seguenti operazioni.

InHandler.java, commenta la riga cleanUp(s3Client, bucket, key) del sendRequest metodo e salva il file.
Ricostruisci il progetto mvn clean package eseguendo.
Esegui nuovamente mvn exec:java -Dexec.mainClass="org.example.App" per caricare l'oggetto di testo ancora una volta.
Accedi alla console S3 per visualizzare il nuovo oggetto nel bucket appena creato.

Dopo aver visualizzato il file, elimina l’oggetto e quindi elimina il bucket.

Completato

Se il progetto Maven è stato creato ed eseguito senza errori, congratulazioni! Hai creato con successo la tua prima applicazione Java utilizzando l'SDK for Java 2.x.

Pulizia

Per ripulire le risorse create durante questo tutorial, procedi come segue:

Se non l'hai già fatto, nella console S3, elimina tutti gli oggetti e i bucket creati durante l'esecuzione dell'applicazione.
Elimina la cartella del progetto ()getstarted.

Fasi successive

Ora che hai le nozioni di base, puoi scoprire quanto segue:

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Autenticazione con AWS

Configurazione dei client di servizio