Présentation :
JavaServer Pages™ (JSP) est une technologie
de scripts côté serveur comparable à Netscape
server-side JavaScript (SSJS) et à Microsoft Active Server
Pages (ASP). Cependant, il se distingue des précédents
en étant plus extensible et non propriétaire par
rapport à un constructeur ou un type particulier de serveur.
Même si les spécifications ont été
établies sous l'égide de Sun Microsystems, tout
constructeur peut implémenter JSP sur ses propres systèmes.
Ceux qui travaillent aujourd'hui ou comptent travailler avec
les technologies de Netscape peuvent dès maintenant se
familiariser avec JSP. En effet, Netscape va prochainement présenter
des produits les utilisant. Ainsi, ils ont déjà
déclaré que la prochaine version de leur serveur
Netscape Application Server (NAS) utilisera JSP comme "technologie
de couche de présentation" (presentation layer technology).
Nous verrons les caractéristiques de JSP, ses utilisateurs
cibles et ses utilisations privilégiées. Nous
terminerons par une comparaison avec les technologies actuelles
de Netscape, telles que SSJS et le langage à balises
de NAS.
JSP : les bases
JSP est une technologies de couche
de présentation qui reposent sur le modèle des servlets
Java. A l'instar de SSJS, cette technologie permet de générer
des pages dynamiques en mélangant du HTML statique avec
des scripts côté serveur. Par défaut, le langage
de script est le Java ; cependant, les spécifications permettent
d'employer d'autres langages, tout comme ASP autorisent le JScript
et le VBScript. En dépit du fait que les pages JSP écrites
en Java restent plus flexibles et robustes que les scripts codés
dans des langages plus simples tels que le JavaScript et le VBScript,
le Java demande un temps d'apprentissage plus long que les langages
de scripts simples.
Pour jouer sur les deux tableau à la fois, c'est-à-dire avoir
une plate-forme applicative robuste pour le web et un langage
facile à utiliser, JSP est pourvu d'un certain nombre
de balises côté serveur qui permettent aux développeurs
de produire la plupart des opérations de génération
de contenus dynamiques sans la moindre ligne de code en Java.
Ces balises sont plus particulièrement destinées
aux développeurs familiers aux scripts, voire aux graphistes
n'utilisant que le HTML mais même les développeurs
Java peuvent les utiliser pour obtenir des opérations
avancées dans les pages JSP.
Des "pages" aux "composants"
Pour comprendre toute la puisance
de JSP il faut d'abord saisir la différence entre les développements
orientés composants et ceux orientés pages. Les
technologies SSJS et ASP ont été conçues
il y a deçà quelques années, lorsque le web
était "jeune" et que personne ne savait faire
mieux que de "déverser" dans des pages web de
scripts tout ce qui concerne le commerce, les données et
la logique de présentation. Ce modèle orienté
page était facilement compréhensible et permettait
des développements vraiment rapides. Cependant, les gens
ont réalisé au fil du temps que ce n'était
pas la bonne méthode pour construire des grandes applications
web. Les environnements uniquement de scripts enfermaient les
fonctionnalités à l'intérieur des pages sans
d'autre moyen de réutilisation que le copier-coller. La
logique utilisée pour la présentation graphique
était souvent mélangée avec les fonctionnalités
pour le commerce et les données, compliquant ainsi la maintenance
: comment toucher à la présentation sans changer
la logique commerciale ? Des composants sophistiqués et
réutilisables existaient déjà dans les entreprises
mais personne ne voulait les transcrire pour des applications
web. De ce fait, les graphistes et les développeurs ne
pouvaient travailler séparément, ces derniers devant
implémenter à la main les travaux des premiers pour
chaque page. En peu de temps, les applications web devinrent d'une
grande complexité d'où la mise en cause certaine
des limitations du modèle orienté page.
Alors même qu'on était à la recherche de solutions valables
pour la construction d'applications web, les composants battaient
leur plein dans le monde du client-serveur. Les fournisseurs
d'outils pour des développements rapide d'applications
(Rapid Application Development) présentèrent aux
développeurs Java et Windows les JavaBeans et ActiveX
comme un moyen de développer rapidement de complexes
applications. Ces technologies permettaient aussi à des
experts dans un certain domaine d'écrire des composants
pour des applications verticales, réutilisables par des
développeurs non experts dans ce domaine. Ce n'était
qu'une question de temps avant qu'une technologie émerge
pour mettre en pratique la programmation orientée composants
dans le monde des applications web côtés serveur.
JSP sort alors du lot en se définissant comme une plate-forme
orientée composant. Il est fondé sur un modèle
dans lequel les composants JavaBeans et Enterprise JavaBeans
(EJB) encapsulent la logique de l'application concernant le
commerce et les données. Il fournit en outre des balises
et un environnement de script utilisés pour afficher
dans une page HTML le contenu renvoyé ou généré
par les beans. De part la nature orientée composant de
JSP, il peut être utilisé de la même façon
par des développeurs Java avertis ou non. Les pages JSP
peuvent en effet contenir d'une part des balises JSP implémentant
des beans crées par des développeurs Java expérimentés,
d'autre part directement du code Java pour un contrôle
plus fin au niveau de la présentation.
Requêtes HTTP :
Dans le modèle classique de
requêtes, une requête est envoyée directement
à la page JSP. La Figure 1 ci-dessous illustre à
ce propos les flux d'informations. Le code JSP contrôle
les interactions avec les composants JavaBeans pour les processus
concernant le commerce et les données, puis affiche les
résultats en mixant HTML généré dynamiquement
et HTML statique.
Figure 1. Basic JSP request model
Les beans représentés peuvent être des composants JavaBeans
ou EJB. Il existe d'autres modèles de requêtes,
plus complexes, dans lesquels la page JSP demandée appelle
d'autres pages JSP ou des servlets Java.
JSP, SSJS et NAS :
JSP ne remplace pas ou ne menace pas
nécessairement SSJS en tant que plate-forme de développement
web ; chacun trouve sa place dans le marché. Bien que JSP
reste généralement plus puissant et plus flexible
que SSJS, pour écrire des scripts il faut apprendre le
Java - tout du moins tant que d'autres fournisseurs ne proposent
pas de versions supportant des langages plus simples comme le
JavaScript. En attendant, SSJS fournit toujours le langage simple
mais efficace qu'est le JavaScript, possèdant en outre
l'avantage de présenter un temps d'apprentissage plus court
que le Java et d'être dans un certain sens plus flexible
(langage vaguement typé).
En ce qui concerne NAS, il est clair que JSP ne remplacera jamais la robuste
fonctionnalité offerte par NAS, ce n'est d'ailleurs pas
le but cherché. JSP est plutôt un frontal (portion
d'un programme responsable de l'interface utilisateur), une
technologie agissant sur la couche présentation qui s'adapte
bien à l'architecture NAS. NAS utilise actuellement un
langage à balises propriétaire pour l'élaboration
de documents modèles de présentation (templates).
Ce langage est quelque peu fermé et n'accepte pas qu'on
rajoute des lignes de script dans les pages, ce qui le rend
en fin de compte moins flexible que JSP. Dans la version 4.0
de NAS, Netscape permettra l'utilisation de JSP en alternative
au langage à balises par défaut qui tourne avec
le modèle de base de servlet NAS. De ce fait, JSP est
une bonne chose pour les développeurs sous NAS.
JSP et XML :
JSP et XML ont une relation de parenté
intéressante. D'une part, on peut mélanger XML et
JSP, tout comme on le fait avec HTML et JSP, de telle sorte que
l'on peut utiliser du JSP pour générer dynamiquement
des pages XML. Ce n'est pas une particularité propre à
JSP, tout autre environnement de script, en particulier CGI, SSJS
et ASP, permet de générer du XML et de la même
qu'ils le font pour du HTML. Cependant, les spécifications
de JSP définissent explicitement que la génération
de document XML est supportée par JSP, sans violer aucune
règle XML.
D'autre part, les pages mêmes JSP peuvent être comprises comme
des documents XML. Les spécifications de JSP définissent
des balises compatibles avec XML pour être utiliser à
la place de celles qui ne sont pas. Par exemple, les scriptlets
habituellement écrites entre <%...%> peuvent
se définir à l'aide des balises <jsp:scriptlet>
et </jsp:scriptlet> compatibles avec XML.
On peut faire ici un parallèle avec PHP : <?php...?>
est équivalent à <script language="php">...</script>.
Il est clairement plus facile d'écrire du code sous
la première forme que sous forme XML. Cependant, le format
XML format rend la génération et la validation
de pages JPS plus faciles à l'intérieur d'IDEs
ou d'autres outils de développement JSP. On se réferrera
aux specifications
JSP pour pour plus de détails sur les relations entre
JSP et XML.
Points de vue :
JSP est certain de recevoir beaucoup
de considérations de la part des développerus web,
du fait qu'il peut être utiliser par les non programmeurs
à travers l'emploi des balises, mais aussi par ceux qui
ont des connaissances avancées en Java ou en programmation
de scripts. En fait, un petit nombre de fournisseurs autres que
Netscape proposent d'ors et déjà des implémentations
de JSP. Et comme JSP est un standard ouvert qui accepte d'autres
langages à la place du Java, tels que le JavaScript, JSP
devrait remporter prochainement plus de suffrages chez les industriels.
Lien officiel :
Mes signets :
|
