Adding Custom methods in Batch Apex with Example

In Salesforce, Batch Apex is essential for processing large data volumes that exceed the governor limits for regular Apex operations. The Database.Batchable interface provides the necessary framework for breaking down large data sets into manageable chunks.

The three primary methods in the Database.Batchable interfaces are:

1. Start: Initiates the batch process. This method returns a QueryLocator or Iterable which defines the dataset to be processed.
2. Execute: This method processes each chunk of records. It’s where the logic for handling the data in batches is defined.
3. Finish: Executes any post-processing tasks once all chunks have been processed, such as sending a notification or logging results.

While these methods are foundational, custom methods in your Batch Apex class can significantly enhance functionality. Let’s explore how to elevate your batch classes with these custom methods, addressing key concerns such as error handling, scalability, and overall code readability.

Why do we need Custom Methods in Batch Apex

Custom methods within a Batch Apex class provide several benefits, including:

1. Separation of Concerns: By creating dedicated methods for specific tasks (e.g., data transformation, validation, etc.), you can keep your class modular and more readable.
2. Reusability: Custom methods allow you to write logic once and reuse it across different parts of the batch process. This helps in reducing redundancy.
3. Maintainability: By breaking down logic into smaller, well-defined methods, you make your code easier to maintain in the long run. This also allows for easier unit testing of isolated methods.

Real-World Scenario: Customer Data Cleanup

Business Requirements

1. Standardize Phone Numbers: Format all Contact.Phone values to (XXX) XXX-XXXX.
2. Validate Emails: Flag invalid emails and clear them from records.
3. Generate a Summary Report: Email admins with success/failure metrics.

Technical Challenges

• Processing millions of records without hitting governor limits.
• Retaining error details across batches.
• Ensuring email validation aligns with organizational standards.

Batch Class Code:

public class ContactCleanupBatch implements Database.Batchable<SObject>, Database.Stateful {
// Track metrics across batches
private Integer totalProcessed = 0;
private Integer errors = 0;
private List<String> errorMessages = new List<String>();

// 1. START METHOD: Define scope
public Database.QueryLocator start(Database.BatchableContext bc) {
// Query Contacts with non-null Phone or Email
return Database.getQueryLocator(
'SELECT Id, Phone, Email FROM Contact WHERE Phone != null OR Email != null'
);
}

// 2. EXECUTE METHOD: Process each batch
public void execute(Database.BatchableContext bc, List<Contact> contacts) {
List<Contact> contactsToUpdate = new List<Contact>();

for (Contact con : contacts) {
try {
// --- Custom Method 1: Format Phone ---
if (con.Phone != null) {
con.Phone = formatPhoneNumber(con.Phone); // Reuse logic
}

// --- Custom Method 2: Validate Email ---
if (con.Email != null && !validateEmail(con.Email)) {
errorMessages.add('Invalid email for Contact ID ' + con.Id + ': ' + con.Email);
errors++;
con.Email = null; // Clear invalid data
}

contactsToUpdate.add(con);
totalProcessed++;
} catch (Exception e) {
errors++;
errorMessages.add('Error processing Contact ID ' + con.Id + ': ' + e.getMessage());
}
}

// Bulk DML to avoid limit issues
if (!contactsToUpdate.isEmpty()) {
update contactsToUpdate;
}
}

// 3. FINISH METHOD: Post-processing
public void finish(Database.BatchableContext bc) {
sendSummaryEmail(); // Custom method for reporting
}

// --------- CUSTOM HELPER METHODS --------- //

// 1. Phone Formatting Logic
private String formatPhoneNumber(String phone) {
// Step 1: Remove non-numeric characters
String cleaned = phone.replaceAll('[^0-9]', '');

// Step 2: Validate length (US numbers only)
if (cleaned.length() != 10) return phone;

// Step 3: Apply (XXX) XXX-XXXX format
return '(' + cleaned.substring(0,3) + ') ' +
cleaned.substring(3,6) + '-' +
cleaned.substring(6);
}

// 2. Email Validation Logic
private Boolean validateEmail(String email) {
// Regex for basic email validation
String regex = '^[a-zA-Z0-9._|\\\\%#~`=?&/$^*!}{+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,4}$';
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(email);
return matcher.matches();
}

// 3. Email Reporting Logic
private void sendSummaryEmail() {
// Step 1: Build email content
String subject = 'Contact Cleanup Batch Summary';
String body = 'Total Contacts Processed: ' + totalProcessed + '\n'
+ 'Errors: ' + errors + '\n\n'
+ 'Error Details:\n' + String.join(errorMessages, '\n');

// Step 2: Configure email
Messaging.SingleEmailMessage email = new Messaging.SingleEmailMessage();
email.setToAddresses(new String[] { UserInfo.getUserEmail() }); // Send to current user
email.setSubject(subject);
email.setPlainTextBody(body);

// Step 3: Send (handle exceptions in real code)
try {
Messaging.sendEmail(new List<Messaging.SingleEmailMessage>{ email });
} catch (Exception e) {
System.debug('Email failed: ' + e.getMessage());
}
}
}

