Factory Method Pattern and Reflection in Apex within Salesforce: An In-Depth Analysis with Examples

Introduction

The Factory Method Pattern is a creational design pattern that enables the creation of objects without specifying the exact class of object to be created. This pattern is particularly useful in scenarios where the program needs to create objects with varying types, but it is impossible or impractical to know the exact class of object to create at compile-time. In the context of Salesforce and Apex, the Factory Method Pattern provides a flexible, modular, and maintainable approach to object creation and management.

This article will provide a comprehensive overview of the Factory Method Pattern, discuss its applications within Apex in Salesforce, and delve into the use of Reflection in Apex to create a more dynamic and efficient implementation of the pattern. We will also include several examples to illustrate the concepts discussed.

Factory Method Pattern

The Factory Method Pattern involves the following components:

1. A factory interface, which defines a method for creating objects.
2. Concrete factory classes, which implement the factory interface and override the object creation method to create specific types of objects.
3. A client class, which uses the factory interface to create objects without needing to know the exact class of the objects being created.

Factory Method Pattern in Apex

Let’s consider a scenario where you have multiple types of accounts in Salesforce, and you need to create a separate object for each type to perform specific business logic. Using the Factory Method Pattern in Apex, you can create objects for different account types without specifying the concrete classes.

Example

1. Define the factory interface:

   public interface AccountFactory {
       AccountBase createAccount();
   }
   

2. Create concrete factory classes for each account type:

   public class IndividualAccountFactory implements AccountFactory {
       public AccountBase createAccount() {
           return new IndividualAccount();
       }
   }
   
   public class BusinessAccountFactory implements AccountFactory {
       public AccountBase createAccount() {
           return new BusinessAccount();
       }
   }
   

3. Create the base class for accounts and its subclasses:

   public abstract class AccountBase {
       public abstract void performBusinessLogic();
   }
   
   public class IndividualAccount extends AccountBase {
       public override void performBusinessLogic() {
           // Perform business logic specific to individual accounts
       }
   }
   
   public class BusinessAccount extends AccountBase {
       public override void performBusinessLogic() {
           // Perform business logic specific to business accounts
       }
   }
   

4. Use the factory interface in the client class to create objects:

   public class AccountClient {
       public void processAccount(String accountType) {
           AccountFactory factory;
           if (accountType == 'Individual') {
               factory = new IndividualAccountFactory();
           } else if (accountType == 'Business') {
               factory = new BusinessAccountFactory();
           }
   
           AccountBase account = factory.createAccount();
           account.performBusinessLogic();
       }
   }
   

    

   Reflection in Apex

   Reflection is a technique that enables a program to inspect and manipulate the metadata of its classes, interfaces, and objects during runtime. In Apex, reflection is provided by the Type class, which allows you to create instances of classes based on their names.

   Using reflection in combination with the Factory Method Pattern in Apex can help you create a more dynamic and efficient implementation of the pattern. For example, instead of using multiple conditional statements to instantiate the appropriate factory, you can use reflection to instantiate the factory based on a string that represents its class name.

   Example using reflection:

   1. Modify the AccountFactory interface to accept an input parameter:

      public interface AccountFactory {
          AccountBase createAccount(String accountType);
      }
      

       

   2. Update the concrete factory classes to implement the modified interface:

      public class IndividualAccountFactory implements AccountFactory {
      

       

Service Oriented Architecture in Salesforce Development

Common Design Patterns in Apex