JAVA EE

To do liste MVC

ABDELLAHI YOUCEF
PROFESSEUR
HANI
ABDELLAHI Youcef Java EE

CHAPITRE1 : java EE

pg. 1
ABDELLAHI Youcef Java EE

Java EE, abréviation de Java Platform, Enterprise Edition, est une plate-forme de
développement Java étendue conçue pour simplifier et accélérer le développement
d'applications d'entreprise robustes et extensibles. Voici une présentation détaillée des
principaux aspects de Java EE :

1. Architecture Multi-Tiers :
• Java EE suit le modèle d'architecture multi-tiers, divisant une application en
plusieurs composants distincts fonctionnant sur différentes couches.
• Trois niveaux principaux : la couche de présentation (web et clients), la couche
métier (logique métier) et la couche d'accès aux données (persistance).

2. Composants Java EE :
• Servlets et JSP (JavaServer Pages) : Utilisés pour construire des interfaces web
dynamiques.
• Enterprise JavaBeans (EJB) : Composants côté serveur pour la logique métier.
• Java Persistence API (JPA) : Permet la persistance des données dans les bases
de données relationnelles.
• Java Message Service (JMS) : Gère les messages entre les applications
distribuées.
• Java API for RESTful Web Services (JAX-RS) : Facilite la création de services
web RESTful.
• Java API for XML Web Services (JAX-WS) : Pour le développement de services
web SOAP.

3. Gestion de Transactions :
• Java EE offre un support intégré pour la gestion des transactions, garantissant
l'intégrité des données dans des opérations complexes.
• Les transactions peuvent englober plusieurs opérations de base de données ou
d'autres ressources.

4. Sécurité :
• Un système de sécurité robuste avec des fonctionnalités telles que
l'authentification, l'autorisation, le chiffrement et la gestion des identités.
• Intégration de mécanismes tels que Java Authentication and Authorization
Service (JAAS).

pg. 2
ABDELLAHI Youcef Java EE

5. Gestion des Ressources :

• Java EE gère automatiquement les ressources telles que les connexions de bases
de données, les pools de connexions et les transactions.
• Les gestionnaires de ressources facilitent la gestion des ressources externes.

6. Connectivité et Intégration :
• API pour la communication entre les différentes couches de l'application et
l'intégration avec d'autres systèmes.
• Support des services web, RMI (Remote Method Invocation), et d'autres
protocoles.

7. Conteneurs Java EE :
• Les applications Java EE s'exécutent dans des conteneurs fournis par des serveurs
d'application, tels que Apache Tomcat, WildFly (anciennement JBoss), GlassFish,
etc.
• Ces conteneurs gèrent le cycle de vie des composants, la sécurité, la gestion des
transactions, etc.

8. Outils de Développement :
• Les développeurs Java EE utilisent des outils tels qu'Eclipse, NetBeans ou IntelliJ
IDEA, avec des plugins spécifiques pour faciliter le développement, le débogage
et le déploiement.

9. Interopérabilité et Standardisation :
• Les spécifications Java EE sont définies par le Java Community Process (JCP) pour
assurer l'interopérabilité entre différentes implémentations et favoriser la
standardisation.

10. Évolutions Récentes (Java EE 8 et Au-delà) :

• Java EE 8 a introduit des fonctionnalités telles que JSON Processing, Servlet 4.0,
CDI 2.0, etc.
• Depuis Java EE 8, le développement de Java EE a été transféré à la Eclipse
Foundation sous le nom de Jakarta EE.

pg. 3
ABDELLAHI Youcef Java EE

En résumé, Java EE est une plate-forme robuste et complète pour le développement

d'applications d'entreprise, offrant des composants modulaires, des services intégrés,
une gestion de transactions et une sécurité avancée. La communauté continue de faire
évoluer la plate-forme sous le nom de Jakarta EE pour répondre aux besoins changeants
du développement d'applications d'entreprise.

pg. 4
ABDELLAHI Youcef Java EE

CHAPITRE2 : MVC

pg. 5
ABDELLAHI Youcef Java EE

Le modèle MVC, ou Modèle-Vue-Contrôleur, est un motif de conception utilisé dans le

développement logiciel pour organiser le code d'une manière qui sépare les
préoccupations liées à la gestion des données, à l'interface utilisateur et à la logique de
contrôle. Voici une présentation détaillée des trois composants du modèle MVC :

1. Modèle (Model) :
• Responsabilité : Gère les données et la logique métier de l'application.
• Caractéristiques :
• Données : Représente les informations avec lesquelles l'application
travaille.
• Logique Métier : Contient les règles métier et les opérations sur les
données.
• Indépendance de l'Interface Utilisateur : Ne dépend pas de la manière
dont les données sont présentées ou collectées.

