Future method in Salesforce with example

In this blog, we will discuss about the future method in Salesforce with an example. We will also discuss how it’s different from the queueable apex.

It operates in the background asynchronously, running in a separate thread whenever resources are available, and it helps in preventing mixed DML errors.

Use @future annotations to declare a method as the future method. It helps us to run long-running operations and prevents us from hitting the governor limit.

How to use the Future method?

Firstly, we have to annotate the method as @future. It must be static and return void. Only take primitive type parameters like Collection of Ids and an array of primitive datatypes.

Syntax:

global class FutureMethodDemo
{
@future
public static void futureMethod()
{

}
}

To do a callout we have to use one extra parameter i.e. (callout=true) while annotating it.

Syntax:

global class FutureMethodDemo
{
@future(callout=true)
public static void futureMethod()
{

}
}

Want to Learn Salesforce Flows? Checkout our Salesforce Flow Course

Let’s understand the Future method in Salesforce with an example.

Scenario

When the opportunity is updated to closed won, we have to send the mail to its account owner informing them about the opportunity details.

Syntax :

OpportunityTrigger.apxt

trigger OpportunityTrigger on Opportunity (after update) {

if(Trigger.isAfter) {
if(Trigger.isUpdate) {
OpportunityTriggerHandler.futureHandler(Trigger.new, Trigger.oldMap);
}}
}

The above snippet is a trigger which executes when the opportunity stage name is updated to closed won. Here we execute it after the update event.

OpportunityTriggerHandler.apxc

public class OpportunityTriggerHandler {

public static void futureHandler(List<Opportunity> newList, Map<Id,Opportunity> oldMap){

Set<Id> OpportunityIds = new Set<Id>();
if(newList != null && newList.size() > 0) {
for(Opportunity opp : newList) {
if(oldMap != null) {
if(opp.StageName == 'Closed Won' && oldMap.get(opp.Id).StageName != 'Closed Won') {
OpportunityIds.add(opp.Id);
}}}
}

// Future method to which we are passing the set of opportunity Ids
FutureMethodDemo.sendEmailMethod(OpportunityIds);
}
}

The above code is the handler for the trigger from which we are checking the old and new values if they have been updated and stored the IDs in the OpportunityIds set that we are passing in the future method.

We can also directly call a future method from the trigger but there may be chances of hitting an error if insert will happen from batch class as we cannot call Future from Batch.

FutureMethodDemo.apxc

global class FutureMethodDemo
{
@future
public static void sendEmailMethod(Set<Id> OpportunityId){

// mail list for sending mails
List<Messaging.SingleEmailMessage> allMails = new List<Messaging.SingleEmailMessage>();
for(Opportunity opp : [SELECT Id,AccountId,Name,StageName,Account.Owner.Name,Account.Owner.Email,Account.Name
FROM Opportunity WHERE Id IN :OpportunityId])
{
List<String> toAddress = new List<String>();
toAddress.add(opp.Account.Owner.Email);
Messaging.SingleEmailMessage mail = new Messaging.SingleEmailMessage();
mail.setToAddresses(toAddress);
mail.setSubject('Opportunity update to Closed Won');
mail.setHtmlBody(
'Dear '+ opp.Account.Owner.Name+',' +'<br>'+'<br>'+
'The Opportunity ' +opp.Name +' which is linked to '+ opp.Account.Name+' is closed won '+'<br>'+'<br>'
);
allMails.add(mail);
}
try{
if( allMails.size() > 0 && allMails != null) {
Messaging.sendEmail(allMails);
}}
catch(Exception e){
System.debug('Error occurred while sending mail '+e.getMessage());
System.debug('Error occurred while sending mail at line no '+e.getLineNumber());
}}
}

Above is the method which is declared as future and here we are using it to send the mail to the account owner. Hence this logic can be run in the background so we have annotated it with @future.

As we can we have one opportunity related to Edge Communication having status Id. Decision Makers. Let’s update it’s stage to closed won.

In the logs, we can see our future method executed successfully.

As a result, we also got the emails. Below is the snapshot of our mail generated.

Advantages of using the Future method

1. The governor limit will be higher in terms of query and heap size limit.
2. Can be used for long-running operations.
3. Consider future methods for a small set of data.

Limitations of future method

1. sObject can’t be passed in the parameter of the future method.
2. Cannot process large sets of data. Instead use Batch Apex.
3. Do not return the Job Id to monitor the jobs.

Queueable Vs Future

1. We cannot call one future method from another. As a result, chaining is not possible in future. However, we can queue one queueable from another.
2. Future don’t return the Job Id which makes it difficult to monitor. On the other hand queueable returns the job Id.
3. Future only supports primitive datatypes but queueable supports both primitive and non primitive datatypes.
4. Unlike queueable, future can’t be scheduled to run at a specific time.

Also Read – Queueable Apex in Salesforce with examples

FAQ’s

1. What is a mixed DML error?

This type of error occurs when we try to perform DML operation on setup and nonsetup objects in a single transaction

Example 

public static void mixedDMLDemo() {
Account a = new Account(Name='Test Account');
insert a;

Profile p = [SELECT Id FROM Profile WHERE Name='Standard User'];
UserRole r = [SELECT Id FROM UserRole WHERE Name='CEO'];
User usr = new User(alias = 'testGeek', email='test@geek.com',
emailencodingkey='UTF-8', lastname='Geek',
languagelocalekey='en_US',
localesidkey='en_US', profileid = p.Id, userroleid = r.Id,
timezonesidkey='America/Los_Angeles',
username='test@geek.com');
insert usr;
}

2. Can we call the future from Batch apex?

No, we cannot call future methods from batch apex. As they operate in different way. Mixing these can lead to unexpected behaviour.

3. How many future methods can be called from a single transaction?

We can invoke 50 future methods in a single transaction.

4. Why sObject is not allowed in future as an argument?

As it is an asynchronous process, the sObject can change between the time you call the method and the time it executes. It may be possible that the argument will receive the older version and can overwrite them.

Conclusion

In this blog, we discussed the Futue method in Salesforce with examples, all the advantages, and limitations, and how it is different from queueable apex.

Get a complete Roadmap To Learn Salesforce Admin And Development

Name *

First

Last

Email *

Comment or Message

Submit