PreparedStatement Penggunaan Semula: Untuk Guna Semula atau Tidak Guna Semula? Menyelam Dalam Kecekapan dan Kebolehskalaan

Menggunakan Semula Penyata Disediakan Berbilang Kali: Meningkatkan Kecekapan dan Kebolehskalaan

Apabila bekerja dengan PreparedStatements dalam satu sambungan tanpa kumpulan sambungan, pembangun sering menghadapi dilema untuk mencipta contoh untuk setiap operasi DML/SQL atau menggunakan semula tika sedia ada. Di sini, kami menganalisis kelebihan dan kelemahan kedua-dua pendekatan dan meneroka penyelesaian alternatif untuk meningkatkan kecekapan dan kebolehskalaan.

Perbandingan Pendekatan

Pendekatan pertama melibatkan penciptaan semula contoh PreparedStatement baharu untuk setiap operasi, memastikan bahawa setiap pernyataan bebas daripada sebarang parameter atau keadaan baki daripada pelaksanaan sebelumnya. Walau bagaimanapun, pendekatan ini boleh membawa kepada penalti prestasi, terutamanya dalam persekitaran berbilang benang.

Pendekatan kedua menangani isu ini dengan menggunakan semula satu contoh PreparedStatement, mengosongkan parameternya sebelum setiap pelaksanaan. Walaupun kaedah ini agak lebih cekap, kaedah ini tidak mempunyai keanggunan dan kesederhanaan pendekatan pertama.

Pelaksanaan Batch untuk Skala Dipertingkat

Penyelesaian yang lebih optimum untuk melaksanakan berbilang operasi DML/SQL adalah dengan menggunakan batching. Teknik ini melibatkan pengumpulan satu siri operasi dan melaksanakannya sebagai satu permintaan kepada pangkalan data. Pengumpulan secara ketara mengurangkan overhed yang berkaitan dengan mencipta dan menutup berbilang contoh PreparedStatement.

<code class="java">public void executeBatch(List<entity> entities) throws SQLException {
    try (
        Connection connection = dataSource.getConnection();
        PreparedStatement statement = connection.prepareStatement(SQL);
    ) {
        for (Entity entity : entities) {
            statement.setObject(1, entity.getSomeProperty());
            // ...

            statement.addBatch();
        }

        statement.executeBatch();
    }
}</entity></code>

Dalam senario di mana bilangan kelompok yang akan dilaksanakan adalah berlebihan, mengehadkan saiz kelompok boleh meningkatkan lagi prestasi.

<code class="java">public void executeBatch(List<entity> entities) throws SQLException {
    try (
        Connection connection = dataSource.getConnection();
        PreparedStatement statement = connection.prepareStatement(SQL);
    ) {
        int i = 0;

        for (Entity entity : entities) {
            statement.setObject(1, entity.getSomeProperty());
            // ...

            statement.addBatch();
            i++;

            if (i % 1000 == 0 || i == entities.size()) {
                statement.executeBatch(); // Execute every 1000 items.
            }
        }
    }
}</entity></code>

Keselamatan Benang dalam Persekitaran Berbilang Benang

Kebimbangan mengenai keselamatan benang dikurangkan dengan menggunakan pernyataan cuba-dengan-sumber untuk memperoleh dan menutup sambungan dan PreparedStatement dalam blok kaedah yang sama:

<code class="java">try (
    Connection connection = dataSource.getConnection();
    PreparedStatement statement = connection.prepareStatement(SQL);
) {
    // ...
}</code>

Dalam senario transaksi, melumpuhkan autokomit pada sambungan memastikan ketekalan data dengan hanya melakukan transaksi selepas semua kelompok selesai.

<code class="java">public void executeBatch(List<entity> entities) throws SQLException {
    try (Connection connection = dataSource.getConnection()) {
        connection.setAutoCommit(false);

        try (PreparedStatement statement = connection.prepareStatement(SQL)) {
            // ...

            try {
                connection.commit();
            } catch (SQLException e) {
                connection.rollback();
                throw e;
            }
        }
    }
}</entity></code>

Dengan memanfaatkan pelaksanaan kelompok dan mematuhi teknik pengurusan sambungan yang betul , pembangun boleh memanfaatkan kuasa PreparedStatements sambil memaksimumkan kecekapan dan kebolehskalaan, walaupun dalam persekitaran berbilang benang.

Atas ialah kandungan terperinci PreparedStatement Penggunaan Semula: Untuk Guna Semula atau Tidak Guna Semula? Menyelam Dalam Kecekapan dan Kebolehskalaan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!