Cours Et TD NTIERS Réparé

REPUBLIQUE TUNISIENNE
MINISTERE DE LENSEIGNEMENT SUPERIEUR, DE LA RECHERCHE SCIENTIFIQUE

ET DES TECHNOLOGIES DE L'INFORMATION ET DE LA COMMUNICATION
DIRECTION GENERALE DES ETUDES TECHNOLOGIQUES

INSTITUT SUPERIEUR DES ETUDES TECHNOLOGIQUES DE KASSERINE
SUPPORT DE
COURS
& TRAVAUX
DIRIGES
Programmation N-TIERS
Adress aux tudiants en troisime anne de
Licence Applique en Technologies de
lInformatique
Parcours Multimdia et Dveloppement Web
Elabor par :
Fatma zahra BOUZIDI
Assistante technologue
Contact :
Fatmazahra.bouzidi85@gmail.com
Anne Universitaire 2013/2014
Avant-propos
Cet ouvrage PROGRAMMATION
N-TIERS
est lintention des tudiants
de troisime anne en Licence applique en technologies de linformatique

lInstitut Suprieur des Etudes Technologique de Kasserine, parcours
Multimdia et Dveloppement Web .
Ltudiant trouvera dans cet ouvrage une initiation la programmation Ntiers en prenant comme exemple la plateforme JavaEE, il sagit
de
prparer ltudiant apprendre les comptences thoriques ncessaires

pour programmer une application
faisant la distinction entre la
prsentation, le traitement et les donnes en imbriquant quelques API de

javaEE .
Aprs avoir compris les diffrentes architectures et la plateforme JavaEE,
ltudiant sera capable la fin de cet ouvrage de crer une application
simple selon le modle MVC et de sapprofondir sur la programmation NTiers.
Ce cours ncessite des prrequis: des notions en dveloppement Java et
des notions en langages HTML sont ncessaires.
Louvrage est divis en cinq chapitres :
Le premier chapitre dcrit les niveaux dabstraction dune application. Le
dcoupage de ces niveaux en couches dfinit son architecture. Ce chapitre
prsente rapidement diffrent architectures applicatifs ainsi que leurs
inconvnients et avantages.
Le deuxime chapitre prsente la plateforme JavaEE, ses API, son
architecture, et son environnement dexcution : ltudiant sera capable
de distinguer entre les diffrentes couches dune architecture JavaEE et les

API qui les composent ainsi que le mode dassemblage et de dploiement
de chaque module dune application JavaEE.
Le troisime chapitre introduit les API Servlet et JSP en prsentant les
concepts ncessaires pour comprendre chaque composant : dfinition,
radiographie, cycle de vie.
Le quatrime chapitre reprsente le noyeau de ce cours en dcrivant une
implmentation simple dune architecture MVC imbriquant les API servlet,
Jsp et un objet Java : ltudiant sera capable de collaborer entre une
servlet et une Jsp, de savoir transmettre des donnes issues dun client et
des
donnes
issus
dun
serveur
et
de
comprendre
un
exemple
implmentant le modle MVC.

Le
dernier chapitre
introduit lAPI
javaBean et
prsente une
implmentation de modle MVC imbriquant les composants JSP, Servlet et

javaBean.
Domaine de Formation : Sciences et

Technologies
Mention TI
Mention : Technologies de lInformatique (TI)
Spcialit MDW
Parcours : Multimdia et Dveloppement Web
Semestre S5
UNIT DENSEIGNEMENT (UE) : PROGRAMMATION N-
Crdits : 5
Coef : 5
TIERS
Volume Horaire par Semestre :

90
Semaine : 6
Fiche Matire
lment Constitutif
(ECUE)
PROGRAMMATION
N-TIERS
Ventilation / Semaine
Vol. Horaire /
Semestre
Cours
11.2
5
0.75
TD
11.2
22.5
5
0.75
1.5
Coeffici
ent
Crdit
s
TP
0
0
1.5
1.5
valuati
on
Contrle
continu
Objectif(s) Gnr(al)/(aux)
Le cours vise donner lapprenant les comptences thoriques ncessaires pour
programmer des applications faisant la distinction entre l'aspect mtier et les
aspects non fonctionnels.
Objectifs Spcifiques
- Comprendre larchitecture client serveur.
- Comprendre l'architecture N-Tiers: Tiers prsentation, tiers mtier, tiers donnes.
-Comprendre larchitecture MVC
- Comprendre La plate-forme Java: J2EE
-savoir programmer des servlets
-savoir programmaer des jsps
-savoir programmer des javabeans
-Etre capable de mettre en uvre une architecture MVC
Mots-Cls
Client, Serveur, Mtier, Plate-forme, Architecture, J2EE, MVC, N-Tiers, JSP, Servlet,
JavaBean etc.
Pr-requis
UE : Dveloppement Web 1.
lments de Contenu
Architecture Client Serveur.

Architecture N-Tiers.
Architecture MVC
Plate-forme J2EE
JSP,Servlet,JavaBean
Implmentation de MVC
Moyens et Outils Pdagogiques

-
Cours, Travaux dirigs, mini-projet
Table des matires

Chapitre I Prsentation gnrale............................................................................. 1
1
Les trois niveaux d'abstraction d'une application.........................................2
L'architecture 1-tiers..................................................................................... 2
2.1
Prsentation........................................................................................... 2
2.2
Limitations.............................................................................................. 3
3.1
Prsentation........................................................................................... 4
3.2
Avantages et inconvnients de l'architecture 2-tiers.............................4
4.1
Prsentation........................................................................................... 5
4.2
Avantages et inconvnients de l'architecture 3-tiers..............................6
Les architectures N-tiers...............................................................................7

5.1
Prsentation........................................................................................... 7
5.2
Avantages et inconvnients de l'architecture N-tiers :..........................8
Larchitecture Modle-Vue- Contrleur (MVC) :............................................8

6.1
Prsentation........................................................................................... 8
6.2
Avantages et inconvnients..................................................................10
6.3
Diffrence avec larchitecture 3-tiers....................................................10
Chapitre II Prsentation de la plateforme Java EE...............................................12

1
La prsentation de Java EE.........................................................................13
Les API de Java EE....................................................................................... 13
Architectures en Java EE............................................................................. 14

3.1
Les composants clients ou tiers Client..................................................15
3.2
Les composants Web ou tiers Web.......................................................17
3.3
Les composants mtier ou tiers Mtier.................................................17
3.4
Enterprise Information System Tier......................................................18
Les conteneurs Java EE............................................................................... 18
L'assemblage et le dploiement d'applications J2EE...................................20
Chapitre III Introduction aux Servlets et pages JSP..............................................22

1
Introduction aux Servlets............................................................................23

1.1
Quest-ce qu'une servlet.......................................................................23
1.2
Cycle de vie dune servlet....................................................................23
1.3
Radiographie dune premire servlet....................................................27
Introduction aux JSP.................................................................................... 30

2.1
Pourquoi une JSP?.................................................................................30
2.2
Cest quoi une JSP?...............................................................................30
2.3
Cycle de vie d'une JSP..........................................................................31
2.4
Radiographie dun Script JSP................................................................33
2.5
Les Balises JSP...................................................................................... 35
2.6
Les variables prdfinis :......................................................................39
Chapitre IV Implmentation de MVC....................................................................40

1
MVC et Java EE............................................................................................ 41
Collaboration entre JSP et servlets : linterface requestdispatcher.............41
Transmission de donnes: les paramtres et les attributs..........................43
3.1
Diffrence entre paramtres et attributs..............................................43
3.2
Transmission des attributs : mthodes setAttribute() et getAttribute() 44
3.3
Transmission des paramtres : mthode getParameter().....................45
Exemples dapplications du design pattern MVC :.....................................46

4.1
Exemple1 :............................................................................................ 46
4.2
Exemple 2 :........................................................................................... 55
Chapitre V JavaBeans et Scope...........................................................................60

1
JavaBeans................................................................................................... 61
1.1
Cest quoi un Javabean.........................................................................61
1.2
Structure dun Javabean.......................................................................61
1.3
Comment utiliser des beans ?..............................................................61
Implmentation du MVC (avec les JavaBeans)............................................62
Les Scopes dun bean................................................................................. 66

3.1
Partage de donnes sur requte...........................................................66
3.2
Partage de donnes sur session...........................................................67
3.3
Partage de donnes sur application (Rare)...........................................68
Travaux diriges................................................................................................... 70
TD N1 : Les bases................................................................................................. 71
Correction TD N1 : Les bases..................................................................................73
TD N2 : Introduction aux Servlets et pages JSP.............................................................79
Correction TD N2 : Introduction aux Servlets et pages JSP...............................................81
TD N3: Implmentation de MVC..............................................................................95
Correction TDN3 : Implmentation de MVC..............................................................100
DEVOIR SURVEILLE............................................................................................. 109

EXAMEN.................................................................................................................. 1
REFERENCES.......................................................................................................... 1
Liste des figures

Figure I-1 : Schma explicatif du modle MVC.....................................................11
Figure II-1 Architecture Java EE standard..............................................................17
Figure II-2 : Tier client, Tier web et Tier mtier.....................................................18
Figure II-3 : Tiers Web et Tiers Mtier Java EE.......................................................20
Figure II-4 : Serveur Java EE et conteneurs...........................................................21
Figure III-1 : Linterface Servlet............................................................................. 26
Figure III-2 : cycle de vie dune Servlet.................................................................27
Figure III-3 : cycle de vie dtaill dune servlet....................................................29
Figure III-4 : traitement de deux requtes par le serveur.....................................30
Figure III-5 : recherche de la Ssevlet dans le fichier web.xml...............................33
Figure III-6 : CorrespondanceJSP/Servlet...............................................................34
Figure III-7 : Cycle de vie dune JSP......................................................................36
Figure IV-1 : Collaboration entre JSP et servlets...................................................45
Figure IV-2 : Liste des promos.............................................................................. 51
Figure IV-3 : tape 1 du modle MVC...................................................................51
Figure IV-7 : tape 5 du modle MVC..................................................................57
Figure IV-8 : Liste des promos.............................................................................. 58
Figure IV-9 : Formulaire HTML............................................................................... 59
Figure IV-10 : pages d'affichage des donnes de formulaire................................59
Figure V-1 : implmentation du MVC....................................................................67
Liste des tableaux

Tableau II-1 : Les diffrents types d'archives........................................................23
CHAPITRE I : PRESENTATION
GENERALE
Chapitre I Prsentation gnrale

OBJECTIFS
Lobjectif de ce chapitre est de :
Comprendre le dcoupage en couches dune application ;

Comprendre larchitecture Client/serveur ;
Connaitre les architectures 1-Tiers, 2-Tiers, 3-Tiers et N-Tiers ;
Comprendre larchitecture MVC.
Les trois niveaux d'abstraction d'une application
En gnral, une application informatique peut tre dcoupe en trois

niveaux d'abstraction distincts :
La prsentation, encore appele IHM permet l'interaction de l'application
avec l'utilisateur. Cette couche gre les saisies au clavier, la souris et la
prsentation des informations l'cran. Dans la mesure du possible, elle
doit tre conviviale et ergonomique.
La logique applicative, les traitements, dcrivant les travaux raliser par
l'application. Ils peuvent tre dcoups en deux familles :
Les traitements locaux, regroupant les contrles effectus au niveau du
dialogue avec l'IHM, visant essentiellement le contrle et l'aide la saisie,
Les traitements globaux, constituant l'application elle-mme. Cette
couche, appele Business Logic ou couche mtier, contient les rgles
internes qui rgissent une entreprise donne.
Les donnes, ou plus exactement l'accs aux donnes, regroupant
l'ensemble des mcanismes permettant la gestion des informations
stockes par l'application.
1
GENERALE
Ces trois niveaux peuvent tre imbriqus ou rpartis de diffrentes

manires entre plusieurs machines physiques.
Le dcoupage et la rpartition de ces niveaux permettent de distinguer les
architectures applicatives suivantes :
l'architecture 1-tiers ;
les architectures n-tiers.
L'architecture 1-tiers
2.1 Prsentation
Dans une application 1-tiers, les trois couches applicatives sont fortement
lies et s'excutent sur le mme ordinateur. On ne parle pas ici
d'architecture client-serveur, mais d'informatique centralise.
Dans un contexte multi-utilisateurs, on trouve les applications sur site
central : les utilisateurs se connectent aux applications excutes par le
serveur central (le mainframe) l'aide de terminaux passifs se comportant
en esclaves. C'est le serveur central qui prend en charge l'intgralit des
traitements, y compris l'affichage qui est simplement dport sur des
terminaux passifs.
Figure I-1 Architecture 1-tiers

2
GENERALE
2.2 Limitations
Les applications sur site central souffrent d'une interface utilisateur en
mode caractres et la cohabitation d'applications micro exploitant des
donnes communes n'est pas fiable au del d'un certain nombre
d'utilisateurs.
Il a donc fallu trouver une solution conciliant les avantages des deux
premires :
La fiabilit des solutions sur site central, qui grent les donnes de
faon centralise,
l'interface utilisateur moderne des applications sur micro-ordinateurs.
Pour obtenir cette synthse, il a fallu scinder les applications en plusieurs

parties distinctes et cooprantes :
gestion centralise des donnes ;

gestion locale de l'interface utilisateur ;
Ainsi est n le concept du client-serveur;

3
3.1 Prsentation
Dans une architecture 2-tiers, encore appele client-serveur de premire
gnration ou client-serveur de donnes, le poste client se contente de
dlguer la gestion des donnes un service spcialis.
Ce type d'application permet de fournir l'utilisateur une interface riche,
tout en garantissant la cohrence des donnes, qui restent gres de
faon centralise.
La gestion des donnes est prise en charge par un SGBD centralis,
s'excutant le plus souvent sur un serveur ddi. Ce dernier est interrog
en utilisant un langage de requte qui, le plus souvent, est SQL.
GENERALE
Figure I-2 : Architecture 2-tiers
3.2 Avantages et inconvnients de l'architecture 2-tiers

Avantages
Larchitecture 2-tiers prsente de nombreux avantages :
elle permet l'utilisation d'une interface utilisateur riche ;

elle a permis l'appropriation des applications par l'utilisateur ;
elle a introduit la notion d'interoprabilit.
Inconvnients : Le client lourd

