Sf Apex

# Apex Design Patterns Reference

## Trigger Handler Framework

### Base Handler
```apex
public virtual class TriggerHandler {
    @TestVisible
    private static Set<String> bypassedHandlers = new Set<String>();

    public void run() {
        if (bypassedHandlers.contains(getHandlerName())) return;

        if (Trigger.isBefore) {
            if (Trigger.isInsert) beforeInsert();
            if (Trigger.isUpdate) beforeUpdate();
            if (Trigger.isDelete) beforeDelete();
        } else if (Trigger.isAfter) {
            if (Trigger.isInsert) afterInsert();
            if (Trigger.isUpdate) afterUpdate();
            if (Trigger.isDelete) afterDelete();
            if (Trigger.isUndelete) afterUndelete();
        }
    }

    public static void bypass(String handlerName) {
        bypassedHandlers.add(handlerName);
    }

    public static void clearBypass(String handlerName) {
        bypassedHandlers.remove(handlerName);
    }

    private String getHandlerName() {
        return String.valueOf(this).split(':')[0];
    }

    protected virtual void beforeInsert() {}
    protected virtual void beforeUpdate() {}
    protected virtual void beforeDelete() {}
    protected virtual void afterInsert() {}
    protected virtual void afterUpdate() {}
    protected virtual void afterDelete() {}
    protected virtual void afterUndelete() {}
}
```

### Handler Implementation
```apex
public with sharing class AccountTriggerHandler extends TriggerHandler {
    private List<Account> newRecords;
    private Map<Id, Account> oldMap;

    public AccountTriggerHandler() {
        this.newRecords = (List<Account>) Trigger.new;
        this.oldMap = (Map<Id, Account>) Trigger.oldMap;
    }

    protected override void beforeInsert() {
        AccountService.setDefaults(newRecords);
    }

    protected override void afterUpdate() {
        List<Account> nameChanged = new List<Account>();
        for (Account acc : newRecords) {
            if (acc.Name != oldMap.get(acc.Id).Name) {
                nameChanged.add(acc);
            }
        }
        if (!nameChanged.isEmpty()) {
            AccountService.syncContactAddresses(nameChanged);
        }
    }
}
```

## Service Layer Pattern
```apex
public with sharing class AccountService {

    public static void setDefaults(List<Account> accounts) {
        for (Account acc : accounts) {
            if (acc.Industry == null) {
                acc.Industry = 'Other';
            }
        }
    }

    public static void syncContactAddresses(List<Account> accounts) {
        Set<Id> accountIds = new Map<Id, Account>(accounts).keySet();
        List<Contact> contacts = [
            SELECT Id, AccountId, MailingStreet
            FROM Contact
            WHERE AccountId IN :accountIds
            WITH USER_MODE
        ];
        // Update logic...
    }
}
```

## Selector Pattern
```apex
public with sharing class AccountSelector {

    public static List<Account> getByIds(Set<Id> ids) {
        return [
            SELECT Id, Name, Industry, BillingStreet
            FROM Account
            WHERE Id IN :ids
            WITH USER_MODE
        ];
    }

    public static List<Account> getByIndustry(String industry) {
        return [
            SELECT Id, Name, Industry
            FROM Account
            WHERE Industry = :industry
            WITH USER_MODE
            LIMIT 200
        ];
    }

    public static List<Account> getWithContacts(Set<Id> ids) {
        return [
            SELECT Id, Name,
                (SELECT Id, FirstName, LastName, Email FROM Contacts)
            FROM Account
            WHERE Id IN :ids
            WITH USER_MODE
        ];
    }
}
```

## Batch Apex Pattern
```apex
public with sharing class AccountCleanupBatch implements
    Database.Batchable<SObject>, Database.Stateful {

    private Integer processedCount = 0;
    private List<String> errors = new List<String>();

    public Database.QueryLocator start(Database.BatchableContext bc) {
        retu