Tuto JSE Persintance

APPLICATION DESKTOP :
Java Persistance avec MySQL

2
Contenu
Contenu .................................................................................... 3
Introduction .............................................................................. 5
Outils de travail ........................................................................ 6
Premier Projet En Java.............................................................. 7
Démarrer NetBeans : .......................................................... 7
Création du Projet ............................................................... 8
Espace de Persistance....................................................... 12
Le MCD ........................................................................... 13
Les Scripts SQL .............................................................. 14
Choix du Design Pattern et Paramètrage du Projet ............... 15
Designs Patterns ............................................................... 15
Paramétrage du projet...................................................... 18
En Pratique ........................................................................ 20
Création des Premiers Modèles ............................................. 22
Composition ...................................................................... 22
Une variable................................................................... 22
Constructeur.................................................................. 24
Les Getters et les Setters .............................................. 24
En pratique ........................................................................ 25
Création du modèle....................................................... 25
Code du modèle ............................................................. 27
3
Les Controller et la JDBC......................................................... 30
JDBC ................................................................................... 30
Controller........................................................................... 33
Création d’un contrôleur .............................................. 34
Codes Commentés ......................................................... 35
Les IHMs ................................................................................. 40
Création d’une view .......................................................... 40
Paramétrage du formulaire .......................................... 47
Chargement des comboBox .......................................... 47
Les En – têtes pour La Grille JTable ............................. 49
Présentation du formulaire parametré ....................... 50
Création des Evénements ................................................. 53
actionPerformed Sur le Bouton ................................... 53
Conclusion .............................................................................. 58
Aller Plus loin .......................................................................... 59
4
Introduction
Java est un langage de programmation Orienté Objets. Son
exécution se fait par la manipulation de ces objets par le
biais de l’état des variables des classes et aussi par le
comportement prévue dans l’implémentation de chaque
méthode de classe.
Java est connue pour ses atouts dans la programmation des

