Accès avancé aux bases de données relationnelles en Java (JDBC)

public interface GenericDAO<T, ID> {
    void create(T entity) throws SQLException;
    T read(ID id) throws SQLException;
    void update(T entity) throws SQLException;
    void delete(ID id) throws SQLException;
    List<T> findAll() throws SQLException;
}

// Record User pour représenter l'entité utilisateur
public record User(Integer id, String name, String email) {}

// Implémentation concrète de UserDAO
public class UserDAO implements GenericDAO<User, Integer> {
    private Connection connection;

    public UserDAO(Connection connection) {
        this.connection = connection;
    }

    @Override
    public void create(User user) throws SQLException {
        String sql = "INSERT INTO users (name, email) VALUES (?, ?)";
        try (PreparedStatement pstmt = connection.prepareStatement(sql)) {
            pstmt.setString(1, user.name());
            pstmt.setString(2, user.email());
            pstmt.executeUpdate();
        }
    }

    @Override
    public User read(Integer id) throws SQLException {
        String sql = "SELECT * FROM users WHERE id = ?";
        try (PreparedStatement pstmt = connection.prepareStatement(sql)) {
            pstmt.setInt(1, id);
            try (ResultSet rs = pstmt.executeQuery()) {
                if (rs.next()) {
                    return new User(rs.getInt("id"), rs.getString("name"), rs.getString("email"));
                }
            }
        }
        return null;
    }

    @Override
    public void update(User user) throws SQLException {
        String sql = "UPDATE users SET name = ?, email = ? WHERE id = ?";
        try (PreparedStatement pstmt = connection.prepareStatement(sql)) {
            pstmt.setString(1, user.name());
            pstmt.setString(2, user.email());
            pstmt.setInt(3, user.id());
            pstmt.executeUpdate();
        }
    }

    @Override
    public void delete(Integer id) throws SQLException {
        String sql = "DELETE FROM users WHERE id = ?";
        try (PreparedStatement pstmt = connection.prepareStatement(sql)) {
            pstmt.setInt(1, id);
            pstmt.executeUpdate();
        }
    }

    @Override
    public List<User> findAll() throws SQLException {
        List<User> users = new ArrayList<>();
        String sql = "SELECT * FROM users";
        try (Statement stmt = connection.createStatement();
             ResultSet rs = stmt.executeQuery(sql)) {
            while (rs.next()) {
                users.add(new User(rs.getInt("id"), rs.getString("name"), rs.getString("email")));
            }
        }
        return users;
    }
}

%maven com.h2database:h2:2.3.232
%maven com.github.javafaker:javafaker:1.0.2
import com.github.javafaker.Faker;

private static final String DB_URL = "jdbc:h2:mem:testdb";
private static final String DB_USERNAME = "sa";
private static final String DB_PASSWORD = "";

Class.forName("org.h2.Driver");

private static void createTables(Connection connection) throws SQLException {
    String createUsersTableSql = "CREATE TABLE users (" +
            "id INT AUTO_INCREMENT PRIMARY KEY," +
            "name VARCHAR(255) NOT NULL," +
            "email VARCHAR(255) NOT NULL)";
    try (Statement statement = connection.createStatement()) {
        statement.execute(createUsersTableSql);
    }
}

private static void populateTables(Connection connection) throws SQLException {
    Faker faker = new Faker();
    String insertUsersSql = "INSERT INTO users (name, email) VALUES (?, ?)";

    try (PreparedStatement pstmt = connection.prepareStatement(insertUsersSql)) {
        IntStream.range(0, 10).forEach(i -> {
            try {
                pstmt.setString(1, faker.name().fullName());
                pstmt.setString(2, faker.internet().emailAddress());
                pstmt.executeUpdate();
            } catch (SQLException e) {
                throw new RuntimeException(e);
            }
        });
    }
}

try (Connection connection = DriverManager.getConnection(DB_URL, DB_USERNAME, DB_PASSWORD)) {
    createTables(connection);
    populateTables(connection);
    System.out.println("Database setup completed successfully.");

    // Utilisation de UserDAO pour effectuer des opérations CRUD
    UserDAO userDAO = new UserDAO(connection);

    // Création d'utilisateurs
    userDAO.create(new User(null, "Alice", "alice@example.com"));
    userDAO.create(new User(null, "Bob", "bob@example.com"));

    // Lecture d'un utilisateur
    User user = userDAO.read(1);
    System.out.println("Read user: " + user);

    // Mise à jour d'un utilisateur
    userDAO.update(new User(1, "Alice Updated", "alice.updated@example.com"));

    // Suppression d'un utilisateur
    userDAO.delete(2);

    // Lecture de tous les utilisateurs
    List<User> users = userDAO.findAll();
    users.forEach(System.out::println);

} catch (SQLException e) {
    e.printStackTrace();
}

