Implementation of a GUI Application for Managing Database Table 'Matière'

Question 1 - Bibliothèques Java nécessaires

Pour implémenter cette application, qui combine une interface graphique (GUI) et un accès à une base de données via JDBC, les bibliothèques suivantes sont requises.

• java.sql.* : Indispensable pour toutes les classes et interfaces liées à la base de données (ex: Connection, Statement, DriverManager, ResultSet, SQLException).
• javax.swing.* : Nécessaire pour les composants de l'interface graphique moderne en Java (ex: JFrame, JPanel, JLabel, JTextField, JButton, JTextArea). Note : le code source extrait mentionne import javax.*;, ce qui est une erreur de syntaxe en Java. Il faut utiliser javax.swing.*.
• java.awt.* : Nécessaire pour les gestionnaires de mise en page comme GridLayout et la gestion des conteneurs (Container).
• java.awt.event.* : Nécessaire pour la gestion des événements liés aux clics sur les boutons (ActionListener, ActionEvent).

Question 2 - Code complet de l'interface graphique

Le code source fourni contient une ébauche avec des espaces à remplir, suivie d'une proposition de solution comportant quelques erreurs de logique (notamment l'initialisation du Statement absente du constructeur, causant une erreur si on clique sur "Afficher" avant "Ajouter", et un GridLayout défini à 4 lignes au lieu des 3 demandées dans les commentaires, bien que 4 lignes soient nécessaires pour y inclure les boutons).

Voici le code corrigé, fonctionnel, et respectant scrupuleusement les consignes de l'énoncé (nom de la base, noms des champs, création du statement dans le constructeur).

import java.sql.*;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

// La classe hérite de JFrame pour la fenêtre et implémente ActionListener pour les boutons
public class MatièreDB extends JFrame implements ActionListener {

    // Déclarations des composants de l'interface
    private JPanel p;
    private JTextField t1, t2, t3;
    private JButton b1, b2;
    private JTextArea ta;

    // Déclarations des objets relatifs à la base
    private String url = "jdbc:odbc:SourceMatière"; // Utilisation du nom défini dans l'énoncé
    private Connection con = null;
    private Statement stmt = null;

    public MatièreDB() {
        // Titre de la fenêtre
        super("Gestion des matières DSI");

        // Récupération de la vitre (Container)
        Container c = this.getContentPane();

        // Création du panneau
        p = new JPanel();

        // Modification du gestionnaire de position
        // Note : L'énoncé demande un GridLayout 3 lignes 2 colonnes dans les commentaires,
        // mais nous avons 3 champs (label + texte) ET 2 boutons, soit 8 éléments.
        // Un GridLayout(4, 2) est donc techniquement requis pour tout afficher correctement.
        p.setLayout(new GridLayout(4, 2));

        // Création de l'ensemble des composants du panneau
        p.add(new JLabel("Code matière :"));
        t1 = new JTextField(10);
        p.add(t1);

        p.add(new JLabel("Libellé matière :"));
        t2 = new JTextField(10);
        p.add(t2);

        p.add(new JLabel("Coefficient :"));
        t3 = new JTextField(10);
        p.add(t3);

        b1 = new JButton("Ajouter");
        b1.addActionListener(this);
        p.add(b1);

        b2 = new JButton("Afficher");
        b2.addActionListener(this);
        p.add(b2);

        // Ajout des composants à la vitre
        c.add(p, BorderLayout.NORTH); // Panneau disposé au nord

        // Création de la zone de texte
        ta = new JTextArea();
        c.add(new JScrollPane(ta), BorderLayout.CENTER); // JScrollPane ajouté pour la lisibilité

        setVisible(true);
        setSize(400, 300); // Taille ajustée pour une meilleure visibilité
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        /*********************************************/
        try {
            // Chargement du driver
            Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
            
            // Connexion à la base
            con = DriverManager.getConnection(url, "", "");
            
            // Création du statement dans le constructeur (comme exigé)
            stmt = con.createStatement();
            
        } catch (java.lang.ClassNotFoundException e) {
            System.err.println("Pb de driver : " + e.getMessage());
        } catch (SQLException e) {
            System.err.println("SQLException: " + e.getMessage());
        }
    }