L'exprience a dmontr qu'il tait coteux et contraignant de vouloir faire
porter l'ensemble des traitements applicatifs par le poste client. On en
arrive aujourd'hui ce que l'on appelle le client lourd, ou fat client.
L'architecture client-serveur de premire gnration s'est heurte ce
constat l'heure des premiers bilans :
on ne peut pas soulager la charge du poste client, qui supporte la
grande majorit des traitements applicatif ;

le poste client est fortement sollicit, il devient de plus en plus
complexe et doit tre mis jour rgulirement pour rpondre aux
besoins des utilisateurs ;
4
GENERALE
la relation troite qui existe entre le programme client et l'organisation

de la partie serveur complique les volutions de cette dernire.
Pour rsoudre les limitations du client-serveur 2-tiers tout en conservant

ses avantages, on a cherch une architecture plus volue, facilitant les
forts dploiements moindre cot. La rponse est apporte par les
architectures distribues
4
4.1 Prsentation
Les limites de l'architecture 2-tiers proviennent en grande partie de la
nature du client utilis, la solution rsiderait donc dans l'utilisation d'un
poste client simple communicant avec le serveur par le biais d'un
protocole standard.
Dans ce but, l'architecture 3-tiers, encore appele client-serveur de
deuxime gnration ou client-serveur distribu, spare l'application en
trois niveaux de service distincts :
premier niveau : l'affichage et les traitements locaux (contrles de

saisie, mise en forme de donnes...) sont pris en charge par le poste
client ;
deuxime niveau : les traitements applicatifs globaux sont pris en
charge par le service applicatif ;

troisime niveau : les services de base de donnes sont pris en charge
par un SGBD.
Tous ces niveaux tant indpendants, ils peuvent tre implants sur des
machines diffrentes.
GENERALE
Figure I-3 : Architecture 3-tiers
4.2 Avantages et inconvnients de l'architecture 3-tiers

Avantages : Le client lger
Dans l'architecture 3-tiers, le poste client est communment appel client
lger ou Thin Client, par opposition au client lourd des architectures 2tiers. Il ne prend en charge que la prsentation de l'application avec,
ventuellement, une partie de logique applicative permettant une
vrification immdiate de la saisie et la mise en forme des donnes. Il est
souvent constitu d'un simple navigateur Internet.
Le poste client ne dispose d'aucune connaissance des traitements
applicatifs ou de la structure des donnes exploites. Les volutions de
l'application sont donc possibles sans ncessiter de modification de la
partie cliente.
Inconvnients
L'architecture 3-tiers a corrig les excs du client lourd en centralisant une
grande partie de la logique applicative sur un serveur HTTP. Le poste
client, qui ne prend sa charge que la prsentation et les contrles de
saisie, s'est trouv ainsi soulag et plus simple grer.
Par contre, le serveur HTTP se trouve souvent fortement sollicit et il est
difficile de rpartir la charge entre client et serveur.
GENERALE
Les contraintes semblent inverses par rapport celles rencontres avec

les architectures 2-tiers : le client est soulag, mais le serveur est
fortement sollicit.
Le juste quilibrage de la charge entre client et serveur semble atteint
avec la gnration suivante : les architectures n-tiers.
5
Les architectures N-tiers
5.1 Prsentation
L'architecture N-tiers a t pense pour pallier aux limitations des
architectures 3-tiers et concevoir des applications puissantes et simples
maintenir.
L'appellation N-tiers pourrait faire penser que cette architecture met en
oeuvre un nombre indtermin de niveaux d'application, alors que ces
derniers sont au maximum trois (pour rappel : la couche IHM la couche
applicative la couche daccs aux donnes).
En fait, l'architecture N-tiers qualifie la distribution de la couche
applicative entre de multiples services et non la multiplication des
couches.
Les composants mtiers'' de la couche applicative sont spcialiss et
indpendants. Ils communiquent entre eux et peuvent donc cooprer en
tant implants sur des machines distinctes.
Ce
type
d'architecture
permet
de
distribuer
librement
la
logique
applicative, ce qui facilite la rpartition de la charge entre tous les

niveaux.
GENERALE
Figure I-4 : Architecture N-tiers
5.2 Avantages et inconvnients
de l'architecture N-
tiers :
Avantages :
Thoriquement, ce type d'architecture supprime tous les inconvnient
s des architectures prcdentes :
Elle permet l'utilisation d'interfaces utilisateurs riches ;

Elle spare nettement tous les niveaux de l'application ;
Elle offre de grandes capacits d'extension ;
facilite la gestion des sessions.
Inconvnient :
Ncessite des ressources matrielles importantes

Larchitecture Modle-Vue- Contrleur (MVC) :
6.1 Prsentation
L'architecture Modle/Vue/Contrleur (MVC) est une faon d'organiser une
application. Elle consiste distinguer trois entits distinctes qui sont,
le modle, la vue et le contrleur ayant chacun un rle prcis dans
l'application.
Dans l'architecture MVC, les rles des trois entits sont les suivants.
8
GENERALE
La vue :
Ce qu'on nomme la vue est en fait une IHM. Celle-ci est en fait ce qu'a
l'utilisateur sous les yeux. La vue peut donc tre :
Une
C#...) ;
une page web
Un terminal Linux ou une console Windows...
application
graphique swing, awt, swt pour
Java
(Form pour
Le modle :
Il dcrit les donnes manipules par l'application .Le modle reprsente le
cur de l'application : traitements des donnes, interactions avec la base
de donnes, etc.. Il regroupe la gestion de ces donnes et est responsable
de leur intgrit. Le modle comporte des mthodes standards pour
mettre jour ces donnes (insertion, suppression, changement de valeur).
Le contrleur
Contrleur: son rle est de traiter les vnements en provenance de
linterface utilisateur et les transmet au modle pour le faire voluer ou
la vue pour modifier son aspect visuel (pas de modification des donnes
affiches mais des modifications de prsentation (couleur de fond,
affichage ou non de la lgende dun graphique, )). Le contrleur connat
la (les) vues quil contrle ainsi que le modle.
Le contrleur pourra
appeler des mthodes du modle pour ragir des vnements (demande

dajout dun client par exemple), il pourra faire modifier la vue son
aspect visuel.
Il pourra aussi instancier
de nouvelles
vues (demande
daffichage de telle ou telle info). Pour faire cela, le contrleur sera

l'coute d'vnements survenant sur les vues.
Interactions
Les diffrentes interactions entre le modle, la vue et le contrleur sont
rsumes par le schma de la figure suivante.
GENERALE
Figure I-5 : Schma explicatif du modle MVC
6.2 Avantages et inconvnients

Un avantage apport par ce modle est la clart de l'architecture qu'il
impose. Cela simplifie la tche du dveloppeur qui tenterait d'effectuer
une maintenance ou une amlioration sur le projet. En
effet, la
modification des traitements ne change en rien la vue. Par exemple on

peut passer d'une base
de donnes de type SQL XML en changeant
simplement les traitements d'interaction avec la base, et les vues ne s'en

trouvent pas affectes.
Le MVC montre ses limites dans le cadre des applications utilisant les
technologies du web,
bties partir de serveurs d'applications. Des
couches supplmentaires sont alors introduites ainsi que les mcanismes

de dpendance.
6.3 Difrence avec larchitecture 3-tiers

L'architecture 3-tiers est un modle en couches, c'est--dire, que chaque
couche communique seulement avec ses couches adjacentes (suprieures
10
GENERALE
et infrieures) et
les couches suprieures contrlent les couches
infrieures, c'est--dire, que les couches suprieures sont toujours sources

d'interaction (clients) alors que les couches infrieures ne font que
rpondre des requtes (serveurs).
Dans le modle MVC, il est gnralement admis que la vue puisse
consulter directement le modle (lecture) sans passer par le contrleur.
Par contre, elle doit ncessairement passer par le contrleur pour effectuer
une modification (criture). Le contrleur peut envoyer des requtes
toutes les vues de manire ce qu'elles se mettent jour.
Dans l'architecture 3-tiers, si une vue modifie les donnes, toutes les vues
concernes par la modification doivent tre mises jour, d'o l'utilit de
l'utilisation du MVC au niveau de la couche de prsentation.
De
plus,La
diffrence
fondamentale
se
trouve
dans
le
fait
que
l'architecture 3-tiers spare la couche Buisness logic (couche mtier) de la

couche Data access (accsaux donnes).Pour qu'une application MVC soit
une vraie application 3-tiers il faut lui ajouter une couche d'abstraction
d'accs aux donnes.
Inversement pour qu'une application 3-tiers respecte MVC il faut lui ajouter
une couche de contrle entreUser interface et Buisness logic.
Loin d'tre antagonistes, ces deux pratiques se combinent et sont la
fondation de la plupart des frameworks de cration d'applications Web.
En rsum :
Ce chapitre a prsent brivement les architectures 1-tiers, 2-tiers, 3-tiers,
N-tiers et MVC, ainsi que
leurs avantages et
inconvnients. Dans les
chapitres suivant on tudiera la distinction entre les aspects prsentation,

mtier, et donnes en utilisant la technologie java EE.
11
CHAPITRE II : PRESENTATION DE LA PLATEFORME JAVA EE
Chapitre II
Prsentation de la plateforme
Java EE
OBJECTIFS
Comprendre la plateforme java EE ;

Connatre les diffrentes couches dune application java EE multi-
tiers et leur distribution sur les machines ;

Savoir les diffrents APIs de la plateforme qui composent chaque
couche ;
Connaitre les diffrents lments qui constituent lenvironnement
dexcution des applications java EE multi-tiers ;

Connaitre le mode dassemblage et de dploiement des applications
java EE multi-tiers.
La prsentation de Java EE
J2EE est l'acronyme de Java 2 Entreprise Edition. Cette dition propos par
Sun Microsystems, dsormais Oracle Corporation,
est ddie la
ralisation d'applications pour entreprises.

J2EE est bas sur J2SE (Java 2 Standard Edition) qui contient les API de
base de Java. Depuis sa version 5, J2EE est renomm Java EE (Enterprise
Edition).
La plate-forme J2EE offre un environnement de dveloppement et
dploiement en langage Java pour les applications distribues plusieurs
niveaux.
Elle est compose de deux parties essentielles :
un ensemble de spcifications pour une infrastructure dans laquelle

s'excutent les composants crits en Java : un tel environnement se
nomme serveur d'application ;

un ensemble d'API qui peut tre obtenu et utilis sparment.
L'utilisation
de
J2EE
pour
dvelopper
et
excuter
une application
propose plusieurs avantages :
une architecture d'application base sur les composants qui permet un

dcoupage de l'application et donc une sparation des rles lors du
dveloppement ;
la possibilit de s'interfacer avec le systme d'information existant
grce de nombreuses API : JDBC, JNDI, JMS, JCA ...

la possibilit de choisir les outils de dveloppement et le ou les
serveurs d'applications utiliss qu'ils soient commerciaux ou libres
Les API de Java EE
Une API (Application Programming Interface) est une interface de

programmation. Cest un ensemble de fonctions, procdures ou classes
mises disposition des programmes informatiques par une bibliothque
logicielle, un systme dexploitation ou un service.
Les API de Java EE peuvent se rpartir en trois grandes catgories :
Les composants. On distingue habituellement deux familles de

composants :
o Les composants web : Servlets et JSP (Java Server Pages). Il s'agit
de la partie Charge de l'interface avec l'utilisateur (on parle de
logique de prsentation) ;
o Les composants mtier : EJB (Enterprise Java Beans). Il s'agit de
composants Spcifiques chargs des traitements des donnes
propres un secteur d'activit (on parle de logique mtier ou de
logique applicative) et de l'interfaage avec les bases de
donnes.
Les services, pouvant tre classs par catgories :
o Les services d'infrastructures : il en existe un grand nombre,
dfinis ci-dessous :
JDBC (Java DataBase Connectivity) est une API d'accs aux bases
de donnes relationnelles ;
JNDI (Java Naming and Directory Interface) est une API d'accs
aux services de nommage et aux annuaires d'entreprises tels que
DNS, LDAP, etc..;

JTA/JTS (Java Transaction API/Java Transaction Services) est une
API de gestion des transactions ;

J2EE Connector est une API qui facilite les connexions aux plates-
formes autres que J2EE ;

JMX (Java Management
Extension)
fournit
des
extensions
permettant de dvelopper des applications web de supervision

d'applications.
o Les services de communication :
- JAAS (Java Authentication and Authorization Service) est une API
-
de gestion de l'authentification et des droits d'accs ;

JavaMail est une API permettant l'envoi de courrier lectronique. ;
JMS (Java Message Service) Permet 2 composants d'applications
J2EE de crer, envoyer et recevoir des messages ;

RMI-IIOP est une API permettant la communication synchrone
entre objets.
Architectures en Java EE
J2EE permet une grande flexibilit dans le choix de l'architecture de

l'application en combinant les diffrents composants. Ce choix dpend des
besoins auxquels doit rpondre l'application mais aussi des comptences
dans les diffrentes API de J2EE.
D'aprs le schma ci-aprs, la spcification Java EE dfinit les composants
suivants :
Les composants Clients (ou tier Client) s'excutent sur la machine des
utilisateurs ;
Les composants Web(ou tiersWeb) s'excutent sur le serveur J2EE ;
Les composants mtier ou ( tier Mtier) s'excutent sur le serveur Java
EE ;
La partie stockage des donnes, nomme tiers Enterprise Information
System (EIS), s'excute sur le serveur de base de donnes.
Figure II-6 Architecture Java EE standard

Une application Java EE multi-tiers correspond un ensemble de
couches. Elle est distribue de manire physique sur trois machines :
La machine des clients ;

Le serveur d'applications Java EE ;
Le serveur de base de donnes ou de stockages.
3.1 Les composants clients ou tiers Client

La plate-forme Java EE propose trois types de clients : les clients Web, les
Applets et les applications clientes riches type Java SE.
3.1.1 Les clients Web

Un client Web consiste en des pages Web de diffrents types (HTML,
XHTML, XML, JavaScript ou autres) gnres partir de composants
excuts ct serveur dans un conteneur Web.
Un client Web se compose de deux parties: des pages web de diffrents

types (HTML, XML, etc) gnres partir de composants Web excuts
ct serveur, et d'un navigateur Web, ce qui permet dafficher les pages
reues du serveur. Un client Web est parfois appel un client lger.
3.1.2 Les clients Applets

