Design pattern for executing and reverting the tasks in same order

Question

I have a Task in my project , to complete that i have call(REST) multiple external systems. If my call fails at some level , i have to rollback all my previous calls(making call with undo action) .

Looking for effective way of implementing it in JAVA. Can Someone point me to any design pattern if exists?

    public void myTask(){


        call subtask1() ; //external sys

        try{
            call subtask2();
        }
        catch(Exception){
            call undo_subtask1();
        }

        try{
            call subtask3();
        }
        catch(Exception){
            call undo_subtask1();
            call undo_subtask2();  //calling in any order is fine.
        }

        .....
    }

The above code is similar to database rollback. Tomorrow there can be subtask 4, 5,6 . I don't want to add try/catch again. Is there recommended way to achieve this?

When i googled i got command pattern. But i don't understand how that will help my case.

Thanks

Answer 1

If it is not a problem to run the undo action also for the steps that either failed or weren't executed at all, you can just use the fact that an exception will cause the execution of the try block to be stopped with a jump to the catch block.

public void myTask()
{
  try
  {
    call subtask1();
    call subtask2();
    call subtask3();
    ...
  }
  catch(Exception){
    ...
    call undo_subtask3();
    call undo_subtask2();
    call undo_subtask1();
    throw; // re-throw the exception
  }
}

Adding a new subtask is just adding the corresponding call subtaskX()/call undo_subtaskX() to the try and catch blocks.

If you want to avoid calling undo actions for subtasks that didn't complete successfully, you could either use nested try blocks, or a set of booleans to indicate which subtasks completed successfully and need to be rolled back in case of an exception.

Answer 2

We can wrap each pair undo_subtask1, undo_subtask2 etc, in an object

interface Subtask {
    void undo();
}

We can then put each task into a container, and the cleanup calls all the undos

public void myTask() {
  try (List<Subtask> done = new ArrayList<Subtask>())
  {
    subtask1();
    done.add(new Subtask {
      public void undo() { undo_subtask1(); }
    })

    subtask2();
    done.add(new Subtask {
      public void undo() { undo_subtask2(); }
    })

    subtask3();
    done.add(new Subtask {
      public void undo() { undo_subtask3(); }
    })

    ...
  }
  catch(Exception){
    for (Subtask subtask : done)
    {
      subtask.undo();
    }

    throw;
  }
}