Error Handling in Salesforce Apex

Error Handling in Salesforce Apex is a critical aspect of building robust and reliable applications in Salesforce Apex. Proper error handling ensures that your code gracefully manages unexpected scenarios, maintains data integrity, and provides meaningful feedback to users.

In this guide, we’ll explore the fundamentals of error handling in Apex, including built-in exceptions, custom exceptions, transaction control, and best practices all illustrated with practical examples.

1. Why Error Handling Matters in Apex

• Prevent Crashes: Handle exceptions to avoid unhandled errors that disrupt user workflows.
• Data Integrity: Use transactions to roll back changes if an error occurs, ensuring consistent data.
• User Experience: Display clear error messages instead of cryptic system-generated alerts.
• Debugging: Capture error details for troubleshooting and auditing.

2. Basic Try-Catch Block

The try-catch block is the foundation of error handling in Apex. Code that might throw an error is placed in the try block, and exceptions are caught and handled in the catch block.

Example: Handling a DML Exception 

try {
// Attempt to insert a Contact without a LastName (required field)
Contact newContact = new Contact(FirstName = 'John');
insert newContact;
} catch (DmlException e) {
// Handle the error
System.debug('Error Message: ' + e.getMessage());
System.debug('Failed Fields: ' + e.getDmlFieldNames(0));
}

Explanation:

• The insert operation fails because LastName is required for a Contact.
• The catch block catches the DmlException and logs details like the error message and affected fields.

3. Built-in Exceptions in Apex

Apex provides several standard exceptions. Here are the most common ones:

a. DmlException:

A DmlException is thrown when there is an issue with a DML operation (insert, update, delete, undelete).

try {
// Trying to insert a new account without required fields
Account acc = new Account();
insert acc; // This will throw a DmlException because 'Name' is required
} catch (DmlException e) {
System.debug('Error occurred during DML operation: ' + e.getMessage());
}

b. QueryException:

Occurs during SOQL query failures (e.g., no records found, too many rows).

try {
Account acc = [SELECT Id FROM Account WHERE Name = 'Nonexistent'];
} catch (QueryException e) {
System.debug('Query Error: ' + e.getMessage());
}

c. NullPointerException

Thrown when accessing a null object reference.

try {
Account acc = null;
System.debug(acc.Name); // Throws NullPointerException
} catch (NullPointerException e) {
System.debug('Null Object Error: ' + e.getMessage());
}

d. ListException

Occurs with invalid list operations (e.g., accessing an out-of-bounds index).

try {
List<Integer> numbers = new List<Integer>{1, 2, 3};
System.debug(numbers[5]); // Throws ListException
} catch (ListException e) {
System.debug('List Error: ' + e.getMessage());
}

4. Custom Exceptions

In Apex, you can define a custom exception class by extending the built-in Exception class. Custom exceptions are useful when you want to handle specific error conditions in your code.

Here’s a simple example of how to define and use a custom exception class in Apex:

Step 1: Define the Custom Exception Class

To create your custom exception class, extend the built-in Exception class and make sure your class name ends with the word Exception. Append extends Exception after your class declaration as follows.

public class CustomException extends Exception {}

Step 2: Use the Custom Exception in Your Code

public class ExampleClass {
public static void checkValue(Integer value) {
if (value < 0) {
// Throw the custom exception with a custom message
throw new CustomException ('Value cannot be negative: ' + value);
}
System.debug('Value is valid: ' + value);
}
}

 

 

5. Finally Block

The finally block executes code regardless of whether an exception is thrown. Use it for cleanup tasks like releasing resources.

try {
// Perform risky operation
insert new Account(Name = 'Test');
} catch (DmlException e) {
System.debug('Error: ' + e.getMessage());
} finally {
System.debug('This block always runs.');
}

Savepoint sp = Database.setSavepoint();
try {
Account acc = new Account(Name = 'Demo');
insert acc;
Contact con = new Contact(LastName = 'Doe');
insert con; // Assume this fails
} catch (DmlException e) {
Database.rollback(sp); // Undo Account and Contact inserts
System.debug('Transaction rolled back: ' + e.getMessage());
}

try {
insert new Account();
} catch (Exception e) {
// Create an Error_Log__c record
Error_Log__c log = new Error_Log__c(
Error_Message__c = e.getMessage(),
Stack_Trace__c = e.getStackTraceString()
);
insert log;
}

import { LightningElement } from 'lwc';

export default class ErrorHandlingExample extends LightningElement {
handleClick() {
try {
// Logic Here
} catch (error) {
console.error('Error caught:', error.message);
// Display the error to the user
this.showToast('Error', error.message, 'error');
}
}

showToast(title, message, variant) {
const event = new ShowToastEvent({
title,
message,
variant,
});
this.dispatchEvent(event);
}
}

import { LightningElement, wire } from 'lwc';

import { getRecord } from 'lightning/uiRecordApi';
import NAME_FIELD from '@salesforce/schema/Account.Name';

export default class RecordApiExample extends LightningElement {
recordId = '001XXXXXXXXXXXXXXX'; // Replace with a valid record ID
accountName;

@wire(getRecord, { recordId: '$recordId', fields: [NAME_FIELD] })
wiredAccount({ error, data }) {
if (data) {
this.accountName = data.fields.Name.value;
} else if (error) {
console.error('Error fetching record:', error);
this.showToast('Error', error.body.message, 'error');
}
}

showToast(title, message, variant) {
const event = new ShowToastEvent({
title,
message,
variant,
});
this.dispatchEvent(event);
}
}

import { LightningElement } from 'lwc';
import getAccountData from '@salesforce/apex/AccountController.getAccountData';

export default class ApexErrorHandlingExample extends LightningElement {
accountData;

handleLoadData() {
getAccountData()
.then((result) => {
this.accountData = result;
})
.catch((error) => {
console.error('Error calling Apex method:', error);
this.showToast('Error', error.body.message, 'error');
});
}

showToast(title, message, variant) {
const event = new ShowToastEvent({
title,
message,
variant,
});
this.dispatchEvent(event);
}
}

1. How to display an error message in Apex?

In Apex, you can display an error message to users using the following methods:

• ApexPages.addMessage – Displays an error message on a Visualforce page.
• addError() – Stops record DML execution and shows an error in the UI.
• Messaging.sendEmail() – Sends an email notification to inform users about an error.

2. What is the ‘Apex CPU Time Limit Exceeded’ error in Salesforce?

The Apex CPU Time Limit Exceeded error in Salesforce occurs when an Apex transaction surpasses the CPU time restriction set by Salesforce governor limits. For synchronous transactions, Salesforce allows a maximum CPU time of 10 seconds per transaction, while asynchronous processes have a higher limit of 60 seconds.

Conclusion

Mastering error handling in Apex ensures your Salesforce applications are resilient, user-friendly, and maintain data integrity. By leveraging try-catch blocks, built-in exceptions, custom validations, and transaction control, you can build robust solutions that handle failures gracefully. Start implementing these techniques in your code today to reduce debugging time and enhance user trust!

Get a complete Roadmap To Learn Salesforce Admin And Development

Name *

First

Last

Email *

Comment or Message

Submit