Použití vláken k vytváření požadavků na databázi

Obecný vzorec pro získávání dat z databáze je tedy:

1. Vytvořte Úkol pro zpracování volání do databáze.
2. Inicializujte Úlohu s jakýmkoli stavem, který je potřebný k provedení volání databáze.
3. Implementujte call() úkolu metoda k provedení volání databáze, která vrátí výsledky volání.
4. Zaregistrujte obslužný program s úkolem odeslat výsledky do uživatelského rozhraní, až bude dokončen.
5. Vyvolejte úlohu ve vláknu na pozadí.

Pro přístup k databázi důrazně doporučuji zapouzdřit skutečný kód databáze do samostatné třídy, která neví nic o uživatelském rozhraní ( Vzor návrhu objektu pro přístup k datům ). Pak stačí, aby úloha vyvolala metody na objektu přístupu k datům.

Takže můžete mít třídu DAO, jako je tato (všimněte si, že zde není žádný kód uživatelského rozhraní):

public class WidgetDAO {

    // In real life, you might want a connection pool here, though for
    // desktop applications a single connection often suffices:
    private Connection conn ;

    public WidgetDAO() throws Exception {
        conn = ... ; // initialize connection (or connection pool...)
    }

    public List<Widget> getWidgetsByType(String type) throws SQLException {
        try (PreparedStatement pstmt = conn.prepareStatement("select * from widget where type = ?")) {
            pstmt.setString(1, type);
            ResultSet rs = pstmt.executeQuery();
            List<Widget> widgets = new ArrayList<>();
            while (rs.next()) {
                Widget widget = new Widget();
                widget.setName(rs.getString("name"));
                widget.setNumberOfBigRedButtons(rs.getString("btnCount"));
                // ...
                widgets.add(widget);
            }
            return widgets ;
        }
    }

    // ...

    public void shutdown() throws Exception {
        conn.close();
    }
}

Načítání hromady widgetů může trvat dlouho, takže všechna volání z třídy uživatelského rozhraní (např. třídy řadiče) by to měla naplánovat na vlákno na pozadí. Třída kontroleru může vypadat takto:

public class MyController {

    private WidgetDAO widgetAccessor ;

    // java.util.concurrent.Executor typically provides a pool of threads...
    private Executor exec ;

    @FXML
    private TextField widgetTypeSearchField ;

    @FXML
    private TableView<Widget> widgetTable ;

    public void initialize() throws Exception {
        widgetAccessor = new WidgetDAO();

        // create executor that uses daemon threads:
        exec = Executors.newCachedThreadPool(runnable -> {
            Thread t = new Thread(runnable);
            t.setDaemon(true);
            return t ;
        });
    }

    // handle search button:
    @FXML
    public void searchWidgets() {
        final String searchString = widgetTypeSearchField.getText();
        Task<List<Widget>> widgetSearchTask = new Task<List<Widget>>() {
            @Override
            public List<Widget> call() throws Exception {
                return widgetAccessor.getWidgetsByType(searchString);
            }
        };

        widgetSearchTask.setOnFailed(e -> {
           widgetSearchTask.getException().printStackTrace();
            // inform user of error...
        });

        widgetSearchTask.setOnSucceeded(e -> 
            // Task.getValue() gives the value returned from call()...
            widgetTable.getItems().setAll(widgetSearchTask.getValue()));

        // run the task using a thread from the thread pool:
        exec.execute(widgetSearchTask);
    }

    // ...
}

Všimněte si, jak je volání (potenciálně) dlouhotrvající metody DAO zabaleno do Task který je spuštěn na vláknu na pozadí (prostřednictvím přístupového objektu), aby se zabránilo blokování uživatelského rozhraní (pravidlo 2 výše). Aktualizace uživatelského rozhraní (widgetTable.setItems(...) ) se ve skutečnosti spustí zpět na vláknu aplikace FX pomocí Task výhodná metoda zpětného volání setOnSucceeded(...) (splňující pravidlo 1).

Ve vašem případě přístup k databázi, který provádíte, vrátí jediný výsledek, takže můžete mít metodu jako

public class MyDAO {

    private Connection conn ; 

    // constructor etc...

    public Course getCourseByCode(int code) throws SQLException {
        try (PreparedStatement pstmt = conn.prepareStatement("select * from course where c_code = ?")) {
            pstmt.setInt(1, code);
            ResultSet results = pstmt.executeQuery();
            if (results.next()) {
                Course course = new Course();
                course.setName(results.getString("c_name"));
                // etc...
                return course ;
            } else {
                // maybe throw an exception if you want to insist course with given code exists
                // or consider using Optional<Course>...
                return null ;
            }
        }
    }

    // ...
}

A pak by váš kód ovladače vypadal takto

final int courseCode = Integer.valueOf(courseId.getText());
Task<Course> courseTask = new Task<Course>() {
    @Override
    public Course call() throws Exception {
        return myDAO.getCourseByCode(courseCode);
    }
};
courseTask.setOnSucceeded(e -> {
    Course course = courseTask.getCourse();
    if (course != null) {
        courseCodeLbl.setText(course.getName());
    }
});
exec.execute(courseTask);

Dokumenty API pro Task mají mnoho dalších příkladů, včetně aktualizace pokroku vlastnost úkolu (užitečné pro ukazatele průběhu... atd.