群晖搭建企业网站厦门人才网个人会员

之前的文章提到函数式编程的一等函数（First-class Function）四个性质中有“可以将过程作为返回值”这一点，但这一点在实际使用中不如“将过程作为参数”（高阶函数）用得多。本文介绍一种这个性质用于分步函数的应用。

（注意：本文旨在介绍一种编程技巧，希望可以给读者一点启发，并非介绍某类问题的最优解，实际使用还需具体问题具体分析）

问题场景

相信所有人都接触过一类需求：完成某个任务x，这个任务x由三个步骤a、b、c组成，比如：一个拍照功能，可能包含三个步骤：1. 调起摄像头拍照；2. 编辑优化照片；3. 保存照片到相册。那么这类功能最简单的形式就是：

class Demo{public static void main(String[] args) {taskX();}static void taskX(){//1. 执行第一步System.out.println("step 1...");//1. 执行第二步System.out.println("step 2...");//1. 执行第三步System.out.println("step 3...");}
}

但是，有时候我们并不要求这三个步骤一气呵成，允许完成各个步骤后去做点其他事情，然后再回来做剩余工作。又或者其中某个步骤在有些时候不能直接执行，需要一些准备工作。比如上面所说的拍照示例中，在Android平台调用摄像头得请求到摄像头权限，然后保存相册还需要文件访问权限。这类行为和系统平台相关，如果我们想一套代码运行于多个平台上，就得分离核心功能和平台相关功能。

一种方式是直接把三个步骤写成三个子过程：

class Demo {public static void main(String[] args) {TaskX.step1();System.out.println("do other task....");TaskX.step2();System.out.println("do other task2....");TaskX.step3();}
}class TaskX{static void step1() {System.out.println("step 1...");}static void step2() {System.out.println("step 1...");}static void step3() {System.out.println("step 1...");}
}

但是这样相当于直接暴露三个子步骤，外部可以以任意顺序调用三个步骤，而且如果step2的执行依赖于step1的执行成功，那么就可能引发问题，需要额外的文档/注释来说明，即便有了注释也没法保证安全。（这里假设写TaskX模块的人与使用的人并非同一个）

如果我们可以像下面这样表达一个过程：

主过程：1. 子过程12. 子过程23. 子过程3

并且这些子过程的执行分步执行，那么就可以处理这个情况了。

分步过程的实现

如果我们把一个无参无返回值的过程的类型写作() -> void，那么分步函数的类型是不是可以写作() -> -> -> void，表示可以分三步执行，这个表示法稍微再加点元素就是() -> () -> () -> void，跟柯里化的形式很像，对吧？接下来就是要利用这个。

这样的过程用Scala很容易表达：

val taskX = () => {println("step 1...")() => {println("step 2...")() => {println("step 3...")}}
}

但是用Java，我们就得写成：

class Demo {public static void main(String[] args) {Supplier<Supplier<Runnable>> taskXSupplier = doTaskX();Supplier<Runnable> step2Supplier = taskXSupplier.get();//执行step1System.out.println("do other task....");Runnable step3 = step2Supplier.get();//执行step2System.out.println("do other task....");step3.run();执行step3}static Supplier<Supplier<Runnable>> doTaskX() {return () -> {System.out.println("step 1...");return () -> {System.out.println("step 2...");return () -> System.out.println("step 3...");};};}
}

调用方的代码太难看，我们添加几个函数式接口来稍微美化一下：

class Demo {public static void main(String[] args) {Step1 step1 = doTaskX();Step2 step2 = step1.run();//执行step1System.out.println("do other task....");Step3 step3 = step2.run();//执行step2System.out.println("do other task....");step3.run();//执行step3}static Step1 doTaskX() {return () -> {System.out.println("step 1...");return () -> {System.out.println("step 2...");return () -> System.out.println("step 3...");};};}public interface Step1 {Step2 run();}public interface Step2 {Step3 run();}public interface Step3 extends Runnable {}
}

这样每次写接口定义也挺麻烦，我们可以预先定义好Step1、Step2…Step10，这样写过程的时候想分几步，就选择对应类型的接口。

简化分步过程的编写

如果不想定义接口，我们可以编写这样一个工具MultiStepTask：

class MultiStepTask {private final Iterator<Runnable> stepIterator;private MultiStepTask(List<Runnable> stepList) {stepIterator = stepList.iterator();}public static MultiStepTask create(Runnable... actions) {List<Runnable> stepList = Arrays.stream(actions).toList();return new MultiStepTask(stepList);}public void doNext() {if (stepIterator.hasNext()) {stepIterator.next().run();}}public void doComplete() {while (stepIterator.hasNext()) {stepIterator.next().run();}}public boolean isCompleted(){return !stepIterator.hasNext();}
}

这样我们的创建分步过程的代码就变成了：

static MultiStepTask taskX() {return MultiStepTask.create(() -> System.out.println("step 1..."),() -> System.out.println("step 2..."),() -> System.out.println("step 3..."));
}

然后调用的代码就是：

class Demo {public static void main(String[] args) {MultiStepTask taskX = taskX();taskX.doNext();//执行step1System.out.println("do other task....");taskX.doNext();//执行step2System.out.println("do other task....");taskX.doNext();//执行step3}
}