콜백과 비동기 패턴 — 자바에서 나중에 불러줘를 구현하는 법

// 동기 콜백 — sort가 Comparator를 즉시 호출
List<String> names = new ArrayList<>(List.of("Charlie", "Alice", "Bob"));
Collections.sort(names, (a, b) -> a.compareTo(b));

// 비동기 콜백 — 작업 완료 후 나중에 호출
CompletableFuture.supplyAsync(() -> fetchFromApi())
    .thenAccept(result -> System.out.println("나중에 실행: " + result));

// 콜백 인터페이스 정의
public interface TaskCallback {
    void onComplete(String result);  // 성공 시 호출
    void onError(Exception e);       // 실패 시 호출
}

public class AsyncWorker {
    // 콜백을 매개변수로 받아 비동기로 실행
    public void doWork(TaskCallback callback) {
        new Thread(() -> {
            try {
                Thread.sleep(1000); // 시간이 걸리는 작업
                callback.onComplete("작업 완료!"); // 성공 콜백
            } catch (Exception e) {
                callback.onError(e); // 실패 콜백
            }
        }).start();
    }
}

// 익명 클래스로 콜백 전달
AsyncWorker worker = new AsyncWorker();
worker.doWork(new TaskCallback() {
    @Override
    public void onComplete(String result) {
        System.out.println("성공: " + result);
    }
    @Override
    public void onError(Exception e) {
        System.out.println("실패: " + e.getMessage());
    }
});
System.out.println("doWork 호출 후 바로 실행 — 비동기!");

@FunctionalInterface
public interface SimpleCallback {
    void onComplete(String result);
}

// 익명 클래스 → 람다 → 메서드 레퍼런스 진화
worker.doSimpleWork(new SimpleCallback() {
    @Override
    public void onComplete(String result) {
        System.out.println("결과: " + result);
    }
});

worker.doSimpleWork(result -> System.out.println("결과: " + result));

worker.doSimpleWork(System.out::println);

// Consumer를 콜백으로 사용
public void fetchData(Consumer<String> onSuccess) {
    new Thread(() -> {
        String data = callExternalApi();
        onSuccess.accept(data); // 콜백 호출
    }).start();
}

fetchData(data -> System.out.println("받은 데이터: " + data));

// 리스너 인터페이스
public interface OrderEventListener {
    void onOrderCreated(Order order);
}

// 이벤트 소스 — 리스너를 등록하고, 이벤트 발생 시 호출
public class OrderService {
    private final List<OrderEventListener> listeners = new ArrayList<>();

    public void addListener(OrderEventListener listener) {
        listeners.add(listener);
    }

    public void createOrder(Order order) {
        saveOrder(order);
        // 등록된 모든 리스너에게 알림
        listeners.forEach(l -> l.onOrderCreated(order));
    }
}

// Spring 이벤트 리스너 — 콜백의 실전 활용
@Component
public class OrderNotificationListener {
    @EventListener
    public void handleOrderCreated(OrderCreatedEvent event) {
        sendNotification(event.getOrder());
    }
}

ExecutorService executor = Executors.newSingleThreadExecutor();

Future<String> future = executor.submit(() -> {
    Thread.sleep(2000);
    return "API 응답 데이터";
});

System.out.println("다른 작업 수행 중...");
String result = future.get(); // 여기서 블로킹!
System.out.println("결과: " + result);
executor.shutdown();

CompletableFuture<String> cf = CompletableFuture.supplyAsync(() -> {
    return callExternalApi(); // ForkJoinPool.commonPool()에서 실행
});

// thenApply — 값 변환 (map)
CompletableFuture.supplyAsync(() -> "Hello World")
    .thenApply(s -> s.length()); // 결과: 11

// thenAccept — 값 소비 (void)
CompletableFuture.supplyAsync(() -> fetchUserName())
    .thenAccept(name -> System.out.println("안녕하세요, " + name + "님!"));

// thenRun — 결과와 무관하게 실행
CompletableFuture.supplyAsync(() -> saveToDatabase())
    .thenRun(() -> System.out.println("저장 완료!"));

// thenApply를 쓰면 CompletableFuture가 중첩됨
CompletableFuture<CompletableFuture<Order>> nested =
    getUserId().thenApply(id -> getOrder(id)); // 중첩!

