Comment faire plusieurs insertions dans la base de données en utilisant un lot JDBC Printemps?

J'ai besoin d'insérer des milliers d'enregistrements dans la base de données d'un seul coup. Je suis à l'aide de spring JDBC modèle dans mon application.

Ci-dessous le code que j'ai écrit jusqu'à présent qui s'exécute toutes les insertions d'un seul coup. Donc, si j'ai 10 000 utilisateurs, ils sont insérés. Mais ce que je veux, c'est de les exécuter dans des lots de dire par exemple de 500 enregistrements en un seul lot et ainsi de suite.

@Override
public void saveBatch(final List<Employee> employeeList) {
    final int batchSize = 500;

    getJdbcTemplate().batchUpdate(QUERY_SAVE,
            new BatchPreparedStatementSetter() {
                @Override
                public void setValues(PreparedStatement ps, int i)
                        throws SQLException {
                    Employee employee = employeeList.get(i);
                    ps.setString(1, employee.getFirstname());
                    ps.setString(2, employee.getLastname());
                    ps.setString(3, employee.getEmployeeIdOnSourceSystem());
                }

                @Override
                public int getBatchSize() {
                    return employeeList.size();
                }
            });

}

Comment puis-je changer le code ci-dessus de sorte qu'au lieu de employeeList.size() comme la taille du lot, pouvons-nous avoir la taille du lot comme le disent les de 500, de les exécuter, puis 500 et ainsi de suite?

S'il vous plaît aider.

source d'informationauteur ashishjmeshram

  1. 23

    Je ne suis pas sûr si vous pouvez le faire à l'aide de JDBC modèle seul. Peut-être que vous pourriez appeler la batchUpdate méthode par étapes, par tranchage de le grand liste dans le lot-morceaux de taille.

    Ont un coup d'oeil ici:

    @Override
public void saveBatch(final List<Employee> employeeList) {
    final int batchSize = 500;

    for (int j = 0; j < employeeList.size(); j += batchSize) {

        final List<Employee> batchList = employeeList.subList(j, j + batchSize > employeeList.size() ? employeeList.size() : j + batchSize);

        getJdbcTemplate().batchUpdate(QUERY_SAVE,
            new BatchPreparedStatementSetter() {
                @Override
                public void setValues(PreparedStatement ps, int i)
                        throws SQLException {
                    Employee employee = batchList.get(i);
                    ps.setString(1, employee.getFirstname());
                    ps.setString(2, employee.getLastname());
                    ps.setString(3, employee.getEmployeeIdOnSourceSystem());
                }

                @Override
                public int getBatchSize() {
                    return batchList.size();
                }
            });

    }
}
  2. 14

    Je sais c'est un peu tard, mais vous pourriez faire quelque chose de semblable à ce que @adarshr est en train de faire, à l'exception de l'utilisation Google Goyave Listes.partition pour obtenir les sous-listes.

    public void saveBatch(final List<Employee> employeeList) {
    final int batchSize = 500;
    List<List<Employee>> batchLists = Lists.partition(employeeList, batchSize);

    for(List<Employee> batch : batchLists) {  
        getJdbcTemplate().batchUpdate(QUERY_SAVE, new BatchPreparedStatementSetter() {
            @Override
            public void setValues(PreparedStatement ps, int i)
                    throws SQLException {
                Employee employee = batch.get(i);
                ps.setString(1, employee.getFirstname());
                ps.setString(2, employee.getLastname());
                ps.setString(3, employee.getEmployeeIdOnSourceSystem());
            }

            @Override
            public int getBatchSize() {
                return batch.size();
            }
        });
    }
}
  3. 4

    Spring fournit les opérations par Lots avec plusieurs lots. Dans l'exemple ci-dessous, la taille du lot est de 100.

     public class JdbcActorDao implements ActorDao {

    private JdbcTemplate jdbcTemplate;

    public void setDataSource(DataSource dataSource) {
        this.jdbcTemplate = new JdbcTemplate(dataSource);
    }

    public int[][] batchUpdate(final Collection<Actor> actors) {
        int[][] updateCounts = jdbcTemplate.batchUpdate(
                "update t_actor set first_name = ?, last_name = ? where id = ?",
                actors,
                100,
                new ParameterizedPreparedStatementSetter<Actor>() {
                    public void setValues(PreparedStatement ps, Actor argument) throws SQLException {
                        ps.setString(1, argument.getFirstName());
                        ps.setString(2, argument.getLastName());
                        ps.setLong(3, argument.getId().longValue());
                    }
                });
        return updateCounts;
    }

    //... additional methods

 }
  4. -1

    Encore de manière simplifiée, c'est de modifier getBatchsize() la méthode que ci-dessous fonctionne bien

    Pas besoin de partitionner ou de sous-ensemble de la liste :),

    @Override
public void saveBatch(final List<Employee> employeeList) {
    final int batchSize = 500;
    getJdbcTemplate().batchUpdate(QUERY_SAVE,
            new BatchPreparedStatementSetter() {
                @Override
                public void setValues(PreparedStatement ps, int i)
                        throws SQLException {
                    Employee employee = employeeList.get(i);
                    ps.setString(1, employee.getFirstname());
                    ps.setString(2, employee.getLastname());
                    ps.setString(3, employee.getEmployeeIdOnSourceSystem());
                }

                @Override
                public int getBatchSize() {
                    if (batchSize > employeeList.size()) {
                        return employeeList.size();
                    }
                    return batchSize;
                }
            });
}