Sử dụng các chuỗi để thực hiện các yêu cầu cơ sở dữ liệu

Vì vậy, công thức chung để lấy dữ liệu từ cơ sở dữ liệu là:

1. Tạo Tác vụ để xử lý lệnh gọi đến cơ sở dữ liệu.
2. Khởi tạo Tác vụ với bất kỳ trạng thái nào cần thiết để thực hiện lệnh gọi cơ sở dữ liệu.
3. Triển khai call () của nhiệm vụ để thực hiện lệnh gọi cơ sở dữ liệu, trả về kết quả của cuộc gọi.
4. Đăng ký một trình xử lý với nhiệm vụ gửi kết quả đến giao diện người dùng khi nó hoàn tất.
5. Gọi nhiệm vụ trên một chuỗi nền.

Để truy cập cơ sở dữ liệu, tôi thực sự khuyên bạn nên đóng gói mã cơ sở dữ liệu thực tế trong một lớp riêng biệt mà không biết gì về giao diện người dùng ( Mẫu thiết kế đối tượng truy cập dữ liệu ). Sau đó, chỉ cần có tác vụ gọi các phương thức trên đối tượng truy cập dữ liệu.

Vì vậy, bạn có thể có một lớp DAO như thế này (lưu ý không có mã giao diện người dùng ở đây):

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

Việc truy xuất một loạt các widget có thể mất nhiều thời gian, vì vậy bất kỳ lệnh gọi nào từ một lớp giao diện người dùng (ví dụ:một lớp bộ điều khiển) nên lên lịch cho việc này trên một chuỗi nền. Một lớp bộ điều khiển có thể trông giống như sau:

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

    // ...
}

Lưu ý cách gọi phương thức DAO chạy dài (có khả năng) được bao bọc trong một Tác vụ được chạy trên một chuỗi nền (thông qua trình truy cập) để ngăn chặn việc chặn giao diện người dùng (quy tắc 2 ở trên). Bản cập nhật cho giao diện người dùng ( widgetTable.setItems (...) ) thực sự được thực thi trở lại Chuỗi ứng dụng FX, sử dụng Tác vụ Phương thức gọi lại tiện lợi của setOnSucceeded (...) (thỏa mãn quy tắc 1).

Trong trường hợp của bạn, quyền truy cập cơ sở dữ liệu mà bạn đang thực hiện trả về một kết quả duy nhất, vì vậy bạn có thể có một phương thức như

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

    // ...
}

Và sau đó mã bộ điều khiển của bạn sẽ giống như

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

tài liệu API cho Task có nhiều ví dụ khác, bao gồm cập nhật tiến trình thuộc tính của nhiệm vụ (hữu ích cho thanh tiến trình ..., v.v.