// thenCompose로 평탄화
CompletableFuture<Order> flat =
    getUserId().thenCompose(id -> getOrder(id)); // 깔끔

CompletableFuture.supplyAsync(() -> {
        if (Math.random() > 0.5) throw new RuntimeException("실패!");
        return "성공";
    })
    .exceptionally(ex -> {
        System.out.println("에러: " + ex.getMessage());
        return "기본값"; // 대체값 반환
    });

// handle — 성공/실패 모두 처리
CompletableFuture.supplyAsync(() -> riskyOperation())
    .handle((result, ex) -> {
        if (ex != null) return "에러 복구값";
        return result.toUpperCase();
    });

cf.thenApply(s -> transform(s));          // 같은 스레드 또는 호출 스레드
cf.thenApplyAsync(s -> transform(s));     // ForkJoinPool에서 실행
cf.thenApplyAsync(s -> transform(s), ex); // 지정한 스레드 풀에서 실행

// 주문 처리 파이프라인
CompletableFuture.supplyAsync(() -> authenticateUser(token))
    .thenCompose(user -> checkInventory(user.getCartItems()))
    .thenApply(inventory -> calculateTotal(inventory))
    .thenCompose(total -> processPayment(total))
    .thenAccept(receipt -> sendConfirmationEmail(receipt))
    .exceptionally(ex -> {
        handleOrderFailure(ex); // 어느 단계에서든 실패하면 여기로
        return null;
    });

CompletableFuture<String> userCf = CompletableFuture.supplyAsync(() -> fetchUser());
CompletableFuture<String> orderCf = CompletableFuture.supplyAsync(() -> fetchOrders());
CompletableFuture<String> reviewCf = CompletableFuture.supplyAsync(() -> fetchReviews());

CompletableFuture.allOf(userCf, orderCf, reviewCf)
    .thenRun(() -> {
        // 모든 작업 완료 후 결과 조합
        String user = userCf.join();
        String orders = orderCf.join();
        String reviews = reviewCf.join();
        System.out.println(user + ", " + orders + ", " + reviews);
    });

CompletableFuture<Object> fastest = CompletableFuture.anyOf(
    callServiceA(), callServiceB(), callServiceC()
);
fastest.thenAccept(result -> System.out.println("가장 빠른 응답: " + result));

// 콜백 지옥
getUser(userId, user -> {
    getOrders(user.getId(), orders -> {
        getPayment(orders.get(0).getId(), payment -> {
            getReceipt(payment.getId(), receipt -> {
                sendEmail(receipt, result -> {
                    System.out.println("완료: " + result);
                });
            });
        });
    });
});

getUserAsync(userId)
    .thenCompose(user -> getOrdersAsync(user.getId()))
    .thenCompose(orders -> getPaymentAsync(orders.get(0).getId()))
    .thenCompose(payment -> getReceiptAsync(payment.getId()))
    .thenCompose(receipt -> sendEmailAsync(receipt))
    .thenAccept(result -> System.out.println("완료: " + result))
    .exceptionally(ex -> {
        System.out.println("실패: " + ex.getMessage());
        return null;
    });

public interface CompletionHandler<V, A> {
    void completed(V result, A attachment); // 성공 시 호출
    void failed(Throwable exc, A attachment); // 실패 시 호출
}

AsynchronousFileChannel channel = AsynchronousFileChannel.open(
    Path.of("data.txt"), StandardOpenOption.READ
);
ByteBuffer buffer = ByteBuffer.allocate(1024);

channel.read(buffer, 0, buffer, new CompletionHandler<>() {
    @Override
    public void completed(Integer bytesRead, ByteBuffer buf) {
        buf.flip();
        System.out.println("읽은 바이트: " + bytesRead);
    }
    @Override
    public void failed(Throwable exc, ByteBuffer buf) {
        System.err.println("읽기 실패: " + exc.getMessage());
    }
});
System.out.println("읽기 요청 후 바로 실행 — 논블로킹!");

비동기 작업이 필요한가?
├── 아니요 → 동기 콜백 (Comparator 등)
└── 예
    ├── 단순 비동기 + 블로킹 OK → Future
    ├── 논블로킹 + 체이닝 필요 → CompletableFuture ✅
    └── NIO 비동기 I/O → CompletionHandler