Top 10 Apex Design Patterns Every Salesforce Developer Should Master | Salesforce Best Practices

Description: Discover the top 10 Apex design patterns every Salesforce developer must master to build scalable, maintainable, and efficient solutions. Learn with examples, diagrams, and code snippets!

Introduction

As a Salesforce developer, writing efficient, scalable, and maintainable code is crucial for delivering robust solutions. Apex, Salesforce's proprietary programming language, is powerful but can quickly become unwieldy without proper design patterns. Design patterns are proven solutions to common problems, and mastering them can significantly improve your development process.

In this blog, we’ll explore the top 10 Apex design patterns every Salesforce developer should know. Whether you're a beginner or an advanced developer, these patterns will help you write cleaner code, avoid common pitfalls, and optimize performance.

Table of Contents

1. Singleton Pattern
2. Factory Pattern
3. Facade Pattern
4. Strategy Pattern
5. Decorator Pattern
6. Observer Pattern
7. Bulkification Pattern
8. Trigger Handler Pattern
9. Service Layer Pattern
10. Selector Pattern

1. Singleton Pattern

The Singleton pattern ensures that a class has only one instance and provides a global point of access to it. This is particularly useful for managing shared resources like configuration settings or utility methods.

Code Example

public class Logger {
    private static Logger instance;
    
    private Logger() {
        // Private constructor to prevent instantiation
    }
    
    public static Logger getInstance() {
        if (instance == null) {
            instance = new Logger();
        }
        return instance;
    }
    
    public void log(String message) {
        System.debug('Log: ' + message);
    }
}

Use Case: Centralized logging for debugging across multiple classes.

2. Factory Pattern

The Factory pattern abstracts object creation, allowing you to create objects without specifying the exact class. This is useful when dealing with multiple implementations of an interface.

Code Example

public interface Notification {
    void send(String message);
}

public class EmailNotification implements Notification {
    public void send(String message) {
        System.debug('Sending Email: ' + message);
    }
}

public class NotificationFactory {
    public static Notification getNotification(String type) {
        if (type == 'Email') {
            return new EmailNotification();
        }
        return null;
    }
}

Use Case: Sending notifications via different channels (Email, SMS, etc.).

3. Facade Pattern

The Facade pattern provides a simplified interface to a complex subsystem. It hides the complexities of the system and provides an easy-to-use interface.

Code Example

public class OrderFacade {
    public void placeOrder(Order order) {
        InventoryService.checkStock(order);
        PaymentService.processPayment(order);
        ShippingService.shipOrder(order);
    }
}

Use Case: Simplifying the process of placing an order.

4. Strategy Pattern

The Strategy pattern allows you to define a family of algorithms, encapsulate each one, and make them interchangeable. This is useful when you need to switch between different algorithms at runtime.

Code Example

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

public class SeasonalDiscount implements DiscountStrategy {
    public Double applyDiscount(Double amount) {
        return amount * 0.9; // 10% discount
    }
}

public class Order {
    private DiscountStrategy discountStrategy;
    
    public void setDiscountStrategy(DiscountStrategy strategy) {
        this.discountStrategy = strategy;
    }
    
    public Double calculateTotal(Double amount) {
        return discountStrategy.applyDiscount(amount);
    }
}

Use Case: Applying different discount strategies based on the season.

5. Decorator Pattern

The Decorator pattern allows you to add behavior to individual objects dynamically without affecting other objects.

Code Example

public interface Coffee {
    Double getCost();
    String getDescription();
}

public class BasicCoffee implements Coffee {
    public Double getCost() {
        return 5.0;
    }
    
    public String getDescription() {
        return 'Basic Coffee';
    }
}

public class MilkDecorator implements Coffee {
    private Coffee coffee;
    
    public MilkDecorator(Coffee coffee) {
        this.coffee = coffee;
    }
    
    public Double getCost() {
        return coffee.getCost() + 1.0;
    }
    
    public String getDescription() {
        return coffee.getDescription() + ', Milk';
    }
}

Use Case: Customizing coffee orders with additional toppings.

6. Observer Pattern

The Observer pattern defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified.

Code Example

public interface Observer {
    void update(String message);
}

public class Customer implements Observer {
    public void update(String message) {
        System.debug('Customer notified: ' + message);
    }
}

public class Order {
    private List observers = new List();
    
    public void addObserver(Observer observer) {
        observers.add(observer);
    }
    
    public void notifyObservers(String message) {
        for (Observer observer : observers) {
            observer.update(message);
        }
    }
}

Use Case: Notifying customers about order status updates.

7. Bulkification Pattern

Bulkification ensures your code can handle multiple records efficiently, avoiding governor limits.

Code Example

public class AccountHandler {
    public static void updateAccounts(List accounts) {
        for (Account acc : accounts) {
            acc.Name = acc.Name + ' Updated';
        }
        update accounts;
    }
}

Use Case: Updating multiple accounts in a single transaction.

8. Trigger Handler Pattern

The Trigger Handler pattern separates trigger logic into a handler class, making it easier to maintain and test.

Code Example

public class AccountTriggerHandler {
    public static void beforeInsert(List accounts) {
        for (Account acc : accounts) {
            acc.Name = acc.Name + ' - New';
        }
    }
}

trigger AccountTrigger on Account (before insert) {
    AccountTriggerHandler.beforeInsert(Trigger.new);
}

Use Case: Managing complex trigger logic.

9. Service Layer Pattern

The Service Layer pattern centralizes business logic, making it reusable across different parts of the application.

Code Example

public class AccountService {
    public static void createOpportunities(List accounts) {
        List opportunities = new List();
        for (Account acc : accounts) {
            opportunities.add(new Opportunity(Name = acc.Name + ' Opp', AccountId = acc.Id));
        }
        insert opportunities;
    }
}

Use Case: Creating opportunities for new accounts.

10. Selector Pattern

The Selector pattern abstracts SOQL queries, making them reusable and easier to maintain.

Code Example

public class AccountSelector {
    public static List getAccountsById(Set accountIds) {
        return [SELECT Id, Name FROM Account WHERE Id IN :accountIds];
    }
}

Use Case: Fetching accounts by their IDs.

Best Practices & Tips

1. Use Bulkification: Always write code that can handle multiple records to avoid hitting governor limits.
2. Separate Concerns: Use patterns like Trigger Handler and Service Layer to separate business logic from triggers.
3. Leverage Interfaces: Use interfaces to make your code more flexible and reusable.
4. Test Thoroughly: Write unit tests for all your design patterns to ensure they work as expected.
5. Optimize Queries: Use the Selector pattern to centralize and optimize SOQL queries.

Common Errors & How to Avoid Them

1. Not Bulkifying Code: Always test your code with multiple records to ensure it handles bulk operations.
2. Hardcoding Logic: Avoid hardcoding business logic; use patterns like Strategy or Factory to make it configurable.
3. Ignoring Governor Limits: Be mindful of Salesforce's governor limits and optimize your code accordingly.

Performance, Security, and Limit Considerations

• Performance: Use efficient algorithms and avoid nested loops.
• Security: Enforce CRUD and FLS checks in your code.
• Limits: Monitor and optimize your code to stay within Salesforce's governor limits.

Conclusion

Mastering these top 10 Apex design patterns will elevate your Salesforce development skills, enabling you to build scalable, maintainable, and efficient solutions. Whether you're working on triggers, services, or integrations, these patterns will help you write cleaner and more robust code.

Found this blog helpful? Share it with your fellow developers, leave a comment below, and subscribe for more Salesforce tips and tutorials!

Happy Coding! 🚀