How to implement instance factory for multiple classes

How to implement instance factory for multiple classes

An instance factory is a design pattern that encapsulates the creation of objects and allows for flexibility in instantiation. Implementing an instance factory can be quite useful when dealing with multiple classes, as it centralizes object creation and can simplify code maintenance.

Here's how you can implement an instance factory for multiple classes in TypeScript:

Define Interface:

If your all class have the same methods, then its a good idea to define the interface.

ITestPremiumCalculators.ts

                          import { PremiumRequest, PResults, ProductPremiumDetail } from './dto';
                          
                          export interface ITestPremiumCalculator {
                            ISValidDetails?(premiumCalculatorDetails: ProductPremiumDetail): Promise<boolean>;
                            CalculatePremium(PremiumRes: PremiumRequest): Promise<PResults>;
                          }
                        

Define Classes:

Start by defining the classes for which you want to create instances using the factory.

PlanA.ts

                          import { LoggerService } from './logger.service';
                    
                          export class PlanA {
                          constructor(private readonly loggerService: LoggerService) {}
                    
                            async ISValidDetails(premiumCalculatorResponse: ProductPremiumDetail): Promise<boolean> {
                              /*** Implementations ***/
                              return true;
                            }
                    
                            async CalculatePremium(premium: PremiumRequest): Promise<PResults> {
                              /*** Implementations ***/
                              return new PResults();
                            }
                          }
                        

PlanB.ts

                          import { LoggerService } from './logger.service';
                    
                          export class PlanB {
                          constructor(private readonly loggerService: LoggerService) {}
                    
                            async ISValidDetails(premiumCalculatorResponse: ProductPremiumDetail): Promise<boolean> {
                              /*** Implementations ***/
                              return true;
                            }
                    
                            async CalculatePremium(premium: PremiumRequest): Promise<PResults> {
                              /*** Implementations ***/
                              return new PResults();
                            }
                          }
                        

Create Factory:

Create a factory class that contains methods for creating instances of the different classes

PlanFactory.ts

                          import { LoggerService } from './logger.service';
                          import { ITestPremiumCalculator } from './ITestPremiumCalculator.ts';
                          import { PlanA } from './PlanA.ts';
                          import { PlanB } from './PlanB.ts';
                    
                          export class PlanFactory {
                            public static getPlanInstance(planType: string, loggerService: LoggerService): ITestPremiumCalculator {
                              let instance: ITestPremiumCalculator = null;
                              if (planType === 'PlanA') instance = new PlanA(loggerService);
                              if (planType === 'PlanB') instance = new PlanB(loggerService);
                              return instance;
                            }
                          }
                        

Usage:

Now you can use the instance factory to create instances of the classes in a centralized manner.

                        import { ITestPremiumCalculator } from './ITestPremiumCalculator.ts';
                        import { PlanFactory } from './PlanFactory.ts';
                        
                        export class PlanManager {
                        constructor( private readonly loggerService: LoggerService) {}
                        
                          async validateAndCalculatePremium(planType:string, validObj: ProductPremiumDetail, PremiumDetails:PremiumRequest){
                              const planTypeInstance: ITestPremiumCalculator = PlanFactory.getPlanInstance(planType, this.loggerService);
                              let isValid = await planTypeInstance.IsValidate(validObj);
                              if (isValid) {
                              await planTypeInstance.CalculatePremium(PremiumDetails));
                              return PremiumDetails;
                              }
                              throw new Error('Invalid')
                          }
                        
                        }
                        

By using an instance factory, you can easily manage and maintain object creation for multiple classes. If you need to modify the instantiation process or add common logic, you can do so within the factory without affecting the client code that uses the factory.
Additionally, if you have a large number of classes or want more dynamic instantiation, you can use a more advanced approach like a registry or mapping to associate class names or identifiers with their corresponding creation methods in the factory.

 implementing an instance factory pattern provides a structured and centralized way to create instances of multiple classes. This design pattern offers several advantages that contribute to cleaner, more maintainable, and flexible code:

1. Code Organization: The instance factory segregates object creation logic from the rest of the application, promoting better code organization and separation of concerns.

2. Flexibility: The factory enables you to modify the instantiation process or add common logic in a single place without affecting the client code that uses the factory. This enhances flexibility and maintainability.

3. Simplicity: Creating instances through a factory reduces redundancy in the client code by abstracting away the instantiation details. This leads to cleaner and more concise code.

4. Centralization: All object creation logic is contained within the factory, making it easier to manage, update, and extend the creation process for various classes.

5. Dynamic Creation: By incorporating class mappings or identifiers, the factory can provide dynamic instance creation based on runtime conditions or configurations.

6. Extensibility: As the application evolves, adding new classes to the factory is straightforward. The factory can be updated to accommodate new classes without modifying existing code.

7. Error Handling: The factory can handle cases where a class does not exist or when instantiation fails, providing better error handling and reducing the likelihood of runtime errors.

---

Conclusion:

This approach allows you to extend the factory with new classes without modifying the factory class itself, making your code more open to changes and easier to maintain.

Whether you have a few classes or a complex hierarchy of objects, an instance factory pattern promotes modular and maintainable code. It encapsulates the object creation process and abstracts away the details, allowing developers to focus on the overall functionality of their application while ensuring consistent and reliable instance creation. By adopting this pattern, you can build more robust and adaptable software systems that are easier to extend and maintain over time.

Related Keywords:

What is the best example of factory method?

Factory Method Design Pattern - Definition & Examples

What is the factory pattern to create different objects?

How to implement factory class

Usage of Factory Design Pattern

Factory Design Pattern