> Markdown version of [Futures](https://vaadin.com/docs/v24/building-apps/deep-dives/presentation-layer/server-push/futures). Section index: [llms.txt](https://vaadin.com/docs/v24/building-apps/llms.txt)

# Consuming Futures Flow

Some background jobs may use `CompletableFuture` to inform the user interface of results and errors. This is covered in the [Returning Futures](https://vaadin.com/docs/v24/building-apps/deep-dives/application-layer/background-jobs/interaction/futures.md) documentation page.

When building the user interface with Vaadin Flow, you can use [callbacks](https://vaadin.com/docs/v24/building-apps/deep-dives/presentation-layer/server-push/callbacks.md) and register them with the `CompletableFuture` to update your user interface.

For example, a method for handling successful completion could look like this:

```java
private void onJobCompleted(String result) {
    Notification.show("Job completed: " + result);
}
```

> **Note:** The examples on this page only work with push enabled (see [Server Push](https://vaadin.com/docs/v24/building-apps/deep-dives/presentation-layer/server-push.md#enabling-push-flow)).

A method for handling errors might look like this:

```java
private void onJobFailed(Throwable error) {
    Notification.show("Job failed: " + error.getMessage());
}
```

Note, that the error handler must accept a `Throwable`, and not an `Exception` when you’re working with `CompletableFuture`.

## <a id="successful-completion"></a>Successful Completion

If a `CompletableFuture` completes successfully, you can instruct it to perform a specific operation by calling the `thenAccept()` method on it. This method takes a `Consumer` as its input. When the `CompletableFuture` completes, it calls this consumer with the result.

Here is an example of a button click listener that starts a background job, and updates the user interface when it has completed successfully:

```java
button.addClickListener(clickEvent -> {
    var ui = UI.getCurrent();
    service.startBackgroundJob()
        .thenAccept(ui.accessLater(this::onJobCompleted, null)); // (1)
});
```

1. The `UI.accessLater()` method is explained on the [Pushing UI Updates](https://vaadin.com/docs/v24/building-apps/deep-dives/presentation-layer/server-push/updates.md#access-later) documentation page.

## <a id="exceptional-completion"></a>Exceptional Completion

If a `CompletableFuture` is completed with an exception, you can instruct it to perform a specific operation by calling the `exceptionally()` method on it. However, this method works in a different way than `thenAccept()`.

The `exceptionally()` method takes a `Function`, instead of a `Consumer` as input. The exception is passed to the function as input. The function output is used as the result of the `CompletableFuture` that is returned by `exceptionally()`.

Flow has no version of `UI.accessLater()` that works with `Function`. However, since you’re probably not interested in returning a result, you can create a helper function that adapts a `Consumer` to a `Function`, like this:

```java
public static <T> Function<T, Void> consumerToFunction(Consumer<T> consumer) {
    return input -> {
        consumer.accept(input);
        return null;
    };
}
```

Here is an example of a button click listener that starts a background job, and uses the helper function to update the user interface if an error occurs:

```java
button.addClickListener(clickEvent -> {
    var ui = UI.getCurrent();
    service.startBackgroundJob()
        .thenAccept(ui.accessLater(this::onJobCompleted, null))
        .exceptionally(consumerToFunction(ui.accessLater(this::onJobFailed, null)))
});
```