The Singleton pattern attempts to solve the issue of repeatedly using an object instance, but only wishing to instantiate it once within a single transaction context.
Sample Code:
Apex Class:
public class Utility {
public static Utility objInstance = null;
public Integer acctCount;
public Utility() {
acctCount = [ SELECT COUNT() FROM Account ];
}
public static Utility getInstance() {
if ( objInstance == null )
objInstance = new Utility();
return objInstance;
}
}
If you execute the below code, the SOQL will be executed only once.
for ( Integer i = 0; i < 3; i++ ) {
Utility obj = Utility.getInstance();
system.debug(‘Count is ‘ + obj.acctCount);
}
Strategy:
Defining a family of algorithms, enscapsulating each one and making them interchangeable and selectable at runtime.
Sample Code:
1. Create an interface.
public interface Strategy {
Integer doOperation(Integer num1, Integer num2);
}
2. Create concrete classes implementing the same interface.
public class OperationAdd implements Strategy {
public Integer doOperation(Integer num1, Integer num2) {
return num1 + num2;
}
}
public class OperationSubstract implements Strategy {
public Integer doOperation(Integer num1, Integer num2) {
return num1 – num2;
}
}
3. Create Context Class.
public class Context {
private Strategy strategy;
public Context(Strategy strategy) {
this.strategy = strategy;
}
public Integer executeStrategy(Integer num1, Integer num2) {
return strategy.doOperation(num1, num2);
}
}
4. Use the Context to see change in behaviour when it changes its Strategy.
Context context = new Context(new OperationAdd());
System.debug(’10 + 5 = ‘ + context.executeStrategy(10, 5));
context = new Context(new OperationSubstract());
System.debug(’10 – 5 = ‘ + context.executeStrategy(10, 5));
Decorator:
Extending the functionality of an sObject in Apex.
Example is Wrapper Class – https://www.infallibletechie.com/2015/03/sample-wrapper-class-using-apex-in.html
Facade:
Simplifying the execution of classes with complex interfaces (e.g. web service callouts).
Sample Code:
/* Complex parts */
class CPU {
public void freeze() { … }
public void jump(long position) { … }
public void execute() { … }
}
class HardDrive {
public byte[] read(long lba, int size) { … }
}
class Memory {
public void load(long position, byte[] data) { … }
}
/* Facade */
class ComputerFacade {
private CPU processor;
private Memory ram;
private HardDrive hd;
public ComputerFacade() {
this.processor = new CPU();
this.ram = new Memory();
this.hd = new HardDrive();
}
public void start() {
processor.freeze();
ram.load(BOOT_ADDRESS, hd.read(BOOT_SECTOR, SECTOR_SIZE));
processor.jump(BOOT_ADDRESS);
processor.execute();
}
}
/* Client */
class You {
public static void main(String[] args) {
ComputerFacade computer = new ComputerFacade();
computer.start();
}
}
Composite:
Treating a group of objects in a similar manner to a single instance of that object. Composite pattern is used where we need to treat a group of objects in similar way as a single object. Composite pattern composes objects in term of a tree structure to represent part as well as whole hierarchy. This type of design pattern comes under structural pattern as this pattern creates a tree structure of group of objects.
Sample Code:
Apex Class:
public class Employee {
private String name;
private String dept;
private Integer salary;
private List<Employee> subordinates;
// constructor
public Employee(String name,String dept, Integer sal) {
this.name = name;
this.dept = dept;
this.salary = sal;
subordinates = new List < Employee >();
}
public void add(Employee e) {
subordinates.add(e);
}
public List<Employee> getSubordinates() {
return subordinates;
}
}
Execute the below code to set the hierarchy and view the debug log.
Employee CEO = new Employee(‘John’,’CEO’, 30000);
Employee headSales = new Employee(‘Robert’,’Head Sales’, 20000);
Employee headMarketing = new Employee(‘Michel’,’Head Marketing’, 20000);
Employee clerk1 = new Employee(‘Laura’,’Marketing’, 10000);
Employee clerk2 = new Employee(‘Bob’,’Marketing’, 10000);
Employee salesExecutive1 = new Employee(‘Richard’,’Sales’, 10000);
Employee salesExecutive2 = new Employee(‘Rob’,’Sales’, 10000);
CEO.add(headSales);
CEO.add(headMarketing);
headSales.add(salesExecutive1);
headSales.add(salesExecutive2);
headMarketing.add(clerk1);
headMarketing.add(clerk2);
//print all employees of the organization
System.debug(CEO);
for ( Employee headEmployee : CEO.getSubordinates() ) {
System.debug(headEmployee);
for ( Employee employee : headEmployee.getSubordinates() ) {
System.debug(employee);
}
}
Bulk State Transition:
Efficiently tracking the change of a field value in a trigger and executing functionality based on this change.
Example is bulking the trigger.
in singleton approach,objInstance should be declared as Private. so that always we ensure the same instance is returned throughout the transaction.