Schritt 1: Einrichtung für dieses Tutorial Schritt 2: Erstellen des Projekts Schritt 3: Schreiben des Codes Schritt 4: Anwendung erstellen und ausführen Nächste Schritte

Erstellen einer einfachen Anwendung mit dem AWS SDK for Java 2.x

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: Einrichtung für dieses Tutorial

Bevor Sie mit diesem Tutorial beginnen, brauchen 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 des Projekts

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, schließt Maven den Aufbau des Projekts ab, indem es pom.xml Java-Stub-Dateien erstellt und erstellt.

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

Geben Sie den folgenden Befehl am Terminal ein und drücken Sie. Enter


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

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

Prompt	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 mit dem getstarted Namen, den Sie artifactId eingegeben haben. 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

Unten sehen Sie die Inhalte der pom.xml-Projektdatei.

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.source- und maven.compiler.target-Eigenschaften.


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

Schritt 3: Schreiben des Codes

Der folgende Code zeigt die von Maven erstellte App Klasse. Die main-Methode ist der Einstiegspunkt in die Anwendung, die eine Instance 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-Instance verwendet eine Instance des Apache-basierten HTTP-Clients. Dies liegt daran, dass Sie apache-client angegeben haben, 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 eine Instance von Handler in der Klasse App erstellt wird, stellt DependencyFactory den Service-Client für S3Client 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 TODOersetzt den With-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 zu ergänzen, ersetzen Sie den gesamten Inhalt der Klasse Handler durch den folgenden Code: Die Methode sendRequest ist vollständig implementiert, 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: Anwendung erstellen und ausführen

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

Stellen Sie sicher, dass Sie eine aktive IAM Identity Center-Sitzung haben. 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 ein Befehlszeilenfenster und navigieren Sie zu Ihrem Projektverzeichnis getstarted.
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 die Datei angezeigt 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 für 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

Authentifizierung mit AWS

Konfiguration von Service-Clients