Université de Tunis El Manar

---*---
Institut Supérieur d’Informatique
---*---

Le modèle MVC

Mohamed Ben Ali

Mohamed.benali@riadi.rnu.tn
Layered Application Design

Structuration des applications en deux couches (niveaux) :

Niveau Interaction
Interface avec le client,
Gestion des requêtes,
Délègue les tâches au niveau traitement,
Réponse aux clients.
Niveau Traitement
Traite les requêtes selon la logique métier,
Accès à la base de données.

Faible couplage entre les deux niveaux

Définition

MVC : Modèle – Vue – Contrôleur

Motif ou patron de conception pour le développement

d’application logicielles qui sépare le modèle de données,
l’interface utilisateur et la logique de contrôle.

Vue Contrôleur Modèle

(View) (Controller) (Model)
Description
Le Modèle représente le comportement de l'application : traitements
des données, interactions avec la base de données, etc.
Il décrit les données manipulées par l'application et définit les méthodes d'accès.

la Vue correspond à l'interface avec laquelle l'utilisateur interagit.

Les résultats renvoyés par le modèle sont dénués de toute présentation mais sont
présentés par les vues.
Plusieurs vues peuvent afficher les informations d'un même modèle. Elle peut être
conçue en html, ou tout autre « langage » de présentation.
La vue n'effectue aucun traitement, elle se contente d'afficher les résultats des
traitements effectués par le modèle, et de permettre à l'utilisateur d'interagir
avec elles.

le Contrôleur prend en charge la gestion des événements de

synchronisation pour mettre à jour la vue ou le modèle.
Il n'effectue aucun traitement, ne modifie aucune donnée, il analyse la requête du
client et se contente d'appeler le modèle adéquat et de renvoyer la vue
correspondant à la demande.
Évolution

MVC Modèle 1
Page Centeric

MVC Modèle 2
Servlet Centeric

Web Application Frameworks

Struts

Standard Based Web Application Framework

Java Server Faces
MVC 1

Modèle basé sur les page JSP (Page Centering)

Les pages JSP supportent tous les aspects d’une application à savoir la
présentation, le contrôle de données et la logique métier.
Le processus métier est écrit « en dur » dans les pages JSP
MVC 2

Introduction d’un niveau intermédiaire : Les servlets

Les pages JSP servent uniquement pour la présentation,
Les servlets agissent comme un « vrai contrôleur »
Authentification, Autorisation, Error handling…
Décider de la logique métier appropriée en fonction des requêtes,
Redirections
Les Framworks d’Applications Web
Complexité croissante du développement des applications
web (technologies, architectures, modèles…)

L'intérêt majeur des frameworks est de proposer une

structure identique pour toutes les applications web.

Ces frameworks sont accompagnés d'outils et de normes à

respecter lors du développement.

Plusieurs avantages :
augmenter la productivité (une fois le framework pris en main)
assurer la réutilisation de composants fiables
faciliter la maintenance

Le plus gros défaut des frameworks est lié à leur complexité

Jakarta Struts
Struts est un framework pour applications web développé par
le projet Jakarta de la fondation Apache.

Struts est en une collection de programmes Java conçue pour

aider à construire des applications robustes en gagnant du
temps. Il fournit la charpente et le gros œuvre de base.

Caractéristiques
Un MVC Framework,
Utilisé pour la construction d’applications web utilisant des servlets ainsi
que des pages JSP,
Se focalise sur le développement de la vue ainsi que du contrôleur,
Utilisation des bibliothèques de tags personnalisés au niveau des JSP.
Environnement flexible, extensible, stables et mature.
Large communauté.
Architecture





 Servlet Générique fournie par Struts.Toutes les requêtes des clients y transitent
 struts-config.xml : Contient toutes les informations requises par la servlet
générique.
 Si la requête du client contient des paramètres de formulaire, ceux-ci sont mis par le
contrôleur dans un objet Bean.
 Une classe de type Action chargée de traiter une requête dont les données sont stockées
dans un bean.
Développement des Vues
Les vues de l’application web sont des pages JSP.
Pour faciliter le développement, Struts propose trois
bibliothèques de tags personnalisés
HTML : gère l’ensemble des balises html (champs texte, liste choix, …)
Bean : gère l’accès aux beans (et à leur propriétés) de l’application (page,
request, session …)
Logic : gère la logique de vos Vue (itération, condition …)

Les objets de types ActionForm sont des objets qui permettent

