Is there a pattern to execute a chain of methods based on the result of the previous in Java?

Question

The use case is there is a set of methods which need to be executed based on whether the previous one has returned true or not. For example:

class Test {
    boolean method1() {...}
    boolean method2() {...}
    boolean method3() {...}

    ...

    void callAll() {
        if(method1()) {
             if(method2() {
                 if(method3() {
                     ...
                 }
             }
        } else {
            error();
        }
    }
}

There has to be an else for all the ifs. Is there a better way of handling this scenario?

Answer 1

I would just do it like this:

void callAll(){
    if(method1() && method2() && method3()){
        // all passed
    } else {
        error();    
    }
}

Java short-circuits the && logical operation so failure in a previous method here will prevent running the next one.

If in error() you need to know which of the methods failed, you could declare an error message field for storing the information within the class and set its value corresponding the failure:

private String errorMessage;

//...

boolean method2() {

    // something went wrong
    errorMessage = "Failed to do method2 stuff";
}

Are more elegant way to achieve the same would be to use the Chain of responsibility design pattern and encapsulate the boolean methods in their own handler objects. Doing this would however require more refactoring to the code you currently have and more information about your specific use case.

Answer 2

It's easy enough to write your own varargs method to do this:

public static void run(Supplier<Boolean>... methods) {
    for (Supplier<Boolean> method : methods) {
        if (!method.get()) return;
    }
}

Sample usage:

run(this::method1, this::method2, this::method3);

Answer 3

You can use some form of Observable pattern for these kind of thins too. In most normal cases it seems a bit silly to implement it but otherwise a great way to decouple code from control structures if you have a lot of these. Note that ObservableBoolean is an Android class, but just showing the logic here:

    ObservableBoolean a = new ObservableBoolean();
    ObservableBoolean b = new ObservableBoolean();

    public void call() {
        a.addOnPropertyChangedCallback(new OnPropertyChangedCallback() {
            @Override
            public void onPropertyChanged(android.databinding.Observable sender, int propertyId) {
                method2();
            }
        });
        b.addOnPropertyChangedCallback(new OnPropertyChangedCallback() {
            @Override
            public void onPropertyChanged(android.databinding.Observable sender, int propertyId) {
                //..you end the "chain" here
            }
        });
        method1();
    }

    void method1() {
        if(true) {
            a.set(true);
        }
        else {
            b.set(false);
        }
    }

    void method2() {
        if(true) {
            b.set(true);
        }
        else {
            b.set(false);
        }
    }

Answer 4

You define a class that holds an action (calling one of the methods) and with a corresponding failure handler (the else block of an if call)

public static class ActionWithFailureHandler {
    private Supplier<Boolean> action;
    private Runnable failureHandler;

    public ActionWithFailureHandler(Supplier<Boolean> action, Runnable failureHandler) {
        this.action = action;
        this.failureHandler = failureHandler;
    }
    //Getters for the instance variables

}

You make a list of the above and call each of the actions till one of the following happens

1. One of the actions fails (i.,e one of the method returns false). In that case, you need to execute the failureHandler corresponding to that action.
2. All actions pass. In this case, execute the successHandler (the logic that you execute when all methods return true).

---

private static void callAll(List<ActionWithFailureHandler> actionWithFailureHandlers, Runnable successHandler) {
    actionWithFailureHandlers.stream()
            .filter(actionWithFailureHandler -> !actionWithFailureHandler.getAction().get())
            .findFirst() //Find first failing action
            .map(ActionWithFailureHandler::getFailureHandler)
            .orElse(successHandler)
            .run(); //You might be running either the successHandler or the failureHandler for the first failed action
}

---

Driver code:

public static void main(String[] args) {
    Test test = new Test();
    List<ActionWithFailureHandler> actionWithFailureHandlers = com.google.common.collect.ImmutableList.of(
            new ActionWithFailureHandler(test::method1, () -> System.out.println("Method 1 returned false")),
            new ActionWithFailureHandler(test::method2, () -> System.out.println("Method 2 returned false")),
            new ActionWithFailureHandler(test::method3, () -> System.out.println("Method 3 returned false"))

        );
    callAll(actionWithFailureHandlers, () -> System.out.println("All returned true"));
}

Answer 5

I use this technique - although some would find it odd.

boolean method1() {
    System.out.println("method1");
    return true;
}

boolean method2() {
    System.out.println("method2");
    return false;
}

boolean method3() {
    System.out.println("method3");
    return true;
}

void callAll() {
    boolean success = method1();
    success = success ? method2() : success;
    success = success ? method3() : success;
    if (success) {
        System.out.println("Success");
    } else {
        System.out.println("Failed");
    }
}

Answer 6

I could suggest you to use RX approach, with rxjava it should look like

public boolean test1() {
    Log.d("TESTIT", "test1 called");
    return true;
}

public boolean test2() {
    Log.d("TESTIT", "test2 called");
    return true;
}

public boolean test3() {
    Log.d("TESTIT", "test3 called");
    return false;
}

public boolean test4() {
    Log.d("TESTIT", "test4 called");
    return true;
}

public boolean elseMethod(boolean result) {
    if (result) return true;
    else {
        Log.d("TESTIT", "ELSE");
    }
    return false;
}

public void chainedCallback() {
    Observable.just(test1())
            .filter(this::elseMethod)
            .flatMap(aBoolean -> Observable.just(test2()))
            .filter(this::elseMethod)
            .flatMap(aBoolean -> Observable.just(test3()))
            .filter(this::elseMethod)
            .flatMap(aBoolean -> Observable.just(test4()))
            .filter(this::elseMethod)
            .subscribe();
}

call for chainedCallback() will print

test1 called
test2 called
test3 called
ELSE

Answer 7

Exception firstly comes to my mind, but see the link below to learn more about its performance hit.

Original answer. I would do..

public class MyException extends Exception
{
}
public void doAll()
{
     try
     {
          method1();
          method2();
          method3();
     }catch (MyException e)
     {
            error();
      }
}

And let's assume that method1, method2, and method3 throws MyException when it fails.

Though it does not fit your question, it is a good pattern to use Exceptions.

public class Helper
{
    public Helper(Method m)
    {
          this.method=m;
     }
     public void Do() throws MyException
     {
          if(method.invoke()==false)
                throw new MyException ();
      }
} 

Using this class,

public void doAll()
    {
         Helper [] helpers={new Helper(this::method1), new Helper(this::method2), new Helper (this::method3)};

         try
         {
              for(Helper helper:helpers)
              {
                     helper.Do();
               }
         }catch (MyException e)
         {
                error();
          }
    }

But

according to the comment of @dilix and the link, it can be a performance-expensive strategy. So let's use them only for their purpose.