Correction EX07 CRUD couleur

Dans un premier temps nous alons Créer une class DatabaseConnection pour gérer la connection plus simplement.
Cette classe, que nous appellerons DatabaseConnection, fournira une méthode pour établir une connexion avec la base de données et une autre pour la fermer. Voici un exemple simple :

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class DatabaseConnection {

    private String jdbcURL;
    private String jdbcUsername;
    private String jdbcPassword;
    private Connection jdbcConnection;

    public DatabaseConnection(String jdbcURL, String jdbcUsername, String jdbcPassword) {
        this.jdbcURL = jdbcURL;
        this.jdbcUsername = jdbcUsername;
        this.jdbcPassword = jdbcPassword;
    }

    public void connect() throws SQLException {
        if (jdbcConnection == null || jdbcConnection.isClosed()) {
            try {
                Class.forName("com.mysql.cj.jdbc.Driver");
            } catch (ClassNotFoundException e) {
                throw new SQLException("MySQL JDBC Driver not found.", e);
            }
            jdbcConnection = DriverManager.getConnection(jdbcURL, jdbcUsername, jdbcPassword);
        }
    }

    public void disconnect() throws SQLException {
        if (jdbcConnection != null && !jdbcConnection.isClosed()) {
            jdbcConnection.close();
        }
    }

    public Connection getJdbcConnection() {
        return jdbcConnection;
    }
}

Explications :

• La classe DatabaseConnection contient des méthodes pour connecter et déconnecter la base de données.
• Le constructeur prend l'URL JDBC, le nom d'utilisateur et le mot de passe comme paramètres pour établir la connexion.
• La méthode connect établit la connexion à la base de données en utilisant DriverManager.getConnection.
• La méthode disconnect ferme la connexion si elle est ouverte.
• La méthode getJdbcConnection permet d'obtenir l'objet Connection pour effectuer des opérations sur la base de données.

Utilisation :

Pour utiliser cette classe, créez une instance de DatabaseConnection avec les détails de votre connexion à la base de données, puis utilisez les méthodes connect et disconnect pour gérer la connexion.

public class Main {
    public static void main(String[] args) {
        String jdbcURL = "jdbc:mysql://localhost:3306/yourdatabase";
        String jdbcUsername = "root";
        String jdbcPassword = "password";

        DatabaseConnection dbConnection = new DatabaseConnection(jdbcURL, jdbcUsername, jdbcPassword);

        try {
            dbConnection.connect();
            // Effectuer des opérations sur la base de données
            dbConnection.disconnect();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

Assurez-vous de gérer les exceptions SQLException qui peuvent survenir lors de la connexion ou de la déconnexion de la base de données.

La Class CouleurDAO utilisera la class DatabaseConnection pour se connecter à la base de données.

public class CouleurDAO {

    private DatabaseConnection dbConnection;

    public CouleurDAO(DatabaseConnection dbConnection) {
        this.dbConnection = dbConnection;
    }

    public boolean insertCouleur(String nomCouleur) throws SQLException {
        String sql = "INSERT INTO couleurs (nom_couleur) VALUES (?)";
        dbConnection.connect();

        PreparedStatement statement = dbConnection.getJdbcConnection().prepareStatement(sql);
        statement.setString(1, nomCouleur);

        boolean rowInserted = statement.executeUpdate() > 0;
        statement.close();
        dbConnection.disconnect();
        return rowInserted;
    }

    public ResultSet listAllCouleurs() throws SQLException {
        String sql = "SELECT * FROM couleurs";
        dbConnection.connect();

        Statement statement = dbConnection.getJdbcConnection().createStatement();
        ResultSet resultSet = statement.executeQuery(sql);

        // Note: The caller should handle closing the resultSet and disconnecting
        return resultSet;
    }

    public boolean updateCouleur(int id, String nomCouleur) throws SQLException {
        String sql = "UPDATE couleurs SET nom_couleur = ? WHERE id = ?";
        dbConnection.connect();

        PreparedStatement statement = dbConnection.getJdbcConnection().prepareStatement(sql);
        statement.setString(1, nomCouleur);
        statement.setInt(2, id);

        boolean rowUpdated = statement.executeUpdate() > 0;
        statement.close();
        dbConnection.disconnect();
        return rowUpdated;
    }

    public boolean deleteCouleur(int id) throws SQLException {
        String sql = "DELETE FROM couleurs WHERE id = ?";

        dbConnection.connect();

        PreparedStatement statement = dbConnection.getJdbcConnection().prepareStatement(sql);
        statement.setInt(1, id);

        boolean rowDeleted = statement.executeUpdate() > 0;
        statement.close();
        dbConnection.disconnect();
        return rowDeleted;
    }
}

Modifications :

• La classe CouleurDAO prend désormais un objet DatabaseConnection en tant que paramètre dans son constructeur.
• Chaque méthode CRUD utilise dbConnection.connect() pour établir la connexion et dbConnection.disconnect() pour la fermer après l'opération.
• Les méthodes utilisent dbConnection.getJdbcConnection() pour obtenir l'objet Connection nécessaire pour créer des Statement ou PreparedStatement.

Utilisation :

Pour utiliser CouleurDAO avec DatabaseConnection, créez d'abord une instance de DatabaseConnection et passez-la à CouleurDAO :

public class Main {
    public static void main(String[] args) {
        String jdbcURL = "jdbc:mysql://localhost:3306/alimentations";
        String jdbcUsername = "root";
        String jdbcPassword = "";

        DatabaseConnection dbConnection = new DatabaseConnection(jdbcURL, jdbcUsername, jdbcPassword);
        CouleurDAO couleurDao = new CouleurDAO(dbConnection);

        try {
            // Utiliser couleurDao pour les opérations CRUD
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

DAO, qui signifie Data Access Object, est un patron de conception (design pattern) utilisé en programmation orientée objet pour isoler la couche d'accès aux données de la logique métier de l'application. L'objectif principal d'un DAO est de réduire la redondance du code d'accès aux données et de séparer les préoccupations de manière à rendre le code plus propre, plus maintenable et plus facile à comprendre.

Voici quelques points clés sur le DAO :

1. Abstraction et Encapsulation : Le DAO fournit une interface abstraite pour accéder à la base de données ou à toute autre source de données. Cela signifie que la logique métier de l'application n'a pas besoin de connaître les détails de la base de données, tels que les requêtes SQL.

2. Séparation des préoccupations : En séparant la logique d'accès aux données de la logique métier, les modifications dans la manière d'accéder aux données n'affectent pas le reste de l'application. Cela facilite la maintenance et l'évolution de l'application.

3. Réutilisabilité et maintenabilité : Le code d'accès aux données est centralisé dans les classes DAO, ce qui évite la duplication du code et facilite les modifications. Si la source de données change, seul le DAO doit être mis à jour.

4. Testabilité : Les DAO peuvent être mockés ou stubbés dans les tests unitaires, ce qui permet de tester la logique métier sans dépendre de la base de données.

5. Flexibilité : Si l'application doit changer de source de données (par exemple, passer d'une base de données SQL à une base de données NoSQL), il suffit de créer une nouvelle implémentation du DAO sans avoir à modifier la logique métier.

En résumé, le pattern DAO est une approche de conception logicielle qui permet de séparer la logique d'accès aux données de la logique métier, offrant ainsi une meilleure organisation du code, une plus grande flexibilité et une meilleure maintenabilité.