Java8函数式编程应用小结
作者：红文
我们经常提到，Java8是革命性的一个版本，原因就是正式引入了函数式编程，那Java的函数式编程在实际应用中到底有什么用呢？结合实际的应用，我整理出了函数式在Java的几个经典用途。
缓求值
惰性求值（Lazy evaluation）是在需要时才进行求值的计算方式。惰性求值自然地在数据结构中包含递归，可以以简单的方式表示无限的概念，这种方式有利于程序的模块化。
在Java这种Strict语言中，我们定义了临时变量代码块就会立即运算并且取得结果，而实际上很多结果未必会使用到，就存在不必要的计算，如下面的代码
/**
* 是否是标准或默认工作台
* 理论上仅判断默认工作台即可（因为标准就是默认），此处是兜底一下历史逻辑
*
* @param context
* @return
*/
public boolean isStandardOrDefaultWorkbench(SchemaContext context) {
Supplier<Boolean> isDefaultWorkbench = () -> StringUtils.isNotBlank(context.getDefaultAppUuid())
&& StringUtils.equals(context.getAppUuid(), context.getDefaultAppUuid());
return WorkbenchType.WORKBENCH.equals(context.getWorkbenchType()) || isDefaultWorkbench.get();
}当我们使用临时变量定义的时候，需要理解计算出代码
StringUtils.isNotBlank(context.getDefaultAppUuid())
&& StringUtils.equals(context.getAppUuid(), context.getDefaultAppUuid())的值，并用于后面的判断，不管下面的代码是否为True，我们都消耗了一次计算
WorkbenchType.WORKBENCH.equals(context.getWorkbenchType())
而我们使用了Supplier，就可以定义一个匿名表达式，只有当前面判断为False的时候，才会执行
isDefaultWorkbench.get()
，而当前面判断为True的时候，就不会执行后面的代码了，通过缓求值的方式，可以节省在某些情况下的消耗，可以提升系统性能，节省资源。
高阶函数
高阶函数是指使用其他函数作为参数、或者返回一个函数作为结果的函数。
我们常用的Stream就是典型的流处理思想，可以通过Stream来处理集合并执行相关的操作，其中Stream包含了大量的高阶函数，我们可以直接使用匿名表达式来传递业务逻辑。值得注意，匿名表达式本身返回的就是函数，因此匿名表达式就是一种高阶函数。
// 过滤隐藏应用
return appDetails.stream().filter(app -> {
AppModel appModel = new AppModel(app.getAppId(), app.getAppType());
return !appDisplayModel.getHideApps().contains(appModel);
}).collect(Collectors.toList());从上面可以逻辑可以看到，我们可以通过集合的Stream对象进行filter、map、collect操作，其中这些高阶函数就可以传递lambda表达式，用于处理我们需要的逻辑。
当然除了Stream之外，Java很多工具类也支持外部传入lambda，比如还有一种常见的工具类Optional。
/**
* 获取组织默认工作台appUuid
* @param corpId
* @param orgConfigTag
* @return
*/
public String getDefaultWorkbenchAppUuid(String corpId, OrgConfigTag orgConfigTag) {
return Optional.ofNullable(orgConfigTag).map(OrgConfigTag::getDefaultAppUuid)
.orElseGet(() -> OpenPageUtils.buildWorkbenchAppUuid(corpId));
}其中的orElseGet方法就支持外部传入lambda表达式。
函数回调
在计算机程序设计中，回调函数，或简称回调（Callback 即call then back 被主函数调用运算后会返回主函数），是指通过参数将函数传递到其它代码的，某一块可执行代码的引用。 这一设计允许了底层代码调用在高层定义的子程序。
函数回调可用于接口两块完全无关的逻辑，比如在A模块执行完毕后，执行B模块，B模块的代码事先在A模块注册。很多框架型的逻辑，比如统一结果处理、缓存框架、分布式锁、线程缓存等都可以通过这个方式来优化，就可以使用lambda的方式来实现。核心的逻辑就是先处理相关的通用的中间件逻辑，然后通过lambda来执行业务逻辑。
/**
* 创建我的页面
*
* @param corpId
* @param uid
*/
protected void createMyPage(String corpId, Long uid, String appUuid, Method method) throws WorkbenchException {
// 并发锁控制
distributeLockSupport.lockAndDo(key,
() -> {
//创建页面方法
userCorpPageSupport.createMyPage(corpId, uid);
return null;
}
);
}如上面的代码，对于要实现分布式锁控制的模块，可以使用lambda的回调，来实现加锁和业务逻辑的分离。其中的定义如下述代码所示
/**
* 基于缓存的分布式锁操作
*
* @param key 资源key
* @param callback 回调函数
* @param <T> 返回结果类型
* @return
* @throws Exception
*/
public <T> T lockAndDo(String key, Callback<T> callback) throws WorkbenchException {
//取锁
...
try {
//加锁
...
return callback.process();
} catch (WorkbenchException ex) {
throw ex;
} finally {
try {
//释放锁
...
} catch (Exception ex) {
//异常处理
}
}
}
//回调接口定义，供外部传入lambda
@FunctionalInterface
public interface Callback<T> {
/**
* 回调处理
*
* @return 处理结果
* @throws WorkbenchException
*/
T process() throws WorkbenchException, ServiceException;
}自定义函数
从函数式编程的核心思想来说，函数是一等公民，而面向对象的核心是封装。可以通过定义函数的方式来降低面向对象命令式编程的复杂度。即尽量把处理逻辑都抽象成可复用的函数，并通过lambda的方式进行调用。
/**
* 批量操作
*
* @param consumer 函数式写法，对批量对象操作
*/
public void batchProccess(BiConsumer<Long, OrchardDTO> consumer) {
if(orchardDTOMap!=null && orchardDTOMap.size()>0){
for (Map.Entry<Long, OrchardDTO> entry : orchardDTOMap.entrySet()) {
consumer.accept(entry.getKey(), entry.getValue());
}
}
}public void syncPush(MicroAppContext context, BatchOrchardDTO batchOrchardDTO) {
//传入lambda来执行逻辑
batchOrchardDTO.batchProccess((k, v) -> pushFacadeService.push(k, v));
}如上图所示，就是在类中定义了一个高阶函数，在调用的时候从外部传入lambda表达式，从而实现batchProccess和pushFacadeService.push两个方法的解耦。上面的核心和集合支持lambda是一个意思，也就是把需要外部频繁操作的部分抽象出来定义成函数式接口，以供外部传入不同的lambda进行丰富的操作。
总结
Java8非常重要的就是引入了函数式编程的思想，使得这门经典的面向对象语言有了函数式的编程方式。弥补了很大程度上的不足，函数式思想在处理复杂问题上有着更为令人称赞的特性。
到此这篇关于Java8函数式编程应用小结的文章就介绍到这了,更多相关Java8函数式编程应用内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！