Java案例怎么实现异步回调？

本文目录导读：

1. 使用接口实现回调（最基础的方式）
2. 使用Lambda表达式（Java 8+）
3. 使用CompletableFuture（推荐方式）
4. 使用Future和Callable
5. 使用事件监听器模式（适用于UI或复杂场景）
6. 使用响应式编程（RxJava）
7. 最佳实践建议

在Java中实现异步回调有多种方式，下面我为你介绍几种常见且实用的实现方法,从基础到进阶。

使用接口实现回调（最基础的方式）

// 定义回调接口
interface Callback {
    void onSuccess(String result);
    void onFailure(Exception e);
}
// 异步任务执行器
class AsyncTask {
    public void execute(Callback callback) {
        new Thread(() -> {
            try {
                // 模拟耗时操作
                Thread.sleep(2000);
                // 模拟成功
                String result = "任务执行成功";
                callback.onSuccess(result);
            } catch (Exception e) {
                callback.onFailure(e);
            }
        }).start();
    }
}
// 使用示例
public class CallbackExample {
    public static void main(String[] args) {
        AsyncTask task = new AsyncTask();
        task.execute(new Callback() {
            @Override
            public void onSuccess(String result) {
                System.out.println("成功: " + result);
            }
            @Override
            public void onFailure(Exception e) {
                System.out.println("失败: " + e.getMessage());
            }
        });
        System.out.println("主线程继续执行...");
    }
}

使用Lambda表达式（Java 8+）

// 函数式接口
@FunctionalInterface
interface AsyncCallback {
    void onComplete(String result);
}
// 异步任务
class AsyncExecutor {
    public void runAsync(AsyncCallback callback) {
        CompletableFuture.runAsync(() -> {
            try {
                Thread.sleep(1000);
                callback.onComplete("任务完成");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
    }
}
// 使用
public class LambdaCallback {
    public static void main(String[] args) {
        AsyncExecutor executor = new AsyncExecutor();
        executor.runAsync(result -> System.out.println(result));
        System.out.println("主线程继续执行...");
    }
}

使用CompletableFuture（推荐方式）

import java.util.concurrent.CompletableFuture;
public class CompletableFutureExample {
    public static void main(String[] args) {
        // 1. 创建异步任务
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            // 模拟耗时操作
            sleep(2000);
            return "任务结果";
        });
        // 2. 注册回调
        future.thenAccept(result -> {
            System.out.println("成功回调: " + result);
        }).exceptionally(ex -> {
            System.out.println("异常回调: " + ex.getMessage());
            return null;
        });
        // 3. 另一个例子：链式调用
        CompletableFuture.supplyAsync(() -> "Hello")
            .thenApply(s -> s + " World")
            .thenAccept(System.out::println)
            .exceptionally(ex -> {
                System.err.println("错误: " + ex);
                return null;
            });
        System.out.println("主线程继续执行...");
        // 等待异步任务完成（仅用于演示）
        sleep(3000);
    }
    private static void sleep(long millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

使用Future和Callable

import java.util.concurrent.*;
public class FutureExample {
    public static void main(String[] args) throws Exception {
        ExecutorService executor = Executors.newFixedThreadPool(2);
        // 提交异步任务
        Future<String> future = executor.submit(() -> {
            Thread.sleep(2000);
            return "异步结果";
        });
        // 方式1：阻塞获取结果
        // String result = future.get();
        // 方式2：轮询检查完成状态（简单回调模拟）
        new Thread(() -> {
            while (!future.isDone()) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    break;
                }
            }
            try {
                String result = future.get();
                System.out.println("回调：任务完成，结果：" + result);
            } catch (Exception e) {
                System.out.println("回调：任务失败：" + e.getMessage());
            }
        }).start();
        System.out.println("主线程继续执行...");
        executor.shutdown();
    }
}

使用事件监听器模式（适用于UI或复杂场景）

import java.util.*;
// 事件类
class AsyncEvent extends EventObject {
    private final String message;
    public AsyncEvent(Object source, String message) {
        super(source);
        this.message = message;
    }
    public String getMessage() {
        return message;
    }
}
// 监听器接口
interface AsyncListener extends EventListener {
    void onEvent(AsyncEvent event);
}
// 异步任务管理器
class AsyncManager {
    private final List<AsyncListener> listeners = new ArrayList<>();
    public void addListener(AsyncListener listener) {
        listeners.add(listener);
    }
    public void removeListener(AsyncListener listener) {
        listeners.remove(listener);
    }
    public void executeAsync() {
        new Thread(() -> {
            try {
                Thread.sleep(2000);
                AsyncEvent event = new AsyncEvent(this, "任务完成");
                // 通知所有监听器
                for (AsyncListener listener : listeners) {
                    listener.onEvent(event);
                }
            } catch (Exception e) {
                AsyncEvent errorEvent = new AsyncEvent(this, "错误: " + e.getMessage());
                for (AsyncListener listener : listeners) {
                    listener.onEvent(errorEvent);
                }
            }
        }).start();
    }
}
// 使用示例
public class EventExample {
    public static void main(String[] args) {
        AsyncManager manager = new AsyncManager();
        // 注册回调
        manager.addListener(event -> 
            System.out.println("收到事件: " + event.getMessage())
        );
        manager.executeAsync();
        System.out.println("主线程继续执行...");
    }
}

使用响应式编程（RxJava）

import io.reactivex.rxjava3.core.Observable;
import io.reactivex.rxjava3.schedulers.Schedulers;
public class RxJavaExample {
    public static void main(String[] args) {
        Observable.create(emitter -> {
            // 异步操作
            try {
                Thread.sleep(2000);
                emitter.onNext("RxJava结果");
                emitter.onComplete();
            } catch (Exception e) {
                emitter.onError(e);
            }
        })
        .subscribeOn(Schedulers.io())  // 在IO线程执行
        .observeOn(Schedulers.single())  // 在单线程观察结果
        .subscribe(
            result -> System.out.println("成功: " + result),
            error -> System.err.println("错误: " + error),
            () -> System.out.println("完成")
        );
        System.out.println("主线程继续执行...");
        // 等待异步完成
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

最佳实践建议

1. 推荐使用CompletableFuture：Java 8引入，功能强大，支持链式调用和组合
2. 考虑线程安全：回调中访问共享资源时注意同步
3. 错误处理：始终处理异常情况
4. 避免回调地狱：使用CompletableFuture或响应式库简化嵌套回调
5. 上下文传递：如需传递上下文，考虑使用设计模式或线程局部变量

根据你的具体场景选择合适的方式，如果是新项目,强烈推荐使用CompletableFuture。