Une page Web reu de la couche web peut inclure une applet intgre.
Une applet est une petite application cliente crite en langage de
programmation Java qui s'excute dans la machine virtuelle Java installe
dans le navigateur. Cependant cette technique est plus contraignante
maintenir, requiert des accs et des droits pour la scurit et ncessite un
plug-in pour les navigateurs. Les clients Web sont donc prfrables pour la
cration du tiers Client.
3.1.3 Les applications clientes

Une application de type client est un logiciel riche, qui s'excute sur la
machine du client et fournit un ensemble de services aux utilisateurs par
l'intermdiaire
d'une
interface
graphique
volue
encore
appele
Graphical User Interface (GUI).

Ces applications riches sont dveloppes avec les composants SWING en
gnral, excutes Application Client Container (ACC).
Figure II-7 : Tiers client, Tiers web et Tiers mtier
La figure ci-dessus montre les diffrents types de clients utiliss dans une
plate-forme Java EE. Les clients riches de type application communiquent
directement avec le tiers Mtier alors que les clients de type navigateur
Internet communiquent travers le tiers Web par l'intermdiaire de pages
excutes sur le serveur et gnres par des Servlets, JSP ou JSF.
3.2 Les composants Web ou tiers Web

Les composants Web Java EE sont des Servlets et/ou des pages web
( JavaServer Pages et/ou des JavaServer Faces). Les Servlets sont des
classes Java, capables d'intercepter et de grer les requtes du protocole
HTTP. Les pages JSP sont des documents textuels excuts comme des
Servlets apportant une solution simplifie pour la programmation de pages
Web. La technologie JavaServer Faces est construite partir de Servlets et
fournit un framework de dveloppement pour acclrer la cration
d'applications Web.
3.3 Les composants mtier ou tiers Mtier

Les composants mtier ou tiers Mtier reprsentent la couche business,
avec les donnes du systme, et sont de deux types :
Les entits beans (entity bean ou bean entity) peuvent tre excutes par
un conteneur lger (pas forcment un serveur Java EE)
Les Enterprise JavaBeans offrent des possibilits plus riches comme la
gestion des transactions, les accs directs par clients riches ou encore la
gestion automatique des sessions utilisateur, mais sont excuts sur un
conteneur lourd, c'est--dire compatible Java EE.
Figure II-8 : Tiers Web et Tiers Mtier Java EE
3.4 Enterprise Information System Tier

La partie stockage des donnes, nomme Enterprise Information System
(EIS) Tier est directement lie au tiers Mtier et correspond dans la
majorit des cas, aux systmes de gestion de bases de donnes (Derby,
MySQL, PostgreSQL, Oracle ou autres) ou n'importe quel systme de
stockage volu.
4
Les conteneurs Java EE
Les serveurs Java EE proposent plusieurs types de conteneurs (containers)

pour chaque type de composant. Chaque conteneur a un rle bien dfini et
offre un ensemble de services pour les dveloppeurs.
Les conteneurs assurent la gestion du cycle de vie des composants qui
s'excutent en eux et fournissent des services qui peuvent tre utiliss
par les applications lors de leur excution.
Une application Java EE de type Web ncessite un conteneur Web pour son
excution alors quune application utilisant les EJB ncessite un conteneur
EJB pour son excution. Chaque conteneur propose un ensemble de
services avec ses avantages et ses contraintes.
Les serveurs dapplications peuvent fournir un conteneur web uniquement
(exemple : Tomcat) ou un conteneur d'EJB uniquement (exemple : JBoss,
Jonas, ...) ou les deux (exemple : Websphere, Weblogic, ...).
Figure II-9 : Serveur Java EE et conteneurs

Le serveur Java EE est compos de deux types de conteneurs :
Web Container ou conteneur Web, capable dexcuter des pages JSP,

Servlets et programmes JSF (implmentation JSF ncessaire). Ces
composants sexcutent avec le conteneur serveur Java EE. Ce
conteneur supporte les protocoles HTTP et HTTPS et dialogue avec
diffrents types de clients (navigateur, application) ;
EJB Container ou conteneur EJB, responsable de la couche mtier et de

lexcution des EJB. Ce conteneur fournit le mcanisme de gestion des
EJB et la gestion de leur cycle de vie ;
L'assemblage et le dploiement d'applications J2EE
Pour dployer une application dans un conteneur, il faut lui fournir deux
lments :
l'application
avec
tous
les
composants
(classes
compiles,
ressources ...) regroupe dans une archive ou module. Chaque
conteneur possde son propre format d'archive.

un fichier descripteur de dploiement contenu dans le module qui
prcise au conteneur des options pour excuter l'application
Il existe diffrents types d'archives :

Descript
Archive
module
Contenu
Extensi eur
on
de
dploie
ment
application
client
Regroupe les ressources ncessaires
applicatio
leur excution (classes, bibliothques, jar
n-
images, ...)
client.xml
Regroupe les servlets et les JSP ainsi

Web
que les ressources ncessaires leur

excution (classes, bibliothques de
war
web.xml
balises, images, ...)

EJB
Regroupe les EJB et leurs composants

(classes)
jar
ejbjar.xml
Tableau II-1 : Les difrents types d'archives
Une application J2EE peut regrouper diffrents modules : modules web,
modules EJB ... Chacun de ces modules possde son propre mode de
packaging. J2EE propose de regrouper ces diffrents modules dans un
module unique sous la forme d'un fichier EAR (Entreprise Archive).
Le format de cette archive est trs semblable celui des autres archives :
un contenu : les diffrents modules qui composent l'application
(module web, EJB, fichier RAR, ...) ;

un fichier descripteur de dploiement nomm application.xml.
En rsum
Ce chapitre a donn un aperu sur la plateforme JavaEE et les diffrentes
API qui la composent, il a dcrit les diffrents lments qui composent
l'environnement d'excution des applications JavaEE et leurs modes
d'assemblage et de dploiement. Dans le chapitre qui suit nous allons
dcouvrir les servlets et les jsp qui seront utiliss pour implmenter le
modle MVC.
Chapitre III : Introduction aux Servlets et pages JSP
Chapitre III
Introduction aux Servlets et
pages JSP
OBJECTIFS
Comprendre le cycle de vie dune servlet ;

Savoir programmer une servlet ;
Comprendre le cycle de vie dune jsp ;
Savoir programmer une jsp.
Introduction aux Servlets
1.1 Quest-ce qu'une servlet

Une Servlet est un composant web conu sous la forme dune classe java
qui existe au sein dune application web et dont la mise en uvre est gr
par un conteneur web (exemple Tomcat ).
une Servlet interagit avec un client web par lintermdiaire du protocole
http, via un mcanisme de requte/rponse.
Une servlet s'excute dynamiquement sur le serveur web et permet
l'extension des fonctions de ce dernier. Typiquement : accs des bases
de donnes, transactions d'e-commerce, etc. Une servlet peut tre
charge automatiquement lors du dmarrage du serveur web ou lors de la
premire requte du client. Une fois charges, les servlets restent actives
dans l'attente d'autres requtes du client.
1.2 Cycle de vie dune servlet

Une servlet est un objet qui peut tre manipul par le conteneur via
linterface suivante:
Figure III-10 : Linterface Servlet

Lorsque le conteneur reoit une requte, il la transmet au servlet qui
correspond lURL pour que la requte soit traite effectivement.
Le cycles de vie dune servlet se rsume comme suit :
1. Chargement de la classe
2. Instanciation du servlet (constructeur par dfaut)
3. Appel de init()
4. Appel(s) de service()(1 thread par requte)
5. Appel de destroy()
Figure III-11 : cycle de vie dune Servlet
Les servlets ne sont pas des objets instancis chaque requte HTTP,
Il n'existe qu'une et une seule instance d'une servlet dans le
conteneur.
Ce qu'il se passe c'est que pour chaque requte HTTP, un thread est
cr pour satisfaire la requte et proposer une rponse :
Si on reprend la vie de notre servlet partant du principe que la servlet est

initialise, voici ce que a donnerait :
La servlet reoit une requte HTTP ;

Elle cre les deux objets :
o Un objet HttpServletRequest contenant les informations de la
requte HTTP ;
o Un objet HttpServletResponse, servant fournir la rponse attendue.
Une fois ceci fait, il va utiliser la servlet correspondant la requte

demande
et
va
invoquer
la
mthode
adquate,
ici
doGet(HttpServletRequest request, HttpServletResponse response)
Elle alloue un nouveau thread cette requte ;

Elle invoque la mthode service (HttpServletRequest
request,
HttpServletResponse response) en passant les deux objets en

paramtres ;
Ladite mthode invoque la bonne mthode de traitement (doGet,

doPost, doHead, doDelete, doPut,...) ; il y existe une mthode pour
chaque type de requte HTTP, les plus utilises sont
o GET : mthode doGet() , c' est la mthode la plus courante pour
demander une ressource. Une requte GET est sans effet sur la
ressource, il doit tre possible de rpter la requte sans effet ;
o POST : mthode doPost() , cette mthode doit tre utilise
lorsqu'une requte modifie la ressource ;
Figure III-12 : Type de requte HTTP

Le schma ci-dessous explique la diffrence entre les requtes de type
Get et Post:
Le traitement se fait ;
La rponse est renvoye au client.
Voici un schma illustrant le cycle de vie dune servlet (partant du principe

que la servlet est initialise)
Figure III-13 : cycle de vie dtaill dune servlet

A chaque fois que le conteneur reoit une requte HTTP, il cre les objets
requte et rponse puis, il cre un thread afin d'invoquer la mthode
service (HttpServletRequest req, HttpServletREsponse rep)
Voici petit schma rsumant ce qu'il se passe lorsque deux personnes
envoient une requte vers la mme ressource sur le serveur :
Figure III-14 : traitement de deux requtes par le serveur
1.3 Radiographie dune premire servlet

Nous examinons l'exemple ci-dessus :
La servlet Test.java
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class Test extends HttpServlet {
public
void
doGet(HttpServletRequest
request,
response) throws IOException,ServletException{

response.setContentType("text/html");
PrintWriter out = response.getWriter();
out.println("<h1> Hello World</h1>");
}
HttpServletResponse
}
Le fichier web.xml est le suivant :
<web-app>
<servlet>
<servlet-class> Test </servlet-class>
<servlet-name>firstServlet</servlet-name>
</servlet>
<servlet-mapping>
<servlet-name>firstServlet</servlet-name>
<url-pattern>/Serv1 /</url-pattern>
</servlet-mapping>
</web-app>
La servlet :
On notera les points suivants :
la servlet HTTP hrite de la classe abstraite HttpServlet ;

La mthode dclare dans notre servlet contient le nom du type de
requte http envoye : requte de type GET - mthode doGet.

la mthode doGet de notre servlet prend deux objets en paramtres et
ceux-ci ont des noms qui ressemblent beaucoup requte HTTP et
rponse HTTP.
Ensuite, le contenu de la servlet est trs simple :
o response.setContentType("text/html") : dfinit le type de rponse,
ici, on retourne une page HTML ;
o PrintWriter out = response.getWriter() : on rcupre un objet
permettant d'crire dans la future page HTML ;
o out.println("....") : crit dans la page.
Le fichier descripteur web.xml

Chaque application sur le serveur a une structure et cette structure est
dfinie dans le fichier web.xml. Il existe Un seul fichier web.xml par
application.Ce fichier est utilis par le conteneur pour faire une relation
entre une requte HTTP et une servlet (mapping des servlets).
On dit aussi que le fichier sert dfinir le contexte de l application. , ceci
est tout simplement une sorte d'annuaire pour Tomcat : la dfinition des
applications sur le serveur ainsi que la structure de celles-ci.
On note les ponts suivants :
Le contenu est englob par une balise <web-app> et </web-app>

La servlet est tout d'abord dfinie dans l'application via l'lment
<servlet></servlet>. Deux lments dans ce dernier :

o <servlet-class></servlet-class> : code rel de la servlet ;
o <servlet-name></servlet-name> : nom interne l'application.
Ensuite, on trouve <servlet-mapping></servlet-mapping> contenant
les informations de paramtrage client :
o <servlet-name></servlet-name> : nom interne l'application ;
o <url-pattern></url-pattern> : nom qui apparat ct client.
Voici un petit rcapitulatif de ce qu'il se passe.
1/
Tomcat,
son
lancement,
prend
connaissance
des
donnes
mentionnes dans le fichier de configuration.

2/ Il reoit une requte HTTP demandant "/", dans notre cas bien sr.
3/ Il sait que ce nom est associ au nom de servlet "FirstServlet" qui, lui,
correspond la servlet com.servlet.test.DoIt.
4/ Celle-ci est instancie et la mthode adquate est invoque.
5/ La rponse est rcupre par Tomcat qui renvoie cette dernire au
client.
Voici un petit schma rcapitulatif (les instanciations des objets requtes
et rponses sont tacites) :
Figure III-15 : recherche de la Ssevlet dans le fichier web.xml
Introduction aux JSP
2.1 Pourquoi une JSP?

La technologie servlet est trop difficile d'accs et ne convient pas la
gnration du code de prsentation : crire une page web en langage Java
est horriblement pnible. Il est ncessaire de disposer d'une technologie
qui joue le rle de simplification de l'API servlet : les pages JSP sont en
quelque sorte une abstraction "haut niveau" de la technologie servlet.
2.2 Cest quoi une JSP?

Les pages JSP sont une des technologies de la plate-forme Java EE les plus
puissantes, simples utiliser et mettre en place.
Elles se prsentent sous la forme dune page HTML dans laquelle on peut
ajouter du code Java (mme principe quavec PHP).
Pour que le serveur puisse diffrencier le code HTML du code JSP, il est
ncessaire dentourer les instructions JSP par des lments de script
spcifiques, appels tiquettes ou encore balises JSP.
Ecrire un script JSP demande donc dacqurir une bonne connaissance du
code HTML et dapprendre programmer en Java.
Exemple dune portion de page JSP :

<H3>Aujourdhui, nous sommes le:</h3>
<I> <%= (new java.util.Date()) %> </I>
IL existe deux syntaxes pour les Jsps :
Standard (JSP 1.2)
XML (JSP 2.0)
On ne peut pas mixer les deux versions dans une mme page. Il faut
utiliser XML pou la page entire si on utilise la deuxime syntaxe.
2.3 Cycle de vie d'une JSP

les
JSP
ont
un
cycle
de
vie
un
peu
plus
compliqu
que
les
servlets..Cependant, aussi complexe soit ce cycle de vie, toutes nos JSP

