Inizia con la versione AWS SDK for Java 2.x - AWS SDK for Java 2.x
Fase 1: Configurazione per questo tutorialFase 2: Creare il progettoPassaggio 3: scrivere il codiceFase 4: Compilare ed eseguire l'applicazionePassaggi successivi

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Inizia con la versione AWS SDK for Java 2.x

AWS SDK for Java 2.x Fornisce Java APIs per Amazon Web Services (AWS). UtilizzandoSDK, è possibile creare applicazioni Java che funzionano con Amazon S3, Amazon EC2 DynamoDB, e altro ancora.

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

Segui questi passaggi per completare questo tutorial:

Fase 1: Configurazione per questo tutorial

Prima di iniziare questo tutorial, è necessario 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, esegui 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.

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

  2. Immettete il seguente comando nel terminale e Enter premete.

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

  3. Immettete il valore elencato nella seconda colonna per ogni prompt.

    Prompt Valore da inserire
    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. 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 il seguente albero 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

Quanto segue mostra 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 1.8 valore delle maven.compiler.source proprietà and. 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>

Passaggio 3: scrivere il codice

Il codice seguente mostra la App classe creata da Maven. Il main metodo è il punto di ingresso nell'applicazione, che crea un'istanza della Handler classe e quindi ne sendRequest chiama il metodo.

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'S3Clientistanza utilizza un'istanza del client basato su Apache. HTTP Questo perché hai specificato apache-client quando Maven ti ha chiesto quale client usare. HTTP

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

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

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 Handler classe con il codice seguente. Il sendRequest metodo viene compilato e vengono aggiunte le importazioni necessarie.

Il codice crea innanzitutto un nuovo bucket S3 con l'ultima parte del nome generata utilizzando System.currentTimeMillis() per rendere 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: Compilare ed eseguire l'applicazione

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

  1. Assicurati di avere una sessione attiva di IAM Identity Center. A tale scopo, 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.

  2. Apri un terminale o una finestra del prompt dei comandi e accedi alla directory getstarted del progetto.

  3. Usa il seguente comando per creare il tuo progetto:

    mvn clean package

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

  1. InHandler.java, commenta la riga cleanUp(s3Client, bucket, key) del sendRequest metodo e salva il file.

  2. Ricostruisci il progetto mvn clean package eseguendo.

  3. Esegui nuovamente mvn exec:java -Dexec.mainClass="org.example.App" per caricare l'oggetto di testo ancora una volta.

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

Riuscito

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

Rimozione

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.

Passaggi successivi

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