JavaFX.concurrent.Task：如何分离库代码与GUI代码？

我开发了一个JavaFX应用，核心功能是在大型二进制数据中搜索特定模式。为保证GUI响应性，使用JavaFX的Task在独立线程运行搜索，代码如下：

public void search(SearchPattern pattern) {
    
    Task<ObservableList<...>> task = new Task<>() {
        @Override protected ObservableList<...> call() throws Exception {

            try {                    
                for(int i=0;i<....size();i++) {
                    if (isCancelled()) {
                        break;
                    }
                    if(i%50000 == 0) {
                        updateProgress(i, entries.size());
                    }
                    if(pattern.matches(entries.get(i))) {
                        // 处理匹配结果
                    }                        
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                // IO资源清理
            }
            return FXCollections.observableArrayList(...);
        }
    };

    progressBar.progressProperty().bind(task.progressProperty());

    task.setOnSucceeded(e -> {
        unregisterRunningTask(task);
        searchResults = task.getValue();
    });

    Thread thread = new Thread(task);
    registerRunningTask(task);
    thread.setDaemon(false);
    thread.start();
}

当前实现功能正常，但搜索逻辑与GUI代码耦合严重。我希望将搜索代码抽离为独立库，支持：

• 无GUI的自动化测试用例
• 命令行环境下的单线程测试/基准测试
• 同时保留GUI环境的进度更新能力

遇到的问题：updateProgress()依赖JavaFX的Task，如果把完整搜索逻辑移到库中，要么在非GUI环境也创建Task（完全没必要），要么砍掉进度更新（影响GUI用户体验）。想找一种通过抽象层传递进度的方案，让搜索函数能同时适配多线程GUI和单线程命令行环境。

核心思路是把进度更新、取消检查逻辑从搜索函数中剥离，通过一个回调接口传递状态，让调用方（GUI或命令行）自行决定如何处理这些状态。

步骤1：定义进度回调接口 #

在独立库中定义一个轻量级接口，不依赖任何GUI框架：

public interface ProgressCallback {
    // 传递当前进度与总进度
    void updateProgress(long current, long total);
    // 检查是否需要取消搜索
    boolean isCancelled();
}

步骤2：实现无GUI依赖的核心搜索函数 #

将完整的搜索逻辑移到独立库中，依赖上述接口处理进度和取消请求：

// 独立库中的搜索工具类
public class SearchUtils {
    public static List<MatchResult> searchPattern(String filename, SearchPattern pattern, ProgressCallback callback) throws IOException {
        List<MatchResult> results = new ArrayList<>();
        List<Entry> entries = loadBinaryEntries(filename); // 加载二进制数据的逻辑，与GUI无关

        long totalEntries = entries.size();
        for (int i = 0; i < totalEntries; i++) {
            // 响应外部取消请求
            if (callback != null && callback.isCancelled()) {
                break;
            }
            // 定期更新进度
            if (callback != null && i % 50000 == 0) {
                callback.updateProgress(i, totalEntries);
            }
            // 模式匹配逻辑
            if (pattern.matches(entries.get(i))) {
                results.add(new MatchResult(entries.get(i)));
            }
        }
        return results;
    }

    // 辅助方法：加载二进制数据（示例）
    private static List<Entry> loadBinaryEntries(String filename) throws IOException {
        // 实现二进制文件读取逻辑
        return new ArrayList<>();
    }
}

步骤3：GUI环境适配（结合JavaFX Task） #

在JavaFX代码中，实现ProgressCallback接口，将进度和取消状态转发给Task：

public void search(SearchPattern pattern) {
    Task<ObservableList<MatchResult>> task = new Task<>() {
        @Override
        protected ObservableList<MatchResult> call() throws Exception {
            // 绑定Task的状态到回调接口
            ProgressCallback callback = new ProgressCallback() {
                @Override
                public void updateProgress(long current, long total) {
                    // 调用Task的updateProgress方法更新GUI进度
                    SearchUtils.this.updateProgress(current, total);
                }

                @Override
                public boolean isCancelled() {
                    // 复用Task的取消状态
                    return isCancelled();
                }
            };

            // 调用独立库的搜索函数
            List<MatchResult> rawResults = SearchUtils.searchPattern("target.bin", pattern, callback);
            return FXCollections.observableArrayList(rawResults);
        }
    };

    // 绑定进度条到Task的进度属性
    progressBar.progressProperty().bind(task.progressProperty());

    task.setOnSucceeded(e -> {
        unregisterRunningTask(task);
        searchResults = task.getValue();
    });

    Thread thread = new Thread(task);
    registerRunningTask(task);
    thread.setDaemon(false);
    thread.start();
}

步骤4：命令行/测试环境适配 #

在非GUI环境中，实现简单的ProgressCallback（或传空回调跳过进度更新）：

// 命令行测试示例
public static void main(String[] args) throws IOException {
    ProgressCallback consoleCallback = new ProgressCallback() {
        @Override
        public void updateProgress(long current, long total) {
            // 控制台打印进度百分比
            System.out.printf("搜索进度：%.2f%%%n", (current * 100.0) / total);
        }

        @Override
        public boolean isCancelled() {
            // 命令行环境可监听输入实现取消，这里默认不取消
            return false;
        }
    };

    List<MatchResult> results = SearchUtils.searchPattern("test.bin", new SearchPattern("0x1234"), consoleCallback);
    System.out.println("找到匹配项：" + results.size());
}

// 自动化测试示例（无需进度更新）
@Test
public void testSearchAccuracy() throws IOException {
    // 使用空实现的回调
    ProgressCallback noOpCallback = new ProgressCallback() {
        @Override
        public void updateProgress(long current, long total) {}
        @Override
        public boolean isCancelled() { return false; }
    };

    List<MatchResult> results = SearchUtils.searchPattern("test_data.bin", testPattern, noOpCallback);
    assertEquals(3, results.size());
}

额外优化 #

可以给ProgressCallback添加默认方法，简化调用方代码：

public interface ProgressCallback {
    default void updateProgress(long current, long total) {}
    default boolean isCancelled() { return false; }
}

这样命令行或测试环境可以直接传null，或者使用lambda简化实现：

// 命令行简化写法
List<MatchResult> results = SearchUtils.searchPattern("test.bin", pattern, 
    (current, total) -> System.out.printf("进度：%.2f%%%n", (current*100.0)/total));

内容的提问来源于stack exchange，提问作者ndbd