Explanation: 

Let’s break down the Batch Apex code and its custom methods with real-world examples to illustrate how it works. We’ll use the ContactCleanupBatch class as a reference.

The ContactCleanupBatch class implements Database.Batchable and Database.Stateful to process Contact records in batches.

Key Components:

• Stateful Variables: Track progress across batches (totalProcessed, errors, errorMessages).
• Core Methods: start, execute, finish.
• Custom Methods: formatPhoneNumber, validateEmail, sendSummaryEmail.

Start Method:

Define the scope of records to process.

public Database.QueryLocator start(Database.BatchableContext bc) {
return Database.getQueryLocator(
'SELECT Id, Phone, Email FROM Contact WHERE Phone != null OR Email != null'
);
}

Explanation:

• Queries all Contact records with non-null Phone or Email fields.
• Example: If there are 10,000 Contacts with phone numbers or emails, this query fetches them for processing.

Execute Method:

Process each batch of records (default batch size: 200).

public void execute(Database.BatchableContext bc, List<Contact> contacts) {
List<Contact> contactsToUpdate = new List<Contact>();
for (Contact con : contacts) {
try {
// Format phone number (custom method)
if (con.Phone != null) {
con.Phone = formatPhoneNumber(con.Phone);
}
// Validate email (custom method)
if (con.Email != null && !validateEmail(con.Email)) {
errorMessages.add('Invalid email for Contact ID ' + con.Id + ': ' + con.Email);
errors++;
con.Email = null;
}
contactsToUpdate.add(con);
totalProcessed++;
} catch (Exception e) {
errors++;
errorMessages.add('Error processing Contact ID ' + con.Id + ': ' + e.getMessage());
}
}
update contactsToUpdate; // Bulk DML
}

Step-by-Step Explanation:

1. Input: A batch of up to 200 Contact records.

2. Process Each Contact:
Format Phone: Use formatPhoneNumber to standardize the format.
Example: “123-456-7890” ➔ “(123) 456-7890”.

Validate Email: Use validateEmail with regex to check validity.

Valid: “user@example.com” ➔ allowed.

Invalid: “user@invalid” ➔ email cleared, error logged.

3.Bulk DML Update: Updates all processed contacts in one operation to avoid hitting DML limits.

Custom Method formatPhoneNumber:

Standardize phone numbers to (XXX) XXX-XXXX.

private String formatPhoneNumber(String phone) {
// Remove non-numeric characters
String cleaned = phone.replaceAll('[^0-9]', '');
// Validate length (10 digits for US numbers)
if (cleaned.length() != 10) return phone;
// Format as (XXX) XXX-XXXX
return '(' + cleaned.substring(0,3) + ') ' + cleaned.substring(3,6) + '-' + cleaned.substring(6);
}

Examples:

• Input: “123.456.7890” ➔ cleaned to “1234567890” ➔ output “(123) 456-7890”.
• Input: "1234" ➔ length ≠ 10 ➔ returns original value.

Custom Method validateEmail