2. Vue (View) :
• Responsabilité : Affiche les données au format approprié pour l'utilisateur final.
• Caractéristiques :
• Interface Utilisateur : Présente les données au travers d'une interface
graphique ou textuelle.
• Passive : Ne manipule généralement pas les données directement. Elle se
contente d'afficher l'état actuel du modèle.
• Réactivité : Peut être mise à jour en temps réel lorsque le modèle change.

3. Contrôleur (Controller) :
• Responsabilité : Gère les entrées de l'utilisateur et met à jour le modèle en
conséquence.
• Caractéristiques :
• Réception des Événements : Réagit aux interactions de l'utilisateur, telles
que les clics de souris, les touches du clavier, etc.
• Mise à Jour du Modèle : Modifie l'état du modèle en fonction des actions
de l'utilisateur.
• Indépendance de la Vue : Ne connaît pas nécessairement la manière
dont les données sont présentées.

pg. 6
ABDELLAHI Youcef Java EE

Fonctionnement Général du Modèle MVC :

1. L'utilisateur interagit avec l'interface utilisateur (Vue).
2. La Vue transmet les actions de l'utilisateur au Contrôleur.
3. Le Contrôleur met à jour le Modèle en fonction des actions de l'utilisateur.
4. Le Modèle notifie la Vue de tout changement.
5. La Vue met à jour son affichage en fonction des modifications du Modèle.

Avantages du Modèle MVC :

• Séparation des Préoccupations : Chaque composant a une responsabilité claire
et distincte.
• Réutilisabilité du Code : Les composants peuvent être réutilisés dans différentes
parties de l'application.
• Facilité de Maintenance : Les modifications dans un composant n'affectent pas
nécessairement les autres.

Variantes du Modèle MVC :

• MVC Classique : Utilisé dans le développement d'applications de bureau.
• MVC Web : Adapté pour le développement web, avec la Vue représentée
généralement par des pages HTML/JSP et le Contrôleur par des Servlets.

Implémentations Courantes :
• Frameworks Web : Spring MVC, Ruby on Rails, Django.
• Développement d'Applications de Bureau : JavaFX, Cocoa (pour les
applications macOS).

En résumé, le Modèle MVC fournit une structure organisée pour le développement

logiciel, améliorant la maintenabilité et la modularité des applications en séparant les
responsabilités liées aux données, à l'interface utilisateur et à la logique de contrôle. Il
est largement utilisé dans le développement d'applications variées, de sites web à des
applications de bureau.

pg. 7
ABDELLAHI Youcef Java EE

CHAPITRE 03 : realisation d'un modèle

base sur l'architecture MVC
Le cas d’un to do list

pg. 8
ABDELLAHI Youcef Java EE

Le modèle MVC est un modèle de conception qui sépare les préoccupations de

présentation, de traitement des données et de contrôle.

Supposons que nous construisions une application de gestion des tâches (to-do list) en
utilisant Java EE et le modèle MVC. Voici un exemple basique avec trois parties
principales : le modèle, la vue et le contrôleur.

Modèle (Model) - Gestion des Tâches

Task.java :
• Le modèle représente la structure des données de l'application. Dans cet
exemple, le modèle est la classe Task, qui a un attribut name pour stocker le nom
de la tâche.
• Le modèle est responsable de la gestion des données, de leur validation et de
leur traitement.

// Task.java - Modèle représentant une tâche

public class Task {
private String name;

public Task(String name) {

this.name = name;
}

public String getName() {

return name;
}
}

pg. 9
ABDELLAHI Youcef Java EE

Vue (View) - taskList.jsp :