    /******************************************************/
    public void actionPerformed(ActionEvent e) {
        
        // Si on clique sur le bouton "Ajouter"
        if (e.getSource() == b1) {
            // Requête d'insertion des champs récupérés dans l'interface
            // Attention au formatage : Code (entier), Libellé (chaîne -> apostrophes), Coefficient (entier)
            String req1 = "INSERT INTO Matière VALUES (" 
                        + Integer.parseInt(t1.getText()) + ", '" 
                        + t2.getText() + "', " 
                        + Integer.parseInt(t3.getText()) + ")";
            try {
                // Exécution de la requête
                int x = stmt.executeUpdate(req1);
                System.out.println("Nombre d'enregistrements ajoutés : " + x);
                // Optionnel : effacer les champs après ajout
                t1.setText(""); t2.setText(""); t3.setText("");
            } catch (SQLException e1) {
                e1.printStackTrace();
            }
        }
        
        // Si on clique sur le bouton "Afficher"
        if (e.getSource() == b2) {
            try {
                // Sélection de l'ensemble des matières
                String req2 = "SELECT * FROM Matière";
                
                // Exécution de la requête
                ResultSet rs = stmt.executeQuery(req2);
                ResultSetMetaData rsmd = rs.getMetaData();
                int nbcols = rsmd.getColumnCount();
                
                // Réinitialiser la zone de texte avant affichage
                ta.setText("");
                
                // Affichage du nom des colonnes
                for (int i = 1; i <= nbcols; i++) {
                    ta.append(rsmd.getColumnLabel(i) + " \t| ");
                }
                ta.append("\n--------------------------------------------------\n");
                
                // Affichage des lignes du résultat de l'exécution
                while (rs.next()) {
                    for (int i = 1; i <= nbcols; i++) {
                        ta.append(rs.getString(i) + " \t| ");
                    }
                    ta.append("\n");
                }
            } catch (SQLException ex) {
                System.err.println("Erreur d'affichage : " + ex.getMessage());
            }
        }
    }

    public static void main(String[] arg) {
        MatièreDB mdb = new MatièreDB();
    }
}

Méthode

Pour réussir ce type d'exercice liant une interface graphique Java (Swing) à une base de données (JDBC), il est recommandé de suivre cette démarche systématique :

1. Identifier les imports nécessaires : Ne négligez pas les bibliothèques. Tout ce qui est visuel provient de javax.swing.* et java.awt.*, la gestion des clics vient de java.awt.event.*, et l'accès aux données de java.sql.*.
2. Structurer l'interface (Vue) : Identifiez le conteneur principal (JFrame), le gestionnaire de disposition (GridLayout, BorderLayout) et les composants. Placez toujours la logique de construction de l'interface dans le constructeur de la classe.
3. Gérer le cycle de vie de la base de données (Modèle) :
   • Charger le pilote (Class.forName(...)). À noter que le pont JDBC-ODBC utilisé ici (sun.jdbc.odbc.JdbcOdbcDriver) est obsolète depuis Java 8, mais vous devez utiliser celui défini par l'énoncé de l'examen.
   • Établir la connexion (DriverManager.getConnection(...)).
   • Créer l'objet Statement. Il est crucial de le faire une seule fois dans le constructeur plutôt que de le recréer à chaque clic, afin d'optimiser les ressources.
4. Associer les événements (Contrôleur) : N'oubliez pas d'attacher vos boutons au gestionnaire d'événements via addActionListener(this).
5. Exécuter et traiter les requêtes :
   • Utilisez executeUpdate() pour les requêtes de modification (INSERT, UPDATE, DELETE).
   • Utilisez executeQuery() pour les requêtes de lecture (SELECT). Cette méthode renvoie un ResultSet que vous devez parcourir avec une boucle while(rs.next()).
   • Faites particulièrement attention aux types de données lors de la concaténation de chaînes SQL : les chaînes de caractères (comme le Libelle) doivent être encadrées par des apostrophes simples (' '), contrairement aux entiers.