Groovy vs Java : Connecter une base de données PostgreSQL avec JDBC

Dernièrement, j’ai regardé comment Groovy rationalise la légère maladresse de Java. Cet article examine certaines différences entre la connexion à une base de données PostgreSQL à l’aide de JDBC en Java et Groovy.

Installer Java et Groovy

Groovy est basé sur Java et nécessite une installation Java. Une version récente/décente de Java et de Groovy peut se trouver dans les référentiels de votre distribution Linux, ou vous pouvez installer Groovy en suivant ces consignes. Une bonne alternative pour les utilisateurs Linux est SDKMan, qui fournit plusieurs versions de Java, Groovy et de nombreux autres outils connexes. Pour cet article, j’utilise les versions du SDK de :

• Java version 11.0.12-open d’OpenJDK 11
• Groovy version 3.0.8

Retour au problème

Si vous ne l’avez pas déjà fait, veuillez consulter cet article sur l’installation de JDBC et cet article sur la configuration de PostgreSQL.

Que vous utilisiez Java ou Groovy, plusieurs étapes de base se produisent dans tout programme qui utilise JDBC pour extraire des données d’une base de données :

1. Établir un Connection instance à la base de données principale où résident les données.
2. À l’aide d’une chaîne SQL, obtenez une instance d’un Statement (ou quelque chose de similaire, comme un PreparedStatement) qui gérera l’exécution de la chaîne SQL.
3. Traiter le ResultSet instance retournée en ayant le Statement instance exécute la requête, par exemple en imprimant les lignes renvoyées sur la console.
4. Fermer la Statement et Connection instances lorsque vous avez terminé.

En Java, la correspondance entre le code et la liste ci-dessus est essentiellement un pour un. Groovy, comme d’habitude, rationalise le processus.

Exemple Java

Voici le code Java pour consulter les données de couverture du sol que j’ai chargées dans le deuxième article lié ci-dessus :

1  import java.sql.Connection;
2  import java.sql.Statement;
3  import java.sql.ResultSet;
4  import java.sql.DriverManager;
5  import java.sql.SQLException;
       
6  public class TestQuery {
       
7      public static void main(String[] args) {
       
8          final String url = "jdbc:postgresql://localhost/landcover";
9          final String user = "clh";
10          final String password = "carl-man";
       
11          try (Connection connection = DriverManager.getConnection(url, user, password)) {
       
12              try (Statement statement = connection.createStatement()) {
       
13                  ResultSet res = statement.executeQuery("select distinct country_code from land_cover");
14                  while (res.next()) {
15                      System.out.println("country code " + res.getString("country_code"));
16                  }
       
17              } catch (SQLException se) {
18                  System.err.println(se.getMessage());
19              }
20          } catch (SQLException ce) {
21              System.err.println(ce.getMessage());
22          }
23      }
24  }

Les lignes 1 à 5 sont les instructions d’importation nécessaires pour les classes JDBC. Bien sûr, je pourrais raccourcir cela en import java.sql.* mais ce genre de chose est quelque peu mal vu de nos jours.

Les lignes 6 à 24 définissent la classe publique TestQuery Je vais l’utiliser pour me connecter à la base de données et imprimer une partie du contenu de la table principale.

Les lignes 7 à 23 définissent le main méthode qui fait le travail.

Les lignes 8 à 10 définissent les trois chaînes nécessaires pour se connecter à une base de données : l’URL, le nom d’utilisateur et le mot de passe de l’utilisateur.

Les lignes 11 à 22 utilisent un try-with-resources pour ouvrir le Connection instance et la ferme automatiquement lorsque vous avez terminé.

Les lignes 12 à 19 utilisent un autre try-with-resources pour ouvrir le Statement instance et la ferme automatiquement lorsque vous avez terminé.

La ligne 13 crée le ResultSet instance gère la requête SQL, qui utilise SÉLECTIONNER DISTINCT pour obtenir toutes les valeurs uniques de code postal du couverture_terrestre table dans la base de données.

Les lignes 14 à 16 traitent le jeu de résultats renvoyé par la requête, en imprimant les codes de pays un par ligne.

Les lignes 17-19 et 20-22 traitent toutes les exceptions SQL.

Exemple génial

Je vais faire quelque chose de similaire dans Groovy :

1  import groovy.sql.Sql
       
2  final String url = "jdbc:postgresql://localhost/landcover"
3  final String user = "me"
4  final String password = "my-password"
5  final String driver = "org.postgresql.Driver"
       
6  Sql.withInstance(url, user, password, driver) { sql ->
       
7      sql.eachRow('select distinct country_code from land_cover') { row ->
8        println "row.country_code ${row.country_code}"
9      }
10  }

D’accord, c’est beaucoup plus court – 10 lignes au lieu de 24 ! Voici les détails:

La ligne 1 est la seule importation nécessaire. À mon avis, ne pas avoir à sauter autour de JavaDocs pour trois classes différentes est un avantage distinct.

Les lignes 2 à 5 définissent les quatre chaînes nécessaires pour se connecter à une base de données à l’aide de la Sql classer. Les trois premiers sont les mêmes que pour java.sql.Connection; le quatrième nomme le pilote que je veux.

La ligne 6 fait un tas de gros travaux. L’appel de méthode est Sql.withInstance(), similaire aux autres utilisations de “with” dans Groovy. L’appel:

• Crée une instance de Sql (connexion, déclaration, etc.).
• Prend une fermeture comme paramètre final, en lui passant l’instance de Sql qu’il a créé.
• Ferme l’instance de Sql quand la fermeture sort.

La ligne 7 appelle le eachRow() méthode de la Sql instance, enveloppant la création et le traitement du jeu de résultats. La eachRow() prend une fermeture comme argument final et passe chaque row à la fermeture pendant qu’il traite les lignes de données renvoyées à partir de la table.

Groovy peut vous simplifier la vie

Pour ceux d’entre vous dont le travail quotidien implique des scripts et des bases de données relationnelles, je pense qu’il est assez évident de ce qui précède que Groovy peut vous simplifier la vie. Quelques commentaires de clôture :

• J’aurais pu accomplir cela de la même manière que la version Java ; par exemple, au lieu d’appeler sql.eachRow()j’aurais pu appeler sql.query()qui prend une fermeture comme dernier argument et passe un jeu de résultats à cette fermeture, auquel cas j’aurais probablement utilisé un while() comme dans la version Java (ou peut-être each()).
• Je pourrais également lire les lignes résultantes dans une liste, toutes à la fois, en utilisant un appel à sql.rows()qui peut transformer les données d’une manière similaire à l’utilisation .collect() sur une liste.
• Rappelez-vous que le SQL passé dans le eachRow() (ou query()) peut être arbitrairement complexe, y compris les jointures de table, le regroupement, le classement et toute autre opération prise en charge par la base de données en question.
• Notez que SQL peut également être paramétré lors de l’utilisation d’une instance de PreparedStatementce qui est un bon moyen d’éviter l’injection SQL si une partie du SQL provient de l’extérieur de la sphère de contrôle du codeur.
• C’est un bon moment pour orienter le lecteur assidu vers JavaDocs pour groovy.sql.Sql.

Ressources géniales

La Site en langage Apache Groovy fournit un bon aperçu au niveau du didacticiel de l’utilisation des bases de données, y compris d’autres moyens de se connecter, ainsi que des opérations supplémentaires, notamment les insertions, les suppressions, les transactions, le traitement par lots, la pagination – la liste est longue. Cette documentation est assez concise et facile à suivre, du moins en partie parce que l’installation qu’elle documente a elle-même été conçue pour être concise et facile à utiliser !