Static variable used for Recurssion check

Question

Scenario: I have two objects - Object A and Object B.Object A has recursion checking mechanism using Static Boolean variables covering different events(IsBeforeUpdate,IsBeforeInsert etc..) I have two apex classes (Class 1 and Class 2) running on Object B that updates Object A on after update.

Question: Let us say an update operation happens on Object B. whats happens to the Static Boolean (IsBeforeUpdate on Object A) will it be set to false by the first class 1 ? and second class 2 will not be able do its update on Object A? if this is true , how can i make sure both my class 1 and 2 from Object B update Object A?

//MasterTaskTrigger
if (trigger.isUpdate && trigger.isAfter) 
{
    handler.afterUpdate(trigger.old, trigger.oldMap, trigger.new, trigger.newMap);
    system.debug('inside After Update');
}

//This is an handler for Task Object
public class TriggerhandlerTask extends TriggerHandler
{
    public void afterUpdate(List<Task> originalTask,Map<ID, Task> originalTaskMap,List<Task>updatedTask,Map<ID, Task>  updatedTaskMap) 
    {
        if(afterUpdateHasRun()) 
        {
            return;
        }
        //Call Class 1 - has logic to update Object A 
        Class1 Cs =  new Class1();
        //Call Class 2 - has logic to update Object A
        Class2 Cs =  new Class2();
    } 
}

//this handler is extended across all other objects Triggerhandlers
public virtual class TriggerHandler 
{
    public   static  boolean isBeforeInsertFirstRun   = true;
    public   static  boolean isBeforeUpdateFirstRun   = true;
    public   static  boolean isBeforeDeleteFirstRun   = true;
    public   static  boolean isAfterInsertFirstRun    = true;
    public   static  boolean isAfterUpdateFirstRun    = true;
    public   static  boolean isAfterDeleteFirstRun    = true;
    public   static  boolean isAfterUndeleteFirstRun  = true;

    protected boolean beforeInsertHasRun() 
    {
        if (isBeforeInsertFirstRun) 
        {       
            return isBeforeInsertFirstRun = false;
            System.debug('---->isBeforeInsertFirstRun'+isBeforeInsertFirstRun); 
        }
        return true;
    }
    protected boolean beforeUpdateHasRun() 
    {
        if (isBeforeUpdateFirstRun) 
        {
            return isBeforeUpdateFirstRun = false;
            System.debug('---->beforeUpdateHasRun'+beforeUpdateHasRun); 
        }
        return true;
    }  
}

Answer 1

You should handle recursion as a locking mechanism. That means that the trigger should first see if it's locked, and if not, lock itself, and when done, unlock itself. Here's the basic design:

public class TriggerLocks {
    public static Boolean triggerA_beforeUpdate = false;
    // and so on
}

trigger triggerA_BeforeUpdate on A (before update) {
    if(TriggerLocks.triggerA_beforeUpdate) {
        return;
    }
    TriggerLocks.triggerA_beforeUpdate = true;
    // Do your logic here
    // When done...
    TriggerLocks.triggerA_beforeUpdate = false;
}

This way, if you have two or more updates on A records, you can do both of them without the trigger flag getting in the way.

Note: "Class 1" nor "Class 2" should update the Boolean flag without good reason. The data is conceptually internal to the trigger itself, but due to language limitations, can't actually be protected in the same way. The trigger, and only the trigger, should modify that flag directly. This limits the responsibility of breaking recursion to just the single trigger's logic.

---

Here's a "not very optimized" version of a handler I might build to help with consistency.

public virtual class BaseTriggerHandler {
    static Map<Type, BaseTriggerHandler> cache = new Map<Type, BaseTriggerHandler>();

    Boolean inBeforeInsert = false, inBeforeUpdate = false, inBeforeDelete = false,
            inAfterInsert = false, inAfterUpdate = false, inAfterDelete = false, inAfterUndelete = false;

    protected virtual void beforeInsert(SObject[] records) {

    }
    protected virtual void beforeUpdate(SObject[] oldRecords, SObject[] records) {

    }
    protected virtual void beforeDelete(SObject[] oldRecords) {

    }
    protected virtual void beforeUndelete(SObject[] records) {

    }
    protected virtual void afterInsert(SObject[] records) {

    }
    protected virtual void afterUpdate(SObject[] oldRecords, SObject[] records) {

    }
    protected virtual void afterDelete(SObject[] oldRecords) {

    }
    protected virtual void afterUndelete(SObject[] records) {

    }
    void doBeforeInsert(SObject[] records) {
        if(!inBeforeInsert) {
            inBeforeInsert = true;
            beforeInsert(records);
            inBeforeInsert = false;
        }
    }
    void doBeforeUpdate(SObject[] oldRecords, SObject[] records) {
        if(!inBeforeUpdate) {
            inBeforeUpdate = true;
            beforeUpdate(oldRecords, records);
            inBeforeUpdate = false;
        }
    }
    void doBeforeDelete(SObject[] oldRecords) {
        if(!inBeforeDelete) {
            inBeforeDelete = true;
            beforeDelete(oldRecords);
            inBeforeDelete = false;
        }
    }
    void doAfterInsert(SObject[] records) {
        if(!inAfterInsert) {
            inAfterInsert = true;
            afterInsert(records);
            inAfterInsert = false;
        }
    }
    void doAfterUpdate(SObject[] oldRecords, SObject[] records) {
        if(!inAfterUpdate) {
            inAfterUpdate = true;
            afterUpdate(oldRecords, records);
            inAfterUpdate = false;
        }
    }
    void doAfterDelete(SObject[] oldRecords) {
        if(!inAfterDelete) {
            inAfterDelete = true;
            afterDelete(oldRecords);
            inAfterDelete = false;
        }
    }
    void doAfterUndelete(SObject[] records) {
        if(!inAfterUndelete) {
            inAfterUndelete = true;
            afterUndelete(records);
            inAfterUndelete = false;
        }
    }
    // The only method you need to call
    public void dispatch() {
        if(Trigger.isInsert && Trigger.isBefore) {
            doBeforeInsert(Trigger.new);
        }
        if(Trigger.isUpdate && Trigger.isBefore) {
            doBeforeUpdate(Trigger.old, Trigger.new);
        }
        if(Trigger.isDelete && Trigger.isBefore) {
            doBeforeDelete(Trigger.old);
        }
        if(Trigger.isInsert && Trigger.isAfter) {
            doAfterInsert(Trigger.new);
        }
        if(Trigger.isUpdate && Trigger.isAfter) {
            doAfterUpdate(Trigger.old, Trigger.new);
        }
        if(Trigger.isDelete && Trigger.isAfter) {
            doAfterDelete(Trigger.old);
        }
        if(Trigger.isUndelete && Trigger.isAfter) {
            doAfterUndelete(Trigger.new);
        }
    }

    protected BaseTriggerHandler() {

    }

    // Singleton/factory
    public static BaseTriggerHandler getHandlerFor(Type handlerType) {
        if(!cache.containsKey(handlerType)) {
            cache.put(handlerType, (BaseTriggerHandler)handlerType.newInstance());
        }
        return cache.get(handlerType);
    }
}

And here's a possible implementation:

public class TaskTriggerHandler extends BaseTriggerHandler {
    protected override void afterUpdate(SObject[] records) {
        Class1 c1 = new Class1();
        Class2 c2 = new Class2();
    }
}

And here's the trigger you use to actually call this entire framework:

trigger TaskTrigger on Task (before insert, before update, before delete, after insert, after update, after delete, after undelete) {
    BaseTriggerHandler.getHandlerFor(TaskTriggerHandler.class).dispatch();
}