sortiront de leurs chrysalides afin de se transformer en servlets et tre
utilises par le conteneur.
Figure III-16 : CorrespondanceJSP/Servlet

Exemple : CorrespondanceJSP/Servlet
JSP dorigine
<h1>Time on server</h1>
<p> <%= new java.util.Date() %></p>
<% baz(); %>
<%! private int accessCount = 0; %>
Servlet gnr parTomcat
public final class XXX_jsp

extends org.apache.jasper.runtime.HttpJspBase
implements org.apache.jasper.runtime.JspSourceDependent{
public void _jspService(HttpServletRequest request,
HttpServletResponse response)
throws java.io.IOException, ServletException{
JspWriter out = response.getWriter();
out.write("<h1>Time on server</h1>\r\n");
out.write("<p>");
out.print( new java.util.Date() );
out.write("</p>\r\n");
baz();
}
private int accessCount = 0 ;
}
Le e cycle
de vie dune jsp ressemble trs fortement celui de la vie
d'une servlet standard. Le schma suivant reprsente le cycle de vie d'une

JSP :
Figure III-17 : Cycle de vie dune JSP

Examinons un peu ce schma :
1. Quelqu'un appelle une page JSP, via une URL ou en cliquant sur un
lien.
2. La requte est dirige vers le serveur de notre application.
3. Tomcat prend en charge la requte et s'aperoit qu'une page JSP est
demande.
4. Il trouve ladite page et la convertit en fichier source java, en servlet
pour tre exact.
5. Ladite servlet est compile et mise en mmoire, enfin prte
l'utilisation.
6. La mthode _jspInit() est invoque.
7. Tomcat cre un nouveau thread pour traiter la demande et invoque
dans ce thread la mthode _jspService().
8. Le rsultat, une page entirement constitue de code HTML, est
retourne par Tomcat au demandeur de dpart, le client
2.4 Radiographie dun Script JSP

Considrons un exemple de code source dun premier programme JSP qui
affiche la liste suivante des ralisateurs et des films : L. Besson, le grand
bleu; F. Truffaut, Jules et Jim; J.-J. Annaud, la guerre du feu; J,-J. Beinex,
372 le matin.
Cette liste doit safficher sous la forme dun tableau deux colonnes, la
premire pour les ralisateurs, la seconde pour les films raliss par ces
auteurs.

