Projet de 2ème année BTS SIO SLAM - Application SIO2Jeux

Contexte

Ce projet a été réalisé en deuxième année de BTS SIO avec la spécialité SLAM. L'objectif était de développer une application en Java pour la gestion d'une bibliothèque de jeux vidéo, en utilisant le pattern MVC (Modèle-Vue-Contrôleur).

Besoins et Missions

Le projet visait à permettre la gestion des jeux vidéo, incluant la gestion des éditeurs, des catégories, des plateformes, et des consoles. Il comportait plusieurs fonctionnalités importantes, telles que :

Création, modification et suppression des jeux vidéo.
Gestion des relations entre jeux, éditeurs, catégories et plateformes.
Interface utilisateur permettant la navigation dans l'application.
Validation des données en utilisant des tests unitaires avec JUnit et des fichiers XML.

Langages et Outils

Java
XML
JUnit

Dates

Année scolaire 2024/2025

Annexes Intéressantes du Projet

Page d'accueil de gestion des jeux vidéo

Notions et Concepts Clés

Le projet intègre plusieurs concepts avancés :

Héritage : La relation d'héritage entre la table Plateforme et la table Console, qui permet de gérer les consoles comme une forme spécifique de plateforme.
Double Navigabilité : La relation entre Biblio et Jeu illustre une double navigabilité, facilitant la gestion des jeux dans différentes bibliothèques.
Tests Unitaires : Des tests unitaires ont été réalisés avec JUnit pour vérifier la bonne gestion des éditeurs, catégories, et jeux, en utilisant également des fichiers XML pour valider les structures de données.

Enchaînement des Panels avec CardLayout

Le passage entre les différents panels de l'application est géré par un CardLayout dans la classe FenetrePrimaire. Cela permet de naviguer entre les sections telles que l'accueil, la gestion des jeux, et les différentes catégories. Voici un extrait de code qui montre cette gestion :


public class FenetrePrimaire extends JFrame {
    private CardLayout cardLayout;
    private JPanel mainPanel;
    
    public FenetrePrimaire(Biblio biblio) {
        // Configuration de la fenêtre principale
        setTitle("SIO2Jeux - Gestion des Jeux");
        setSize(800, 600);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLocationRelativeTo(null);
        setLayout(new BorderLayout());

        // Création du panneau principal avec CardLayout pour changer de vues
        cardLayout = new CardLayout();
        mainPanel = new JPanel(cardLayout);

        // Ajout des panels au CardLayout
        mainPanel.add(new PanelAccueil(), "Accueil");
        mainPanel.add(new PanelJeu(new JeuControleur(biblio)), "Jeux");
        
        add(mainPanel, BorderLayout.CENTER);

        // Afficher le panel d'accueil par défaut
        afficherPanel("Accueil");
    }

    private void afficherPanel(String nomPanel) {
        cardLayout.show(mainPanel, nomPanel);
    }
}

Cette approche m'a permis de gérer efficacement la navigation entre les différentes sections de l'application, bien que cela ait été un défi lors de la première implémentation.

Interaction entre Panel Vue et Contrôleur

Le PanelJeu est une composante clé de la vue qui interagit avec le contrôleur pour gérer les jeux. Voici un extrait qui montre comment les actions (ajouter, modifier, supprimer) sont implémentées :


public class PanelJeu extends JPanel implements ActionListener {
    private JTable tableJeux;
    private JeuControleur jeuControleur;

    public PanelJeu(JeuControleur jeuControleur) {
        this.jeuControleur = jeuControleur;
        setLayout(new BorderLayout());

        // Configuration du modèle de table
        String[] columnNames = {"ID", "Nom", "Prix", "Catégorie", "Éditeur", "Plateforme"};
        tableJeux = new JTable(new DefaultTableModel(columnNames, 0));
        add(new JScrollPane(tableJeux), BorderLayout.CENTER);

        JButton btnAjouter = new JButton("Ajouter");
        btnAjouter.addActionListener(this);
        add(btnAjouter, BorderLayout.SOUTH);
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        String nom = txtNomJeu.getText().trim();
        double prix = Double.parseDouble(txtPrix.getText().trim());
        jeuControleur.ajouterJeu(nom, prix, "FPS", "Ubisoft", "PS5");
        chargerJeux();
    }
}

Cette classe permet de manipuler la liste des jeux via le contrôleur, en suivant le pattern MVC.

Accès aux Données avec JDBC (`ModeleJeu`)

La classe ModeleJeu est responsable de la gestion des interactions avec la base de données. Voici un extrait montrant comment les données sont récupérées :


public static ArrayList getTousLesJeux() {
    ArrayList jeux = new ArrayList<>();
    try {
        Connection connexion = Connexion.getConnexion();
        String sql = "SELECT j.id, j.nom, j.prix, c.nom AS nomCategorie, e.nomEditeur AS nomEditeur, p.nom AS nomPlateforme " +
                     "FROM jeu j, categorie c, editeur e, plateforme p " +
                     "WHERE j.idCategorie = c.code " +
                     "AND j.idEditeur = e.idEditeur " +
                     "AND j.idPlateforme = p.id";
        try (PreparedStatement preparedStatement = connexion.prepareStatement(sql);
             ResultSet rs = preparedStatement.executeQuery()) {
            while (rs.next()) {
                Jeu jeu = new Jeu(rs.getInt("id"), rs.getString("nom"), rs.getDouble("prix"), -1, -1, -1);
                jeu.setNomCategorie(rs.getString("nomCategorie"));
                jeu.setNomEditeur(rs.getString("nomEditeur"));
                jeu.setNomPlateforme(rs.getString("nomPlateforme"));
                jeux.add(jeu);
            }
        }
    } catch (SQLException e) {
        System.out.println("Erreur lors de la récupération des jeux : " + e.getMessage());
    }
    return jeux;
}

Cette méthode montre comment récupérer les informations des jeux en utilisant JDBC et les relations entre les différentes tables.

Résumé et Apports du Projet

Ce projet m'a permis de mettre en pratique les concepts de programmation orientée objet, y compris l'héritage et la double navigabilité, tout en développant une application complexe en Java. J'ai également renforcé mes compétences en test unitaire avec JUnit et en utilisation de fichiers XML pour la gestion des configurations et des données.

Évolutions Potentielles

Pour l'avenir, plusieurs évolutions pourraient être envisagées :

Intégration d'une base de données relationnelle pour stocker de manière persistante les informations sur les jeux, les éditeurs, et les plateformes.
Développement d'une interface utilisateur plus moderne et responsive en utilisant des technologies telles que JavaFX.
Ajout de nouvelles fonctionnalités, comme un système de recherche avancée ou une gestion des utilisateurs avec des rôles spécifiques (administrateur, utilisateur, etc.).

Défis et Difficultés

Ce projet a représenté un véritable défi pour moi, car il s'agissait de ma première application en Java utilisant l'architecture MVC. J'ai particulièrement rencontré des difficultés avec l'enchaînement des panels et la gestion de la logique entre les différentes vues. Cela m'a permis d'acquérir de l'expérience précieuse et de mieux comprendre les bonnes pratiques pour structurer une application Java en utilisant le pattern MVC de manière efficace.