引言
最近在使用函数式编程时,突然有了一点心得体会,简单说,用好了函数式编程,可以极大的实现方法调用的解耦,业务逻辑高度内聚,同时减少不必要的分支语句(if-else)。
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,代码冗杂不说,扩展性也很糟糕。
当然,上述代码只是个模型,实际业务可能比这还要复杂。那到底有没有一种,既可以实现懒加载,又高度内聚,不需要循环依赖的实现方式呢?
请原谅我起了一个这么哗众取宠的小节标题,我后面会解释。
传统的实现思路,将数据提前准备好传递过去,或使用循环依赖,增加判断条件,执行不同的业务逻辑。
似乎这类实现已被大家习以为常,但就像前面描述的,数据传递可能会造成性能、资源等浪费;传统的延迟处理又需要搭配循环依赖,从而造成严重的依赖混乱问题,明明公共服务被业务服务依赖,公共服务却反过来还要依赖业务服务,扩展性极低。
而函数式编程可以很好的解决这个问题!
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 提供的函数式编程,将获取数据的方式通过函数传递给被调用者,授人以渔,即满足懒加载,又解耦了依赖关系。这在依赖关系复杂的系统中是一个非常有用的设计思想。