Der Support für AWS SDK für Java Version 1.x endete am 31. Dezember 2025. Wir empfehlen Ihnen, auf den zu migrieren, AWS SDK for Java 2.x um weiterhin neue Funktionen, Verfügbarkeitsverbesserungen und Sicherheitsupdates zu erhalten.

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Asynchrone Programmierung

Sie können entweder synchrone oder asynchrone Methoden verwenden, um Operationen für Dienste aufzurufen. AWS Synchrone Methoden blockieren die Ausführung Ihres Threads, bis der Client eine Antwort vom Service erhält. Asynchrone Methoden kehren sofort zurück. So haben Sie die Gewissheit, dass die Kontrolle an den aufrufenden Thread zurückgegeben wird, ohne auf eine Antwort zu warten.

Da eine asynchrone Methode zurückmeldet, bevor eine Antwort verfügbar ist, benötigen Sie einen Weg, an die Antwort zu gelangen, sobald diese bereitsteht. Das AWS SDK für Java bietet zwei Möglichkeiten: Future-Objekte und Callback-Methoden.

Java-Futures

Asynchrone Methoden AWS SDK für Java geben ein Future-Objekt zurück, das die Ergebnisse der asynchronen Operation in der Zukunft enthält.

Rufen Sie die Future isDone()-Methode auf, um festzustellen, ob der Service bereits ein Antwortobjekt bereitgestellt hat. Wenn die Antwort bereit ist, können Sie das Antwortobjekt durch Aufrufen der Future get()-Methode erhalten. Mit diesem Mechanismus können Sie regelmäßig eine Abfrage nach den Ergebnissen der asynchronen Operation durchführen, während die Anwendung an anderen Aufgaben arbeitet.

Hier ist ein Beispiel für einen asynchronen Vorgang, der eine Lambda Funktion aufruft und eine empfängt, die ein Future Objekt aufnehmen kann. InvokeResult Das InvokeResult-Objekt wird erst abgerufen, sobald isDone() true ergibt.

import com.amazonaws.services.lambda.AWSLambdaAsyncClient;
import com.amazonaws.services.lambda.model.InvokeRequest;
import com.amazonaws.services.lambda.model.InvokeResult;
import java.nio.ByteBuffer;
import java.util.concurrent.Future;
import java.util.concurrent.ExecutionException;

public class InvokeLambdaFunctionAsync
{
    public static void main(String[] args)
    {
        String function_name = "HelloFunction";
        String function_input = "{\"who\":\"SDK for Java\"}";

        AWSLambdaAsync lambda = AWSLambdaAsyncClientBuilder.defaultClient();
        InvokeRequest req = new InvokeRequest()
            .withFunctionName(function_name)
            .withPayload(ByteBuffer.wrap(function_input.getBytes()));

        Future<InvokeResult> future_res = lambda.invokeAsync(req);

        System.out.print("Waiting for future");
        while (future_res.isDone() == false) {
            System.out.print(".");
            try {
                Thread.sleep(1000);
            }
            catch (InterruptedException e) {
                System.err.println("\nThread.sleep() was interrupted!");
                System.exit(1);
            }
        }

        try {
            InvokeResult res = future_res.get();
            if (res.getStatusCode() == 200) {
                System.out.println("\nLambda function returned:");
                ByteBuffer response_payload = res.getPayload();
                System.out.println(new String(response_payload.array()));
            }
            else {
                System.out.format("Received a non-OK response from {AWS}: %d\n",
                        res.getStatusCode());
            }
        }
        catch (InterruptedException | ExecutionException e) {
            System.err.println(e.getMessage());
            System.exit(1);
        }

        System.exit(0);
    }
}

Asynchrone Callbacks

Das SDK verwendet nicht nur das Future Java-Objekt zur Überwachung des Status asynchroner Anforderungen, sondern ermöglicht Ihnen auch die Implementierung einer Klasse, die die Schnittstelle verwendet. AsyncHandler AsyncHandlerstellt zwei Methoden bereit, die je nachdem, wie die Anfrage abgeschlossen wurde, aufgerufen werden: onSuccess und. onError

