Salesforce Queueable Apex is an asynchronous process that runs long processes efficiently in the background. Sometimes, we need to execute another queueable job on completion of the first job for handling business requests. This is called queueable chanining. This post will explain queueable chaining and how to implement it in Salesforce Apex.
We can also handle job chaining using Salesforce Batch and Schedule Apex. For this post, we will use a Queueable Apex job.
What is Queueable Chaining in Salesforce?
Queueable Chaining is the process of executing a sequence of Salesforce queuable apex jobs, where one job enqueues another job after it completes execution. This allows sequential, asynchronous processing of tasks in Salesforce.
Use Case for Queueable Chaining
Medstore, a pharma company, sells medical products online. It needs order processing within the Salesforce system. It should validate orders, process payments, generate invoices, and then update inventory.
Solution
We can handle the above business request using queueable apex chaining. Below are two solutions for handling queueable apex
- Strong Coupled Solution
- Loose Coupled Solution
In this post, we will explore a strongly coupled solution, and in another post, we will solve the above business requirement using the loose-coupled solution.
Strong Coupled Solution
In a strongly coupled solution, we place the next job name in the current job’s apex. As we put the next job in the current job itself, both apex jobs are tightly coupled. So we can not change the next job at runtime.
Below are apex classes to handle business requests using strongly coupled architecture.
ValidationQueueable:
This queueble apex will validate orders and customer information for order processing. Once the order queueable logic is finished, it will put the PaymentQueueable job in the queue.
public class ValidationQueueable implements Queueable {
OrderRequest request;
public ValidationQueueable(OrderRequest reqst)
{
request=reqst;
}
public void execute(QueueableContext context) {
System.debug('ValidationQueueable Called with params:'+ request);
//Put all Validation Logic here
//....
// At the end start PaymentQueueable Job
System.enqueueJob(new PaymentQueueable(request));
}
}
PaymentQueueable
PaymentQueueable class will handle payment-related logic for order processing. It might be a new payment system addition or an existing wallet/card payment; it will handle all the business logic. Once all payment information is finished, we can add the next apex job, InvoiceQueueable in the queue.
public class PaymentQueueable implements Queueable {
OrderRequest request;
public PaymentQueueable(OrderRequest reqst)
{
request=reqst;
}
public void execute(QueueableContext context) {
System.debug('PaymentQueueable Called with params:'+ request);
//Put all Payment Related Logic here
//....
// At the end start InvoiceQueueable
System.enqueueJob(new InvoiceQueueable(request));
}
}
InvoiceQueueable
InvoiceQueueable will handle business logic related to invoicing. All document processing can be handled in this queueable. Once we finish invoicing logic, we can put InventoryQueueable apex in queue for execution.
public class InvoiceQueueable implements Queueable {
OrderRequest request;
public InvoiceQueueable(OrderRequest reqst)
{
request=reqst;
}
public void execute(QueueableContext context) {
System.debug('InvoiceQueueable Called with params:'+ request);
//Put all Invoicing Related Logic here
//....
// At the end start InvoiceQueueable
System.enqueueJob(new InventoryQueueable(request));
}
}
InventoryQueueable
InventoryQueueable apex jobs will handle inventory-related logic, like updating product inventory in the warehouse. If inventory goes beyond the minimum threshold, then it will send an email to the warehouse manager about the inventory.
public class InventoryQueueable implements Queueable {
OrderRequest request;
public InventoryQueueable(OrderRequest reqst)
{
request=reqst;
}
public void execute(QueueableContext context) {
System.debug('InventoryQueueable Called with params:'+ request);
//Put all Inventory Related Logic here
//....
}
}
OrderRequest wrapper class has parameters that will be used to pass information to all queueable classes. These parameters will be passed from the first queueable class (ValidationQueueable).
public class OrderRequest {
public string customerId;
public string paymentId;
public string orderId;
}
To run the first queueable class, we can add a scheduler apex or invocable method. If we want to execute it from any user interface (LWC or Aura), then we can add controller class. To execute it from flow, we can add an invocable method. To run from developer console, execute below code
System.enqueueJob(new ValidationQueueable(null));
Benefits of this solution
This solution is easy to implement, and even a new developer with little experience can handle it with guidance.
Disadvantage of this solution
This solution is tightly coupled, so if we need to remove or add a new queueable in the queue, then we have to change the code. We also have to test both queueable jobs; we even need to change a single queueable job.
Similar Posts
- Avoid Batch Apex and Use Queueable Class
- Transaction Finalizers for Salesforce Queueable Job
- Enhancing Performance with File Compression in Apex
- How to Correctly Publish Platform Event Using Salesforce Apex
- How to Manage Technical Debt in Salesforce
- How to Elevate Your Career to Salesforce Architect
- Handle Heap Size for Apex Code Optimization
- Implementing Apex Cursors for Optimal Resource Management in Salesforce
- Build Scalable Solutions with Salesforce
- Dynamic Code Execution using Callable Interface
- Optimizing Salesforce Apex Code
- Revisit Asynchronous Apex : Type and Usage
- Salesforce Interview Question for Asynchronous Apex
- Top 20 Salesforce Developer Interview Questions
- Queueable Vs Batch Apex In Salesforce
