Java: Écriture d'instructions SQL
J'écris un programme Java unique pour ajouter un tas de lignes dans un fichier CSV à une base de données MySQL. Existe-t-il des classes/boîtes à outils Java pour vous aider? Quelque chose qui échappera aux personnages nécessaires, etc? (par exemple, déclarations préparées)
Ou devrais-je écrire les déclarations moi-même, comme ceci:
result += String.format(
"INSERT INTO node (type, language, title) VALUES (%s, %s, %s)",
node.get("type"), node.get("language"), node.get("title")
);
4 answers
Si vous utilisez JDBC, utilisez un PreparedStatement. Cette classe vous évitera d'échapper manuellement vos entrées.
Le code ressemblera essentiellement à ceci (totalement de mémoire hope j'espère que je n'ai pas négligé quelque chose):
String sql = "INSERT INTO node (type, language, title) VALUES (?, ?, ?)";
PreparedStatement pstmt = conn.prepareStatement(sql);
try
{
pstmt.setString(1, node.get("type"));
pstmt.setString(2, node.get("language"));
pstmt.setString(3, node.get("title"));
pstmt.executeUpdate();
}
finally
{
pstmt.close();
}
Voir cette section dans le tutoriel sur Utilisation des instructions préparées:
La caractéristique principale d'un objet PreparedStatement est que, contrairement à un objet Statement, il reçoit une instruction SQL lors de sa création. L'avantage est que dans la plupart des cas, cette instruction SQL est immédiatement envoyée au SGBD, où elle est compilée. Par conséquent, l'objet PreparedStatement ne contient pas seulement une instruction SQL, mais une instruction SQL précompilée. Cela signifie que lorsque le PreparedStatement est exécuté, le SGBD peut simplement exécuter l'instruction SQL PreparedStatement sans avoir à la compiler au préalable.
Bien que les objets PreparedStatement puissent être utilisés pour les instructions SQL sans paramètres, vous les utilisez probablement le plus souvent pour les instructions SQL qui prennent des paramètres. L'avantage d'utiliser des instructions SQL qui prennent des paramètres que vous pouvez utiliser la même instruction et d'approvisionnement avec des valeurs différentes à chaque fois que vous exécuter. Des exemples de ceci sont dans les sections qui suivent.
...
En regardant ces exemples, vous pourriez vous demander pourquoi vous choisiriez d'utiliser un objet PreparedStatement avec des paramètres au lieu d'une simple instruction, car la simple instruction implique moins d'étapes. Si vous n'alliez mettre à jour la colonne SALES qu'une ou deux fois, il n'y aurait pas besoin d'utiliser une instruction SQL avec des paramètres d'entrée. Si vous mettez à jour souvent, en revanche, il pourrait être beaucoup plus facile d'utiliser un Objet PreparedStatement, en particulier dans les situations où vous pouvez utiliser une boucle for ou while pour définir un paramètre sur une succession de valeurs.
Curieusement, ce tutoriel ne semble pas mentionner que l'utilisation d'un PreparedStatement vous donne également l'avantage d'avoir des caractères spéciaux automatiquement échappés, qu'il aide à empêcher l'injection SQL, etc. - mais ce sont les principaux avantages.
Vous voudrez peut-être vérifier DbUnit. Il dispose d'un tas d'outils pour manipuler des bases de données à partir de fichiers XML et plats.
Cela peut être considéré comme un peu une approche sledgehammer, mais vous voudrez peut-être envisager d'utiliser spring pour vos appels SQL, alors ce qui précède devient aussi simple que:
getSimpleJdbcTemplate().update(
"INSERT INTO node (type, language, title) VALUES (?, ?, ?)",
node.get("type"),
node.get("language"),
node.get("title"));
Cela a l'avantage d'utiliser les statments préparés JDBC sous le capot, de sorte que vous ne vous retrouverez pas en difficulté si le titre inclut des guillemets ou d'autres caractères qui devraient autrement être échappés, tout en laissant Spring gérer toute la connexion, l'instruction préparée et la transaction (si nécessaire) complexité.
Pour plus voir: SimpleJdbcTemplate du framework Spring