• La vue est responsable de l'affichage des données au format approprié pour
l'utilisateur.
• Dans cet exemple, taskList.jsp est une page JSP qui affiche la liste des tâches
sous forme de balises HTML. Elle utilise des boucles JSP ( <% for (Task task :
taskList) { %>) pour parcourir la liste de tâches et les afficher.

<%@ page contentType="text/html;charset=UTF-8"

language="java" %>
<html>
<head>
<title>To-Do List</title>
</head>
<body>
<h1>To-Do List</h1>
<ul>
<% for (Task task : taskList) { %>
<li><%= task.getName() %></li>
<% } %>
</ul>
<form action="TaskController" method="post">
<input type="text" name="taskName" required>
<input type="submit" value="Ajouter une tâche">
</form>
</body>

pg. 10
ABDELLAHI Youcef Java EE

</html>

Contrôleur (Controller) - TaskController.java :

• Le contrôleur gère la logique de l'application, notamment la gestion des requêtes
de l'utilisateur et la mise à jour du modèle et de la vue en conséquence.
• Dans cet exemple, TaskController étend HttpServlet pour gérer les requêtes HTTP
(POST dans ce cas).
• Lorsqu'une nouvelle tâche est ajoutée via le formulaire dans la vue, le contrôleur
récupère les données de la requête (taskName), crée une nouvelle instance de Task,
l'ajoute à la liste de tâches, puis redirige vers la vue mise à jour.

@WebServlet("/TaskController")
public class TaskController extends HttpServlet {
private List<Task> taskList = new ArrayList<>();

protected void doPost(HttpServletRequest request,

HttpServletResponse response) throws ServletException,
IOException {
String taskName = request.getParameter("taskName");
Task newTask = new Task(taskName);
taskList.add(newTask);

// Mise à jour de la liste des tâches dans la requête

request.setAttribute("taskList", taskList);

pg. 11
ABDELLAHI Youcef Java EE

// Redirection vers la vue

RequestDispatcher dispatcher =
request.getRequestDispatcher("taskList.jsp");
dispatcher.forward(request, response);
}
}

En résumé, le modèle gère les données, la vue gère l'interface utilisateur, et le contrôleur
gère la logique de l'application. Ces trois composants travaillent ensemble de manière
cohérente pour suivre le modèle MVC, offrant une séparation claire des préoccupations
et facilitant la maintenance et l'extension de l'application.

pg. 12
ABDELLAHI Youcef Java EE

Conclusion :
En conclusion, l'adoption du modèle MVC (Modèle-Vue-Contrôleur) dans le
développement logiciel représente une approche puissante et structurée qui apporte de
nombreux avantages. En séparant clairement les responsabilités liées aux données, à
l'interface utilisateur et à la logique de contrôle, le modèle MVC offre une solution
élégante pour répondre aux défis complexes du développement logiciel.

La séparation des préoccupations inhérente au modèle MVC améliore la maintenabilité

des applications en permettant des modifications indépendantes dans chaque
composant. Cette modularité conduit également à une réutilisabilité accrue du code,
facilitant le développement, la gestion et l'extension des logiciels.

La structure du modèle MVC favorise la collaboration entre les membres de l'équipe de

développement, chacun pouvant se concentrer sur sa spécialité sans empiéter sur les
autres domaines. Cela conduit à une répartition efficace des tâches et à une gestion plus
fluide des projets logiciels.

La testabilité améliorée des composants individuels, ainsi que la capacité à effectuer des
tests unitaires et d'interface utilisateur séparément, contribuent à la qualité globale du
logiciel. De plus, l'adaptabilité du modèle MVC à différents environnements et sa large
adoption dans l'industrie en font une approche polyvalente et pérenne.

En somme, le modèle MVC offre une architecture robuste qui a résisté à l'épreuve du
temps et continue d'être une méthode de conception populaire pour le développement
d'applications logicielles, fournissant une base solide pour la création d'applications
modulaires, évolutives et bien structurées.

pg. 13
ABDELLAHI Youcef Java EE

Contents
CHAPITRE1 : java EE ...................................................................................................................................... 1
1. Architecture Multi-Tiers : .......................................................................................................................... 2
2. Composants Java EE : ................................................................................................................................ 2
3. Gestion de Transactions : .......................................................................................................................... 2
4. Sécurité : ................................................................................................................................................... 2
5. Gestion des Ressources :........................................................................................................................... 3
6. Connectivité et Intégration : ..................................................................................................................... 3
7. Conteneurs Java EE : ................................................................................................................................. 3
8. Outils de Développement : ....................................................................................................................... 3
9. Interopérabilité et Standardisation : ......................................................................................................... 3
10. Évolutions Récentes (Java EE 8 et Au-delà) : ........................................................................................... 3
CHAPITRE2 : MVC .......................................................................................................................................... 5
1. Modèle (Model) : ...................................................................................................................................... 6
2. Vue (View) : ............................................................................................................................................... 6
3. Contrôleur (Controller) : ........................................................................................................................... 6
Fonctionnement Général du Modèle MVC : ................................................................................................. 7
Avantages du Modèle MVC : ......................................................................................................................... 7
Variantes du Modèle MVC : .......................................................................................................................... 7
Implémentations Courantes :........................................................................................................................ 7
CHAPITRE 03 : realisation d'un modèle base sur l'architecture MVC ........................................................... 8
Le cas d’un to do list ...................................................................................................................................... 8
Modèle (Model) - Gestion des Tâches .......................................................................................................... 9
Vue (View) - taskList.jsp : ...................................................................................................................... 10
Contrôleur (Controller) - TaskController.java : .................................................................................... 11
Conclusion : ................................................................................................................................................. 13

pg. 14