Java 函数式编程思考 —— 授人以渔

引言

最近在使用函数式编程时，突然有了一点心得体会，简单说，用好了函数式编程，可以极大的实现方法调用的解耦，业务逻辑高度内聚，同时减少不必要的分支语句（if-else）。

一、函数式编程就是Lambda表达式吗？

Java语言早在 JDK8 就提供了函数式编程的基础。

你可能会问，函数编程不就是lambda表达式吗？

的确，大多数开发可能还停留在 lambda 表达式的使用层面，但请注意，我从标题、文章开篇都在强调“函数式编程”，很明显，我有意区别函数式编程和lambda表达式两者的概念。

Java 8 引入的函数式编程到底是什么？最近我在开发过程中遇到了一个场景，才让我解开了这个困扰我的问题。

二、一个小场景——多路调用

我遇到的场景其实并不复杂，或者说我们每天都在写如此场景，我甚至并不知道这么简单的场景有没有相应的专有名词来表示，就暂将其称为“多路调用场景”。让我们简单模拟一下。

场景描述：
A Service 和 B Service 都依赖 CService。
A 和 B都用到了 C的一个方法 doProcess()，但 doProcess() 在处理 A 和 B的请求时，又需要拿到 A 或 B 的业务数据。
该如何实现 doProcess() 方法？

@AllArgsConstructor
class AService {
    private CService cService;

    public void processData() {
        List<Object> all = this.getAll();
        cService.doProcess(all);
    }

    private List<Object> getAll() {
        return Collections.emptyList();
    }
}

@AllArgsConstructor
class BService {
    private CService cService;

    public void processData() {
        List<Object> data = this.queryBDatas();
        cService.doProcess(data);
    }

    private List<Object> queryBDatas() {
        return new ArrayList<>();
    }
}

class CService {
    public void doProcess(List<Object> busiData) {
        // 执行C自己的处理逻辑...
        busiData.stream().forEach(d -> {
            System.out.println(d);
        });
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

/**
 * 测试代码
 */
public class Test {
    public static void main(String[] args) {
        // 实例化服务对象
        CService cService = new CService();
        AService aService = new AService(cService);
        BService bService = new BService(cService);

        // A -> C 处理请求
        aService.processData();

        // B -> C 处理请求
        bService.processData();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

如上代码所示 A、B 的processData 方法都调用C的doProcess 方法，他们都将 doProcess 所需的数据通过参数传递过去。这种实现方式虽然可以成功的适配不同的调用者，但是数据的生成是在调用 doProcess 前，一旦doProcess执行了一些校验逻辑而无法用到这些已经准备好的数据，就可能白白浪费查询资源。

另一种实现是通过循环依赖，将A或B的实例反过来也注入到 C 服务中，在 doProcess 中，需要用到A 或 B 的数据时才去查询。这种实现方式虽然可以实现懒加载，但又引入了另一个问题，就是高耦合性，而且依然需要通过 if-else 判断具体是要执行 A.getAll 还是需要执行 B.queryList，代码冗杂不说，扩展性也很糟糕。

当然，上述代码只是个模型，实际业务可能比这还要复杂。那到底有没有一种，既可以实现懒加载，又高度内聚，不需要循环依赖的实现方式呢？

三、授人以鱼不如授人以渔

请原谅我起了一个这么哗众取宠的小节标题，我后面会解释。

3.1 传统思路的弊端

传统的实现思路，将数据提前准备好传递过去，或使用循环依赖，增加判断条件，执行不同的业务逻辑。

似乎这类实现已被大家习以为常，但就像前面描述的，数据传递可能会造成性能、资源等浪费；传统的延迟处理又需要搭配循环依赖，从而造成严重的依赖混乱问题，明明公共服务被业务服务依赖，公共服务却反过来还要依赖业务服务，扩展性极低。

而函数式编程可以很好的解决这个问题！

3.2 授人以渔

Java 8 引入的函数式编程，允许开发者将函数像参数一样传递。

直到最近，我才终于理解了这个定义。函数，实际上就是一个具体的处理逻辑，一个解决方案，一个“捕鱼的方法”、一个可开箱即用的“锦囊妙计”。

我们将函数传递到另一个方法中，那么在这个方法中，就可以直接去执行这个函数。

再回到上面的场景中，A和 B调用 C 的 doProcess() 方法，如果使用函数式编程，该如何实现？

首先定义一个业务数据查询函数：

// 业务数据查询函数
@FunctionalInterface
public interface BusiDataQueryFunc {
    List<Object> queryList();
}
1
2
3
4
5

然后将其作为参数声明到 doProcess 参数中，令A或B调用时传递一个具体的实现逻辑，如下所示：

@AllArgsConstructor
class AService {
    private CService cService;

    public void processData() {
        cService.doProcess(() -> this.getAll());
    }

    private List<Object> getAll() {
        // A 业务数据查询逻辑
        return Collections.emptyList();
    }
}

@AllArgsConstructor
class BService {
    private CService cService;

    public void processData() {
        // 传入数据查询函数
        cService.doProcess(() -> this.queryBDatas());
    }

    private List<Object> queryBDatas() {
        // B 业务数据查询逻辑
        return new ArrayList<>();
    }
}

class CService {
    public void doProcess(BusiDataQueryFunc busiDataQueryFunc) {
        // 查询调用者所需数据
        List<Object> busiData = busiDataQueryFunc.queryList();
        // 执行C自己的处理逻辑...
        busiData.stream().forEach(d -> {
            System.out.println(d);
        });
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

如此，在doProcess中，就不需要使用任何的 if 判断，同时也实现了懒加载获取到业务的数据。相比传统的将数据传递，或通过特定参数加if-else按条件查询，耦合度更低，这是集性能强、扩展性强、耦合度低等优点于一身的优秀实现方式。

如果把数据传递到方法中，比作授人以鱼，那么函数传递，就是授人以渔。将“捕鱼的方法”告诉被调用者，这就是为什么我将函数式编程称为——授人以渔的开发思想。

四、总结

在多路调用的场景中，通常会需要在被调用方法中使用到调用者的一些数据，传统的编程方式是直接将数据作为参数传递过去，或者通过一些业务标识用if-else的方式来判断该调用哪个业务方法。

直接传递数据的方式，提前将数据准备好，会有性能问题，可能在被调用方法的校验逻辑执行中断，用不到数据，浪费系统资源；而通过普通的if-else 分支，又需要将调用者注入到被依赖方，虽然实现了懒加载，但本身形成了循环依赖，造成了高耦合，存在潜在的开发成本。

所以，Java 8 提供的函数式编程，将获取数据的方式通过函数传递给被调用者，授人以渔，即满足懒加载，又解耦了依赖关系。这在依赖关系复杂的系统中是一个非常有用的设计思想。