try (Connection connection = DriverManager.getConnection(DB_URL, DB_USERNAME, DB_PASSWORD)) {

    // Récupération des métadonnées de la base de données
    DatabaseMetaData metadata = connection.getMetaData();

    // Affichage des informations sur le système de gestion de base de données
    System.out.printf("DBMS: %s %d.%d%n",
            metadata.getDatabaseProductName(),
            metadata.getDatabaseMajorVersion(),
            metadata.getDatabaseMinorVersion());

    // Affichage de la base de données et du schéma actuels
    System.out.printf("Current Database: %s Schema: %s%n",
            connection.getCatalog(), connection.getSchema());

    // Récupération de la liste des tables pour vérifier l'existence de "SIMPLEJDBC_PERSON"
    ResultSet tables = metadata.getTables(connection.getCatalog(),
            connection.getSchema(),
            "SIMPLEJDBC_PERSON", null);

    if (tables.next()) {
        // Si la table existe déjà, affichage d'un message
        System.out.println("Table " + tables.getString("TABLE_NAME") + " already exists.");
    } else {
        // Si la table n'existe pas, création de la table "SIMPLEJDBC_PERSON"
        String createTableSql = "CREATE TABLE \"SIMPLEJDBC_PERSON\"(" +
                "id INT PRIMARY KEY NOT NULL, " +
                "firstname VARCHAR(100))";
        try (Statement statement = connection.createStatement()) {
            statement.execute(createTableSql);
            System.out.println("Table SIMPLEJDBC_PERSON created.");
        }
    }

} catch (SQLException e) {
    // Gestion des exceptions SQL
    e.printStackTrace();
}

// Connexion à la base de données et récupération des métadonnées du ResultSet
try (Connection connection = DriverManager.getConnection(DB_URL, DB_USERNAME, DB_PASSWORD);
     ResultSet rs = connection.createStatement().executeQuery("SELECT * FROM stops")) {

    // Récupération de l'objet ResultSetMetaData pour obtenir des informations sur les colonnes
    ResultSetMetaData rsmd = rs.getMetaData();
    int nbColonnes = rsmd.getColumnCount();

    // Parcours des colonnes et affichage des informations
    for (int i = 1; i <= nbColonnes; i++) {
        String typeColonne = rsmd.getColumnTypeName(i); // Type de la colonne
        String nomColonne = rsmd.getColumnName(i);      // Nom de la colonne
        System.out.printf("Colonne %d: nom = %s, type = %s%n", i, nomColonne, typeColonne);
    }
} catch (SQLException e) {
    // Gestion des exceptions SQL
    e.printStackTrace();
}

import java.sql.*;
import java.util.stream.IntStream;

// Connexion à la base de données et récupération des métadonnées du ResultSet
try (Connection connection = DriverManager.getConnection(DB_URL, DB_USERNAME, DB_PASSWORD);
     ResultSet rs = connection.createStatement().executeQuery("SELECT * FROM stops LIMIT 5")) {

    // Récupération de l'objet ResultSetMetaData pour obtenir des informations sur les colonnes
    ResultSetMetaData rsmd = rs.getMetaData();
    int nbColonnes = rsmd.getColumnCount();

    // Affichage des noms de colonnes
    IntStream.range(1, nbColonnes + 1)
             .mapToObj(i -> {
                 try {
                     return rsmd.getColumnName(i)+" "+rsmd.getColumnTypeName(i);
                 } catch (SQLException e) {
                     throw new RuntimeException(e);
                 }
             })
             .forEach(nomColonne -> System.out.printf("%-20s", nomColonne));
    System.out.println();

    // Affichage des données des lignes
    while (rs.next()) {
        IntStream.range(1, nbColonnes + 1)
                 .mapToObj(i -> {
                     try {
                         return rs.getString(i);
                     } catch (SQLException e) {
                         throw new RuntimeException(e);
                     }
                 })
                 .forEach(valeur -> System.out.printf("%-20s", valeur));
        System.out.println();
    }

} catch (SQLException e) {
    // Gestion des exceptions SQL
    e.printStackTrace();
}