函数式接口与回调函数实践

一、Java 的函数式接口

是指仅包含一个抽象方法的接口，通常用于 lambda 表达式或方法引用。Java 8 引入了很多内置的函数式接口，比如 Runnable、Callable、Predicate、Function、Consumer 等

演示，数据类型转换的函数式接口的简单使用

step 1 定义函数式接口

@FunctionalInterface
public interface ConvertFunctionalInterface<F, T> {
    /**
     * 把F转换为T 类型
     * @param form 输入对象 F
     * @return 输出对象 T
     */
    T convert(F form);
}

step 2 定义同一调用方法类

public class DataConvert{
    /**
     * 把F转换为T 类型
     * @param data 输入对象 F
     * @return 输出对象 T
     */
    public static <F, T> T processData(F data, ConvertFunctionalInterface<F, T> functional) {
        return functional.convert(data);
    }
}

step 3.定义数据类型转换方法

public class BuildObjTool {
  public static FillTaskSqlEntity buildFillTaskSql(FillTaskSqlDTO fillTask) {

        FillTaskSqlEntity fillTaskSql = new FillTaskSqlEntity();
        fillTaskSql.setExecuteSql(fillTask.getExecuteSql());
        fillTaskSql.setBatch(fillTask.getBatchTime());
        return fillTaskSql;
    	}

 public static ValidTableFieldReqDTO buildValidTableField(CreateTableRelateReqDTO createTable){

        ValidTableFieldReqDTO valid = new ValidTableFieldReqDTO();
        valid.setUserId(createTable.getUserId());
        valid.setEnterpriseId(createTable.getEnterpriseId());
        valid.setCollectionTarget(createTable.getCollectionTarget());
    }
 }

step 4 代码中使用示例

FillTaskSqlEntity fillTask = DataConvert.processData(fillTaskSql, BuildObjTool::buildFillTaskSql);

写到这里，似乎还没体会到函数式接口的好处吧？

如果第二处涉及类型转换，那么，如下：

ValidTableFieldReqDTO valid = DataConvert.processData(createTableRelateReqDTO, BuildObjTool::buildValidTableField);

如果涉及几十处类型转换，那么，对外的转换接口只有这一个，自己传入入参对象，转换方法，以及接收对象。
函数式接口极大地提高了 Java 的灵活性和可读性，使得许多编程模式更为简洁和易于理解。它们在事件处理、异步编程、策略模式以及集合处理等多个场景中都得到了广泛应用

二、回调函数

回调（Callback）是一种编程模式，其中一个函数（或方法）在执行完成后通过调用另一个函数（或方法）来传递执行结果，或在特定事件发生时调用。这种模式常用于异步操作、事件驱动编程中，可以提升代码的可扩展性、灵活性和模块化

示例1：有返回值的，同步调用案例：
step 1 定义回调接口

interface Callback3 {
    String onComplete(String result);
}

step 2 定义任务类

class Task3 {
    public String execute(Callback3 callback3) {
        // 模拟一些业务逻辑处理
        String result = "模拟一些业务逻辑处理!";
        System.out.println("step 1…………………execute……………");
        // 回调通知调用方
        String res = callback3.onComplete(result);
        return res;
    }
}

step 3 业务调用

public static void main(String[] args) {
    Task3 task3 = new Task3();
    // 通过匿名类实现回调
    String res = task3.execute(result -> {
        System.out.println("step 2.Callback received: " + result);
        return "我是中国";
    });
    System.out.println("main ======res:"+res);
}

示例2：看一个创建无关系表中实际使用的回调函数：

step 1.创建回调接口

public interface CallBackInterface {
    List<Map<String, Object>> onComplete(int maxLength);
}

step 2 回调方法类

public class CallBackTask {

    public List<Map<String, Object>> execute(CallBackInterface callback, Map<String, List<Map<String, Object>>> result) {
        // 贪心算法计算数据最长表
        int maxLength = BuildObjTool.greedyAlgorithm(result);
        return callback.onComplete(maxLength);
    }
}

step 3 业务中调用

 CallBackTask callBackTask = new CallBackTask();
            List<Map<String, Object>> buildRespList = callBackTask.execute(res -> BuildObjTool.buildEachTableDataResp(result, createTableInfo, res), result);

复盘一下：
1.业务调用，首先进入CallBackTask 执行execute方法
2.CallBackTask 的execute方法，返回贪心算法得到的长度maxLength
3.回调再调用业务方法中的BuildObjTool.buildEachTableDataResp(result, createTableInfo, res) 执行完返回得到的buildRespList
总路线：业务-->回调任务--->业务

其中用到的工具方法：

public class BuildObjTool {
	//贪心算法
    public static int greedyAlgorithm(Map<String, List<Map<String, Object>>> result) {
        int max = 0;
        for (List<Map<String, Object>> list : result.values()) {
            int length = list.size();
            max = Math.max(max, length);
        }
        return max;
    }
    //把数据组装成List<Map>>结构
  public static List<Map<String, Object>> buildEachTableDataResp(Map<String, List<Map<String, Object>>> result, CreateTableInfoReqDTO createTableInfo, int maxLength) {

        List<Map<String, Object>> resp = new ArrayList<>();

        List<CreateTableFieldReqDTO> tables = createTableInfo.getTables();
        // 1.获取每张表对应取了哪些字段
        Map<String, List<String>> tableFieldMap = tables.stream().collect(Collectors.toMap(CreateTableFieldReqDTO::getEntityName,
            item -> item.getFields().stream().map(CreateTableFieldTypeReqDTO::getTargetFieldName).collect(Collectors.toList()), (k1, k2) -> k1));
        // 2.循环-以最长元素集合为标准
        for (int i = 0; i < maxLength; i++) {

            Map<String, Object> map = new ConcurrentHashMap<>();

            int finalI = i;
            result.forEach((key, value) -> {

                // 4.依次取每个表数据的第i条数据
                int size = value.size();
                Map<String, Object> eachMap;
                if (size > finalI) {
                    eachMap = value.get(finalI);
                } else {
                    eachMap = null;
                }

                List<String> fieldList = tableFieldMap.get(key);
                // 5.获取字段对应的数据
                fieldList.forEach(ite -> {
                    Object obj = null;
                    if (ObjectUtils.isNotEmpty(eachMap)) {

                        obj = eachMap.get(ite);
                    }
                    // 6.存储值到map---没有值的话去获取该字段对应类型的默认值
                    map.put(ite, Objects.nonNull(obj) ? obj : getFieldDefaultValue(ite, createTableInfo));
                });
            });
            resp.add(map);
        }
        return resp;
    }
    }

总结:Java中的回调机制（Callback）是实现异步编程、解耦代码、灵活处理任务的一种重要方式。通过回调，方法A可以在方法B完成时被通知并处理结果。Java的回调机制并不像JavaScript那样原生支持函数作为参数，但通过接口、匿名类或Lambda表达式，可以轻松实现类似的效果。