<% @ page contentType="test/html" %>
<%-- dclaration de variables -- %>
<%!
String lFilm [] = {"le grand bleu", "Jules et Jim", "La guerre du feu", "372 le
matin"};
String lRealisateur [] = {"L. Besson", "F. Truffaut", "J.-J. Annaud", "J.-J. Beineix"
};
String lAffiche="";
int i;
%>
<body>
<%
lAffiche = "<table border=1>";
lAffcihe+= "<TR><TH> +Ralisateur </TH><TH>Film</TH></TR>";
for (i=0; i< 4; i++)

{ lAffcihe+= "<TR><TD>"+lRealisateur[i]+"</TD>";
lAffcihe+= "<TD>"+lFilm[i]+"</TD></TR>";
}
lAffcihe+= "</table>";
%>
<%= lAffiche %>
</body></html>
Un script JSP contient :
Des balises HTML: <html>, <head>, <title>, <body>, </html>,

</head>, </title>, </body>, etc;
Des Balises JSP :
o Les balises de commentaire ;
o Les balises de dclaration ;
o Les balises de scriptlet ;
o Les balises dexpression ;
o Les balises de directives.
Des Variables Prdfinis.
2.5 Les Balises JSP

2.5.1 Les balises de commentaire :
Tout comme dans les langages Java et HTML, il est possible d'crire des
commentaires dans le code de vos pages JSP. Ils doivent tre compris
entre les balises <%-- et --%>. Ils sont uniquement destins au(x)
dveloppeur(s), et ne sont donc pas visibles par l'utilisateur final dans la
page HTML gnre :
Exemple :
<%-- dclaration de variables -- %>
2.5.2 Les balises de dclaration:

Format :
<%!JavaCode%>
Syntaxe XML :
<jsp:declaration>Code Java</jsp:declaration>
Cette balise vous permet de dclarer une variable l'intrieur d'une JSP.
Cette dclaration se fait laide des balises <%! . %>. Il est possible
d'effectuer plusieurs dclarations au sein d'un mme bloc.
Exemple :
<%!
String lFilm [] = { "le grand bleu", "Jules et Jim", "La guerre du feu", "372
le matin" };
String lRealisateur [] = {"L. Besson", "F. Truffaut", "J.-J. Annaud", "J.-J.
Beineix" };
String lAffiche="";
int i;
%>
2.5.3 Les balises de scriptlets:

Format
<%CodeJava%>
Syntaxe XML :
<jsp:scriptlet>Code Java</jsp:scriptlet>
Derrire ce mot trange, un mlange atroce entre "script" et "servlet", se

cache simplement du code Java. Elle sert en effet inclure du code Java au
sein des pages HTML
Elle permet dinsrer lintrieur dune page HTML toutes les instructions
de type dclaration, test, boucle, et affichage dcrites par le langage Java.
Exemple :
<%
lAffiche = "<table border=1>";
lAffcihe+= "<TR><TH> +Ralisateur </TH><TH>Film</TH></TR>";
for (i=0; i< 4; i++)
{ lAffcihe+= "<TR><TD>"+lRealisateur[i]+"</TD>";
lAffcihe+= "<TD>"+lFilm[i]+"</TD></TR>";
}
lAffcihe+= "</table>";
%>
2.5.4 Les balises dexpression

Format
<%= . %>
Syntaxe XML :
<jsp:expression>Java Expression</jsp:expression>
La balise d'expression est en quelque sorte un raccourci de la scriptlet
suivante : <% out.println("Bip bip !"); %> Elle retourne simplement le
contenu d'une chane.
NB : Une balise dexpression ne contient jamais de point-virgule.
Exemple :
Dans lexemple prcdent la chane lAffiche contient les balises HTML ainsi
que les noms des ralisateurs et des films. Cette liste de mots est stockes
en mmoire mais nest pas encore affiche par le navigateur. En insrant
la chane lAffiche entre les balises <%= et %>, le contenu de la chane est
envoy au navigateur qui affiche un tableau.
2.5.5 Les balises de directive :

Format :
<%@ directive attribut="valeur" %>
Les directives JSP permettent :
d'importer un package ;
d'inclure d'autres pages JSP ;
d'inclure des bibliothques de balises (nous y reviendrons dans un
prochain chapitre) ;
de dfinir des proprits et informations relatives une page JSP.
Pour gnraliser, elles contrlent comment le conteneur de servlets va

grer votre JSP. Il en existe trois : taglib, page et include.
Elles sont toujours comprises entre les balises <%@ et %>, et hormis la
directive d'inclusion de page qui peut tre place n'importe o, elles sont
placer en tte de page JSP.
Directive taglib
Format :
<%@ taglib uri="maTagLib.tld" prefix="tagExemple" %>
Le code inclut une bibliothque personnalise nomme maTagLib
Directive page
Format
<%@ page import="paquetage.classe" %>
<%@ page import="paquetage.classe1,...,paquetage.classeN" %>
La directive page dfinit des informations relatives la page JSP. Voici par
exemple comment importer des classes Java :
<%@ page import="java.util.*, java.net.*" %>
D'autres options sont utilisables via cette balise page, comme le
contentType ou l'activation de la session.
<%@ page contentType="text/plain" %>
<%@ page session="true|false " %>
Directive include
Format
<%@ include file="chemin relatif du fichier" %>
En pratique, il est trs courant de dcouper littralement une page web en
plusieurs fragments, qui sont ensuite rassembls dans la page finale
destination de l'utilisateur. Cela permet notamment de pouvoir rutiliser
certains blocs dans plusieurs vues diffrentes
Pour permettre un tel dcoupage, la Directive include permet dinclure le
contenu d'un autre fichier dans le fichier courant.
Exemple
<%@ include file="/toto.html" %>
2.6 Les variables prdfinis :

Quelques variables sont prdfinies dans une page JSP, et peuvent donc
tre utilises sans dclaration.
request :
contient
une
rfrence
sur
lobjet
de
type HttpServletRequest qui contient la requte cette page. Les en
ttes HTTP sont disponibles au travers de cet objet.

response : rfrence sur le flux sortant de la servlet. Une JSP ne
touche en gnral pas explicitement au flux sortant. Il est possible de
modifier len-tte HTTP via cet objet, y compris dans le corps de la
page.
out : Un Writer, utilis pour envoy des informations au client
Session : variable de type Httpession. On peut donc lui attacher des
objets, puisquune JSP est une servlet. Cette variable reprsente la
session dans laquelle se trouve la requte.

application : variable de type ServletContext, laquelle on peut
aussi attacher des objets. Cette variable modlise l'application web
dans laquelle on se trouve.
En rsum
Dans ce chapitre nous avons russi faire un simple servlet et une simple
jsp, et nous avons comprendre comment sont excuts. Dans le chapitre
suivant, nous allons voir que Les servlets ne servent pas crire du code
Java dans des pages web, et dmarrer avec des JSP pour des traitements
complexes nest pas pratique. En fait, la plateforme JEE implmente
le pattern MVC.
CHAPITRE IV : IMPLEMENTATION DE MVC
Chapitre IV
Implmentation de MVC
OBJECTIFS
Savoir faire la coopration entre servlet et jsp ;
Savoir envoyer et rcuprer des donnes issues du client ;
Savoir envoyer et rcuprer des donnes issues du serveur ;
Savoir utiliser les servlets et jsps pour implmenter le modle MVC.

MVC et Java EE
Avec la plate-forme JEE, nous allons devoir utiliser le pattern MVC. Nous
avons vu que le pattern MVC est compos de trois entits (Modle, Vue,
Contrleur)
Si nous appliquons le pattern MVC l'architecture JEE, a nous donne :
Dans le pattern MVC, il y a un objet qui a pour rle de rcuprer des

demandes, de les traiter et de retourner ce qu'on lui a demand : le
contrleur. En effet, nous avons fait en sorte que notre servlet crive
elle-mme du code HTML, mais dans la plupart des cas, les servlets
ont
pour
rle
de
rcuprer
les
requtes
client
et
d'agir
en
consquence
Le modle peut tre divers et vari, comme tout modle digne de ce
nom :un objet Java basique ;un objet Java devant faire appel une
base de donnes ;
La vue, elle, reste une page web contenant du code HTML, la
diffrence prs que celle-ci contiendra aussi du code Java : on appelle
ces pages web des Java Server Pages, ou JSP
Figure IV-18 : MVC et Java EE

Nous remarquerons que des flches de dpendance ont disparu. En effet,
nous allons voir que la vue est appele par le contrleur et reoit les
informations du modle via ce dernier.
2
Collaboration entre JSP et servlets : linterface requestdispatcher
Nous allons voir comment faire en sorte qu'une servlet puisse utiliser une
JSP afin de la fournir au client.
Figure IV-19 : Collaboration entre JSP et servlets

Pour
ce
faire,
nous
allons
appellerons InvokeJsp
import java.io.*;
crer
une
nouvelle
servlet
que
nous
public class InvokeJsp extends HttpServlet {

public
void
request,
HttpServletResponse
response)
throws IOException, ServletException{
RequestDispatcher dispatch =request.getRequestDispatcher("firstJsp.jsp");
dispatch.forward(request, response);
}
}
Le fichier web.xml :
<web-app>
<servlet>
<servlet-class> InvokeJsp</servlet-class>
<servlet-name>invoke</servlet-name>
</servlet>
<servlet-mapping>
<servlet-name>invoke</servlet-name>
<url-pattern>/invoke</url-pattern>
</servlet-mapping>
</web-app>
Pour
accder
cette
servlet,
il
suffit
daller
l'adresse
suivante : localhost:8080/Test/invoke nous aurons le contenu de notre JSP

mais cette fois, celui-ci nous a t fourni par notre servlet InvokeJsp. Il est
clair que ceci se faisait par le biais de ces deux lignes de code :
RequestDispatcher
dispatch
request.getRequestDispatcher("firstJsp.jsp");
dispatch.forward(request, response);
//en contract :
request.getRequestDispatcher("firstJsp.jsp").forward(request,response);
Un
objet
de
type RequestDispatcher est
obtenu
en
invoquant
la
mthode getRequestDispatcher(String) de la requte. Cet objet expose la

mthodes : forward() qui redirige la requte vers la ressource dsigne.
Cette mthode prend en paramtre la requte et la rponse courantes.
3
Transmission de donnes: les paramtres et les attributs
3.1 Difrence entre paramtres et attributs

Les paramtres de requte sont un concept appartenant au protocole
HTTP. Ils sont envoys par le client au serveur directement au sein de
l'URL, et donc sous forme de chanes de caractres.
Ce concept n'tant absolument pas spcifique la plate-forme Java EE
mais commun toutes les technologies web.
Les paramtres sont donc des donnes issues du Client
Les attributs de requte sont un concept appartenant au conteneur Java,
et sont donc crs ct serveur : c'est au sein du code de l'application que
l'on procde leur initialisation. Contrairement aux paramtres, ils ne sont
pas prsents directement dans la requte HTTP mais uniquement dans
l'objet Java qui l'enveloppe (l'objet HttpServletRequest), et peuvent
contenir n'importe quel type de donnes. Ils sont utiliss pour permettre
une servlet de communiquer avec d'autres servlets ou pages JSP.
Les attributs sont donc des donnes issues du Serveur
3.2 Transmission
des
attributs :
mthodes
setAttribute() et getAttribute()
Pour transmettre des variables de la servlet la jsp , le principe est trs
simple ; Il suffit d'appeler la mthode setAttribute() de l'objet requte pour
crer un attribut dans une requte depuis une servlet, Cette mthode
prend en paramtre le nom que l'on souhaite donner l'attribut suivi de
l'objet lui-mme, et il suffit d'appeler la mthode getAttribute() pour en
rcuprer un depuis une JSP
Exemple :
Dans lexemple suivant on rcupre bien un objet nomm test.
Public void doGet( HttpServletRequest request, HttpServletResponse
response ) throws ServletException, IOException{
String message = "Transmission de variables : OK !";
request.setAttribute( "testAttribut", message );
request.getRequestDispatcher(" test.jsp" ).forward( request, response );
}
Code : test.jsp
<body>
<p>Ceci est une page gnre depuis une JSP. </p>
<p>
<%
String attribut = (String) request.getAttribute("testAttribut");
out.println( attribut );
%>
</p>
</body>
</html>
3.3 Transmission
des
paramtres :
mthode
getParameter()
Un url peut prendre plusieurs formes :
URL sans paramtres : /page.jsp

URL avec un paramtre : /page.jsp?auteur=mohamed
URL avec deux paramtres : /page.jsp?auteur=mohamed&livre=java
Pour rcuprer un paramtre il suffit de faire appel la mthode

getParameter() de l'objet requte, en lui passant comme argument le nom
du paramtre que l'on souhaite rcuprer
Exemple :
Code : URL
http://localhost:8080/test/toto?auteur=Coyote
Code : Java - Servlet
public
void
doGet(
HttpServletRequest
request,
HttpServletResponseresponse ) throws ServletException, IOException{

String paramAuteur = request.getParameter( "auteur" );
String message = "Transmission de variables : OK ! " + paramAuteur;
request.setAttribute( "testAttribut", message );
this.getServletContext().getRequestDispatcher(
).forward( request, response );
}
test.jsp
<html>
"test.jsp
<head>
<title>Test</title>
</head>
<body>
<p>Ceci est une page gnre depuis une JSP. </p>
<p>
<%
String attribut = (String) request.getAttribute("testAttribut");
out.println( attribut );
%>
</p>
</body>
</html>
4
Exemples dapplications du design pattern MVC :
Dans les exemples on utilisera les trois composantes de la plateforme

JEE :
4.1
Modle : objets Java ;

Vue : pages JSP ;
Contrleur : servlet.
Exemple1 :
Lobjectif est dafficher la liste des tudiants partir dune liste des
promos .
Figure IV-20 : Liste des promos
tape 1 : Le client rcupre un formulaire (index.html) pour passer une

requte avec paramtres (1, 2, puis 3)
Figure IV-21 : tape 1 du modle MVC
Formulaire : index.html
<html>
<head>
<title> AREL V6.0 </title>

</head>
<body>
<h1 align="center"> AREL: L'cole virtuelle de l'EISTI </h1>
<form method="GET" action="http://localhost:8080/MVC/SelectPromo">
Slectionner la promo afficher:
<select name="promo" size="1">
<option>ing1</option>
</select><input type="SUBMIT" />
</form>
</body>
</html>
tape 2 :
1. Le client envoie son formulaire (GET/POST avec paramtres)
2. Le conteneur transmet au servlet correspondant (le controller)
Controller : SelectPromo.java
import java.io.*;
public class SelectPromo extends javax.servlet.http.HttpServlet
implements javax.servlet.Servlet{
//...
protected void doGet(HttpServletRequest request,
throws ServletException, IOException{
String promoName = request.getParameter("promo");
//...
}
}
Configuration : web.xml
<web-app>
<display-name>MVC</display-name>
<servlet>
<description></description>
<servlet-name> SelectPro</servlet-name>
<servlet-class>SelectPromo</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name> SelectPro</servlet-name>
<url-pattern> /SelectPromo</url-pattern>
</servlet-mapping>
</web-app>
tape 3:
3. Le servlet controller interroge le model sur ing2
4. Le model retourne au controller le rsultat correspondant
Model : Promo.java
import ...;
public class Promo{
public List<String> getPromo(String promo){
List<String> promoList= new ArrayList<String>();
if(promo.equals("ing1")){
promoList.add("Donald Duck");
promoList.add("Minnie Mouse");
promoList.add("Pluto"); //...
} else if (promo.equals("ing2")){
promoList.add("Mickey Mouse");
promoList.add("Daisy Duck");
promoList.add("Goofy");//...
} else{ return null;}
return promoList;
}
}
tape 4 :
5. Le controller utilise les donnes du model pour sa rponse
6. Le controller transmet sa rponse la view (JSP)

Controller : SelectPromo.java
import java.io.*;
public class SelectPromo extends .HttpServlet
implements javax.servlet.Servlet{
//...
throws ServletException, IOException{

Promo promo = new Promo();
List<String> result = promo.getPromo(promoName);
request.setAttribute("promo", result); // // on ajoute lattribut promo la
requte
RequestDispatcher view =
request.getRequestDispatcher("result.jsp");
view.forward(request, response); // On forward la requte la JSP
}
}
tape 5 :
7. La JSP (view) traite la rponse transmise par le controller
8. La page HTML rsultante est reue par le client

View : result.jsp
<%@ page import="java.util.*" %>

<%@ page language= "java" contentType="text/html; charset=ISO-88591"
pageEncoding="ISO-8859-1" %>
<html>
<head>
<title>Result</title>
</head>
<body>
<%
List<String> promoList=(List<String>)request.getAttribute("promo");
Iterator it=promoList.iterator();
while(it.hasNext()){
out.print("<br />"+it.next());
}
%>
</body >
</html>
Liste des promos :
Figure IV-26 : Liste des promos
4.2 Exemple 2 :
Ici, nous avons un formulaire :
qui s'appelle "formulaire" ;

qui envoie les donnes des champs vers la page "/traitement" ;
et qui envoie ces informations via une requte de type "post".
Figure IV-27 : Formulaire HTML

En cliquant sur le bouton envoyer on obtient une page qui reoit les
informations et ressemble a :
Figure IV-28 : pages d'affichage des donnes de formulaire

Les sources dun formulaire
On a
utilis le couple servlet - JSP pour afficher le formulaire et pour
afficher les donnes de celui-ci. Voici les codes source de couple

d'affichage de formulaires :
Code: JSP-forms.jsp
<html>
<body>
<form name="firstForm" action="firstFormAction.do" method="post">
<h2>Formulaire HTML</h2>
<p >Nom : <input type="text" name="nom" /></p>
<p>Prenom : <input type="text" name="prenom" /></p>
<p><input type="submit" name="Valider" /></p>
</form>
</body>
</html>
Code : Java-Formulaire1.java
import java.io.*;
public class Formulaire1 extends HttpServlet {

public void doGet( HttpServletRequest request,
request.getRequestDispatcher("forms.jsp").forward(request,response);
}
}
Et le code source des pages d'affichage des donnes de formulaire :
Code: JSP-formResult.jsp
<html>
<body>
<div >
<p>Vous avez saisi : </p>
<ul>
<li>Nom : <%=request.getParameter("nom").toUpperCase() %></li>
<li>Prnom : <%=request.getParameter("prenom").toUpperCase()
%></li>
</ul>
<p>Pour retourner au formulaire, c'est <a href="form">par ici</a></p>
</div>
</body>
</html>
Code : Java-FormulaireAction .java
import java.io.*;
public class FormulaireAction extends HttpServlet {
public void doGet( HttpServletRequest request,
request.getRequestDispatcher("formResult.jsp").forward(request,
response);
}
public void doPost( HttpServletRequest request,
doGet(request, response);
}
}
Code : XML-web.xml
<web-app>
<servlet>
<servlet-class>com.servlet.test.Formulaire1</servlet-class>
<servlet-name>FirstForm</servlet-name>
</servlet>
<servlet>
<servlet-class>com.servlet.test.FormulaireAction</servlet-class>
<servlet-name>FormAction</servlet-name>
</servlet>
<servlet-mapping>
<servlet-name>FirstForm</servlet-name>
<url-pattern>/form</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>FormAction</servlet-name>
<url-pattern> firstFormAction.do</url-pattern>
</servlet-mapping>
</web-app>
En rsum
Ce chapitre a dcrit tape par tape limplmentation de pattern MVC en
imbriquant un servlet,une jsp et un simple objet java. Nous allons dans ce
qui suit utiliser les javaBean dans cette architecture.
CHAPITRE V : JAVABEANS ET SCOPE
Chapitre V
JavaBeans et Scope
OBJECTIFS
Savoir programmer des Javabeans ;

Savoir utiliser les Javabeans ;
Savoir implmenter le modle MVC avec les Servlets, Jsps et les
Javabeans.
JavaBeans
1.1 Cest quoi un Javabean

Souvent raccourci en "bean", un JavaBean dsigne tout simplement un
composant rutilisable. Il est construit selon certains standards, dfinis
dans les spcifications de la plate-forme et du langage Java eux-mmes :
un bean n'a donc rien de spcifique au Java EE.
Autrement dit, aucun concept nouveau n'intervient dans la cration d'un
bean,. Son utilisation ne requiert aucune bibliothque ; de mme, il
nexiste pas de superclasse dfinissant ce qu'est un bean, ni d'API.
Ainsi, tout objet conforme ces quelques rgles peut tre appel un bean.
Dcouvrons pour commencer quels sont les objectifs d'un bean, puis quels
sont ces standards d'criture dont je viens de vous parler. Enfin,
dcouvrons comment l'utiliser dans un projet
1.2 Structure dun Javabean

Les
JavaBeans
sont
des
classes
Java(POJO)
qui
suivent
certaines
conventions:
Doivent avoir un constructeur vide (zro paramtre) : On peut

satisfaire cette contrainte soit en dfinissant explicitement un tel
constructeur, soit en ne spcifiant aucun constructeur ;
Ne
rutilisable par ailleurs ;

La valeur des attributs doit tre manipule travers des accesseurs
(getters et setters) ;
Si une classe possde une mthode getTitle qui retourne un String, on
doivent
pas
avoir
dattributs
publics,une
bonne
pratique
dit que le bean possde une proprit String nomme title .

=> Les proprits Boolean utilisent isXXX la place de getXXX
1.3 Comment utiliser des beans ?

Une fois la classe cre, les beans sont des objets Java sur lesquels on
peut faire ces actions :
instanciation d'un nouveau bean

rcupration de la valeur d'une proprit du bean
affectation/modification de la valeur d'une proprit du bean
Pour faire cela dans une Servlet, a ne pose pas de problme particulier, le
bean est trait comme un objet Java standard.
Cependant, dans une JSP, l'utilisation des balises de scriptlets n'est pas
trs propre , on utilisera plutt l'une des manires suivantes :
balises
<jsp:setProperty>
utilisation des EL (JSP 2.0) (si le serveur le supporte) : ${...}
JSP
(JSP
1.2)
<jsp:useBean>,
<jsp:getProperty>,
=> Dans ce cours nous verrons la deuxime approche, la premire n'tant

aujourd'hui utilise que pour des raisons de compatibilits avec la version
du serveur install
2
Implmentation du MVC (avec les JavaBeans)
Figure V-29 : implmentation du MVC

1. Dfinir les beans pour reprsenter les donnes
2. Utiliser un servlet pour grer les requtes : Le servlet lit les paramtres
de requtes, vrifie les donnes manquantes ou malformes, appelle le
code mtier, etc.
3. Crer les beans : Le servlet invoque le code mtier (spcifique
lapplication) ou accde une base de donnes pour obtenir les rsultats.
Les rsultats sont dans les beans dfinis ltape 1
4. Placer le bean dans le bon scope (dfini dans la suite du cours) : Le
servlet appelle setAttribute sur la requte, la session, ou le servlet context
pour garder une rfrence sur les beans qui reprsentent le rsultat de la
requte
5. Transmettre la requte la JSP (forward) !) : Le servlet dtermine quelle
JSP est approprie la situation et utilise la mthode forward du
RequestDispatcher pour transfrer le contrle la JSP
6. Extraire les donnes des beans :
JSP 1.2: la JSP accde aux beans avec jsp:useBean et un scope

correspondant
au
choix
de
ltape
4.
La
JSP
utilise
ensuite
jsp:getProperty pour afficher les proprits des beans

JSP 2.0: la JSP utilise ${nameFromServlet.property} pour afficher les
proprits des beans
=> La JSP ne cre pas ou ne modifie pas les beans: cest la vue du MVC.
24Exemple
Modle
package model;
public class PersonneBean {
private String nom;
private String prenom;
public String getNom() {
return nom;
}
public void setNom(String nom) {
this.nom = nom;
}
public String getPrenom() {
return prenom;
}
public void setPrenom(String prenom) {
this.prenom = prenom;
}
}
Contrleur
import model.PersonneBean;
import java.io.*;
public class MyServlet extends HttpServlet {
protected void doGet(...)
{
String urlVue = "vue.jsp"; // URL de la vue appeler
String nom = request.getParameter("..."); // Rcupration du champs nom
//(par exemple via un formulaire)
String prenom = request.getParameter("..."); // Rcupration du champs
prenom
if(nom == null || nom.trim().equals("")) {
// Erreur : nom non saisi
}
else if(prenom == null || prenom.trim().equals("")) {
// Erreur : prenom non saisi
}
else // Cas sans erreur : on traite la requte, et cre les beans ncessaires
{
PersonneBean bean = new PersonneBean(); // Instanciation d'un bean
// de type PersonneBean
bean.setNom(nom); // Affectation de la proprit nom
bean.setPrenom(prenom); // Affectation de la proprit prenom
request.setAttribute("myBean", bean); // Attacher ce bean au
// scope de requte
}
// Forward la vue:
request.getRequestDispatcher(urlVue).forward(request, response);
}
}
En MVC, les beans sont cres/modifis par le contrleur, en fonction de la
requte du client et pas par la vue.
Vue
<%@ page language="java" contentType="text/html; %><html>
<head>
<title>Ma Vue</title>
</head>
<body>
Salut ${myBean.prenom} ${myBean.nom} !
</body>
</html>
En MVC, les beans sont uniquement consults par la vue, pour faire
son affichage ;
L'instruction ${...} est une EL (Expression Language), l'EL permet de

rcuprer l'information sur un bean (s'il a t mis pralablement dans
un
scope
par
une
servlet
avec
un
setAttribute):
{nomBean.property} ;
nomBean est celui dfini lors du setAttribute fait par la servlet ;
property est le nom de la proprit que l'on veut accder (attention
aux normes d'criture Java => respectez la casse).
Les Scopes dun bean
Un scope peut tre vu comme un conteneur de beans stock du ct du

serveur (le client ne peut avoir aucune connaissance sur ces beans), il
existe 4 types de Scopes, que l'on distingue par la dure de vie des beans
qui y sont stocks :
Requte : ce scope est cr chaque requte du client, les beans qu'il
contient sont dtruit lorsque le serveur envoy la rponse au client ;

Session : ce scope est cr automatiquement par le conteneur JEE
pour chaque client qui se connecte au serveur. Les beans qu'il contient
ne sont visible que par le client dtenant la session, et sont dtruit
lorsque la session du client se termine (gr par un timeout du ct du
serveur) ;
Application : ce scope est cr automatiquement au lancement du
projet JEE sur le serveur. Les beans qu'il contient sont partags par
tous les clients et ne sont dtruit que lors de l'arrt/rechargement du
projet JEE sur le serveur ;

Page : ce scope restreint la dure de vie des beans aux requtes POST
effectues sur une page donne, ds qu'on en sort, les beans sont
dtruit, ce scope n'est quasiment pas utilis
3.1 Partage de donnes sur requte

Servlet
ValueObject value = new ValueObject(...);
request.setAttribute("key", value);
RequestDispatcher
dispatcher
request.getRequestDispatcher("SomePage.jsp");
dispatcher.forward(request, response);
JSP 1.2
<jsp:useBean
id="key"
type="somePackage.ValueObject"
scope="request" />
<jsp:getProperty name="key" property="someProperty" />
JSP 2.0 (utilisation des EL)
${key.someProperty}
Exemple simple
Servlet
Customer
myCustomer=
new
Customer(request.getParameter("customerID"));
request.setAttribute("customer", myCustomer);
RequestDispatcher
dispatcher=
JSP 1.2
<jsp:useBean
id="customer"
type="somePackage.Customer"
scope="request" />
<jsp:getProperty name="customer" property="firstName"/>
JSP 2.0
${customer.firstName}
3.2 Partage de donnes sur session

Servlet
ValueObject value = new ValueObject(...);
HttpSession session=request.getSession();
session.setAttribute("key", value);
RequestDispatcher
dispatcher=
JSP 1.2
<jsp:useBean
id="key"
type="somePackage.ValueObject"
scope="session" />
JSP 2.0
${key.someProperty}
3.3 Partage de donnes sur application (Rare)

Servlet
synchronized(this){
ValueObjectvalue= new ValueObject(...);
getServletContext().setAttribute("key", value);
RequestDispatcher dispatcher=
request.getRequestDispatcher("/WEB-INF/SomePage.jsp");
}
JSP 1.2
<jsp:useBean id=" key" type="somePackage.ValueObject"

scope="application" />
JSP 2.0
${key.someProperty}
En rsum
Ce court chapitre a prsent un type d'objet un peu particulier : le
JavaBean, et limplmentation de pattern MVC en utilisant les trois
composants : Jsp, Servlet et JavaBean.
TRAVAUX DIRIGEES
Travaux dirigs
OBJECTIFS
Se rappeler des architectures 1-tiers, 2-tiers, 3-tiers et MVC ;

Maitriser la plateforme java EE ;
Se rappeler du cycle de vie dune Servlet ;
Se rappeler du cycle de vie dune Jsp :
Programmer des Servlets ;
Programmer des Jsps ;
Se rappeler de larchitecture MVC ;
Savoir crer une application selon le modle MVC avec les composants
Jsps, Servlet et JavaBeans ;
Savoir partager des donnes sur requte et sur session.
TDN 1
TD N1 : Les bases
Objectifs
Se rappeler des architectures 1-tiers, 2-tiers, 3-tiers et MVC ;
Maitriser la plateforme java EE.
1. Citez et expliquez les diffrents niveaux dabstraction dune

application.
2. Citez et expliquez les diffrentes architectures n-tiers (1-tiers, 2tiers, 3-tiers)
3. Dans un modle Client/Serveur, quelle sont les diffrents type d'un
Client ? Expliquez-les.
4. Expliquez par un schma l'exemple d'un modle Client/Serveur Web
5. Expliquez ses diffrents lments (Prsentation, Coordination,
Services, Domaine, Persistance).
6. Schmatisez larchitecture MVC
7. Quest ce que la plateforme Java EE ?
J2EE est l'acronyme de .,et est bas sur .,qui

contient les API de base de Java.

dploiement en langage Java pour les applications .,

nomme .,;
un ensemble .,qui peut tre obtenu et utilis sparment.
8. Quelle est la diffrence entre J2EE, JAVA et Javascript ?
9. Quel est le rle d'un serveur d'applications ?
10.
Que sont les JSPs, les Servlet et les EJB ?
11.
Quelles diffrences et cas d'utilisation d'un WAR, dun JAR et
d'un EAR pour livrer une application ?
12.
Qu'est ce qu'un conteneur? Quelle diffrence avec le serveur
dapplication?
TDN 1
13.
Quel
serveur
soccupe
de
lexcution
des
composants
SERVLET /JSP? Donner un exemple.

14.
Quels sont les composants web et les composants mtiers ?
15.
Quel serveur soccupe de lexcution des composants EJB ?
16.
Donner sus forme dun schma larchitecture java EE standard
17.
CORRECTION TDN 1
Correction TD N1 : Les bases

1. Citez et expliquez les diffrents niveaux dabstraction dune
application.
La prsentation ou IHM (Interface Homme/Machine) : gre les
interactions utilisateur/machine, la prsentation
Les traitements :
Locaux : contrles effectus au niveau du dialogue avec l'IHM
Globaux : L'application elle-mme
Les donnes : Gre le stockage des donnes et l'accs ces
dernires
2. Citez et expliquez les diffrentes architectures n-tiers (1-tiers, 2tiers, 3-tiers)
Le modle 1-Tiers Les 3 couches applicatives s'excutent sur la

mme machine, on parle d'informatique centralise
Le modle 2-Tiers : ou Client / serveur de base, avec 2 lments
Client : prsentation, interface utilisateur
Serveur : partie persistance, gestion physique des donnes
Le modle 3-Tiers :
Client : prsentation, interface utilisateur
Serveur applicatif: partie services mtiers.
Serveur de donnes: partie persistance, gestion physique des

donnes
CORRECTION TDN 1
3. Dans un modle Client/Serveur, quelle sont les diffrents type d'un

Client ? Expliquez-les.
Une architecture logiciel client/serveur est une architecture 2Tiers qui : repartie la prsentation, les services mtier et la
persistance d'un systme informatique sur deux postes diffrentes
(une nomme client et l'autre serveur).
Client lger
Le poste client accde une application situe sur un ordinateur dit

serveur via une interface et un navigateur Web. L'application
fonctionne entirement sur le serveur, le poste client reoit la
rponse toute faite la demande (requte) qu'il a formule
Client lourd
Le poste client doit comporter un systme d'exploitation capable

d'excuter en local une partie des traitements. Le traitement de la
rponse la requte du client utilisateur va mettre en uvre un
travail combin entre l'ordinateur serveur et le poste client.
CORRECTION TDN 1
Client riche
Une interface graphique plus volue permet de mettre en uvre

des fonctionnalits comparables celles d'un client "lourd". Les
traitements sont effectus majoritairement sur le serveur, la rponse
"semi-finie" tant envoye au poste client, o le client "riche" est
capable de la finaliser et de la prsenter.
4. Expliquez par un schma l'exemple d'un modle Client/Serveur Web
CORRECTION TDN 1
5. Prsenter les lments de larchitecture MVC par un schma
CORRECTION TDN 1
6. Quest ce que la plateforme Java EE ?
J2EE est l'acronyme de Java 2 Entreprise Edition.
J2EE est bas sur J2SE (Java 2 Standard Edition) qui contient les
API de base de Java.

dploiement en langage Java pour les applications distribues
plusieurs niveaux.

nomme serveur d'application ;

un ensemble d'API qui peut tre obtenu et utilis sparment.
7. Quelle est la diffrence entre J2EE, JAVA et Javascript ?
Le javascript est utilis pour effectuer de la programmation web

cot client, Java quant lui est un langage de programmation
complet (qui est compil en langage machine alors que javascript
n'est qu'interprt) et Java EE est une plateforme Java entreprise
(Java EE) est un ensemble de spcifications coordonnes et
pratiques
qui
permettent
ensemble
des
solutions
pour
le
CORRECTION TDN 1
dveloppement, le dploiement, et de la gestion des applications

multitiers centralises sur un serveur
8. Quel est le rle d'un serveur d'applications ?
Fournir une infrastructure de services (transaction, accs aux objets

mtiers, pool de ressources ) pour l'excution d'applications
9.
Que sont les Servlet ?
Techonologie Java utilise pour effectuer des traitements cot

serveur en rponse aux requtes provenant en gnral de poste
clients distants.
Que sont les EJB
Un composant Entreprise JavaBeans (EJB) est une classe ayant des

champs et des mthodes pour mettre en application des modules du
logique mtier (Business logic).
Que sont les JSPs
Les JavaServerPages (JSP) vous permet d'insrer des petits bouts

de code Java (scriptlets) directement dans du code html. Une page
JSP est un document qui contient deux types de texte:
des donnes statiques (qui peuvent tre exprimes en n'importe quel

format texte tel que le HTML, le WML, et le XML)
des lments de JSP, qui dterminent comment la page construit le

contenu dynamique.
10.

11.
Qu'est ce qu'un conteneur? Quelle diffrence avec le serveur
dapplication ?
CORRECTION TDN 1
Environnement dexcution Java EE permettant dhberger des

composants applicatifs et de contrler leur excution
Il existe plusieurs conteneurs dfinit par Java EE :
Conteneur web : pour excuter les Servlets et les JSP

Conteneur d'EJB : pour excuter les EJB
Les serveurs dapplications peuvent fournir
un conteneur web uniquement (exemple : Tomcat)

un conteneur d'EJB uniquement (exemple : JBoss
un conteneur web et un conteneur d'EJB (exemple : Websphere,
Weblogic, ...).
12.
Quel
serveur
soccupe
de
lexcution
des
composants
SERVLET /JSP? Donnez un exemple
Conteneur web, exemple : Tomcat

13.
Quels sont les composants web et les composants mtiers de
javaEE ?
Les composants web : Servlet et JSP(Java Server Pages).
Les composants mtier : EJB (Enterprise Java Beans).
14.
Quel serveur soccupe de lexcution des composants EJB ?
Donnez un exemple
Conteneur EJB, JBoss

15.
Donner sus forme dun schma larchitecture java EE standard
CORRECTION TDN 1
16.

Jar : Regroupe les EJB et leurs composants (classes)
War : Regroupe les servlets et les JSP ainsi que les ressources
ncessaires leur excution (classes, bibliothques de balises,

images, ...)
EAR : J2EE propose de regrouper ces diffrents modules (module web,
module EJB)
TDN 2
TD N2 : Introduction aux Servlets et pages JSP

Objectifs
Se rappeler du cycle de vie dune Servlet

Se rappeler du cycle de vie dune Jsp
Programmer des Servlets
Programmer des Jsps
Exercice 1
1. Donnez les deux diagrammes reprsentant le cycle de vie dun
servlet dans son conteneur.
2. Donnez un schma expliquant le fonctionnement de conteneur
lorsquil reoit deux requtes demandant la mme ressource
3. Donnez le diagramme reprsentant le cycle de vie dune JSP dans
son conteneur.
Exercice 2
En utilisant des servlets :
1. crire un programme qui crit 500 fois Je dois faire des

sauvegardes rgulires de mes fichiers..
2. crire un programme qui calcule 20!
3. Afficher la table de multiplication complte de {1,...,14} par
{1,...,14}.
4. crire un formulaire qui demande le nom et l'ge de l'utilisateur. Le
bouton submit de ce formulaire provoquera l'affichage d'une page
qui saluera l'utilisateur avec cette phrase : Bonjour machin, vous
avez xx ans... (avec les bonnes valeurs, bien entendu)
5. crire un formulaire qui demande le nom et le sexe de l'utilisateur (M
ou Mme). Ce formulaire appelle une page qui affichera Bonjour
monsieur Truc ou Bonjour madame Bidule suivant le cas (avec le
vrai nom de la personne, bien entendu!)
TDN 2
6. crire un formulaire calculatrice : 2 cases pour la saisie des

