Avoiding Logic in Triggers

// Growing increasingly hard to manage
trigger OpportunityTrigger on Opportunity (before insert, before update, after insert) {
    if (Trigger.isBefore) {
        for (Opportunity opp : Trigger.new) {
            if (opp.Amount != null && opp.Amount > 100000) {
                opp.Priority__c = 'High';
            }
            // ...five more unrelated rules added over time...
        }
    }
    if (Trigger.isAfter && Trigger.isInsert) {
        // ...yet more logic...
    }
}

1. // Growing increasingly hard to manage — the label warns what's coming.
2. trigger OpportunityTrigger on Opportunity (before insert, before update, after insert) { — one trigger handling three events at once.
3. if (Trigger.isBefore) { — branches on timing.
4. for (Opportunity opp : Trigger.new) { — loops over the records.
5. if (opp.Amount != null && opp.Amount > 100000) { — the original business rule.
6. opp.Priority__c = 'High'; — applies it.
7. } — closes the if.
8. // ...five more unrelated rules added over time... — as more rules get added directly inside the trigger body, it becomes harder to read.
9. } — closes the loop.
10. } — closes the outer if.
11. if (Trigger.isAfter && Trigger.isInsert) { — a second branch, for a different event.
12. // ...yet more logic... — critically, impossible to unit test in isolation, since a trigger can't be called directly the way a regular method (Module 9) can.
13. } — closes the if.
14. } — closes the trigger.

public class OpportunityTriggerHandler {
    public void beforeInsert(List<Opportunity> newOpportunities) {
        for (Opportunity opp : newOpportunities) {
            if (opp.Amount != null && opp.Amount > 100000) {
                opp.Priority__c = 'High';
            }
        }
    }
}

trigger OpportunityTrigger on Opportunity (before insert) {
    new OpportunityTriggerHandler().beforeInsert(Trigger.new);
}

1. public class OpportunityTriggerHandler { — a regular Apex class, not a trigger.
2. public void beforeInsert(List<Opportunity> newOpportunities) { — a plain method, taking a plain List<Opportunity>.
3. for (Opportunity opp : newOpportunities) { — the same loop as before.
4. if (opp.Amount != null && opp.Amount > 100000) { — the same business rule.
5. opp.Priority__c = 'High'; — the same effect.
6. } — closes the if.
7. } — closes the loop.
8. } — closes the method.
9. } — closes the class.
10. (blank line)
11. trigger OpportunityTrigger on Opportunity (before insert) { — the trigger itself is now nearly empty.
12. new OpportunityTriggerHandler().beforeInsert(Trigger.new); — it just hands Trigger.new off to the handler.
13. } — closes the trigger.

All the actual logic lives in a regular Apex class, which — critically — can be called directly and tested like any other class from Modules 9-17.

This is Module 14's Single Responsibility Principle, applied to triggers specifically: the trigger's one job is "notice the event and hand off," while the handler class's job is "actually decide what to do." A later Testing module will show exactly why this separation makes triggers realistically testable — testing OpportunityTriggerHandler.beforeInsert() directly, with a plain List<Opportunity>, is far simpler than trying to test trigger behavior indirectly through actual DML.