任务假设

假设现在有这样的需求，有一系列的初始化任务。A 任务初始化是最基础的初始化任务，B,C ... 后面的初始化任务都依赖上个任务的成功结果，直到最后一个任务完成。中间需要每个任务和全部任务结束的状态反馈。

初版实现

抽象层

public abstract class TaskChain {

  public static final String TAG = TaskChain.class.getSimpleName();

  public static TaskStatusListener taskStatusListener;

  private TaskChain next;

  public TaskChain(TaskChain next) {
    this.next = next;
  }

  public abstract boolean handlerTask();

  public void doNext() {
    if (handlerTask() && next != null) {
      if (taskStatusListener != null) {
        taskStatusListener.currentTaskCompleted(this);
      }
      next.doNext();
    } else {
      if (next == null && handlerTask()) {
        if (taskStatusListener != null) {
          taskStatusListener.allCompleted();
        }
      } else {
        if (taskStatusListener != null) {
          taskStatusListener.currentTaskFail(this);
        }
      }
    }
  }

  public interface TaskStatusListener {

    void allCompleted();

    void currentTaskFail(TaskChain taskChain);

    void currentTaskCompleted(TaskChain taskChain);
  }

  @CheckResult
  public TaskChain setTaskStatusListener(TaskStatusListener listener) {
    taskStatusListener = listener;
    return this;
  }

  public TaskChain release() {
    taskStatusListener = null;
    return this;
  }
}

实现

public class Task1 extends TaskChain {

  public Task1(TaskChain next) {
    super(next);
  }

  @Override
  public boolean handlerTask() {
    try {
      Thread.sleep(200); //模拟任务耗时
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    return true;
  }
}

public class Task2 extends TaskChain {

  public Task2(TaskChain next) {
    super(next);
  }

  @Override
  public boolean handlerTask() {
    try {
      Thread.sleep(200);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    return true;
  }
}

public class Task3 extends TaskChain {

  public Task3(TaskChain next) {
    super(next);
  }

  @Override
  public boolean handlerTask() {
    try {
      Thread.sleep(200);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    return true;
  }
}

调用

new Task1(new Task2(new Task3(null))).setTaskStatusListener(
    new TaskStatusListener() {
      @Override
      public void allCompleted() {
        Log.e(TaskChain.TAG,"全部任务完成");
       
      }

      @Override
      public void currentTaskFail(TaskChain taskChain) {
        Log.e(TaskChain.TAG,"子任务失败，任务中断 ：" + taskChain.toString());
      }

      @Override
      public void currentTaskCompleted(TaskChain taskChain) {
        Log.e(TaskChain.TAG,"子任务成功，任务继续 ：" + taskChain.toString());
      }
    }).doNext();

缺陷

我想像 RxJava 一样，当前任务除了能告诉下一个任务成功和失败以外，还想传递当前任务的处理结果给下一个任务使用，但是不希望是直接是个 Object 传递给下个任务还需要下面的任务去做类型判断强转， 目前在代码的抽象设计(或者泛型设计)这块上有些阻塞，期望大佬多多指教！