Comment utiliser une requête préparée correctement avec le Printemps JDBCTemplate?

Je dois faire une requête select sur une base de données que je vais exécuter souvent. Il fonctionne entièrement fine normale avec une déclaration:

 List<Invoice> l = this.jdbcTemplate.query(
                     "SELECT id, name, stuff FROM example WHERE amount > ?",
                     new Object[] { "100" }, new RowMapper<Invoice>() {...} );

- Je exécuter l'instruction ci-dessus, très souvent, donc, pour des raisons de performances, je veux utiliser une instruction préparée. Cependant, je suis maintenant pas comment j'ai correctement serait d'utiliser le printemps de l'API pour atteindre cet objectif.

Je suis confus pourquoi le printemps souhaitez me donner un exemple d'un PreparedStatementCreator comme un argument pour la requête? Je pensais que c'est exactement le point que je fais pas créer une nouvelle déclaration préparée à l'avance chaque fois que j'utilise la méthode de requête. Donc je pense que quelque chose le long de la ligne de l'extrait de code suivant serait absolument inutile, car l'instruction préparée est nouvellement créée chaque fois que j'appelle le query-méthode:

 List<Invoice> l = this.jdbcTemplate.query(
                     new PreparedStatementCreator() {
                         String query = "SELECT id, name, stuff FROM example WHERE amount > ?";
                         public PreparedStatement createPreparedStatement(Connection connection) throws SQLException {
                              return connection.prepareStatement(query);
                         }
                     },
                     new PreparedStatementSetter() {...}, 
                     new RowMapper<Invoice>() {...} );

Dois-je créer mon propre ReusablePreparedStatementCreator? Ce qui ne ferait que créer une nouvelle méthode sur le premier appel de createPreparedStatement.

Pourrait le PreparedStatementCreatorFactory m'aider?

Donc, pour dire les choses autrement, comment pourrais-je créer correctement une requête select qui utilise une requête préparée avec le Printemps JDBCTemplate pour gagner un avantage de performance sans perdre l'avantage de la RowMapper?

Printemps utilise déjà un PreparedStatement, donc pas besoin de la rendre plus complexe.
avez-vous une référence officielle à cette déclaration? J'ai regardé peu de temps dans le code de JdbcTemplate::query(final String sql, final ResultSetExtractor<T> rse) et n'a pu trouver aucune indication que cela est vrai.
Voir github.com/spring-projects/spring-framework/blob/master/... qui est l'intérieur de la classe utilisée lors de l'utilisation de l'un des query méthodes. Si vous obtenez une nouvelle déclaration ou non dépend aussi de votre pilote jdbc et si il met en cache les déclarations.
merci!!!! mais dans ce cas un objet PreparedStatement est créé pour chaque appel à la méthode de requête. J'ai peut-être tort, mais je pense que ne pas me donne de l'amélioration je cherche à atteindre.
Cela dépend de votre fournisseur JDBC si il est mis en cache (et donc réutilisés) ou si un nouveau est créé. Aussi, je doute que vous souhaitez mettre en cache les PreparedStatement parce que comment allez-vous exécuter pour la prochaine connexion? (En gros, chaque transaction est exécutée sur sa propre connexion).

OriginalL'auteur leo | 2014-05-28

  1. 4

    Tout d'abord, je ne suis pas sûr que vous obtenez une augmentation significative des performances par pas recréer l'instruction préparée à chaque fois, parce que le pilote JDBC/base de données de souvent caches d'instructions préparées.

    Mais si vous voulez exécuter plusieurs requêtes avec une seule instruction préparée, il suffit d'utiliser l'un des execute() méthodes de JdbcTemplate, ce qui crée une instruction préparée à partir d'une requête SQL (ou vous permet de créer), puis exécute un rappel de la prise de la déclaration préparée à l'avance comme argument. Vous pouvez faire une boucle à l'intérieur de ce rappel, et exécutez l'instruction autant de fois que vous voulez.

    OriginalL'auteur JB Nizet