Java异步回调案例

wen java案例 2026-08-03 196

本文目录导读：

Java异步回调案例

基础回调接口实现
使用FutureTask和Callable
Spring框架中的异步回调
简单易用的工具类封装
实战完整案例：网络请求异步处理

我来为您提供一个完整的Java异步回调案例,涵盖多种实现方式。

基础回调接口实现

// 回调接口
public interface Callback {
    void onSuccess(String result);
    void onFailure(Exception e);
}
// 异步任务类
public class AsyncTask {
    public void execute(Callback callback) {
        System.out.println("开始执行异步任务...");
        // 模拟异步操作
        new Thread(() -> {
            try {
                // 模拟耗时操作
                Thread.sleep(2000);
                // 模拟业务逻辑
                String result = "任务执行成功，当前时间：" + System.currentTimeMillis();
                // 执行回调
                callback.onSuccess(result);
            } catch (Exception e) {
                callback.onFailure(e);
            }
        }).start();
        System.out.println("异步任务已启动，主线程继续执行...");
    }
}
// 使用示例
public class CallbackDemo {
    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.err.println("回调失败： " + e.getMessage());
            }
        });
        // 主线程继续执行其他操作
        for (int i = 0; i < 3; i++) {
            System.out.println("主线程执行其他操作: " + i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

使用FutureTask和Callable

import java.util.concurrent.*;
public class FutureTaskDemo {
    public static void main(String[] args) {
        // 创建一个ExecutorService
        ExecutorService executor = Executors.newFixedThreadPool(2);
        // 方式1： 使用Future
        Future<String> future = executor.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {
                Thread.sleep(2000);
                return "异步任务结果";
            }
        });
        System.out.println("提交任务后，主线程继续执行...");
        try {
            // 获取异步结果（会阻塞主线程）
            String result = future.get();
            System.out.println("获取到结果: " + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        // 方式2： 使用FutureTask
        Callable<String> callable = new Callable<String>() {
            @Override
            public String call() throws Exception {
                Thread.sleep(3000);
                return "FutureTask异步结果";
            }
        };
        FutureTask<String> futureTask = new FutureTask<>(callable);
        executor.execute(futureTask);
        try {
            String result = futureTask.get();
            System.out.println("FutureTask结果: " + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        // 使用 CompletableFuture（推荐）
        CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(2000);
                return "CompletableFuture异步结果";
            } catch (InterruptedException e) {
                return "任务异常";
            }
        });
        completableFuture.thenAccept(result -> 
            System.out.println("获取到CompletableFuture结果: " + result)
        );
        executor.shutdown();
    }
}

Spring框架中的异步回调

import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.AsyncResult;
import org.springframework.stereotype.Service;
import org.springframework.util.concurrent.ListenableFuture;
@Service
public class AsyncService {
    @Async
    public void asyncMethod() {
        System.out.println("异步方法执行中...");
        try {
            Thread.sleep(3000);
            System.out.println("异步方法执行完成");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    @Async
    public CompletableFuture<String> asyncMethodWithResult() {
        System.out.println("执行带返回值的异步方法");
        return CompletableFuture.completedFuture("异步方法返回值");
    }
    @Async
    public ListenableFuture<String> asyncMethodWithListenableFuture() {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return new AsyncResult<>("异步执行结果");
    }
}
// 调用类
@Service
public class AsyncCallable {
    @Autowired
    private AsyncService asyncService;
    public void invokeAsync() {
        // 调用异步方法
        asyncService.asyncMethod();
        // 调用带返回值的异步方法
        CompletableFuture<String> future = asyncService.asyncMethodWithResult();
        future.thenAccept(result -> 
            System.out.println("异步方法返回: " + result)
        );
        // 使用ListenableFuture
        ListenableFuture<String> listenableFuture = 
            asyncService.asyncMethodWithListenableFuture();
        listenableFuture.addCallback(
            result -> System.out.println("成功: " + result),
            error -> System.err.println("失败: " + error)
        );
    }
}

简单易用的工具类封装

import java.util.concurrent.*;
import java.util.function.Consumer;
public class AsyncExecutor {
    private static final ExecutorService executor = 
        Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
    /**
     * 执行异步任务
     * @param task 任务逻辑
     * @param successCallback 成功回调
     * @param errorCallback 失败回调
     */
    public static <T> void runAsync(Callable<T> task, 
                                   Consumer<T> successCallback,
                                   Consumer<Exception> errorCallback) {
        CompletableFuture<T> future = CompletableFuture.supplyAsync(() -> {
            try {
                return task.call();
            } catch (Exception e) {
                throw new CompletionException(e);
            }
        }, executor);
        future.thenAccept(successCallback)
              .exceptionally(ex -> {
                  if (errorCallback != null) {
                      Throwable cause = ex.getCause();
                      errorCallback.accept(cause instanceof Exception ? 
                          (Exception) cause : new Exception(cause));
                  }
                  return null;
              });
    }
    /**
     * 带超时的异步执行
     */
    public static <T> T submitWithTimeout(Callable<T> task, 
                                         long timeout, TimeUnit unit) {
        Future<T> future = executor.submit(task);
        try {
            return future.get(timeout, unit);
        } catch (TimeoutException e) {
            future.cancel(true);
            throw new RuntimeException("任务执行超时", e);
        } catch (InterruptedException | ExecutionException e) {
            throw new RuntimeException("任务执行失败", e);
        }
    }
    public static void shutdown() {
        executor.shutdown();
    }
}
// 使用示例
public class AsyncExecutorDemo {
    public static void main(String[] args) {
        // 演示异步执行
        AsyncExecutor.runAsync(
            () -> {
                // 模拟耗时业务逻辑
                Thread.sleep(2000);
                return "业务处理结果";
            },
            result -> System.out.println("成功回调: " + result),
            error -> System.err.println("失败回调: " + error.getMessage())
        );
        // 演示带超时的异步执行
        try {
            String result = AsyncExecutor.submitWithTimeout(
                () -> {
                    Thread.sleep(3000);
                    return "超时测试结果";
                },
                2, TimeUnit.SECONDS
            );
            System.out.println("结果: " + result);
        } catch (Exception e) {
            System.out.println("超时异常: " + e.getMessage());
        }
        System.out.println("主线程继续工作...");
        // 关闭executor
        try {
            Thread.sleep(4000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        AsyncExecutor.shutdown();
    }
}

实战完整案例：网络请求异步处理

import java.net.HttpURLConnection;
import java.net.URL;
import java.util.concurrent.*;
public class NetworkAsyncDemo {
    // 网络请求回调接口
    interface NetworkCallback {
        void onSuccess(String response);
        void onFailure(Exception e);
    }
    // 模拟网络请求
    static class AsyncHttpClient {
        private final ExecutorService executor = 
            Executors.newFixedThreadPool(4);
        public void get(String urlStr, NetworkCallback callback) {
            Future<?> future = executor.submit(() -> {
                try {
                    HttpURLConnection connection = (HttpURLConnection) 
                        new URL(urlStr).openConnection();
                    connection.setRequestMethod("GET");
                    connection.setConnectTimeout(5000);
                    int responseCode = connection.getResponseCode();
                    if (responseCode == 200) {
                        StringBuilder response = new StringBuilder();
                        try (java.io.BufferedReader reader = 
                            new java.io.BufferedReader(new java.io.InputStreamReader(
                                connection.getInputStream()))) {
                            String line;
                            while ((line = reader.readLine()) != null) {
                                response.append(line);
                            }
                        }
                        callback.onSuccess(response.toString());
                    } else {
                        callback.onFailure(new Exception("请求失败，状态码: " + responseCode));
                    }
                } catch (Exception e) {
                    callback.onFailure(e);
                }
            });
        }
        public void shutdown() {
            executor.shutdown();
        }
    }
    public static void main(String[] args) {
        AsyncHttpClient client = new AsyncHttpClient();
        client.get("https://httpbin.org/get", new NetworkCallback() {
            @Override
            public void onSuccess(String response) {
                System.out.println("请求成功: " + response);
            }
            @Override
            public void onFailure(Exception e) {
                System.err.println("请求失败: " + e.getMessage());
            }
        });
        System.out.println("异步请求已发送，等待响应...");
        try {
            Thread.sleep(6000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        client.shutdown();
    }
}

接口回调模式：定义回调接口，在异步任务完成后执行
Future模式：使用Future或FutureTask获取异步执行结果
CompletableFuture：JDK8+推荐的异步编程方式，支持链式调用
Spring异步支持：使用@Async注解简化异步开发
超时控制：合理设置异步任务超时时间，避免无限等待
线程池管理：使用合适的线程池，避免资源浪费
错误处理：完善的异常处理机制，包括成功和失败回调

这些案例涵盖了Java异步回调的常用场景,您可以根据具体需求选择合适的实现方案。

本文地址： https://www.bmjup.com/post/37166.html