Der wichtigste Vorteil der Rückruf-Schnittstelle besteht darin, dass Sie das Future-Objekt nicht mehr regelmäßig abfragen müssen, um zu ermitteln, wann die Anforderung abgeschlossen wurde. Stattdessen kann Ihr Code sofort die nächste Aktivität beginnen und sich auf das SDK verlassen, das für den Aufruf Ihrer Handler zum richtigen Zeitpunkt sorgt.

import com.amazonaws.services.lambda.AWSLambdaAsync;
import com.amazonaws.services.lambda.AWSLambdaAsyncClientBuilder;
import com.amazonaws.services.lambda.model.InvokeRequest;
import com.amazonaws.services.lambda.model.InvokeResult;
import com.amazonaws.handlers.AsyncHandler;
import java.nio.ByteBuffer;
import java.util.concurrent.Future;

public class InvokeLambdaFunctionCallback
{
    private class AsyncLambdaHandler implements AsyncHandler<InvokeRequest, InvokeResult>
    {
        public void onSuccess(InvokeRequest req, InvokeResult res) {
            System.out.println("\nLambda function returned:");
            ByteBuffer response_payload = res.getPayload();
            System.out.println(new String(response_payload.array()));
            System.exit(0);
        }

        public void onError(Exception e) {
            System.out.println(e.getMessage());
            System.exit(1);
        }
    }

    public static void main(String[] args)
    {
        String function_name = "HelloFunction";
        String function_input = "{\"who\":\"SDK for Java\"}";

        AWSLambdaAsync lambda = AWSLambdaAsyncClientBuilder.defaultClient();
        InvokeRequest req = new InvokeRequest()
            .withFunctionName(function_name)
            .withPayload(ByteBuffer.wrap(function_input.getBytes()));

        Future<InvokeResult> future_res = lambda.invokeAsync(req, new AsyncLambdaHandler());

        System.out.print("Waiting for async callback");
        while (!future_res.isDone() && !future_res.isCancelled()) {
            // perform some other tasks...
            try {
                Thread.sleep(1000);
            }
            catch (InterruptedException e) {
                System.err.println("Thread.sleep() was interrupted!");
                System.exit(0);
            }
            System.out.print(".");
        }
    }
}

Bewährte Methoden

Ausführen eines Rückrufs

Ihre Implementierung des AsyncHandler wird in dem Threadpool ausgeführt, der dem asynchronen Client gehört. Kurzer, schnell ausgeführter Code eignet sich am besten für Ihre AsyncHandler Implementierung. Long-running oder das Blockieren von Code in Ihren Handler-Methoden kann zu Konflikten im Thread-Pool führen, der vom asynchronen Client verwendet wird, und den Client daran hindern, Anfragen auszuführen. Wenn Sie eine lang andauernde Aufgabe haben, die mit einem Rückruf gestartet werden soll, lassen Sie den Rückruf die Aufgabe in einem neuen Thread oder in einem Threadpool ausführen, der von Ihrer Anwendung verwaltet wird.

Threadpool-Konfiguration

Die asynchronen Clients im AWS SDK für Java bieten einen Standard-Threadpool, der für die meisten Anwendungen funktionieren sollte. Sie können einen benutzerdefinierten Code implementieren ExecutorService und ihn an AWS SDK für Java asynchrone Clients weitergeben, um mehr Kontrolle über die Verwaltung der Threadpools zu erhalten.

Sie könnten beispielsweise eine ExecutorService Implementierung bereitstellen, die eine benutzerdefinierte Methode verwendet, ThreadFactory um zu steuern, wie Threads im Pool benannt werden, oder um zusätzliche Informationen zur Threadnutzung zu protokollieren.

Asynchroner Zugriff

Die TransferManager Klasse im SDK bietet asynchrone Unterstützung für die Arbeit mit. Amazon S3TransferManagerverwaltet asynchrone Uploads und Downloads, bietet detaillierte Fortschrittsberichte zu Übertragungen und unterstützt Rückrufe bei verschiedenen Ereignissen.