Schritt 1: Bereiten Sie sich auf dieses Tutorial vor Schritt 2: Erstellen Sie das Projekt Schritt 3: Schreiben Sie den Code Schritt 4: Erstellen Sie die Anwendung und führen Sie sie aus Nächste Schritte

Erste Schritte mit dem AWS SDK for Java 2.x

Die AWS SDK for Java 2.x stellt Java-APIs für Amazon Web Services (AWS) bereit. Mit dem SDK können Sie Java-Anwendungen erstellen, die mit Amazon S3, Amazon EC2 DynamoDB, und mehr funktionieren.

Dieses Tutorial zeigt Ihnen, wie Sie Apache Maven verwenden, um Abhängigkeiten für das SDK for Java 2.x zu definieren und dann Code zu schreiben, der eine Verbindung herstellt, Amazon S3 um eine Datei hochzuladen.

Folgen Sie diesen Schritten, um dieses Tutorial abzuschließen:

Schritt 1: Richten Sie sich für dieses Tutorial ein
Schritt 2: Erstellen Sie das Projekt
Schritt 3: Schreiben Sie den Code
Schritt 4: Erstellen Sie die Anwendung und führen Sie sie aus

Schritt 1: Bereiten Sie sich auf dieses Tutorial vor

Bevor Sie mit diesem Tutorial beginnen, benötigen Sie Folgendes:

Erlaubnis zum Zugriff Amazon S3
Eine Java-Entwicklungsumgebung, die für den Zugriff AWS-Services per Single Sign-On auf die konfiguriert ist AWS IAM Identity Center

Verwenden Sie die Anweisungen unterÜbersicht über die Einrichtung, um sich auf dieses Tutorial vorzubereiten. Nachdem Sie Ihre Entwicklungsumgebung mit Single Sign-On-Zugriff für das Java SDK konfiguriert haben und eine aktive AWS Access-Portal-Sitzung eingerichtet haben, fahren Sie mit Schritt 2 dieses Tutorials fort.

Schritt 2: Erstellen Sie das Projekt

Um das Projekt für dieses Tutorial zu erstellen, führen Sie einen Maven-Befehl aus, der Sie zur Eingabe der Konfiguration des Projekts auffordert. Nachdem alle Eingaben eingegeben und bestätigt wurden, beendet Maven den Aufbau des Projekts durch die Erstellung von Java-Stub-Dateien pom.xml und erstellt diese.

Öffnen Sie ein Terminal oder ein Befehlszeilenfenster und navigieren Sie zu einem Verzeichnis Ihrer Wahl, z. B. Ihrem Ordner Desktop oderHome.

Geben Sie im Terminal den folgenden Befehl ein und drücken SieEnter.


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

Geben Sie für jede Eingabeaufforderung den in der zweiten Spalte aufgeführten Wert ein.

Telefonansage	Einzugebender Wert
`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>`

Nachdem der letzte Wert eingegeben wurde, listet Maven die von Ihnen getroffenen Entscheidungen auf. Bestätigen Sie, indem Sie Werte eingeben, Yoder geben Sie sie erneut ein, indem Sie sie eingeben. N

Maven erstellt den Projektordner, der auf dem von Ihnen artifactId eingegebenen Wert getstarted basiert. Suchen Sie im getstarted Ordner nach einer README.md Datei, die Sie überprüfen können, nach einer pom.xml Datei und einem src Verzeichnis.

Maven erstellt den folgenden Verzeichnisbaum.


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

Im Folgenden wird der Inhalt der pom.xml Projektdatei gezeigt.

Der dependencyManagement Abschnitt enthält eine Abhängigkeit von AWS SDK for Java 2.x und der dependencies Abschnitt hat eine Abhängigkeit von Amazon S3. Das Projekt verwendet Java 1.8 aufgrund des 1.8 Werts in den maven.compiler.target Eigenschaften maven.compiler.source und.


<?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>

Schritt 3: Schreiben Sie den Code

Der folgende Code zeigt die von Maven erstellte App Klasse. Die main Methode ist der Einstiegspunkt in die Anwendung, die eine Instanz der Handler Klasse erstellt und dann ihre sendRequest Methode aufruft.


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

Die von Maven erstellte DependencyFactory Klasse enthält die s3Client Factory-Methode, die eine S3ClientInstanz erstellt und zurückgibt. Die S3Client Instanz verwendet eine Instanz des Apache-basierten HTTP-Clients. Dies liegt daran, dass Sie angegeben habenapache-client, als Maven Sie nach dem zu verwendenden HTTP-Client gefragt hat.

