Java Swing 自定义组件库分享（二）：回调函数处理器 — CallbackProcessor
一、这个类解决什么问题？
在 Swing 开发中，经常需要传回调函数，比如按钮点击事件、窗口关闭事件、异步任务完成后的处理。
原来写法经常是这样：
if (null != callback) {
callback.run();
}
到处写判空，代码臃肿且重复。
CallbackProcessor 的作用就是：封装判空逻辑，让代码更简洁。
二、类源码
/**
* 回调函数处理器
* 封装各种函数式接口的判空调用，简化代码
*
* 使用示例：
* 1. 执行可能为null的Runnable：
* CallbackProcessor.run(() -> doSomething());
* 2. 获取返回值并带默认值：
* String result = CallbackProcessor.get(() -> getData(), "默认值");
* 3. 条件判断：
* boolean valid = CallbackProcessor.test(value -> value > 0, 10);
*/
public class CallbackProcessor {
/**
* 执行无参无返回值的回调
* @param callback 回调函数，可为null
*/
public static void run(Runnable callback) {
if (null != callback) {
callback.run();
}
}
/**
* 执行带一个参数的回调
* @param callback 回调函数，可为null
* @param t 参数
* @param <T> 参数类型
*/
public static <T> void accept(Consumer<T> callback, T t) {
if (null != callback) {
callback.accept(t);
}
}
/**
* 执行带两个参数的回调
* @param callback 回调函数，可为null
* @param t 第一个参数
* @param u 第二个参数
*/
public static <T, U> void accept(BiConsumer<T, U> callback, T t, U u) {
if (null != callback) {
callback.accept(t, u);
}
}
/**
* 获取供给值，返回Optional包装
* @param callback 供给函数，可为null
* @return Optional包装的结果，回调为null时返回Optional.empty()
*/
public static <R> Optional<R> get(Supplier<R> callback) {
return null != callback ? Optional.ofNullable(callback.get()) : Optional.empty();
}
/**
* 获取供给值，带默认值
* @param callback 供给函数，可为null
* @param defaultValue 回调为null或返回null时的默认值
* @return 供给值或默认值
*/
public static <R> R get(Supplier<R> callback, R defaultValue) {
return null != callback ? callback.get() : defaultValue;
}
/**
* 执行转换函数，返回Optional包装
* @param callback 转换函数，可为null
* @param t 输入参数
* @return Optional包装的结果，回调为null时返回Optional.empty()
*/
public static <T, R> Optional<R> apply(Function<T, R> callback, T t) {
return null != callback ? Optional.ofNullable(callback.apply(t)) : Optional.empty();
}
/**
* 执行转换函数，带默认值
* @param callback 转换函数，可为null
* @param t 输入参数
* @param defaultValue 回调为null或返回null时的默认值
* @return 转换结果或默认值
*/
public static <T, R> R apply(Function<T, R> callback, T t, R defaultValue) {
return null != callback ? callback.apply(t) : defaultValue;
}
/**
* 执行双参数转换函数，返回Optional包装
* @param callback 转换函数，可为null
* @param t 第一个参数
* @param u 第二个参数
* @return Optional包装的结果，回调为null时返回Optional.empty()
*/
public static <T, U, R> Optional<R> apply(BiFunction<T, U, R> callback, T t, U u) {
return null != callback ? Optional.ofNullable(callback.apply(t, u)) : Optional.empty();
}
/**
* 执行双参数转换函数，带默认值
* @param callback 转换函数，可为null
* @param t 第一个参数
* @param u 第二个参数
* @param defaultValue 回调为null或返回null时的默认值
* @return 转换结果或默认值
*/
public static <T, U, R> R apply(BiFunction<T, U, R> callback, T t, U u, R defaultValue) {
return null != callback ? callback.apply(t, u) : defaultValue;
}
/**
* 执行一元运算，返回Optional包装
* @param callback 一元运算函数，可为null
* @param t 输入参数
* @return Optional包装的结果，回调为null时返回Optional.empty()
*/
public static <T> Optional<T> apply(UnaryOperator<T> callback, T t) {
return null != callback ? Optional.ofNullable(callback.apply(t)) : Optional.empty();
}
/**
* 执行一元运算，带默认值
* @param callback 一元运算函数，可为null
* @param t 输入参数
* @param defaultValue 回调为null或返回null时的默认值
* @return 运算结果或默认值
*/
public static <T> T apply(UnaryOperator<T> callback, T t, T defaultValue) {
return null != callback ? callback.apply(t) : defaultValue;
}
/**
* 执行二元运算，返回Optional包装
* @param callback 二元运算函数，可为null
* @param t1 第一个参数
* @param t2 第二个参数
* @return Optional包装的结果，回调为null时返回Optional.empty()
*/
public static <T> Optional<T> apply(BinaryOperator<T> callback, T t1, T t2) {
return null != callback ? Optional.ofNullable(callback.apply(t1, t2)) : Optional.empty();
}
/**
* 执行二元运算，带默认值
* @param callback 二元运算函数，可为null
* @param t1 第一个参数
* @param t2 第二个参数
* @param defaultValue 回调为null或返回null时的默认值
* @return 运算结果或默认值
*/
public static <T> T apply(BinaryOperator<T> callback, T t1, T t2, T defaultValue) {
return null != callback ? callback.apply(t1, t2) : defaultValue;
}
/**
* 执行断言判断
* @param callback 断言函数，可为null
* @param t 参数
* @return 判断结果，回调为null时返回false
*/
public static <T> boolean test(Predicate<T> callback, T t) {
return null != callback && callback.test(t);
}
/**
* 执行双参数断言判断
* @param callback 断言函数，可为null
* @param t 第一个参数
* @param u 第二个参数
* @return 判断结果，回调为null时返回false
*/
public static <T, U> boolean test(BiPredicate<T, U> callback, T t, U u) {
return null != callback && callback.test(t, u);
}
}
三、核心方法说明
| 方法 | 参数类型 | 返回值 | 用途 |
|---|---|---|---|
| run | Runnable | void | 执行无参无返回值的回调 |
| accept | Consumer / BiConsumer | void | 执行带参数的回调 |
| get | Supplier | Optional / 默认值 | 获取供给值，可设默认 |
| apply | Function / BiFunction / UnaryOperator / BinaryOperator | Optional / 默认值 | 转换或计算，可设默认 |
| test | Predicate / BiPredicate | boolean | 条件判断，回调为 null 时返回 false |
四、使用示例
4.1 执行 Runnable
// 传统写法
if (action != null) {
action.run();
}
// 用 CallbackProcessor
CallbackProcessor.run(action);
4.2 执行带参数的 Consumer
// 传统写法
if (consumer != null) {
consumer.accept(data);
}
// 用 CallbackProcessor
CallbackProcessor.accept(consumer, data);
4.3 获取返回值，带默认值
// 传统写法
String result = (supplier != null) ? supplier.get() : "默认值";
// 用 CallbackProcessor
String result = CallbackProcessor.get(supplier, "默认值");
4.4 条件判断
// 传统写法
boolean valid = (predicate != null) && predicate.test(value);
// 用 CallbackProcessor
boolean valid = CallbackProcessor.test(predicate, value);
五、注意事项
1、返回值带 Optional 的方法：适合链式调用，但注意 Optional 本身不能为 null
2、带默认值的方法：回调为 null 或返回 null 时，都会返回默认值
3、test 方法：回调为 null 时返回 false，不是 null 才执行判断
六、小结
CallbackProcessor 是一个简单的工具类，核心就是判空封装。
它没有复杂的技术点，但在实际项目中能减少大量重复判空代码，配合 Lambda 表达式使用体验不错。
下一篇会讲 ComponentUtils 和 FormPanelUtils，是 Swing 组件开发中更常用的工具类。
