What Are Apex Design Patterns in Salesforce?

Apex Design Patterns are reusable solutions for common coding problems.
They help structure your code in a smart way.

Using design patterns in Apex helps to:

Reduce duplicate code
Improve performance
Make code easy to maintain
Follow Salesforce best practices

1. Singleton Pattern in Apex (With Example)

The Singleton Pattern allows only one instance of a class to exist.

Why use Singleton Pattern in Apex?

When you want shared data
When multiple instances are not needed
When memory usage should be controlled

Singleton Pattern Apex Code Example

public class AppConfig {

    private static AppConfig instance;

    private AppConfig() {
        // private constructor
    }

    public static AppConfig getInstance() {
        if(instance == null) {
            instance = new AppConfig();
        }
        return instance;
    }
}

How this works

The constructor is private
Only one object is created
Same object is reused everywhere

✅ Result: Clean and controlled access to data.

2. Strategy Pattern in Apex (With Example)

The Strategy Pattern lets you change business logic easily without touching main code.

Why use Strategy Pattern in Salesforce?

To avoid long if-else statements
To support multiple business rules
To make code flexible

Step 1: Create an Interface

public interface DiscountStrategy {
    Decimal applyDiscount(Decimal amount);
}

Step 2: Create Different Strategies

public class RegularCustomerDiscount implements DiscountStrategy {
    public Decimal applyDiscount(Decimal amount) {
        return amount * 0.90;
    }
}

public class PremiumCustomerDiscount implements DiscountStrategy {
    public Decimal applyDiscount(Decimal amount) {
        return amount * 0.80;
    }
}

Step 3: Use Strategy in Main Class

public class DiscountService {

    private DiscountStrategy strategy;

    public DiscountService(DiscountStrategy strategy) {
        this.strategy = strategy;
    }

    public Decimal calculatePrice(Decimal amount) {
        return strategy.applyDiscount(amount);
    }
}

✅ Result:
New discount types can be added without changing existing code.

3. Apex Trigger Framework (Best Practice Example)

Triggers become difficult to manage when logic is written directly inside them.

A Trigger Framework keeps triggers clean.

Bad Practice (What to Avoid)

trigger AccountTrigger on Account (before insert, after update) {
    if(Trigger.isBefore && Trigger.isInsert) {
        // logic here
    }
}

❌ Hard to maintain
❌ Difficult to test

Good Practice: Trigger Framework

Trigger

trigger AccountTrigger on Account (before insert, after update) {
    AccountTriggerHandler handler = new AccountTriggerHandler();

    if(Trigger.isBefore && Trigger.isInsert) {
        handler.beforeInsert(Trigger.new);
    }
}

Trigger Handler Class

public class AccountTriggerHandler {

    public void beforeInsert(List<Account> newAccounts) {
        for(Account acc : newAccounts) {
            acc.Description = 'Created using Trigger Framework';
        }
    }
}

Benefits of Trigger Framework

Clean triggers
Organized logic
Easy unit testing
Easy debugging

Why Use Apex Design Patterns in Salesforce?

Using Apex Design Patterns helps you:

Write scalable code
Follow Salesforce coding standards
Improve application performance
Reduce future bugs

They are very useful for large projects, enterprise orgs, and interview preparation.

Conclusion

Apex Design Patterns like:

Singleton Pattern
Strategy Pattern
Trigger Framework

help developers write clean, flexible, and maintainable Salesforce code.

If you want to become a strong Salesforce developer, learning these patterns is a must 🚀

Please Wait

Comments (0)