Version AWS SDK for Java 1.x wurde am 31. Juli 2024 in den Wartungsmodus versetzt und wird end-of-supportam 31. Dezember 2025 verfügbar sein. 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 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 for Java bietet zwei Möglichkeiten: Zukünftige Objekte und Callback-Methoden.

Java-Futures

Asynchrone Methoden AWS SDK for Java geben ein Future-Objekt zurück, das die Ergebnisse der asynchronen Operation in der future 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 eine asynchrone Operation, die eine Lambda Funktion aufruft und eine empfängt, Future die ein Objekt enthalten 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

Neben der Verwendung des Future Java-Objekts zur Überwachung des Status asynchroner Anfragen können Sie damit SDK auch eine Klasse implementieren, die die Schnittstelle verwendet. AsyncHandler AsyncHandlerbietet zwei Methoden, die je nachdem, wie die Anfrage abgeschlossen wurde, aufgerufen werden: onSuccess undonError.

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 mit der nächsten Aktivität beginnen und sich darauf verlassen, SDK dass der Ihren Handler zur richtigen Zeit aufruft.

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. Der kurze, schnell ausgeführte Code sollte am besten in der AsyncHandler-Implementierung eingefügt werden. Der lange ausgeführte oder blockierende Code in Handler-Methoden kann zu Konkurrenzsituationen für den Threadpool, der vom asynchronen Client verwendet wird, und kann den Client daran hindern, Anforderungen 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 for Java stellen einen Standard-Thread-Pool bereit, der für die meisten Anwendungen funktionieren sollte. Sie können einen benutzerdefinierten Code implementieren ExecutorServiceund ihn an AWS SDK for Java asynchrone Clients übergeben, um mehr Kontrolle darüber zu haben, wie die Thread-Pools verwaltet werden.

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

Asynchroner Zugriff

Die TransferManagerKlasse in der 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.