oprandes, un groupe de 4 cases cocher (ou une liste droulante)
pour le choix de l'opration, et affichage du rsultat de l'opration
Exercice 4
Refaites lexercice prcdent en utilisant les JSPs .
CORRECTION TDN 2
Correction TD N2 : Introduction aux Servlets et pages JSP

Exercice 1
1. Donnez les deux diagrammes reprsentant le cycle de vie dun
servlet dans son conteneur.
CORRECTION TDN 2
2. Donnez un schma expliquant le fonctionnement de conteneur

lorsquil reoit deux requtes demandant la mme ressource
CORRECTION TDN 2
3. Donnez le diagramme reprsentant le cycle de vie dune JSP dans

son conteneur.
CORRECTION TDN 2
Exercice 2
1. crire un programme qui crit 500 fois Je dois faire des sauvegardes
rgulires de mes fichiers..
public class exercice1 extends HttpServlet{
public void doGet(HttpServletRequest request, HttpServletResponse

response)
throws ServletException, IOException {
for (int i=1;i<=500;i++) {
out.println(i
de mes fichiers<BR>");
}
}
+". Je dois faire des sauvegardes rgulires
CORRECTION TDN 2
public void doGet(HttpServletRequest request,

int n=20;
long f=1;
for (int i=1;i<=n;f*=i,i++) ;
out.println (n+"!="+f);
}
}

{1,...,14}.

out.println("<TABLE BORDER><TR><TD></TD>")
<%
CORRECTION TDN 2
for (int i=1;i<=MAX;i++) {
out.println("\t<TH>"+i+"</TH>");
out.println("</TR>");
for (int i=1;i<=14;i++) {
out.println("<TR>\n\t<TH>"+i+"</TH>");
for (int j=1;j<=MAX;j++) {
out.println("\t<TD ALIGN=\"center\">"+(i*j)+"</TD>");
out.println("</TABLE>");
}
}

avez xx ans... (avec les bonnes valeurs, bien entendu):

out.println(<FORM METHOD=get action=/URLServlet>+
CORRECTION TDN 2
<TABLE><TR>+
<TD ALIGN=right>Votre nom</TD>+
<TD><INPUT NAME=nom></TD>+
</TR><TR>+
<TD ALIGN=right>Votre ge</TD>+
<TD><INPUT NAME=age></TD>+
</TR><TR>+
<TD ALIGN=center COLSPAN=2><INPUT TYPE=submit

VALUE=envoyer>+
<INPUT TYPE=reset VALUE=vider></TD>+
</TR></TABLE>+
</FORM>)
String nom=request.getParameter("nom");
String age=request.getParameter("age");
if (nom!=null) {
out.println(<P><B>Le traitement :</B><BR>")
out.println(Bonjour"+nom+", vous avez "+age+" ans") .
}
}

CORRECTION TDN 2

response)
out.println(<B>Le formulaire :</B><BR>
<FORM METHOD=get>
<TABLE><TR VALIGN=top>
<TD ALIGN=right>Sexe</TD>
<TD><INPUT
NAME=sexe
VALUE=M
TYPE=radio
CHECKED>Monsieur<BR>
<INPUT
NAME="sexe"
VALUE="Mme"
TYPE=radio>Madame</TD>
</TR><TR>
<TD ALIGN="right">Nom</TD>
<TD><INPUT NAME="nom"></TD>
</TR><TR>
<TD ALIGN="center" COLSPAN="2><INPUT TYPE=submit

VALUE=envoyer>
<INPUT TYPE=reset VALUE=vider></TD>

</TR></TABLE>
</FORM>);
String sexe=request.getParameter("sexe");
if (sexe!=null) {
out.println ("<P><B>Le traitement:</B><BR>") ;
out.println ("Bonjour "+sexe,nom) ;
CORRECTION TDN 2


response)
out.println("<B>Le formulaire:</B><BR>
<FORM METHOD=get>
<CENTER>
<INPUT NAME=a SIZE=5>
<SELECT NAME=par>
<OPTION VALUE=+>+
<OPTION VALUE=->-
<OPTION VALUE=*>*
<OPTION VALUE=/>/
</SELECT>
<INPUT NAME=b SIZE=5>
<BR>
<INPUT TYPE=submit VALUE=envoyer>
<INPUT TYPE=reset VALUE=vider>
</CENTER>
</FORM>
CORRECTION TDN 2
<P>
</FORM>);
String aStr=request.getParameter("a");
String bStr=request.getParameter("b");
String par=request.getParameter("par");
if (par!=null) {
out.println("<P><B>Le traitement</><BR>") ;
int a=Integer.parseInt("0"+aStr);
int b=Integer.parseInt("0"+bStr);
out.println("<CENTER>Le rsultat du calcul prcdent est:
<TT>"+a,par,b+"=");
if (par.equals("+")) {
out.println(a+b);
} else if (par.equals("-")) {
out.println(a-b);
} else if (par.equals("*")) {
out.println(a*b);
} else if (b==0) {
out.println("Impossible..");
} else {
out.println(a/b);
out.println("</TT></CENTER>") ;
CORRECTION TDN 2
}
}
Exercice 4
Tous ces exercices supposent l'existence du fichier commun.jsp suivant:
<%!
String entete(String titre) {
return "<HTML><HEAD>\n<TITLE>Premiers
exercices de JSP : "
+titre
+"</TITLE>\n</HEAD><BODY>\n"
+"<H1>Premiers exercices de JSP :
"+titre+"</H1>";
}
String pied() {
return "</BODY></HTML>";
}
%>
1. crire un programme qui crit 500 fois Je dois faire des sauvegardes
rgulires de mes fichiers..
.<\%@ include file="commun.jsp"\%>
<\%=entete("1er exercice")\%>
<\%
for (int i=1;i<=500;i++) {
out.println(i
+". Je dois faire des sauvegardes rgulires de mes
fichiers<BR>");
\%>
<\%=pied()\%>
CORRECTION TDN 2
.<%@ include file="commun.jsp"%>
<%=entete("3me exercice")%>
<%
int n=20;
long f=1;
for (int i=1;i<=n;f*=i,i++) ;
out.println (n+"!="+f);
%>
<%=pied()%>

{1,...,14}.
<%!String couleur="#DDDDDD"; int MAX=14;%>
<TABLE BORDER><TR BGCOLOR="<%=couleur%>">
<TD></TD>
<%
out.println("\t<TH>"+i+"</TH>");
out.println("<TR>\n\t<TH
BGCOLOR=\""+couleur+"\">"+i+"</TH>");
for (int j=1;j<=MAX;j++) {
out.println("\t<TD ALIGN=\"center\">"+(i*j)+"</TD>");
CORRECTION TDN 2
%>
</TABLE>
<%=pied()%>

avez xx ans... (avec les bonnes valeurs, bien entendu)
<B>Le formulaire :</B><BR>
<FORM METHOD="get">
<TABLE><TR>
<TD ALIGN="right">Votre nom</TD>
</TR><TR>
<TD ALIGN="right">Votre ge</TD>
<TD><INPUT NAME="age"></TD>
</TR><TR>
<TD ALIGN="center" COLSPAN="2"><INPUT TYPE="submit"

VALUE="envoyer">
<INPUT TYPE="reset" VALUE="vider"></TD>

</TR></TABLE>
</FORM>
<%
String age=request.getParameter("age");
if (nom!=null) {
%>
<P><B>Le traitement :</B><BR>
CORRECTION TDN 2
Bonjour <%=nom%>, vous avez <%=age%> ans.
<%
%>
<%=pied()%>

<FORM METHOD="get">
<TABLE><TR VALIGN="top">
<TD ALIGN="right">Sexe</TD>
<TD><INPUT
NAME="sexe"
VALUE="M"
TYPE="radio"
CHECKED>Monsieur<BR>
<INPUT
NAME="sexe"
VALUE="Mme"
TYPE="radio">Madame</TD>
</TR><TR>
<TD ALIGN="right">Nom</TD>
</TR><TR>
<TD ALIGN="center" COLSPAN="2"><INPUT TYPE="submit"

VALUE="envoyer">
<INPUT TYPE="reset" VALUE="vider"></TD>

</TR></TABLE>
</FORM>
<%
CORRECTION TDN 2
String sexe=request.getParameter("sexe");
if (sexe!=null) {
%>
<P><B>Le traitement :</B><BR>
Bonjour <%=sexe%> <%=nom%>.
<%
%>
<%=pied()%>

<%@ include file="commun.jsp"%>
Avec liste droulante<BR>
<FORM METHOD="get">
<CENTER>
<INPUT NAME="a" SIZE="5">
<SELECT NAME="par">
<OPTION VALUE="+">+
<OPTION VALUE="-">-
<OPTION VALUE="*">*
<OPTION VALUE="/">/
</SELECT>
<INPUT NAME="b" SIZE="5">
<BR>
<INPUT TYPE="submit" VALUE="envoyer">
CORRECTION TDN 2
<INPUT TYPE="reset" VALUE="vider">
</CENTER>
</FORM>
<TD>
<INPUT NAME="b" SIZE="5">

</TD>
</TR><TR>
<TD COLSPAN="3" ALIGN="center">
<INPUT TYPE="submit" VALUE="envoyer">
<INPUT TYPE="reset" VALUE="vider">
</TD>
</TABLE></CENTER>
</FORM>
<%
String aStr=request.getParameter("a");
String bStr=request.getParameter("b");
String par=request.getParameter("par");
if (par!=null) {
%>
<P><B>Le traitement </><BR>
<%
int a=Integer.parseInt("0"+aStr);
int b=Integer.parseInt("0"+bStr);
%>
<CENTER>Le rsultat du calcul prcdent est :
<TT><%=a%><%=par%><%=b%>=<%
if (par.equals("+")) {
out.println(a+b);
} else if (par.equals("-")) {
out.println(a-b);
CORRECTION TDN 2
} else if (par.equals("*")) {
out.println(a*b);
} else if (b==0) {
out.println("Impossible..");
} else {
out.println(a/b);
}
%></TT></CENTER>
<%
%>
<%=pied()%>
TDN 3
TD N3: Implmentation de MVC

Objectifs
Se rappeler de larchitecture MVC ;

Savoir crer une application selon le modle
composants Jsps, Servlet et JavaBeans ;

Savoir partager des donnes sur requte et sur session.
MVC avec les
Exercice 1
On considre lapplication MVC que nous avons tudie en cours.

Cette
application
permet
lutilisateur
de
slectionner
une
promotion pour afficher la liste des tudiants correspondante. Voici

les fichiers sources de cette application :
index.html :
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO8859-1">
<title>AREL V6.0</title>
</head>
<body>
<h1 align="center">L'cole virtuelle de l'EISTI</h1>
<form method="GET" action="promo">Slectionner la promo
afficher : <select name="promo" size="1">
</select><input type="SUBMIT" /></form>
</body>
</html>
SelectPromotion.java :
import java
TDN 3
public class SelectPromotion extends HttpServlet
implements javax.servlet.Servlet {
Promo promo = new Promo();
List<String> result = promo.getPromo(promoName);
request.setAttribute("promo", result);
RequestDispatcher
view
request.getRequestDispatcher("result.jsp");
view.forward(request, response);
Promo.java :
package arel;
import java.util.ArrayList;
import java.util.List;
public class Promo {
public List<String> getPromo(String promo) {
List<String> promoList = new ArrayList<String>();
if (promo.equals("ing1")) {
promoList.add("Donald Duck");
promoList.add("Minnie Mouse");
promoList.add("Pluto");
//...
} else if (promo.equals("ing2")) {
promoList.add("Mickey Mouse");
promoList.add("Daisy Duck");
promoList.add("Goofy");
TDN 3
//...
} else {
return null;
return promoList;
result.jsp :
<%@ page import="java.util.*"%>
<%@ page language="java" contentType="text/html; charset=ISO8859-1"
pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Result</title>
</head>
<body>
<%
List<String>
promoList
(List<String>)request.getAttribute("promo");
Iterator it = promoList.iterator();
while(it.hasNext()) {
out.print("<br />" + it.next());
%>
</body>
TDN 3
</html>
1. crez descripteur de dploiement
en fonction des liens et autres
nommages exprims dans les fichiers sources donns ci-dessus.

2. On dsire modifier lapplication pour afficher la liste rsultat dans la
mme page que celle du formulaire initial. Loption choisie est de
remplacer le formulaire HTML index.html par une JSP index.jsp servant
la fois de formulaire de dpart et de vue dans lapplication MVC pour
afficher le rsultat en dessous du formulaire.
index.jsp :
<%@ page import="java.util.*" %>
<%@ page language="java" contentType="text/html; charset=ISO8859-1"
pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>AREL V6.0</title>
</head>
<body>
<h1 align="center">L'cole virtuelle de l'EISTI</h1>
<form method="GET" action="select-promo">Slectionner la promo
afficher : <select name="promo" size="1">
</select><input type="SUBMIT" /></form>
<h2>Liste des tudiants :</h2>
TDN 3
<%
List<String>
promoList
while(it.hasNext()) {
%>
</body></html>
3. Lorsque lon tente daccder la JSP index.jsp, une erreur survient.

Trouvez cette erreur et corrigez-la.
Exercice 2
Ralisez une application suivant larchitecture MVC permettant

dafficher un nombre alatoire lutilisateur dans un intervalle
donn en paramtre.
Note : Chaque requte doit fournir un nouveau nombre donc le

partage sur requte est appropri.
Exercice 3

dafficher le nom et le prnom de lutilisateur. Si lutilisateur ne
donne pas son nom, on affiche le nom quil a prcdemment entr.
Sil
ny
pas
de
nom
antrieur,
on
affiche
un
message
davertissement.
Note : Les donnes sont enregistres pour chaque client, donc le

partage sur session est appropri.
CORRECTION TDN 3
Correction TDN3 : Implmentation de MVC

Exercice 1
1. Crez descripteur de dploiement
en fonction des liens et autres
nommages exprims dans les fichiers sources donns ci-dessus.
web.xml
<web-app>
<display-name>MVC</display-name>
<servlet>
<servlet-name> X </servlet-name>
<servlet-class> arel.SelectPromo </servlet-class>
</servlet>
<servlet-mapping>
<servlet-name> X </servlet-name>
<url-pattern> /select-promo </url-pattern>
</servlet-mapping>
</web-app>
2. On dsire modifier lapplication pour afficher la liste rsultat dans la

mme page que celle du formulaire initial. Loption choisie est de
remplacer le formulaire HTML index.html par une JSP index.jsp servant
la fois de formulaire de dpart et de vue dans lapplication MVC pour
afficher le rsultat en dessous du formulaire.
arel/SelectPromo.java
RequestDispatcher
view
request.getRequestDispatcher("index.jsp") ;
3. Lorsque lon tente daccder la JSP index.jsp, une erreur survient.
Trouvez cette erreur et corrigez-la.
Au premier lancement dindex.jsp, lattribut promo nexiste pas dans

le requestScope. Il faut donc tester sil nest pas null.
Ajouter un test de nullit :
CORRECTION TDN 3
<%
List<String>
promoList
if(promoList!=null)
while(it.hasNext())
%>
${requestScope["promo"]}
Exercice 2

dafficher un nombre alatoire lutilisateur dans un intervalle
donn en paramtre.
Note : Chaque requte doit fournir un nouveau nombre donc le

partage sur requte est appropri.
Index.html
<html>
<head>
<title>MVC Examples</title>
</head>
<body>
<fieldset>
<legend>Random Number</legend>
CORRECTION TDN 3
<form action="./Rand">
Range: <input type="text" name="range"><br/>
<input type="submit" value="Show Number">
</form>
</fieldset>
</body>
</html>
Le modle
package modele;
public class NumberBean // JavaBEAN car :
private double num; // Attributs privs
public NumberBean() // Constructeur sans paramtres
num = 0;
/**
* Getters et Setters
*/
public double getNumber()
return(num);
public void setNumber(double number)
CORRECTION TDN 3
num = number;
Le contrleur
RandomNumberServlet
import ..
import modele.NumberBean;
public class RandomNumberServlet extends HttpServlet
private static final long serialVersionUID = 1L;
public
void
HttpServletResponse
response)
throws
request,
ServletException,
IOException
NumberBean
bean
RanUtils.getRandomNum(request.getParameter("range"));
=
//
Je
gnre le bean par rapport au paramtre
request.setAttribute("randomNum", bean); // Je l'ajoute dans le

scope de requte
RequestDispatcher
dispatcher
request.getRequestDispatcher("vue.jsp"); // Je forward ma vue
import modele.NumberBean;
public class RanUtils
CORRECTION TDN 3
public static NumberBean getRandomNum(String rangeString)
double range;
try
range = Double.parseDouble(rangeString);
catch(Exception e)
range = 10.0;
NumberBean n = new NumberBean();
n.setNumber(Math.random() * range);
return n;
Web.xml
<web-app>
<welcome-file-list>
<welcome-file>index.html</welcome-file>
</welcome-file-list>
<servlet>
<description></description>
<display-name>NombreAleatoire</display-name>
<servlet-name>RandomNumber</servlet-name>
<servlet-class>RandomNumberServlet</servlet-class>
</servlet>
<servlet-mapping>
CORRECTION TDN 3
<url-pattern>/Rand</url-pattern>
</servlet-mapping>
</web-app>
Vue.jsp
<%@ page language="java" contentType="text/html"%>
<jsp:useBean id="randomNum" type="modele.NumberBean"

scope="request" />
<html>
<head>
<title>Random Number</title>
</head>
<body>
<h2>Random Number: <jsp:getProperty name="randomNum"

property="number" /> </h2>
</body>
</html>
Exercice 3

dafficher le nom et le prnom de lutilisateur. Si lutilisateur ne
donne pas son nom, on affiche le nom quil a prcdemment entr.
Sil
ny
pas
de
nom
antrieur,
on
affiche
un
message
davertissement.
Note : Les donnes sont enregistres pour chaque client, donc le

partage sur session est appropri.
Index.html
<html>
<head>
CORRECTION TDN 3
<title>MVC Examples</title>
</head>
<body>
<fieldset>
<legend>Register</legend>
<form action="./Register">
First Name: <input type="text" name="firstName"><br/>
Last Name: <input type="text" name="lastName"><br/>
<input type="submit" value="Register">
</form>
</fieldset>
</body>
</html>
Le modle
package modele;
public class NameBean // JavaBEAN car :
private String firstName; // Attributs privs
private String lastName;
public NameBean() // Constructeur sans paramtre
firstName = "Missing first name";
lastName = "Missing last name";
/**
* Getters et Setters
*/
CORRECTION TDN 3
public String getFirstName()
return(firstName);
public void setFirstName(String firstName)
if (!isMissing(firstName))
this.firstName = firstName;
public String getLastName()
return(lastName);
public void setLastName(String lastName)
if (!isMissing(lastName))
this.lastName = lastName;
private boolean isMissing(String value)
return((value == null) || (value.trim().equals("")));
CORRECTION TDN 3
Le contrleur
Import
import modele.NameBean;
public class RegistrationServlet extends HttpServlet

HttpServletResponse response) throws ServletException,
IOException
NameBean bean =
(NameBean)request.getSession().getAttribute("nameBean"); // Je
rcupre le bean dans le scope de session
if (bean == null) bean = new NameBean(); // S'il n'existe pas

encore je le cre
String firstName = request.getParameter("firstName"); // Je rcupre

le premier paramtre entr par l'utilisateur
String lastName = request.getParameter("lastName"); // Je rcupre

le deuxime paramtre entr par l'utilisateur
bean.setFirstName(firstName); // J'affecte le firstName au bean (si

rien est entr le modle ne le modifie pas)
bean.setLastName(lastName); // J'affecte le lastName au bean (si

rien est entr le modle ne le modifie pas)
request.getSession().setAttribute("nameBean", bean); // J'ajoute le

bean dans le scope de session
RequestDispatcher dispatcher =
request.getRequestDispatcher("vue.jsp"); // Je forward ma vue
CORRECTION TDN 3
Web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app>
<welcome-file-list>
<welcome-file>index.html</welcome-file>
</welcome-file-list>
<servlet>
<servlet-class>RegistrationServlet</servlet-class>
</servlet>
<servlet-mapping>
<url-pattern>/Register</url-pattern>
</servlet-mapping>
</web-app>
La vue
<%@ page language="java" contentType="text/html%>
<jsp:useBean id="nameBean" type="modele.NameBean"

scope="session" />
<html>
<head>
<title>Inscription</title>
</head>
<body>
<h1>Voici vos derniers identifiants entrs :</h1>
CORRECTION TDN 3
<h2>First Name: <jsp:getProperty name="nameBean"

property="firstName" /></h2>
<h2>Last Name: <jsp:getProperty name="nameBean"

property="lastName" /></h2>
</body>
</html>
DEVOIR SURVEILLE
Dpartement Technologies de
lInformatique
Institut
Suprieur des Etudes
Technologiques de Kasserine
Anne Universitaire : 2013/2014 Semestre : 1
DEVOIR SURVEILLE
Module : Programmation N-TIERS

MDW 31
Enseignants : BOUZIDI FZ
Dure : 1h Docs : Non autoriss
Groupes :
Exer
cice
1(6
points)
1. Schmatiser les architectures 3-tiers et MVC (4 points)
2. Peut on combiner ces deux architectures ?si oui, comment ? (2
point)
Exercice 2 (6 points)
1. Complter le schma suivant (3 points)
DEVOIR SURVEILLE
2. Dcrire la faon dassemblage dune application java EE multi tiers.

(3 points)
1. crire une jsp permettant dafficher un formulaire qui demande deux

nombres : une base et une limite. Ce formulaire appelle une page
qui affichera toutes les puissances de la base infrieures la limite.

Par exemple si on donne 2 comme base et 300 comme limite on
devra obtenir la suite 2, 4, 8, 16, 32, 64, 128, 256 (4 points)

2. Refaire lexercice avec une servlet. (4 points)
EXAMEN
Dpartement Technologies de
lInformatique
Institut Suprieur des Etudes

Technologiques de Kasserine
Module : Programmation NTIERS
Enseignants :
Date : Janvier 2014

autoriss
Anne Universitaire : 2013/2014 Semestre : 1
EXAMEN
Groupes : MDW31
BOUZIDI FZ
Dure : 1h30
Nb pages:3
Docs : Non
Entourez la ou les bonnes rponses (seulement la lettre).
1. Quelle est la balise qui devrait remplacer <XXXXXXXXXX> ?
<web-app>
<servlet>
<servlet-name>Controller</servlet-name>
<servlet-class>somepackage.Controller</servlet-class>
</servlet>
<XXXXXXXXXX>
<servlet-name>Controller</servlet-name>
<url-pattern>/Controller</url-pattern>
</XXXXXXXXXX>
</web-app>
A. <servlet-url>
B. <servlet-pattern>
C. <servlet-mapping>
D. <servlet-uri>
2. Quelles sont les mthodes utilises par un servlet pour grer les don
nes envoyes par un client via un formulaire HTML ?
EXAMEN
A. ServletRequest.doHead()
B. HttpServlet.doPost()
C. ServletRequest.doGet()
D. HttpServlet. doGet()
E. ServletRequest.doPost()
F. ServletRequest.doForm()
3. Comment un dveloppeur gretil la mthode service() de son servl

et, lorsque ce dernier tend HttpServlet ?
A. Il redfinit la mthode service().
B. Il redfinit une mthode doXXX() (par ex. doGet ou doPost).
B. Il appelle la mthode service() depuis une mthode doXXX() (par

ex. doGet() ou doPost()).
C. Il appelle la mthode service() depuis la mthode init().
D. Il na rien faire
4. Laquelle sortira "Bonjour" sur la page HTML ?
A. <%= "Bonjour" %>
B. <% "Bonjour" %>
C. <%@ "Bonjour" %>
D. <%! "Bonjour" %>
5. Laquelle crera une variable "var" dans la page JSP ?
A. <%= int var = 0; %>
B. <%@ int var = 0; %>
C. <% int var = 0; %>
D. <%! int var = 0; %>
EXAMEN
6. Laquelle crera une mthode "test" dans la page JSP ?
A. <%= private void test() { } %>
B. <%@ private void test() { } %>
C. <% private void test() { } %>
D. <%! private void test() { } %>
7. Avec le code suivant dans une JSP, comment sortir "Hello World" ?
<%
request.setAttribute("hello", "Hello");
String world = "World";
%>
A. ${ hello } ${ world }
B. ${ hello } <%= world %>
C. <%= hello %> ${ world }
D. <%= hello %> <%= world %>
8. Que sortira le code JSP suivant ?
<%
request.setAttribute("msg", "Hola");
%>
${message} <br />
A. Hola
B. une chaine vide
C. une NullPointerException
9. Dans un scriptlet JSP, quelle variable implicite n'existe pas ?
A. out
B. request
C. response
D. page
E. pageContext
F. contextParam
EXAMEN
10.
Quelle ligne ne marchera pas dans une page JSP ?
A. <%= 5 %>
B. <%! String myString="Hello"; %>
C. <% String myString=request.getServerName(); %>
D. <%= out.print("Hello") %>
Le but de cet exercice est de raliser un formulaire permettant de

saisir un ensemble de donnes. Ces donnes sont ensuite panses
et visualises sous forme d'un tableau. Tout ce travail se fera en
respectant l'architecture MVC.
Le formulaire est le suivant :
Si
les
champs
de
formulaire
sont
valides
le
rsultat
correspondra un tableau contenant l'information stocke dans le

modle. Voici la forme que doit avoir la vue de resultat :
EXAMEN
1. Crez un bean qui reprsente les valeurs envoyes par le formulaire.

(2 points)
2. Crez une Servlet pour accepter les valeurs envoyes par le
formulaire. (2 points)
3. Modifier la servlet pou grer le fait que si le Nom, Prnom, Sexe ou
Code Postal n'est pas envoy la Servlet l'utilisateur reoive une
erreur afin de pouvoir essayer de nouveau. Sinon elle envoie le bean
instanci la vue rsultat.jsp aprs vrification des champs entrs.
(2 points)
4. Crez la vue formulaire.jsp (2 points)
5. Crez la vue resultat.jsp (2 points)
REFERENCES
Ntographie
[1] : http://gardeux-vincent.eu/Cours.php
[2]
http://jlafosse.developpez.com/java/developpement-n-
tiers/plate-forme-java-EE/
[3]
http://tahe.ftp-developpez.com/fichiers-
archive/baseswebmvcjava.pdf
[4]
http://docs.oracle.com/javaee/6/tutorial/doc/bnaay.html#bnabc
[5] :http://fr.openclassrooms.com/informatique/cours/creez-
votre-application-web-avec-java-ee
[6]
http://jmdoudoux.developpez.com/cours/developpons/java/chapj2ee-javaee.php
[7] : http://dept25.cnam.fr/PROJET3I/DOC/J2EE.pdf
[8]:http://gardeux-vincent.eu/Cours/JEE/Activite%201/Java
%20EE%20-%20Cours%201.pdf
[9] : http://uploads.siteduzero.com/pdf/285022-creez-votre-
application-web-avec-java-ee.pdf
[10]
http://alwin.developpez.com/articles/java/archi-multi-
tiers/
[11] : http://saidf.hebergratuit.com/TDI/Java/
[12] : http://www.jmdoudoux.fr/java/dej/chap-j2ee-javaee.htm
[13]
http://blog.paumard.org/cours/servlet/chap05-jsp-
scriptlet.html
Bibliographie
[1] : A. Goncalves (2005). Les Cahiers du Programmeur : Java EE
5.Paris : Edition Eyrolles.
[2] : J.Larosse (2011). Dveloppement n-tiers avec Java EE. Paris :
Edition ENI.
[3] : CLAUDE.D(2008).Programmer en Java. Paris : Edition Eyrolles.

Cours Et TD NTIERS Réparé

Transféré par

Informations du document

Titre original

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

Cours Et TD NTIERS Réparé

Transféré par

Droits d'auteur :

Formats disponibles

REPUBLIQUE TUNISIENNE

MINISTERE DE LENSEIGNEMENT SUPERIEUR, DE LA RECHERCHE SCIENTIFIQUE

DIRECTION GENERALE DES ETUDES TECHNOLOGIQUES

Anne Universitaire 2013/2014

est lintention des tudiants

de troisime anne en Licence applique en technologies de linformatique

prparer ltudiant apprendre les comptences thoriques ncessaires

faisant la distinction entre la

prsentation, le traitement et les donnes en imbriquant quelques API de

de distinguer entre les diffrentes couches dune architecture JavaEE et les

implmentant le modle MVC.

implmentation de modle MVC imbriquant les composants JSP, Servlet et

Domaine de Formation : Sciences et

Mention : Technologies de lInformatique (TI)

Parcours : Multimdia et Dveloppement Web

UNIT DENSEIGNEMENT (UE) : PROGRAMMATION N-

Volume Horaire par Semestre :

Architecture Client Serveur.

Moyens et Outils Pdagogiques

Cours, Travaux dirigs, mini-projet

Table des matires

Les trois niveaux d'abstraction d'une application.........................................2

Avantages et inconvnients de l'architecture 2-tiers.............................4

Avantages et inconvnients de l'architecture 3-tiers..............................6

Les architectures N-tiers...............................................................................7

Avantages et inconvnients de l'architecture N-tiers :..........................8

Larchitecture Modle-Vue- Contrleur (MVC) :............................................8

Diffrence avec larchitecture 3-tiers....................................................10

Chapitre II Prsentation de la plateforme Java EE...............................................12

La prsentation de Java EE.........................................................................13

Les API de Java EE....................................................................................... 13

Architectures en Java EE............................................................................. 14

Les composants clients ou tiers Client..................................................15

Les composants Web ou tiers Web.......................................................17

Les composants mtier ou tiers Mtier.................................................17

Enterprise Information System Tier......................................................18

Les conteneurs Java EE............................................................................... 18

L'assemblage et le dploiement d'applications J2EE...................................20

Chapitre III Introduction aux Servlets et pages JSP..............................................22

Introduction aux Servlets............................................................................23

Quest-ce qu'une servlet.......................................................................23

Cycle de vie dune servlet....................................................................23

Radiographie dune premire servlet....................................................27

Introduction aux JSP.................................................................................... 30

Pourquoi une JSP?.................................................................................30

Cest quoi une JSP?...............................................................................30

Cycle de vie d'une JSP..........................................................................31

Radiographie dun Script JSP................................................................33

Les Balises JSP...................................................................................... 35

Les variables prdfinis :......................................................................39

Chapitre IV Implmentation de MVC....................................................................40

MVC et Java EE............................................................................................ 41

Collaboration entre JSP et servlets : linterface requestdispatcher.............41

Transmission de donnes: les paramtres et les attributs..........................43

Diffrence entre paramtres et attributs..............................................43

Transmission des attributs : mthodes setAttribute() et getAttribute() 44

Transmission des paramtres : mthode getParameter().....................45

Exemples dapplications du design pattern MVC :.....................................46

Chapitre V JavaBeans et Scope...........................................................................60

Cest quoi un Javabean.........................................................................61

Structure dun Javabean.......................................................................61

Comment utiliser des beans ?..............................................................61

Implmentation du MVC (avec les JavaBeans)............................................62