applications robustes pour les entreprises, car son fort
typage permet aux programmeurs d’y trouver la
représentation de chacune des situations rencontrées dans
leur conception.
De l’objet { la persistance, tout est représenté dans des

classes qui contiennent des instructions nécessaires à la
représentation du monde réel.
Le choix des auteurs du java a été d'abandonner des

éléments mal compris ou mal exploités des autres langages
tels que la notion de pointeurs (pour éviter les incidents en
manipulant directement la mémoire), l'héritage multiple et
la surcharge des opérateurs. la sécurité fait partie
intégrante du système d'exécution et du compilateur. Un
programme Java planté ne menace pas le système
d'exploitation. Il ne peut pas y avoir d'accès direct à la
mémoire. L'accès au disque dur est réglementé dans une
applet1.
1
Jean – Michel Doudoux, Développons en Java v 2.30,
https://www.jmdoudoux.fr/java/dej/indexavecframes.htm, p11
5
Outils de travail
1. Le Kit de développement Java : JDK. Dans ce

tutoriel, nous utiliserons le JDK 20 ;
2. Environnement de développement d’Application
Java. Nous utiliserons ici le Apache Nebeans 17.
3. Les Bibliothèques relatives { l’Espace de
persistance (pour notre cas, c’est MySQL Serveur)
et celui des Etats en Sortie(JasperReport)
6
Premier Projet En Java
Nous allons ici créer un projet dans le cadre de

notre objectif qui est le Java Standard Edition en
suivant la démarche suivante :
Démarrer NetBeans :
Un simple double clic sur l’icône dans le poste de

travail (Bureau) suffit.
Ceci va nous amener sur l’écran suivant :
7
Création du Projet
Ça ne sera peut – être pas le même écran chez

vous, pas seulement puisque c’est la première fois
que vous démarrez NetBeans, mais aussi parce
que nous n’avons pas obligatoirement les mêmes
projets.
Dès que vous êtes sur cette écran, il existe

plusieurs manières de créer un nouveau projet
mais nous allons opter pour la combinaison des
touches : CTRL + SHIFT + N qui donnera l’écrans
suivant :
8
Vous avez là une boite de dialogue qui vous
présente deux volets dont : catégories et Projets.
Il s’agit de la catégorie du projet que vous voulez
créer et des propositions que vous fait NetBeans
dans cette dernière.
Pour notre cas, il s’agit de la catégorie « Java with

Ant ». Attention, ne sélectionnez pas ses détails
puisque cela n’est pas la même chose.
En dans la rubrique Projets, nous choisissons

« Java Application » et nous appuyons sur le
bouton « Next ».
9
Voici les rubriques qui vous concernent :
Project Name : nom de votre projet. Donnez un

nom qui respecte les principes de nommage des
variables en programmation.
Project Location : principalement un dossier se

trouvant sur votre mémoire de masse de
l’ordinateur. C’est l{ où vous avez décidé
d’enregistrer vos projets Java.
Project Folder : c’est généralement le répertoire

que gardera tout les composants de votre projet.
10
Vous remarquerez qu’il y a une case { cocher qui
vous dit : « Create Main Class ». il faut la décocher
pour permettre que l’on sache se créer la nôtre
dès que nous sommes dans le projet.
Dès que cela est fait, vous pouvez cliquer sur

« Finish » pour enfin créer le projet. Et vous le
verrez directement s’afficher dans la liste des
projets présents dans NetBeans.
11
Espace de Persistance
L’objectif dans ce projet est de savoir faire la

manipulation des données. Donc, nous devons
enregistrer et réutiliser ces dernières.
Le meilleur moyen de le faire c’est savoir créer

une base de données qui devra accompagnée
notre application.
Nous associeront ici une structure de données

relatives à la passation des promotions des
étudiants. Qui n’est pas nécessairement exhaustif
mais respecte au moins la notion du temps en
rapport avec l’histoire de chaque donnée.
Les données stockées dans des bases de données

modélisent des objets du monde réel, ou des
associations entre objets. Les objets sont en
général représentés par des articles de fichiers,
alors que les associations correspondent
naturellement à des liens entre articles. Les
données peuvent donc être vues comme un
ensemble de fichiers reliés par des pointeurs ;
elles sont interrogées et mises à jour par des
12
programmes d’applications écrits par les
utilisateurs ou par des programmes utilitaires
fournis avec le SGBD (logiciels d’interrogation
interactifs, éditeurs de rapports, etc.)2.
Le MCD
2 ème
Georges Gardarin, Bases de Données, Ed EYROLLES, 5 Tirage
2003, p49
13
Les Scripts SQL
Après passage au MLD Validé et la normalisation,

voici les Scripts SQL correspondant à la structure
de données présentées ci – haut :
CREATE DATABASE ProjetPasserPromo;
USE ProjetPasserPromo;
CREATE TABLE Sections(idSection VARCHAR(10)
PRIMARY KEY,
libesection
VARCHAR(100))ENGINE = INNODB;
CREATE TABLE Etudiants(idEtud VARCHAR(10)
PRIMARY KEY,
nomEtud
VARCHAR(20), postnomEtud VARCHAR(20),
prenomEtud VARCHAR(20),
sexEtud
VARCHAR(1), adresseEtud TEXT, dateNaiss
DATE)ENGINE = INNODB;
CREATE TABLE Promotions(idPro VARCHAR(10)
PRIMARY KEY, idSection VARCHAR(10), libePro
VARCHAR(100),
FOREIGN
KEY(idSection) REFERENCES Sections(idSection)
)ENGINE = INNODB;
CREATE TABLE PasserPromo(idPasser SMALLINT
AUTO_INCREMENT PRIMARY KEY, idPro VARCHAR(10),
idEtud VARCHAR(10),
anneeAcad
VARCHAR(9), pourcentage NUMERIC(2,2), mention
VARCHAR(10),
FOREIGN
KEY(idPro) REFERENCES Promotions(idPro),
FOREIGN KEY(idEtud) REFERENCES
Etudiants(idEtud))ENGINE = INNODB;
14
Choix du Design Pattern et
Paramètrage du Projet
Designs Patterns
Aussi appelé patrons de conception sont des

solutions classiques à des problèmes récurrents
de la conception de logiciels. Ce sont des sortes de
plans ou de schémas que l’on peut personnaliser
afin de résoudre un problème récurrent dans
notre code.
Vous ne pouvez pas vous contenter de trouver un

patron et de le recopier dans votre programme
comme vous le feriez avec des fonctions ou des
librairies prêtes { l’emploi. Un patron, ce n’est pas
un bout de code spécifique, mais plutôt un
concept général pour résoudre un problème
précis. Vous pouvez suivre le principe du patron
et implémenter une solution qui convient à votre
propre programme.
Les patrons sont souvent confondus avec les

algorithmes, car ils décrivent tous deux des
solutions classiques à des problèmes connus. Un
algorithme définit toujours clairement un
ensemble d’actions qui va vous mener vers un
15
objectif, alors qu’un patron, c’est la description
d’une solution { un plus haut niveau. Le code
utilisé pour implémenter un même patron peut
être complètement différent s’il est appliqué {
deux programmes distincts.
Un algorithme c’est un peu comme une recette de

cuisine, ses étapes sont claires et vous guident
vers un objectif précis. Un patron, c’est plutôt
comme un plan : vous pouvez voir ses
fonctionnalités et les résultats obtenus, mais la
manière de l’implémenter vous revient.
La majorité des patrons sont présentés de façon

très générale, afin qu’ils soient reproductibles
dans tous les contextes. Voici les différentes
sections que vous retrouverez habituellement
dans la description d’un patron :
- L’Intention du patron permet de décrire

brièvement le problème et la solution.
- La Motivation explique en détail la
problématique et la solution offerte par le
patron.
- La Structure des classes montre les
différentes parties du patron et leurs relations.
16
- L’Exemple de code écrit dans un des
langages de programmation les plus populaires
facilite la compréhension générale de l’idée
derrière le patron.
Vous retrouverez dans certains catalogues de

patrons, toute une liste de détails pratiques : des
cas d’utilisation, les étapes de l’implémentation et
les liens avec d’autres patrons.
Dans notre cas nous opterons pour le Design

Pattern MVC.
Le Patron de conception Model View Controller

(MVC) spécifie qu'une application se compose
d'un modèle de données, d'informations de
présentation et d'informations de contrôle. Le
modèle nécessite que chacun d'entre eux soit
séparé en objets différents. MVC est davantage un
modèle architectural, mais pas pour une
application complète. MVC concerne
principalement la couche UI/interaction d’une
application. Vous aurez toujours besoin d'une
couche de logique métier, peut-être d'une couche
de service et d'une couche d'accès aux données.
17
Ainsi pour l’accès aux données nous devrions
utiliser la classe d’accès aux données de Java, le
JDBC.
Paramétrage du projet
Nous allons diviser notre projet en trois package

comme suit :
Package « modeles » : pour y placer les classes

java relatives à la structure des données à
persister. Ainsi chaque classe en plus du
18
constructeur devra avoir des déclarations des
variables, des getters et des setters.
Packages « controllerEtDao » : ici nous allons

pouvoir placer les classes java relatives aux
opérations à faire sur les données ainsi que la
classe d’accès { ses données.
Comme nous parlons d’une base de données, la

majeure partie des opérations est faites grâce au
modèle CRUD qui se réfère à la majorité des
opérations effectuées dans une base de données.
Package « View » : considéré comme la partie qui

garde les éléments de la programmation à
présenter aux utilisateurs lors de l’exploitation du
programme, il va ainsi y être placé les classes
relatives interfaces – homme – machine. Les
classes qui s’y trouvent dans le cadre du Java sont
19
des filles de la classe « Swing » qui fournit aux
dérivées les outils nécessaire au graphisme et à
l’événementiel sur le Desktop.
En Pratique
Tout ce qui doit être créé se fait dans le package :

« Source Packages ». Ainsi, un clic droit dessus
dans votre projet donne le menu suivant :
Dedans vous cliquez sur « Java Package » pour

obtenir la boite de dialogue suivante :
20
La rubrique qui vous concerne ici est « Package
Name », et vous devez simplement écrire le nom
de votre package et cliquer sur le bouton
« Finish ». Puis, faire cela pour la suite des autres
packages.
Ainsi, la structure de notre projet se présentera

comme suit :
21
Création des Premiers
Modèles
Composition
Les modèles sont composés des variables, des

constructeurs, des getters et des setters.
Une variable
Une variable est un objet repéré par son nom,

pouvant contenir des données, qui pourront être
modifiées lors de l'exécution du programme. Les
variables en langage Java sont typées, c'est-à-dire
que les données contenues dans celles-ci
possèdent un type, ainsi elles sont donc stockées à
une adresse mémoire et occupent un nombre
d'octets dépendant du type de donnée stockée.
Avec Java, les noms de variables peuvent être

aussi long que l'on désire, toutefois le compilateur
ne tiendra compte "que" des 247 premiers
caractères. De plus, elles doivent répondre à
certains critères :
22
 un nom de variable doit commencer par
une lettre (majuscule ou minuscule) ou un "_"
(pas par un chiffre)
 un nom de variables peut comporter des
lettres, des chiffres et le caractère _ (les espaces
ne sont pas autorisés!)
 Les noms de variables ne peuvent pas être
les noms suivants (qui sont des noms réservés) :
- abstract
- boolean break byte byvalue
- case cast catch char class const continue
- default do double
- else extends
- false final finally float for future
- generic goto
- if implements import inner instanceof int
interface
- long
- native new null
- operator outer
- package private protected public
- return rest return
- short static sctrictfp super switch
synchronized
- this throw throws transient true try
- var void volatile
- while widefp
Les noms de variables sont sensibles à la casse

(Java fait la différence entre un nom en majuscule
23
et un nom en minuscules), il faut donc veiller à
utiliser des noms comportant la même casse!
Voici alors la syntaxe de création d’une variable :
1. Une variable par instruction

type Nom_de_la_variable;
2. Plusieurs variables par instruction

type Nom_de_la_variable1, Nom_de_la_variable2,
...;
Constructeur
Un constructeur en Java est une méthode spéciale

utilisée pour initialiser des objets.
Le constructeur est appelé lorsqu’un objet d’une
classe est créé. Il peut être utilisé pour définir les
valeurs initiales des attributs d’un objet.
Notez que le nom du constructeur correspond au

nom de la classe et qu’il ne possède pas de type de
retour.
Les Getters et les Setters
En Java, Getter et Setter sont des méthodes

utilisées pour protéger vos données et rendre
24
votre code plus sécurisé. Getter et Setter
permettent au programmeur de définir et
d'obtenir facilement la valeur d'un type de
données particulier.
Getter en Java : Getter renvoie la valeur

(restituteur), il renvoie la valeur du type de
données int, String, double, float, etc. Pour la
commodité du programme, le getter commence
par le mot « get » suivi du nom de la variable.
Setter en Java : pendant que Setter définit ou met

à jour la valeur (accesseur). Il définit la valeur de
toute variable utilisée dans les programmes d’une
classe et commence par le mot « set » suivi du
nom de la variable.
En pratique
Création du modèle
Vous faites un clic droit sur votre package

« modele », dans le menu « New » vous choisissez
« Java Class » comme sur la figure suivante :
25
Dès que vous cliquez dessus, cela vous amène sur
la boite de dialogue suivante :
26
Vous n’avez qu’{ signaler le nom de votre modèle
dans la zone « Class Name » et cliquez sur le
bouton « Finish ». Vous Obtiendrez ceci dans votre
projet :
Et la classe s’ouvre en même temps pour vous

permettre d’écrire du code.
Code du modèle
package modele;
/**
*
27
* @author AS FLORRY
*/
public class ModeleSection {
/**
* création des variables de la classe
*/
String idSection,libeSection;
/**
* Les Constructeurs
*/
public ModeleSection(){
}
public ModeleSection(String idSection, String
libeSection) {
this.idSection = idSection;
this.libeSection = libeSection;
}
/**
* Les Getters et Les Setters
*/
public String getIdSection() {
return idSection;
}
public void setIdSection(String idSection) {

this.idSection = idSection;
}
public String getLibeSection() {

return libeSection;
}
public void setLibeSection(String libeSection)

{
this.libeSection = libeSection;
}
28
}
Vous devez faire la même activité avec toutes les
autres classes correspondantes aux tables de la
base de données pour permettre que vous ayez
toute la structure de votre BDD.
Ainsi notre projet continue de se peuplé comme

suit :
29
Les Controller et la JDBC
JDBC
JDBC signifie Java™ EE Database Connectivity. En

développement Java EE, cette technologie est bien
connue et couramment utilisée pour implémenter
l'interaction des bases de données. JDBC est une
API au niveau appel, ce qui signifie que les
instructions SQL sont transmises sous forme de
chaînes à l'API, qui les exécute ensuite sur le
système RDMS. Par conséquent, la valeur de ces
chaînes peut être modifiée lors de l'exécution et
rendre ainsi JDBC dynamique.
Les programmes JDBC sont exécutés plus

lentement que leurs équivalents SQLJ, mais ils
bénéficient du concept "Write once, call
anywhere". Comme aucune interaction n'est
requise lors de la phase d'exécution, un
programme JDBC est donc particulièrement
transférable et peut passer d'un système à un
autre pour un coût minimal.
Toutes les opérations ont quelques instructions

en communs et nous les centrons toutes dans une
classe appelée « projetCours ». la procédure de la
30
création de cette classe, suivez celle présentée aux
modèles, mais cette fois faites – le sur le package
« controllerEtDao ». Avant d’écrire du code dans
cette classe, vous devez télécharger la
bibliothèque Java compatible avec votre espace de
persistance pour vous permettre d’écrire les
instructions correspondantes à la connexion de
celle – ci.
Voici le code de la classe :

package controllerEtDao;
import com.mysql.cj.jdbc.ConnectionImpl;
import java.sql.*;
/**
*
* @author AS FLORRY
*/
public class projetCours {
//Variable de Connection
public static com.mysql.cj.jdbc.ConnectionImpl cn;
//Variable de la Requête Préparée
public static PreparedStatement Pst;
//Variable de Réception du Résultat
public static ResultSet rs;
/**
* La Méthode de Connexion
*/
public static void connexionEasy(){
try {
//L'Appel de la Classe et de Ses Pilotes avant la connexion
31
Class.forName("com.mysql.cj.jdbc.Driver");
//Connexion Grâce à la chaaine de Connexion
//Dedans nous avons aussi le nom de la BDD
//Le nom d'Utilisateur et le PWD
cn = (ConnectionImpl)
DriverManager.getConnection("jdbc:mysql://localhos
t:3306/passerpromo","root","");
//Desactivation de l'enregistrement
cn.setAutoCommit(false);
} catch (ClassNotFoundException |
SQLException e) {
System.err.println("Erreur :
"+e.getMessage());
}
}
/**
* La Méthode de déconnexion
*/
public static void deconnexionEasy(){
try {
//Test si la connexion est Ouverte
if (!cn.isClosed()) {
//L'enregistrement des données en Cours
cn.setAutoCommit(true);
//Fermeture de la Requête
Pst.close();
//Fermeture du Résultat
rs.close();
//Fermeture de la Connexion Preprement dite
cn.close();
}
} catch (SQLException e) {
"+e.getMessage());
}
}
}
32
Controller
Le contrôleur existe entre la vue et le modèle.

C’est l{ que la véritable logique métier est écrite. Il
écoute les événements déclenchés par la vue (ou
une autre source externe) et exécute la réaction
appropriée à ces événements. Dans la plupart des
cas, la réaction consiste à appeler une méthode
sur le modèle. Puisque la vue et le modèle sont
connectés via un mécanisme de notification, le
résultat de cette action est alors automatiquement
reflété dans la vue.
La logique métier est ici représentée par les

opérations à effectuer pour pouvoir atteindre un
objectif fixé par les besoins du monde réel.
C’est ainsi que pour notre cas, comme il s’agit de

la persistance des informations dans la base de
données, nous nous devons de réaliser les quatre
opérations de mise à jour représentées dans le
model CRUD. Grâce à la classe de connexion
conçue avec le JDBC, nous serons en mesure de le
réaliser comme représenté dans les codes qui
suivent pour le contrôleur Etudiant.
33
Création d’un contrôleur
Clic droit sur le package controllerEtDao  New

java class
34
Codes Commentés
/**
* Importation des Bibliothèques
*/
import java.sql.SQLException;
import java.util.ArrayList;
import modele.Etudiants;
/**
*
* @author AS FLORRY
*/
public class EtudiantController {
/**
* Méthode Pour l'Enregistrement
* De l'Etudiant dans la Table
* @param et
*/
35
public void saveEtudiant(Etudiants et){
try {
projetCours.connexionEasy();
projetCours.Pst =
projetCours.cn.prepareStatement("INSERT INTO
Etudiants "
+
"(idEtud,nomEtud,postnomEtud,prenomEtud,sexEtud,ad
resseEtud,dateNaiss) "
+ "VALUES (?,?,?,?,?,?,?)");
projetCours.Pst.setString(1, et.getIdEtud());
projetCours.Pst.setString(2, et.getNomEtud());
projetCours.Pst.setString(3, et.getPostnomEtud());
projetCours.Pst.setString(4, et.getPrenomEtud());
projetCours.Pst.setString(5, et.getSexEtud());
projetCours.Pst.setString(6, et.getAdresseEtud());
projetCours.Pst.setDate(7, et.getDateNais());
projetCours.Pst.execute();
projetCours.deconnexionEasy();
System.out.println("Enregistrement effectué");
System.err.println("Erreur : "+e.getMessage());
}
}
/**
* Méthode pour la Modification
* D'un Etudiant dans la Table
* @param et
*/
public void upDateEtudiant(Etudiants et){
try {
projetCours.Pst =
projetCours.cn.prepareStatement("UPDATE Etudiants
"
+ "SET nomEtud = ?,postnomEtud
= ?,prenomEtud = ?,sexEtud = ?,adresseEtud =
?,dateNaiss = ? "
36
+ " WHERE idEtud = ?");
projetCours.Pst.setString(7, et.getIdEtud());
projetCours.Pst.setString(1, et.getNomEtud());
projetCours.Pst.setString(2, et.getPostnomEtud());
projetCours.Pst.setString(3, et.getPrenomEtud());
projetCours.Pst.setString(4, et.getSexEtud());
projetCours.Pst.setString(5, et.getAdresseEtud());
projetCours.Pst.setDate(6, et.getDateNais());
projetCours.Pst.execute();
System.out.println("Modification effectuée");
}
}
/**
* Recherche d'Un Etudiant
* Dans la Table
* @param id
* @return
*/
public Etudiants findEtudiant(String id){
Etudiants et = new Etudiants();
try {
projetCours.Pst =
projetCours.cn.prepareStatement("SELECT
idEtud,nomEtud, "
+ "postNomEtud, prenomEtud,
sexEtud, adresseEtud, dateNaiss FROM "
+ " Etudiants WHERE idEtud =
?");
projetCours.Pst.setString(1, id);
projetCours.rs = projetCours.Pst.executeQuery();
if (projetCours.rs.next()) {
et.setSexEtud(projetCours.rs.getString(1));
37
et.setNomEtud(projetCours.rs.getString(2));
et.setPostnomEtud(projetCours.rs.getString(3));
et.setPrenomEtud(projetCours.rs.getString(4));
et.setSexEtud(projetCours.rs.getString(5));
et.setAdresseEtud(projetCours.rs.getString(6));
et.setDateNais(projetCours.rs.getDate(7));
}
}
return et;
}
/**
* La Liste des Etudiants
* @return
*/
public ArrayList<Etudiants> findAll(){
ArrayList<Etudiants> etA = new
ArrayList<>();
try {
projetCours.Pst =
projetCours.cn.prepareStatement("SELECT
idEtud,nomEtud, "
+ "postNomEtud, prenomEtud,
sexEtud, adresseEtud, dateNaiss FROM "
+ " Etudiants");
projetCours.rs = projetCours.Pst.executeQuery();
while (projetCours.rs.next()) {
Etudiants et = new Etudiants();
38
et =
findEtudiant(projetCours.rs.getString(1));
etA.add(et);
}
"+e.getMessage());
}
return etA;
}
}
39
Les IHMs
Les interfaces Homme – Machine comme leur nom
l’indiquent, sont les canaux par lesquels un
utilisateur discute avec l’espace de persistance
dans une application dynamique.
C’est par eux que le programmeur prévoit les

zones de récolte de données auprès des
utilisateurs et aussi le canal de distribution des
résultats de chaque traitement.
Ils sont dans notre patron de conception des

logiciels utilisé appelés « Views », et dans ce
tutoriel ils seront tous l’émanation de la
bibliothèque graphique « Swing » de Java
Standard Edition qui nous permet de créer des
formulaires et leurs composants.
Création d’une view
Clic droit sur « views »  new Clic sur JFrame

Form
40
41
Dès que vous cliquez sur « Finish », vous obtenez
l’écran suivant :
Juste à droit, s’affiche la boite à outils suivante :
42
Par la technique de « drag and drop » ou « glisser
– déposer », nous allons peupler notre formulaire
des outils nécessaire pour le bonheur des
utilisateurs. Et nous obtenons ce qui suit :
43
Comme vous le remarquez, toutes les zones
contiennent encore du texte. Mais nous devons
effacer ce texte avec du code java pour enfin
attendre les données venant des utilisateurs, et
préparer les zones qui auront les données pré –
chargées. Mais avant tout, nous devons d’abord
nommer ces zones pour savoir les appelées dans
la programmation. La procédure est la suivante :
Clic droit sur la zone  « Change Variable Name ».
44
Et vous obtenez l’écran suivant pour renseigner le
nom :
Vous devez faire la même chose pour toutes les

zones utilisables. Ces zones constituent les
variables de la classe formulaire dont question est
45
ici. C’est pour cela que NetBeans nous en
déclarent automatiquement, c’est ainsi que nous
avons le code suivant après toutes les
nomenclatures :
private javax.swing.JComboBox<String> cbAnnee;
private javax.swing.JComboBox<String> cbJr;
private javax.swing.JComboBox<String> cbMoi;
private javax.swing.JComboBox<String> cbSexe;
private javax.swing.JButton cmdAjouter;
private javax.swing.JLabel jLabel1;
private javax.swing.JPanel jPanel1;
private javax.swing.JPanel jPanel2;
private javax.swing.JScrollPane jScrollPane1;
private javax.swing.JScrollPane jScrollPane2;
private javax.swing.JTable tblEtudiant;
private javax.swing.JTextArea txtAdresse;
private javax.swing.JTextField txtMatricule;
private javax.swing.JTextField txtNom;
private javax.swing.JTextField txtPostNom;
private javax.swing.JTextField txtPrenom;
private javax.swing.JTextField txtRech;
46
Paramétrage du formulaire
Ceci se passe dans le constructeur du formulaire.

Vous devez écrire toute les instructions après
celle de la méthode « initComponents(); ».
Voici les codes :

public FrmEtudiant() {
initComponents();
//Afficher le formulaire Au Milieu de l'Ecran
setLocationRelativeTo(this);
//Refuse le redimentionnement
setResizable(false);
//Donne le Titre au formulaire
setTitle("Les Etudiants");
//Parametrage des Zones
nettoie();
}
Chargement des comboBox
Les comboBox sont des listes déroulantes où les

utilisateurs choisissent les informations dans une
liste limitée par le programmeur. Nous en avons 4
sur notre formulaire et leur nommenclature
commence par « cb ».
Voici le code :
/**
* Chargement ComboBox Sexe
47
*/
void chargerSexe(){
cbSexe.removeAllItems();
cbSexe.addItem("M");
cbSexe.addItem("F");
}
/**
* Chargement ComboBox Jour
*/
void chargerJR(){
cbJr.removeAllItems();
cbJr.addItem("JJ");
for (int i = 1; i <=31; i++) {
String s = String.valueOf(i);
cbJr.addItem(s);
}
}
/**
* Chargement comboBox Mois
*/
void chargerM(){
cbMoi.removeAllItems();
cbMoi.addItem("MM");
for (int i = 1; i <=12; i++) {
cbMoi.addItem(s);
}
}
/**
* Chargement ComboBox Année
*/
void chargerA(){
cbAnnee.removeAllItems();
cbAnnee.addItem("AAAA");
for (int i = 1950; i <=2200; i++) {
cbAnnee.addItem(s);
}
}
48
Les En – têtes pour La Grille JTable
La JTable est une grille qui doit recevoir toutes les

données enregistrées dans la table ou les tables
dont il sera question dans chaque formulaire.
Nous avons besoins des en – têtes qui définissent
chaque données sur chaque colonne.
/**
* La Méthode des en-têtes
* de la JTable
*
* La Variable qui définie la Grille
*/
DefaultTableModel dt = null;
void enteteTable(){
try {
//Création de l'Instance
dt = new DefaultTableModel();
//Ajout des Entetes
dt.addColumn("Matricules");
dt.addColumn("Noms");
dt.addColumn("PostNoms");
dt.addColumn("Prénoms");
dt.addColumn("Sexe");
dt.addColumn("Date Naissance");
dt.addColumn("Adresses");
//Chargement des Entetes sur la Grille
tblEtudiant.setModel(dt);
//Redimentionnement des Colonnes
tblEtudiant.getColumn("Matricules").setMaxWidth(10
0);
tblEtudiant.getColumn("Sexe").setMaxWidth(40);
49
tblEtudiant.getColumn("Date
Naissance").setMaxWidth(100);
tblEtudiant.getColumn("Adresses").setMaxWidth(0);
} catch (Exception e) {
"+e.getMessage());
}
}
Présentation du formulaire parametré
Après ce paramétrage, nous pouvons commencer

la définition des événements. Mais avant cela nous
50
devons aussi définir un contrôleur qui fait le
formatage de la date pour obtenir la date SQL car
c’est de celle-là que nous avons besoins alors que
nos comboBox ne nous produisent que du String.
Voici le code correspondant :
/**
*
* @author AS FLORRY
*/
import java.sql.Date;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
public class DateSql {
/**
* Methode Typée Date SQL
* @param jour
* @param mois
* @param annee
* @return
*/
public static Date DateS(String jour,String mois,
String annee){
//Variable à Retourner
Date dts = null;
try {
//Convertir un String en Date Locale
LocalDate ldate =
LocalDate.of(Integer.parseInt(annee),
Integer.parseInt(mois), Integer.parseInt(jour));
//Definir le Format de la Date
DateTimeFormatter dtf =
DateTimeFormatter.ofPattern("yyyy/MM/dd");
//Recupérer la Date dans un String
String dfmt = ldate.format(dtf);
//Définir la Date au format SQL
dts = java.sql.Date.valueOf(dfmt);
51
} catch (Exception e) {
"+e.getMessage());
}
return dts;
}
}
Par cette classe dans sa méthode typée DateS,

nous restituons une valeur de type Date SQL.
En plus de cette classe, nous devons créer une

méthode dans le formulaire appelée iciVersBDD,
qui fait le transfert des données du formulaire
vers la structure de la base de donnée.
void iciVersBDD(){
//Test Si les Valeurs du ComboBox sont
Seléctionnées
if (cbJr.getSelectedIndex() == 0 ||
cbAnnee.getSelectedIndex() == 0 ||
cbMoi.getSelectedIndex() == 0 ||
cbSexe.getSelectedIndex() ==0 ) {
//Message à l'Utilisateur
JOptionPane.showMessageDialog(this, "Toutes
Les listes Sont Obligatoires", "Passer de Promotion",
JOptionPane.ERROR_MESSAGE);
}else{
//Envoie des Valeurs dans la Structure de la
Table
et.setIdEtud(txtMatricule.getText().toUpperCase().trim()
);
et.setNomEtud(txtNom.getText().toUpperCase().trim());
52
et.setPostnomEtud(txtPostNom.getText().toUpperCase().tri
m());
et.setPrenomEtud(txtPrenom.getText().toUpperCase().trim(
));
et.setSexEtud(cbSexe.getSelectedItem().toString().trim()
);
//Conversion de la Date Par la Classe
DateSQL
java.sql.Date dts =
DateSql.DateS(cbJr.getSelectedItem().toString(),
cbMoi.getSelectedItem().toString(),
cbAnnee.getSelectedItem().toString());
et.setAdresseEtud(txtAdresse.getText().toUpperCase().tri
m());
et.setDateNais(dts);
}
}
Création des Evénements
actionPerformed Sur le Bouton
Voici le code :
53
et =
etc.findEtudiant(txtMatricule.getText().toUpperCase().tr
im());
String m = et.getIdEtud();
if (m.equalsIgnoreCase("")) {
iciVersBDD();
etc.saveEtudiant(et);
JOptionPane.showMessageDialog(this,
"Enregistrement effectué", "Passer de Promotion",
JOptionPane.INFORMATION_MESSAGE);
nettoie();
}
else
{
int msg =
JOptionPane.showConfirmDialog(this, "Cet'Enregistrement
existe, voulez - vous modifier ?", "Passer de
Promotion", JOptionPane.OK_CANCEL_OPTION,
JOptionPane.QUESTION_MESSAGE);
if (msg==JOptionPane.YES_OPTION) {
iciVersBDD();
etc.upDateEtudiant(et);
JOptionPane.showMessageDialog(this,
"Modification effectuée", "Passer de Promotion",
JOptionPane.INFORMATION_MESSAGE);
nettoie();
}
}
Là vous pouvez essayer pour voir si votre code
fonctionne.
54
Dès que les données sont complètes, vous pouvez
cliquer sur le Bouton Ajouter.
55
56
Ainsi vous voyez que, non seulement
l’enregistrement est effectué, notre grille aussi est
remplie.
57
Conclusion
La programmation en java est merveilleuse et
permet à chaque étudiant de prendre le temps de
pratiquer sur les principes de l’Orienté Objets tout
en effectuant des opérations sur la résolution des
problèmes du monde réel.
Nous avons dans ce tutoriel fait une illustrations

du design pattern MVC pour permettre à chaque
apprenant de savoir appréhender ces principes et
utiliser à bon escient les modèles pour la création
et la représentation de la structure des données,
des contrôleurs pour la manipulation de ces
données en suivant les opérations du modèle
CRUD, ainsi que leur utilisation sur une view en
partant du SWING pour la création des Interfaces
Homme - Machine.
58
Aller Plus loin
1. https://jmdoudoux.developpez.com/cours
/developpons/java/chap-swing.php
2. https://www-lipn.univ-
paris13.fr/~cathy/docs/M1-
ProgJava/JavaSwing1.pdf
3. https://www.jmdoudoux.fr/java/dej/chap-
jdbc.htm
4. http://salihayacoub.com/420Keh/Semaine
%2011/2015Jdbc.pdf
5. https://goulet.ca/media/other/364160CH
18_JDBC.pdf
59

Tuto JSE Persintance

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Tuto JSE Persintance

Transféré par

Droits d'auteur :

Formats disponibles

APPLICATION DESKTOP :

Java Persistance avec MySQL

Java est connue pour ses atouts dans la programmation des

De l’objet { la persistance, tout est représenté dans des

Le choix des auteurs du java a été d'abandonner des

1. Le Kit de développement Java : JDK. Dans ce

Nous allons ici créer un projet dans le cadre de

Un simple double clic sur l’icône dans le poste de

Ceci va nous amener sur l’écran suivant :

Ça ne sera peut – être pas le même écran chez

Dès que vous êtes sur cette écran, il existe

Pour notre cas, il s’agit de la catégorie « Java with

En dans la rubrique Projets, nous choisissons

Project Name : nom de votre projet. Donnez un

Project Location : principalement un dossier se

Project Folder : c’est généralement le répertoire

Dès que cela est fait, vous pouvez cliquer sur

L’objectif dans ce projet est de savoir faire la

Le meilleur moyen de le faire c’est savoir créer

Nous associeront ici une structure de données

Les données stockées dans des bases de données

Après passage au MLD Validé et la normalisation,

Aussi appelé patrons de conception sont des

Vous ne pouvez pas vous contenter de trouver un

Les patrons sont souvent confondus avec les

Un algorithme c’est un peu comme une recette de

La majorité des patrons sont présentés de façon

- L’Intention du patron permet de décrire

Vous retrouverez dans certains catalogues de

Dans notre cas nous opterons pour le Design

Le Patron de conception Model View Controller

Nous allons diviser notre projet en trois package

Package « modeles » : pour y placer les classes

Packages « controllerEtDao » : ici nous allons

Comme nous parlons d’une base de données, la

Package « View » : considéré comme la partie qui

Tout ce qui doit être créé se fait dans le package :

Dedans vous cliquez sur « Java Package » pour

Ainsi, la structure de notre projet se présentera

Les modèles sont composés des variables, des

Une variable est un objet repéré par son nom,

Avec Java, les noms de variables peuvent être

Les noms de variables sont sensibles à la casse

Voici alors la syntaxe de création d’une variable :

1. Une variable par instruction

2. Plusieurs variables par instruction

Un constructeur en Java est une méthode spéciale

Notez que le nom du constructeur correspond au

Les Getters et les Setters

En Java, Getter et Setter sont des méthodes

Getter en Java : Getter renvoie la valeur

Setter en Java : pendant que Setter définit ou met

Vous faites un clic droit sur votre package

Et la classe s’ouvre en même temps pour vous

public void setIdSection(String idSection) {

public String getLibeSection() {

public void setLibeSection(String libeSection)

Ainsi notre projet continue de se peuplé comme

JDBC signifie Java™ EE Database Connectivity. En

Les programmes JDBC sont exécutés plus

Toutes les opérations ont quelques instructions

Voici le code de la classe :

Le contrôleur existe entre la vue et le modèle.

La logique métier est ici représentée par les