Brug af tråde til at lave databaseanmodninger

Så den generelle formel for at hente data fra en database er:

1. Opret en Opgave for at håndtere opkaldet til databasen.
2. Initialiser Opgaven med enhver tilstand, der er nødvendig for at udføre databasekaldet.
3. Implementer opgavens call() metode til at udføre databasekaldet og returnere resultaterne af opkaldet.
4. Registrer en behandler med opgaven for at sende resultaterne til brugergrænsefladen, når den er fuldført.
5. Bring opgaven på en baggrundstråd.

Til databaseadgang anbefaler jeg kraftigt at indkapsle den faktiske databasekode i en separat klasse, der ikke ved noget om brugergrænsefladen ( Data Access Object design mønster ). Lad derefter opgaven påkalde metoderne på dataadgangsobjektet.

Så du har måske en DAO-klasse som denne (bemærk, at der ikke er nogen UI-kode her):

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();
    }
}

Hentning af en masse widgets kan tage lang tid, så alle opkald fra en UI-klasse (f.eks. en controller-klasse) bør planlægge dette i en baggrundstråd. En controller-klasse kan se sådan ud:

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);
    }

    // ...
}

Bemærk, hvordan opkaldet til den (potentielt) langvarige DAO-metode er pakket ind i en Opgave som køres på en baggrundstråd (via accessoren) for at forhindre blokering af brugergrænsefladen (regel 2 ovenfor). Opdateringen til brugergrænsefladen (widgetTable.setItems(...) ) udføres faktisk tilbage på FX Application Thread ved hjælp af Task 's bekvemmeligheds-tilbagekaldsmetode setOnSucceeded(...) (opfylder regel 1).

I dit tilfælde returnerer den databaseadgang, du udfører, et enkelt resultat, så du kan have en metode som

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 ;
            }
        }
    }

    // ...
}

Og så ville din controller-kode se sådan ud

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);

API-dokumenter til Task har mange flere eksempler, inklusive opdatering af fremskridt egenskaben for opgaven (nyttigt til statuslinjer... osv.