Advanced Apex Design Patterns for Scalable Salesforce Solutions

 As a senior Salesforce developer, you’ve likely mastered the basics of Apex and are familiar with many core features of the platform. To build robust, scalable, and maintainable solutions, it’s crucial to leverage advanced design patterns. These patterns not only help organize code more efficiently but also make solutions easier to extend and test.

In this blog post, we’ll explore some key design patterns for Apex development, their real-world applications, and how they can help you architect enterprise-grade Salesforce solutions.

---

Why Use Design Patterns in Apex?

Design patterns are proven solutions to common software engineering problems. In the context of Salesforce, using design patterns allows you to:

• Promote code reuse and modularity
• Simplify testing and maintenance
• Ensure scalability as requirements grow
• Foster collaboration within teams

---

Common Apex Design Patterns

1. Singleton Pattern

Purpose: Restricts instantiation of a class to a single object and provides a global point of access.

Use Case: Managing custom settings, caches, or configuration objects that should only exist once in an execution context.

public class MySingleton {
    private static MySingleton instance;
    public String configValue;

    private MySingleton() {
        // Perform expensive initialization here
        configValue = 'Loaded';
    }

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

---

2. Factory Pattern

Purpose: Creates objects without specifying the exact class of object to create.

Use Case: When you have multiple types of SObjects or business logic handlers that need to be instantiated based on input.

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

public class EmailNotification implements NotificationStrategy {
    public void send(String message) {
        // Send email implementation
    }
}
public class SmsNotification implements NotificationStrategy {
    public void send(String message) {
        // Send SMS implementation
    }
}

public class NotificationFactory {
    public static NotificationStrategy getStrategy(String type) {
        if (type == 'Email') return new EmailNotification();
        if (type == 'SMS') return new SmsNotification();
        throw new IllegalArgumentException('Unknown type');
    }
}

---

3. Strategy Pattern

Purpose: Enables selecting an algorithm’s behavior at runtime.

Use Case: When you need to perform different business logic based on context (e.g., different discount strategies for customers).

public interface DiscountStrategy {
    Decimal calculateDiscount(Decimal price);
}

public class NoDiscount implements DiscountStrategy {
    public Decimal calculateDiscount(Decimal price) { return 0; }
}
public class SeasonalDiscount implements DiscountStrategy {
    public Decimal calculateDiscount(Decimal price) { return price * 0.1; }
}

public class DiscountContext {
    private DiscountStrategy strategy;
    public DiscountContext(DiscountStrategy strategy) {
        this.strategy = strategy;
    }
    public Decimal getDiscount(Decimal price) {
        return strategy.calculateDiscount(price);
    }
}

---

4. Service Layer Pattern

Purpose: Encapsulates business logic and calls to lower layers (like triggers or controllers).

Use Case: Prevents code duplication and centralizes business logic, making maintenance easier.

public class AccountService {
    public static void processAccount(Account acc) {
        // Business logic here
        if (acc.AnnualRevenue > 1000000) {
            acc.Type = 'Enterprise';
        }
    }
}

---

Diagram: How Patterns Interact in a Scalable Solution

Below is a simplified UML diagram showing how these patterns might work together in a Salesforce solution:

+-------------------+        +-------------------+        +----------------------+
|   Controller      |------->| Service Layer     |------->| Factory (Strategy)   |
+-------------------+        +-------------------+        +----------------------+
        |                            |                              |
        |                            v                              v
        |                   +------------------+         +---------------------+
        |                   | Singleton        |         | Concrete Strategies |
        |                   +------------------+         +---------------------+

• Controller: Accepts user input and delegates to the Service Layer.
• Service Layer: Orchestrates business logic, leverages Singleton for config, and uses Factory to instantiate appropriate strategies.
• Factory & Strategies: Factory chooses the right strategy at runtime; strategies execute specific algorithms.
• Singleton: Used for shared configuration or cache.

---

Performance & Scalability Considerations

• Use Singleton to avoid redundant queries or object creation, especially in triggers.
• Encapsulate DML and SOQL in the Service Layer to prevent exceeding governor limits.
• Apply Factory and Strategy patterns to keep controllers and triggers slim and flexible for future changes.

---

Conclusion

Mastering advanced design patterns empowers you to build scalable, maintainable, and efficient Salesforce solutions. Start incorporating these patterns into your projects to elevate your architecture and make your applications truly enterprise-ready!

---

What other patterns or best practices do you use in your Salesforce projects? Share your thoughts in the comments below!