How to Safely Perform Database Requests in JavaFX Without Blocking the UI Thread?

Concurrency in JavaFX: Using Threads for Database Requests

Understanding JavaFX Threading Rules

In JavaFX, two key rules govern threading:

• Rule 1: UI operations (modifying or accessing scene graph elements) must be executed on the JavaFX application thread.
• Rule 2: Long-running operations (e.g., database requests) should be performed on a background thread.

Your Code and the Exception

Your code reveals an exception because you are attempting to modify the courseCodeLbl label (a UI operation) from a background thread (the new Thread created with Runnable). This violates Rule 1.

Correct Implementation using Threads

To resolve this, you should execute the database request in a background thread and then update the UI on the JavaFX application thread. This can be achieved using the following steps:

1. Create a Task object that represents the database operation.
2. Initialize the task with the appropriate parameters for the database call.
3. Implement the Task's call() method to perform the database query and return the result.
4. Register a setOnSucceeded handler with the task to handle the UI update when the task completes.
5. Execute the task on a background thread.

Using the javafx.concurrent API

JavaFX provides the javafx.concurrent API to manage concurrency and handle UI updates from background threads. Task is the fundamental class in this API, and it allows you to:

• Execute code in a background thread and update UI properties on the application thread.
• Handle task completion using callbacks like setOnSucceeded and setOnFailed.

Example with DAO and Task

Following the recommended design pattern, database access should be encapsulated in a Data Access Object (DAO) class, which is unaware of the UI. Then, a task can be used to invoke the DAO's methods on a background thread.

Here's an example of a DAO that retrieves widgets by type:

public class WidgetDAO {
    public List<widget> getWidgetsByType(String type) throws SQLException {
        // Database query to retrieve widgets
    }
}</widget>

And a controller class that uses Task and javafx.concurrent.Executor to perform the database operation and update the UI:

public class MyController {
    private WidgetDAO widgetAccessor;
    private Executor exec; // Executor to execute tasks on a thread pool

    public void searchWidgets() {
        final String searchString = widgetTypeSearchField.getText();
        Task<list>> widgetSearchTask = new Task() {
            @Override
            public List<widget> call() throws Exception {
                return widgetAccessor.getWidgetsByType(searchString);
            }
        };

        widgetSearchTask.setOnSucceeded(e -> {
            widgetTable.getItems().setAll(widgetSearchTask.getValue());
        });

        exec.execute(widgetSearchTask);
    }
}</widget></list>

By encapsulating database access and leveraging JavaFX's concurrency API, you can execute database requests on separate threads while maintaining UI responsiveness.

The above is the detailed content of How to Safely Perform Database Requests in JavaFX Without Blocking the UI Thread?. For more information, please follow other related articles on the PHP Chinese website!