TP Salma JavaAV 1
TP Salma JavaAV 1
Inroduction 4
1 Réalisation 7
1 Création de la base de donnée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.1 Script base de donnée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2 Architecture MVC (Model-View-Controller) . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.1 Implémentation du modèle (couche Model) . . . . . . . . . . . . . . . . . . . . . . . 8
2.2 Gestion des données (DAO) ................................................................................................. 11
2.3 Contrôleur (couche Controller) ............................................................................................ 13
2.4 Interface graphique (couche View)....................................................................................... 15
2.5 Main ..................................................................................................................................... 20
2 Résultats 21
1 Ajout ................................................................................................................................................. 21
2 Modification ...................................................................................................................................... 22
3 Suppression ....................................................................................................................................... 22
2
Table des figures
3
Inroduction
Ce travail pratique (TP) vise le développement d’une application Java de gestion des employés en adop-
tant l’architecture MVC (Modèle-Vue-Contrôleur), tout en mettant en œuvre des interfaces graphiques à l’aide
de la bibliothèque Swing.
Ce projet s’inscrit dans une démarche pédagogique qui combine l’apprentissage des bases de la programma-
tion orientée objet (POO) et des bonnes pratiques de conception logicielle. L’objectif est de concevoir une
application intuitive et modulaire, permettant de gérer efficacement les données des employés à travers des
fonctionnalités telles que l’ajout, la modification, la suppression et l’affichage des informations.
Grâce à une structure bien définie et à une séparation claire des responsabilités, ce TP offre une opportunité
d’approfondir les notions de maintenabilité et d’évolutivité, tout en préparant les étudiants à des développe-
ments logiciels plus avancés.
4
Outils & environnement de travail
1 Environnement de travail
• IntelliJ IDEA : est un IDE développé par JetBrains, conçu principalement pour Java, mais prenant
en charge d’autres langages comme Kotlin, Scala et Python. Il se distingue par ses outils intelligents,
sa complétion de code avancée, son analyse en temps réel et son intégration avec des outils comme
Maven, Gradle et Git, offrant une productivité accrue aux développeurs.
2 Outils de travail
• MySQL Workbench : est un outil graphique développé pour simplifier la conception, l’administra-
tion et la gestion des bases de données MySQL. Il offre une interface intuitive qui permet de manipu-
ler les bases de données visuellement, sans dépendre uniquement des commandes en ligne, rendant les
tâches plus accessibles et efficaces.
5
SI
• XAMPP : est une solution open-source qui regroupe Apache, MySQL, PHP, et Perl pour faciliter le
développement et le déploiement d’applications web. Il est conçu pour créer un environnement de ser-
veur local rapide et simple, adapté aux développeurs souhaitant tester ou gérer des projets web sur leur
machine avant le déploiement.
• java developpement kit : est un ensemble d’outils logiciels indispensables pour le développement
d’applications Java. Il comprend des composants essentiels tels qu’un compilateur, une machine vir-
tuelle Java (JVM), des bibliothèques standard, et des outils de débogage, permettant de coder, compi-
ler, exécuter et tester des programmes Java efficacement.
3 Language de Programmation
• Java : un langage de programmation orienté objet et une plateforme largement utilisée pour le déve-
loppement d’applications logicielles. Il a été créé par Sun Microsystems (maintenant propriété d’Oracle)
en 1995 et reste l’un des langages les plus populaires au monde, notamment pour les applications
d’entreprise, le développement mobile (Android) et les applications web.
6
Réalisation
13 );
14 CREATE TABLE Role (
15 name varchar(30) NOT NULL
16 );
17 INSERT INTO Role (name) VALUES ('Admin'),('Employee');
18 INSERT INTO Poste (name) VALUES ('Ingenieur'),('Team_Leader'),('Pilote');
19
20 CREATE TABLE Poste (
21 name varchar(30) NOT NULL
22 );
Listing 1.1 – Script SQL de la base de données
7
SI
1 package model;
2
3 import enums.*;
4
8
SI
44 return phoneNumber;
45 }
46
47 public double getSalary() {
48 return salary;
49 }
50
EmployerLogic
1 package model;
2
3 import enums.*;
4 import dao.EmployerDAO;
5 import java.util.List;
6
15 public boolean addEmployer(int id, String firstName, String lastName, String email,
int phoneNumber, double salary, Role role, Poste poste) {
16 // Vérifie si l'email est valide avant de mettre à jour l'employé.
17 if ( isValidEmail(email) ) {
18 // Création de l'objet Employer avec les informations fournies.
19 return dao.addEmployer( new Employer(
20 id,
21 firstName,
22 lastName,
23 email,
24 phoneNumber,
25 salary,
26 role,
27 poste
28 ));
29 // Appel à la méthode DAO pour mettre à jour les informations dans la base de
30 données.
31 }
32 // Retourne faux si l'email n'est pas valide.
33 return false;
34 }
35
9
SI
69 }
10
SI
1 package dao;
2
3 import java.sql.Connection;
4 import java.sql.DriverManager;
5 import java.sql.SQLException;
6
7 public class DBConnection {
8
9 private static final String URL = "jdbc:mysql://localhost:3306/DBperson";
10 private static final String USERNAME = "root";
11 private static final String PASSWORD = "";
12
EmployerDAO
1 package dao;
2
3 import java.sql.*;
4 import java.util.ArrayList;
5 import java.util.List;
6 import model.Employer;
7 import enums.Role;
8 import enums.Poste;
9
22
23 @Override
24 public boolean addEmployer(Employer employer) {
25 try (PreparedStatement addStatement = connection.prepareStatement(
26 "INSERT INTO employers (first_name, last_name, email, phone,
salary, role, poste) VALUES (?, ?, ?, ?, ?, ?, ?)")) {
27
28 addStatement.setString(1, employer.getFirstName());
29 addStatement.setString(2, employer.getLastName());
30 addStatement.setString(3, employer.getEmail());
11
SI
31 addStatement.setInt(4, employer.getPhoneNumber());
32 addStatement.setDouble(5, employer.getSalary());
33 addStatement.setString(6, employer.getRole().name());
34 addStatement.setString(7, employer.getPoste().name());
35
36 return addStatement.executeUpdate() > 0;
37
45 @Override
46 public boolean updateEmployer(Employer employer) {
47 try (PreparedStatement updateStatement = connection.prepareStatement("
UPDATE employers SET first_name = ?, last_name = ?, email = ?, phone = ?,
salary = ?, role = ?, poste = ? WHERE id = ?")) {
48
49 updateStatement.setString(1, employer.getFirstName());
50 updateStatement.setString(2, employer.getLastName());
51 updateStatement.setString(3, employer.getEmail());
52 updateStatement.setInt(4, employer.getPhoneNumber());
53 updateStatement.setDouble(5, employer.getSalary());
54 updateStatement.setString(6, employer.getRole().name());
55 updateStatement.setString(7, employer.getPoste().name());
56 updateStatement.setInt(8, employer.getId());
57
66 @Override
67 public boolean deleteEmployer(int id) {
68 try (PreparedStatement deleteStatement = connection.prepareStatement("
DELETE FROM employers WHERE id = ?")) {
69
70 deleteStatement.setInt(1, id);
71 return deleteStatement.executeUpdate() > 0;
72
78 @Override
79 public List<Employer> getAllEmployers() {
80 List<Employer> employers = new ArrayList<>();
81 try (ResultSet getResult = connection.prepareStatement("SELECT * FROM
employers").executeQuery()) {
12
SI
82
83 while (getResult.next()) {
84 employers.add(new Employer(
85 getResult.getInt("id"),
86 getResult.getString("first_name"),
87 getResult.getString("last_name"),
88 getResult.getString("email"),
89 getResult.getInt("phone"),
90 getResult.getDouble("salary"),
91 Role.valueOf(getResult.getString("role")),
92 Poste.valueOf(getResult.getString("poste"))
93 ));
94 }
95
1 package controller;
2
3 import view.*;
4 import dao.*;
5 import model.*;
6 import enums.*;
7 import java.util.List;
8 import javax.swing.JOptionPane;
9
10 public class EmployerController {
11
13
SI
26 try {
27
28 if (employerLogic.addEmployer(
29 1,
30 frame.getInPanel().getFirstNameField().getText(),
31 frame.getInPanel().getLastNameField().getText(),
32 frame.getInPanel().getEmailField().getText(),
33 Integer.parseInt(frame.getInPanel().getTelephoneNumberField().
getText()),
34 Double.parseDouble(frame.getInPanel().getSalaryField().getText
()),
35 Role.valueOf(frame.getInPanel().getSelectedRole().toString()),
36 Poste.valueOf(frame.getInPanel().getSelectedPoste().toString()
)
37 ))
38 {
39 JOptionPane.showMessageDialog(frame, "Employer added successfully
.");
40 loadEmployers();
41 } else {
42 JOptionPane.showMessageDialog(frame, "Failed to add employer.");
43 }
44 } catch (Exception e) {
45 JOptionPane.showMessageDialog(frame, "Invalid input: " + e.getMessage
());
46 }
47 }
48 // Méthode pour mettre à jour un employé via l'interface utilisateur.
49 private void updateEmployer() {
50 try {
// Récupère les données des champs de saisie et les envoie à la couche
logique.
51 if (employerLogic.updateEmployer(
52 frame.getListPanel().getSelectedRowId(),
53 frame.getInPanel().getFirstNameField().getText(),
54 frame.getInPanel().getLastNameField().getText(),
55 frame.getInPanel().getEmailField().getText(),
56 Integer.parseInt(frame.getInPanel().getTelephoneNumberField().
getText()),
57 Double.parseDouble(frame.getInPanel().getSalaryField().getText())
,
58 Role.valueOf(frame.getInPanel().getSelectedRole().toString()),
59 Poste.valueOf(frame.getInPanel().getSelectedPoste().toString())
60 ))
61 {
14
SI
62 // Affiche un message de succès et recharge la liste des employeurs.
JOptionPane.showMessageDialog(frame, "Employer updated successfully
63 .");
64 loadEmployers();
65 } else {
66 // Affiche un message d'échec.
67 JOptionPane.showMessageDialog(frame, "Failed to update employer.");
68 }
69 } catch (Exception e) {
70
// Gère les erreurs d'entrée utilisateur.
71
JOptionPane.showMessageDialog(frame, "Invalid input: " + e.getMessage());
72
}
}
private void deleteEmployer() {
15
SI
73 try {
74 if (employerLogic.deleteEmployer(frame.getListPanel().getSelectedRowId())
) {
75 JOptionPane.showMessageDialog(frame, "Employer deleted successfully
.");
76 loadEmployers();
77 } else {
78 JOptionPane.showMessageDialog(frame, "Failed to delete employer.");
79 }
80 } catch (Exception e) {
81 JOptionPane.showMessageDialog(frame, "Invalid input: " + e.getMessage());
82 }
83 }
84
85 private void loadEmployers() {
86 frame.getListPanel().updateEmployerList(employerLogic.getAllEmployers());
87 }
88 }
1 package view;
2 // Importation des classes nécessaires pour créer une interface graphique
Swing.
3 import javax.swing.*;
4 import java.awt.*;
5 // Déclaration de la classe BtnPanel qui hérite de JPanel.
6 public class BtnPanel extends JPanel {
7 // Déclaration des boutons qui seront ajoutés au panneau.
8 private JButton addBtn, removeBtn , updateBtn;
// Constructeur de la classe BtnPanel.
9
10 public BtnPanel() {
// Définit la disposition des composants dans le panneau comme FlowLayout
(disposition en ligne horizontale).
11 setLayout(new FlowLayout());
12
17
SI
31 return updateBtn;
32 }
33 }
FormFrame
2 package view;
3
4 import javax.swing.*;
5 import java.awt.*;
6
7 public class FormFrame extends JFrame {
8
9 private InputPanel inPanel;
10 private BtnPanel btnPanel;
11 private ListPanel listPanel;
12
13 public FormFrame() {
14 setTitle("Person Form");
15 setSize(800, 600);
16 setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
17 setLayout(new BorderLayout());
18
29 setVisible(true);
30 }
31
InputPanel
1 package view;
18
SI
3 import javax.swing.*;
4 import java.awt.*;
5 import enums.Role;
6 import enums.Poste;
7
14 public InputPanel() {
15 setLayout(new GridLayout(7, 2, 5, 5));
16 setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
17
32 add(new JLabel("Email"));
33 add(emailField);
34
38 add(new JLabel("Salary"));
39 add(salaryField);
40
41 add(new JLabel("Role"));
42 add(roleField);
43
44 add(new JLabel("Poste"));
45 add(posteField);
46 }
47
19
SI
ListPanel
1 package view;
2 // Importation des bibliothèques nécessaires pour créer une interface graphique
3 Swing.
4 import javax.swing.*;
5 import javax.swing.border.LineBorder;
6 import java.awt.*;
7 import java.util.ArrayList;
8 import java.util.List;
9 import model.Employer;
10 import java.awt.event.MouseAdapter;
11 import java.awt.event.MouseEvent;
12 // Déclaration de la classe ListPanel qui hérite de JPanel.
13 public class ListPanel extends JPanel {
14 // Déclaration des variables pour contenir les données et gérer les interactions.
15 private JPanel contentPanel;
16 private int selectedRowId = -1;
17 private List<JPanel> rowPanels = new ArrayList<>();
18 // Constructeur de la classe ListPanel.
19 public ListPanel() {
20 setLayout(new BorderLayout());
21 // Définit la disposition principale du panneau comme BorderLayout.
22 JPanel titlePanel = new JPanel();
23 titlePanel.setLayout(new GridLayout(1, 5));
24 titlePanel.add(new JLabel("Id", SwingConstants.CENTER));
25 titlePanel.add(new JLabel("Nom", SwingConstants.CENTER));
26 titlePanel.add(new JLabel("Prenom", SwingConstants.CENTER));
27 titlePanel.add(new JLabel("Email", SwingConstants.CENTER));
28 titlePanel.add(new JLabel("Salaire", SwingConstants.CENTER));
29 titlePanel.setBorder(new LineBorder(Color.BLACK));
30 add(titlePanel, BorderLayout.NORTH);
31
contentPanel = new JPanel();
20
SI
52 rowPanel.addMouseListener(new MouseAdapter() {
53 @Override
54 public void mouseClicked(MouseEvent e) {
55 highlightRow(rowPanel, employer.getId());
56 }
57 });
58
59 rowPanel.add(idLabel);
60 rowPanel.add(lastNameLabel);
61 rowPanel.add(firstNameLabel);
62 rowPanel.add(emailLabel);
63 rowPanel.add(salaryLabel);
64
65 contentPanel.add(rowPanel);
66 rowPanels.add(rowPanel);
67 }
68
69 contentPanel.revalidate();
70 contentPanel.repaint();
71 }
72
78 selectedRow.setBackground(Color.LIGHT_GRAAY);
79 selectedRowId = employerId;
80 }
81
21
SI
2.5 Main
1 import view.*;
2 import dao.*;
3 import model.*;
4 import controller.EmployerController;
5 // Déclaration de la classe Main, le point d'entrée de l'application.
6 public class Main {
// La méthode main est le point de démarrage de l'application
7 public static void main(String[] args) {
// Création et initialisation du contrôleur principal. // Ce contrôleur
relie la vue (FormFrame) à la logique métier (EmployerLogic) // et à la
couche d'accès aux données (EmployerDAO).
8 new EmployerController( new FormFrame(), new EmployerLogic(new EmployerDAO
()));
9 }
10 }
22
Résultats
•
FIgURE 2.1 – Interface Utilisateur
1 Ajout
23
SI
2 Modification
3 Suppression
24
Dans cette séance de travaux pratiques, nous avons travaillé sur la gestion des employés d'une entreprise à
travers une application Java complète composée de plusieurs couches : logique métier, DAO, contrôleur, et
interface utilisateur. Voici les tâches principales effectuées :
Cette séance a permis de renforcer nos compétences en programmation Java tout en appliquant des concepts
de programmation en couches et d'interactions avec une base de données.
25