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);
        });
    }
}
/**
 * 测试代码
 */
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();
    }
}

如上代码所示 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();
}

然后将其作为参数声明到 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);
        });
    }
}

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

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

四、总结

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

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

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

你可能感兴趣的:(Java,java,python,开发语言)