Review and Refactor

trigger OpportunityTrigger on Opportunity (before update, after update) {
    OpportunityTriggerHandler handler = new OpportunityTriggerHandler();
    if (Trigger.isBefore) {
        handler.beforeUpdate(Trigger.new, Trigger.oldMap);
    }
    if (Trigger.isAfter) {
        handler.afterUpdate(Trigger.new, Trigger.oldMap);
    }
}

1. trigger OpportunityTrigger on Opportunity (before update, after update) { — routes both events.
2. OpportunityTriggerHandler handler = new OpportunityTriggerHandler(); — one handler instance.
3. if (Trigger.isBefore) { — the validation path.
4. handler.beforeUpdate(Trigger.new, Trigger.oldMap); — blocks invalid saves.
5. } — closes the if.
6. if (Trigger.isAfter) { — the rollup path.
7. handler.afterUpdate(Trigger.new, Trigger.oldMap); — detects changes and delegates to AccountRollupService.
8. } — closes the if.
9. } — closes the trigger.

Three pieces, each with one clear job: OpportunityTrigger (routes events), OpportunityTriggerHandler (detects what changed and by how much), AccountRollupService (applies the adjustment). This mirrors every project module's closing lesson — a system that works, then reviewed once more with fresh eyes.

• Bulk-safe? Yes — exactly one query and one DML statement in the rollup path, regardless of batch size (Module 25).
• Thin trigger? Yes — the trigger body only routes to handler methods (Module 24).
• Single Responsibility? Yes — three classes, three distinct jobs (Module 14).
• Validated? Yes — a Closed Won Opportunity can't save without a positive Amount (this module, Lesson 4).
• Verified? Yes, manually — formal automated tests are still ahead, in Module 31.

public class OpportunityTriggerHandler {
    private static final String CLOSED_WON = 'Closed Won';

    public void afterUpdate(List<Opportunity> newOpportunities, Map<Id, Opportunity> oldMap) {
        for (Opportunity opp : newOpportunities) {
            Opportunity oldOpp = oldMap.get(opp.Id);
            Boolean justWon = opp.StageName == CLOSED_WON && oldOpp.StageName != CLOSED_WON;
            // ...
        }
    }
}

1. public class OpportunityTriggerHandler { — the handler class.
2. private static final String CLOSED_WON = 'Closed Won'; — the literal string 'Closed Won' appeared in three separate places across this module's code so far — a classic candidate for Module 13's final keyword.
3. (blank line)
4. public void afterUpdate(List<Opportunity> newOpportunities, Map<Id, Opportunity> oldMap) { — the method.
5. for (Opportunity opp : newOpportunities) { — loops as before.
6. Opportunity oldOpp = oldMap.get(opp.Id); — the prior version.
7. Boolean justWon = opp.StageName == CLOSED_WON && oldOpp.StageName != CLOSED_WON; — one named constant used in place of the repeated literal — changed in exactly one place if the stage name ever needs to change.
8. // ... — the rest of the method, unchanged.
9. } — closes the loop.
10. } — closes the method.
11. } — closes the class.