Das DependencyFactory wird im folgenden Code gezeigt.


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

Die Handler Klasse enthält die Hauptlogik Ihres Programms. Wenn in der App Klasse eine Instanz von erstellt Handler wird, stellt DependencyFactory sie den S3Client Service-Client bereit. Ihr Code verwendet die S3Client Instance, um den Amazon S3 S3-Service aufzurufen.

Maven generiert die folgende Handler Klasse mit einem TODO Kommentar. Der nächste Schritt im Tutorial ersetzt den TODOmit Code.


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

Um die Logik auszufüllen, ersetzen Sie den gesamten Inhalt der Handler Klasse durch den folgenden Code. Die sendRequest Methode wird ausgefüllt und die erforderlichen Importe werden hinzugefügt.

Der Code erstellt zunächst einen neuen S3-Bucket, wobei der letzte Teil des Namens generiert wird, um den Bucket-Namen eindeutig zu machen. System.currentTimeMillis()

Nach dem Erstellen des Buckets in der createBucket() Methode lädt das Programm ein Objekt mit der putObjectMethode von S3Client hoch. Der Inhalt des Objekts ist eine einfache Zeichenfolge, die mit der RequestBody.fromString Methode erstellt wurde.

Schließlich löscht das Programm das Objekt, gefolgt vom Bucket in der cleanUp Methode.


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

Schritt 4: Erstellen Sie die Anwendung und führen Sie sie aus

Nachdem das Projekt erstellt wurde und die komplette Handler Klasse enthält, erstellen Sie die Anwendung und führen Sie sie aus.

Stellen Sie sicher, dass Sie über eine aktive IAM Identity Center-Sitzung verfügen. Führen Sie dazu den AWS Command Line Interface Befehl aus aws sts get-caller-identity und überprüfen Sie die Antwort. Wenn Sie keine aktive Sitzung haben, finden Sie in diesem Abschnitt Anweisungen.
Öffnen Sie ein Terminal- oder Befehlszeilenfenster und navigieren Sie zu Ihrem Projektverzeichnisgetstarted.
Verwenden Sie den folgenden Befehl, um Ihr Projekt zu erstellen:
```
mvn clean package
```
Verwenden Sie den folgenden Befehl, um die Anwendung auszuführen.
```
mvn exec:java -Dexec.mainClass="org.example.App"
```

Gehen Sie wie folgt vor, um den neuen Bucket und das neue Objekt anzuzeigen, die das Programm erstellt.

Kommentieren Sie die Zeile cleanUp(s3Client, bucket, key) in der sendRequest Methode aus und speichern Sie die Datei. Handler.java
Erstellen Sie das Projekt neu, indem Sie es ausführenmvn clean package.
Führen Sie mvn exec:java -Dexec.mainClass="org.example.App" den Vorgang erneut aus, um das Textobjekt erneut hochzuladen.
Melden Sie sich bei der S3-Konsole an, um das neue Objekt im neu erstellten Bucket anzuzeigen.

Nachdem Sie sich die Datei angesehen haben, löschen Sie das Objekt und anschließend den Bucket.

Herzlichen Glückwunsch

Wenn Ihr Maven-Projekt ohne Fehler erstellt und ausgeführt wurde, dann herzlichen Glückwunsch! Sie haben erfolgreich Ihre erste Java-Anwendung mit dem SDK for Java 2.x erstellt.

Bereinigen

Gehen Sie wie folgt vor, um die Ressourcen zu bereinigen, die Sie in diesem Tutorial erstellt haben:

Falls Sie dies noch nicht getan haben, löschen Sie in der S3-Konsole alle Objekte und Buckets, die beim Ausführen der Anwendung erstellt wurden.
Löschen Sie den Projektordner (getstarted).

Nächste Schritte

Nachdem Sie sich mit den Grundlagen vertraut gemacht haben, können Sie sich über Folgendes informieren:

Arbeiten mit Amazon S3
Arbeiten mit anderen Datenbankdiensten wie Amazon Web ServicesDynamoDBAmazon EC2, und verschiedenen Datenbankdiensten
Verwenden Sie das SDK
Sicherheit für die AWS SDK for Java

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Entwicklerhandbuch — AWS SDK for Java 2.x

Aufstellen