Steuern von Prozessen mit Queueable Apex

• Zeitpunkt für die Verwendung der Queueable-Schnittstelle
• Unterschiede zwischen Queueable- und Future-Methoden
• Syntax von Queueable Apex
• Queueable-Methoden – bewährte Vorgehensweisen

Hinweis

Lernen Sie auf Deutsch? In diesem Badge ist für die praktischen Trailhead-Aufgaben Englisch als Bearbeitungssprache festgelegt. Übersetzungen werden zur Referenz in Klammern angegeben. Vergewissern Sie sich, dass Sie in Ihrem Trailhead-Playground (1) das Gebietsschema auf USA und (2) die Sprache auf Englisch festgelegt haben. (3) Verwenden Sie zum Kopieren und Einfügen nur die englischen Werte. Die zugehörigen Anweisungen finden Sie hier.

Weitere Details dazu, wie Sie die übersetzte Trailhead-Umgebung optimal nutzen können, finden Sie unter dem Badge "Trailhead in Ihrer Sprache".

• Nicht primitive Typen: Ihre Queueable-Klasse kann Mitgliedsvariablen mit nicht primitiven Datentypen enthalten, wie etwa sObjects oder benutzerdefinierte Apex-Typen. Auf diese Objekte kann während der Ausführung des Auftrags zugegriffen werden.
• Überwachen: Wenn Sie Ihren Auftrag durch Aufrufen der System.enqueueJob()-Methode senden, gibt die Methode die ID des AsyncApexJob-Datensatzes zurück. Anhand der ID können Sie den Auftrag identifizieren und seinen Fortschritt überwachen, entweder über die Salesforce-Benutzeroberfläche auf der Seite "Apex Jobs (Apex-Aufträge)" oder programmatisch durch Abfrage Ihres Datensatzes aus AsyncApexJob.
• Verketten von Aufträgen: Sie können zwei Aufträge miteinander verketten, indem Sie einen zweiten Auftrag aus einem laufenden Auftrag heraus starten. Das Verketten von Aufträgen ist hilfreich, wenn die Verarbeitung sequenziell durchgeführt werden muss.

@future
static void myFutureMethod(List<String> params) {
    // call synchronous method
    mySyncMethod(params);
}

public class SomeClass implements Queueable {
    public void execute(QueueableContext context) {
        // awesome code here
    }
}

Beispielcode

Ein gängiges Szenario besteht darin, dass man eine Gruppe von sObject-Datensätzen nimmt, einige Verarbeitungsschritte durchführt, wie etwa einen Callout an einen externen REST-Endpunkt oder die Durchführung von Berechnungen, und die Datenbanksätze dann asynchron in der Datenbank aktualisiert. Da @future-Methoden auf primitive Datentypen (oder Arrays bzw. Sammlungen primitiver Datentypen) beschränkt sind, ist Queueable Apex die perfekte Wahl. Der folgende Code nimmt eine Sammlung von Account-Datensätzen, legt die parentId für jeden Datensatz fest und aktualisiert die Datensätze dann in der Datenbank.

public class UpdateParentAccount implements Queueable {
    private List<Account> accounts;
    private ID parent;
    public UpdateParentAccount(List<Account> records, ID id) {
        this.accounts = records;
        this.parent = id;
    }
    public void execute(QueueableContext context) {
        for (Account account : accounts) {
          account.parentId = parent;
          // perform other processing or callout
        }
        update accounts;
    }
}

Führen Sie folgenden Code aus, um diese Klasse als Auftrag zur Warteschlange hinzuzufügen:

// find all accounts in ‘NY’
List<Account> accounts = [select id from account where billingstate = ‘NY’];
// find a specific parent account for all records
Id parentId = [select id from account where name = 'ACME Corp'][0].Id;
// instantiate a new instance of the Queueable class
UpdateParentAccount updateJob = new UpdateParentAccount(accounts, parentId);
// enqueue the job for processing
ID jobID = System.enqueueJob(updateJob);

Nachdem Sie Ihre Queueable-Klasse zwecks Ausführung gesendet haben, wird der Auftrag zur Warteschlange hinzugefügt und verarbeitet, sobald Systemressourcen verfügbar sind.

Anhand der neuen Auftrags-ID können Sie den Fortschritt überwachen, und zwar entweder über die Seite "Apex Jobs (Apex-Aufträge)" oder programmatisch durch Abfragen von AsyncApexJob:

SELECT Id, Status, NumberOfErrors FROM AsyncApexJob WHERE Id = :jobID

@isTest
public class UpdateParentAccountTest {
    @testSetup
    static void setup() {
        List<Account> accounts = new List<Account>();
        // add a parent account
        accounts.add(new Account(name='Parent'));
        // add 100 child accounts
        for (Integer i = 0; i < 100; i++) {
            accounts.add(new Account(
                name='Test Account'+i
            ));
        }
        insert accounts;
    }
    static testmethod void testQueueable() {
        // query for test data to pass to queueable class
        Id parentId = [select id from account where name = 'Parent'][0].Id;
        List<Account> accounts = [select id, name from account where name like 'Test Account%'];
        // Create our Queueable instance
        UpdateParentAccount updater = new UpdateParentAccount(accounts, parentId);
        // startTest/stopTest block to force async processes to run
        Test.startTest();
        System.enqueueJob(updater);
        Test.stopTest();
        // Validate the job ran. Check if record have correct parentId now
        System.assertEquals(100, [select count() from account where parentId = :parentId]);
    }
}

public class FirstJob implements Queueable {
    public void execute(QueueableContext context) {
        // Awesome processing logic here
        // Chain this job to next job by submitting the next job
        System.enqueueJob(new SecondJob());
    }
}

• Die Ausführung eines in der Warteschlange befindlichen Auftrags erfolgt unter Anwendung der gemeinsamen Obergrenze für die asynchrone Ausführung von Apex-Methoden.
• Pro Transaktion können Sie mit System.enqueueJob bis zu 50 Aufträge zur Warteschlange hinzufügen.
• Beim Verketten von Aufträgen können Sie mit System.enqueueJob nur einen Auftrag aus einem laufenden Auftrag hinzufügen, das heißt, es darf zu jedem übergeordneten Queueable-Auftrag nur einen untergeordneten Auftrag geben. Das Starten mehrerer untergeordneter Aufträge vom gleichen Queueable-Auftrag ist ein Tabu.
• Die Verkettungstiefe ist nicht beschränkt, das heißt, dass Sie zwei Aufträge verketten können und diesen Prozess mit jedem neuen untergeordneten Auftrag fortsetzen können, um diese mit einem neuen untergeordneten Auftrag zu verknüpfen. Bei Developer Edition- und Testorganisationen ist die maximale Stapeltiefe für verkettete Aufträge fünf, d. h., ein Auftrag kann nur jeweils vier Mal verkettet werden und es dürfen sich maximal fünf Aufträge in der Kette befinden (der anfänglich übergeordnete Queueable-Auftrag eingeschlossen).

• Apex Developer Guide: Queueable Apex