Contrôle des processus avec Apex pour file d'attente

• Quand utiliser l’interface Queueable
• Les différences entre les méthodes pour file d’attente et futures
• La syntaxe d’un Apex pour file d’attente
• Les meilleures pratiques d’utilisation de méthodes pour file d’attente

Remarque

Vous souhaitez apprendre en français ? Dans ce badge, les validations de défi pratique Trailhead se font en anglais. Les traductions sont fournies entre parenthèses à titre de référence. Dans votre Trailhead Playground, veillez (1) à définir les États-Unis comme région, (2) à sélectionner l’anglais comme langue, et (3) à copier et coller uniquement les valeurs en anglais. Suivez les instructions ici.

Consultez le badge Trailhead dans votre langue pour découvrir comment profiter de l’expérience Trailhead traduite.

• Types non primitifs : votre classe Queueable peut contenir des variables membres de types de données non primitifs, tels que des sObjects ou des types Apex personnalisés. Ces objets peuvent être accédés lors de l’exécution de la tâche.
• Surveillance : lorsque vous soumettez votre tâche en invoquant la méthode System.enqueueJob(), la méthode renvoie l’ID de l’enregistrement AsyncApexJob. Vous pouvez utiliser cet ID pour identifier votre tâche et surveiller sa progression, soit sur la page Tâches Apex de l’interface utilisateur de Salesforce, soit par programmation en interrogeant votre enregistrement dans AsyncApexJob.
• Chaînage des tâches : vous pouvez chaîner une tâche à une autre en commençant la deuxième tâche à partir d’une tâche en cours d’exécution. Le chaînage des tâches est utile pour un traitement séquentiel.

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

Exemple de code

Un scénario courant consiste à sélectionner une série d’enregistrements sObject, d’exécuter un traitement, par exemple un appel externe à un point de terminaison REST externe ou des calculs, puis de mettre les enregistrements à jour de façon asynchrone dans la base de données. Les méthodes @future étant limitées à des types de données primitifs (groupes ou collections de primitifs), un code Apex pour file d’attente est le choix idéal. Le code ci-dessous utilise une série d’enregistrements Compte, définit le parentId de chaque enregistrement, puis met à jour les enregistrements dans la base de données.

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

Pour ajouter cette classe à une tâche dans la file d’attente, exécutez le code suivant :

// 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);

Une fois votre classe pour file d’attente soumise pour exécution, la tâche est ajoutée à la file d’attente et traitée dès que les ressources système sont disponibles.

Vous pouvez utiliser le nouvel ID de la tâche pour surveiller sa progression, soit sur la page Tâches Apex, soit par programmation en interrogeant 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());
    }
}

• L’exécution d’une tâche pour file d’attente est prise en compte dans la limitation partagée d’exécution de méthodes Apex asynchrones.
• Vous pouvez ajouter jusqu’à 50 tâches à la file d’attente avec System.enqueueJob dans une seule transaction.
• Lors du chaînage de tâches, vous pouvez ajouter une seule tâche à partir d’une tâche en cours d’exécution avec System.enqueueJob, ce qui signifie qu’une seule tâche enfant peut exister pour chaque tâche pour file d’attente parente. Vous ne pouvez pas démarrer plusieurs tâches enfants à partir de la même tâche pour file d’attente.
• La profondeur du chaînage des tâches est illimitée, ce qui signifie que vous pouvez chaîner une tâche à une autre et répéter ce processus en chaînant chaque tâche enfant successive à une nouvelle tâche enfant. Cependant, pour des organisations Developer Edition et d’évaluation, la profondeur maximale de la pile est de 5 pour les tâches chaînées. Cela signifie que vous pouvez chaîner des tâches quatre fois et que le nombre maximal de tâches dans la chaîne est de 5, qui comprend la tâche pour file d’attente parente initiale.

• Guide du développeur Apex : Apex pour file d'attente