à Struts de mapper automatiquement les données saisies dans
une page JSP avec les attributs correspondant de l’objet:
Pour chaque page contenant des données à utiliser, il faut définir un objet
qui hérite de la classe org.apache.struts.action.ActionForm
Pour chaque donnée, il faut définir un attribut private qui contiendra la
valeur, un getter, un setter et une méthode reset (réinitialisation)
Développement du contrôleur
Toutes les requêtes sont véhiculés à un contrôleur central.
Cette partie « contrôleur » de Struts est implémentée en utilisant
une seule et unique servlet par application. Cette servlet doit hériter
de la classe org.apache.struts.action.ActionServlet.
Cette servlet possède des traitements génériques qui utilisent les
informations contenues dans le fichier struts-config.xml et dans des
objets du type org.apache.struts.action.Action
La servlet reçoit les requêtes http émises par le client et en fonction
de celles ci, elle appelle un objet du type Action qui lui est associé
dans le fichier struts-config.xml.
Un objet de type Action contient une partie spécifique de la logique
métier de l'application. Cet objet doit étendre la classe
org.apache.struts.action.Action.
La méthode la plus importante de cette classe est la méthode
execute(). C'est elle qui doit contenir les traitements qui seront
exécutés.
Présentation JSF
JSF : Java Server Faces

Java Server Faces (JSF) est une technologie dont le but est de
proposer un framework qui facilite et standardise le
développement d'applications web avec Java.

Son développement a tenu compte des différentes

expériences acquises lors de l'utilisation des technologies
standards pour le développement d'applications web (servlet,
JSP, JSTL) et de différents frameworks (Struts, ...).

Le grand intérêt de JSF est de proposer un framework qui

puisse être mis en oeuvre par des outils pour permettre un
développement de type RAD pour les applications web.
Définition

JSF est une technologie utilisée côté serveur dont le but est de
faciliter le développement de l'interface utilisateur en
séparant clairement la partie « interface » de la partie «
métier » d'autant que la partie interface n'est souvent pas la
plus compliquée mais la plus fastidieuse à réaliser.

La version 1.0 de Java Server Faces, développée sous la

JSR−127 , a été validée en mars 2004.

JSF offre un raffinement au niveau interface utilisateur en

séparant la présentation du comportement des composants au
niveau de l’UI
Fonctionnalités
Assemblage de composants serveur qui génèrent le code de leur rendu avec la
possibilité d'associer certains composants à une source de données encapsulée
dans un bean.
Utilisation d'un modèle de développement standardisé reposant sur l'utilisation
d'événements et de listener ·
Conversion et la validation des données avant leur utilisation dans les
traitements
Gestion de l'état des composants de l'interface graphique.
un modèle riche de composants graphiques réutilisables
Possibilité d'étendre les différents modèles et de créer ces propres composants
Configuration de la navigation entre les pages.
Support de l'internationalisation.
Support pour l'utilisation par des outils graphiques du framework afin de
faciliter sa mise en œuvre
Support de différents clients (HTML, WML, XML, ...) grâce à la séparation des
problématiques de construction de l'interface et du rendu de cette interface
Structure Type

Une structure type d’une application JSF consiste en :

Des pages JSP contenant des composants d’interface utilisateurs (UI

components) encapsulés dans des Taglibs JSP

Un fichier faces-config.xml (analogue à struts-config.xml)

Référencement et propriétés des Beans managés (Managed Beans)
Modèle de navigation

Un ensemble de Managed Beans qui se charge de la logique de

l’interface utilisateur de l’application
Managed Beans

Les beans managés sont des javabeans dont le cycle de vie va être
géré par le framework JSF en fonction des besoins et du paramétrage
fourni dans le fichier de configuration.

Au niveau du fichier de configuration « faces-config.xml », chacun de

ces beans doit être déclaré avec la balise <managed-bean> possédant
trois sous éléments obligatoires
<managed−bean−name> : le nom attribué au bean
<managed−bean−class> : le type de la classe du bean ·
<managed−bean−scope> : la portée dans laquelle le bean sera stocké
Backing Beans

Les beans de type « backing bean » sont spécialement utilisés avec

JSF pour encapsuler tout ou partie des composants qui composent une
page et ainsi faciliter leur accès notamment lors des traitements.

Ces beans sont particulièrement utiles durant des traitements réalisés

lors de validations ou de traitements d'événéments car ils permettent
un accès aux composants dont ils possèdent une référence.
Portée des Beans

La portée peut prendre les valeurs suivantes :

request : limitée entre l'émission de la requête et l'envoi de la

réponse. Les données stockées dans cette portée sont utilisables lors
d'un transfert vers une autre page (forward),

session : échange de données entre plusieurs échanges avec un même

client,

application : permet l'accès à des données pour toutes les pages d'une
même application quelque soit l'utilisateur.
Cycle de Vie

Le traitement d'une requête traitée par une application utilisant JSF

utilise un cycle de vie particulier constitué de plusieurs étapes :
Création de l'arbre de composants ·
Extraction des données des différents composants de la page ·
Conversion et validation des données ·
Extraction des données validées et mise à jour du modèle de données
(javabean) ·
Traitements des événements liés à la page ·
Génération du rendu de la réponse

Request

Response