Validate emails using regex.

 

private Boolean validateEmail(String email) {
String regex = '^[a-zA-Z0-9._|\\\\%#~`=?&/$^*!}{+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,4}$';
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(email);
return matcher.matches();
}

Examples:

Valid: “john.doe@example.com” ➔ returns true.

Invalid: “jane@.com” ➔ returns false.

Finish Method & sendSummaryEmail

Send a summary email after all batches complete.

public void finish(Database.BatchableContext bc) {
sendSummaryEmail();
}

private void sendSummaryEmail() {
String body = 'Total Contacts Processed: ' + totalProcessed + '\n'
+ 'Errors: ' + errors + '\n'
+ 'Error Details:\n' + String.join(errorMessages, '\n');
Messaging.SingleEmailMessage email = new Messaging.SingleEmailMessage();
email.setToAddresses(new String[] { UserInfo.getUserEmail() });
email.setSubject('Contact Cleanup Batch Summary');
email.setPlainTextBody(body);
Messaging.sendEmail(new List<Messaging.SingleEmailMessage>{ email });
}

Example Email Output:

Total Contacts Processed: 5000
Errors: 12
Error Details:
Invalid email for Contact ID 003xx000001TUVW: user@invalid
Error processing Contact ID 003xx000002WXYZ: Script-thrown exception

Testing the Batch

Test Class Example:

@IsTest
private class ContactCleanupBatchTest {
@TestSetup
static void setup() {
// Create test data
insert new Contact(
LastName = 'ValidContact',
Phone = '1234567890',
Email = 'valid@test.com'
);
insert new Contact(
LastName = 'InvalidContact',
Email = 'invalid'
);
}

@IsTest
static void testBatch() {
ContactCleanupBatch batch = new ContactCleanupBatch();
Test.startTest();
Database.executeBatch(batch);
Test.stopTest();

// Verify phone formatting
Contact validContact = [SELECT Phone FROM Contact WHERE LastName = 'ValidContact'];
System.assertEquals('(123) 456-7890', validContact.Phone);

// Verify email cleared
Contact invalidContact = [SELECT Email FROM Contact WHERE LastName = 'InvalidContact'];
System.assertEquals(null, invalidContact.Email);
}
}

Preparing for Salesforce Certification Exams? Check out the practice sets here

Real-World Scenario Walkthrough

Scenario: Clean up 50,000 Contact records.

1. Batch Execution:

• start(): Fetches all 50,000 records.
• execute(): Processes 200 records at a time (250 batches).
• Each batch formats phones validates emails, and logs errors.

2. Result:

• 48,000 contacts updated successfully.
• 2000 errors logged (e.g., invalid emails).
• Summary email sent to the admin.

Also Read – Batch Apex Scenario-Based Interview Questions and Answers

FAQs:

1. What is a custom method in an Apex Batch class and why would I need one?

A custom method in an Apex Batch class is a user-defined method that performs specific operations outside the standard start, execute, and finish methods. You might need a custom method to:

• Reuse code logic across multiple methods.
• Perform pre-processing or post-processing tasks.
• Encapsulate complex logic for better readability and maintainability.

2. Is it possible to test custom methods in a Batch class?

Yes, you can test custom methods by writing unit tests for your Batch class. Use the Test.startTest() and Test.stopTest() methods to execute the batch and verify the behaviour of your custom methods.

3. Can I use a custom method to send emails or notifications during batch execution?

Yes, you can use a custom method to send emails or notifications. However, be mindful of the email sending limits (e.g., Messaging.sendEmail limits) and ensure the logic is bulkified.

4. What happens if a custom method throws an exception in a Batch class?

If a custom method throws an exception, it will interrupt the batch execution for the current chunk. Use try-catch blocks to handle exceptions gracefully and log errors for debugging.

Conclusion

By combining Batch Apex with custom methods, you can efficiently process large datasets while maintaining code readability and security. Let me know if you’d like to explore more complex scenarios.

Get a complete Roadmap To Learn Salesforce Admin And Development

Name *

First

Last

Email *

Comment or Message

Submit