Controlar procesos mediante Apex para inclusión en cola

• Cuándo usar la interfaz Queueable.
• Diferencias entre métodos de inclusión en cola y métodos futuros.
• Sintaxis de Apex para inclusión en cola.
• Mejores prácticas para métodos de inclusión en cola.

Nota

El reto práctico para esta insignia está localizado al japonés, español (LATAM) y portugués (Brasil). Para cambiar el idioma de su Trailhead Playground, siga estas instrucciones. Puede que la localización esté desactualizada. Si no aprueba el reto con las instrucciones localizadas, cambie el idioma a inglés y la configuración local a Estados Unidos, y vuelva a intentarlo.

Consulte la insignia Trailhead en su idioma para obtener más información sobre cómo aprovechar la experiencia de Trailhead en otros idiomas.

• Tipos no primitivos: La clase Queueable puede contener variables de miembro de tipos de datos no primitivos, como sObjects o tipos de Apex personalizados. A estos objetos se puede acceder cuando se ejecuta el trabajo.
• Monitoreo: Cuando envía su trabajo mediante la invocación del método System.enqueueJob(), el método devuelve el Id. del registro AsyncApexJob. Puede usar este Id. para identificar su trabajo y monitorear el progreso, ya sea mediante la interfaz de usuario de Salesforce en la página Trabajos de Apex o mediante programación con una consulta al registro desde AsyncApexJob.
• Encadenamiento de trabajos: Puede encadenar un trabajo con otro trabajo mediante el inicio de un segundo trabajo desde un trabajo en ejecución. El encadenamiento de trabajos es útil si necesita realizar un procesamiento secuencial.

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

Código de ejemplo

Un caso común es el uso de un conjunto de registros de sObject, la ejecución de parte del procesamiento, como una llamada a un extremo de REST externo o la realización de determinados cálculos, y la actualización posterior en la base de datos de forma asíncrona. Dado que los métodos @future se limitan a tipos de datos primitivos (o matrices o recopilaciones de primitivos), en este caso Apex para inclusión en cola es una opción ideal. En el siguiente código se usa una recopilación de registros de cuenta, se establece parentId para cada registro y, a continuación, se actualizan los registros en la base de datos.

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

Para agregar esta clase a un trabajo de la cola, ejecute el siguiente código:

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

Después de enviar la clase de inclusión en cola para la ejecución, el trabajo se agrega a la cola y se procesa cuando los recursos del sistema están disponibles.

Puede usar el nuevo Id. del trabajo para monitorear el progreso, bien en la página Trabajos de Apex o mediante programación con un consulta a 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());
    }
}

• La ejecución de un trabajo en cola solo cuenta una vez en el caso del límite compartido para ejecuciones de métodos de Apex de forma asíncrona.
• Puede agregar hasta 50 trabajos a la cola con System.enqueueJob mediante una sola transacción.
• Al encadenar trabajos, solo puede agregar un único trabajo desde un trabajo en ejecución con System.enqueueJob, lo que significa que solo puede existir un trabajo secundario para cada trabajo principal. El inicio de varios trabajos secundarios desde el mismo trabajo apto para la inclusión en cola no es aceptable.
• No se aplica ningún límite a la profundidad de los trabajos encadenados, lo que significa que puede encadenar un trabajo con otro trabajo y repetir este proceso con cada nuevo trabajo secundario que se vaya a vincular a un nuevo trabajo secundario. No obstante, en el caso de las organizaciones con Developer Edition y una edición de prueba, la profundidad de la pila máxima para los trabajos encadenados equivale a 5, lo que significa que puede encadenar trabajos cuatro veces y que el número máximo de trabajos de la cadena es 5, incluido el trabajo principal apto para inclusión en cola inicial.

• Guía del desarrollador de Apex: Apex para inclusión en cola