Au lieu d'embarquer du code HTML dans les servlets Java, on part du HTML statique et on ajoute des balises spéciales qui sont interprétées par le moteur JSP, produisant ainsi une page web dynamique.
Parmi les serveurs HTTP gratuits qui supportent les JSP, on trouve
Les deux sont téléchargeables à l'adresse java.sun.com/products/jsp/download.html.
L'interprétation d'une page contenant des instructions JSP se fait de la manière suivante. Lorsqu'un utilisateur demande, via son navigateur (ou "client"), un document possédant l'extension .jsp :
Regardons le traitement d'un fichier JSP sur le site de Wikipedia.
De ce fait, utiliser des JSP reste un processus lourd et gourmand en
ressources système. Il faut donc veiller à ne pas "embarquer" trop de code
Java dans une page HTML. Il est préférable d'utiliser des composants
séparés et déjà compilés.
<Context path="/App" docBase="c:\monSite" debug="0" reloadable="true">Pour faire des tests et visualiser vos premières pages, il faut accéder au site via l'adresse http://localhost:8080/App. Pour que les JSP fonctionnent correctement, il faut bien penser à configurer les variables d'environnement nécessaires au bon fonctionnement de Java, à savoir :
</Context>
L'exemple ci-après montre la différence entre ce qui est statique (les instructions HTML en noir) et ce qui est dynamique (le code JSP en rouge). Le traitement applicatif – ici, l'addition – est effectué par la machine où le serveur HTTP s'exécute.
<html>
<body>
<h4>
2+2 = <%=2+2%>
</h4>
</body>
</html>
Vous venez d'apprendre vos deux premiers éléments de syntaxe
JSP :
2+2 = 4
On peut réaliser des traitements plus complexes qu'une expression
élémentaire, tels que les boucles. On peut aussi "découper" sans problème
les instructions JSP, à condition de répéter les balises <% et %>.
Dans cet exemple, le saut de ligne <br> est une instruction
HTML insérée dans la boucle Java for(...){...}.
Note : ici, c'est l'instruction println qui
permet d'afficher le résultat dans la page Web.
<html>
<body>
<%
for (int i=0; i<3; i++)
{
out.println("i = " + i);
%>
<BR>
<%
}
%>
</body>
</html>
Résultat :
i = 0
i = 1
i = 2
Voici une liste non exhaustive des instructions le plus couramment utilisées.
| Instruction JSP | Utilité | Syntaxe réduite | Syntaxe XML |
| Expression | Evalue une expression et affiche le résultat. | <%= expression %> | <jsp:expression> |
| Scriplet | Evalue le code java. | <% code %> | <jsp:scriptlet> |
| Déclaration | Permet de déclarer des variables utilisées par la suite. | <%! déclaration %> | <jsp:declaration> |
| Directive | Permet de déclarer les directives communes à la page (par exemple, l'importation des paquetages utilisés). | <%@ directive %> | <jsp:directive.page att="val"/> |
| Commentaire | Texte de commentaire (ignoré par le serveur). | <%-- comment --%> |
|
| Utilisation des JavaBeans | Déclaration d'un bean et utilisation de ses propriétés. | <jsp:useBean att="val"/> |
Définition
On a dit que l'un des avantages de JSP était de séparer la présentation (le code HTML) de la logique applicative (le code JSP). Or, dans les exemples précédents, les deux parties restaient imbriquées.
A l'usage, on se rend vite compte que l'insertion directe de code Java dans les pages HTML devient trop complexe à gérer. De plus, le temps nécessaire à la compilation du code est rapidement prohibitif. La solution qui permet de faciliter le développement et la maintenance consiste à utiliser des composants JavaBeans.
Les JavaBeans (ou beans) sont des objets compilés en Java qui peuvent être instanciés dans un programme quelconque. L'interface d'un tel objet (c'est-à-dire les services utilisables) est constituée par ses méthodes publiques. Un JavaBean peut aussi avoir des propriétés, qui sont accédées via les méthodes getNomPropriété, setNomPropriété.
Grâce à cette technologie et aux instructions JSP associées, il est plus judicieux de créer des pages JSP très simples, qui se contentent d'accéder à des objets codés à part. Ces objets sont utilisés pour encapsuler les traitements.
public class DataBaseAccess {
private String m_strBase = "Base";
private int m_nBaseSize = 3;
private String m_dataBase[];
public DataBaseAccess() {
// on crée une base de données fictive
// dans le constructeur
m_dataBase = new String[m_nBaseSize];
for (int i=0; i<m_nBaseSize; i++){
m_dataBase[i] = "Nom" + i;
}
}
// on permet d'accéder aux propriétés
public void setBaseName(String strName)
{ m_strBase = strName; }
public String getBaseName()
{ return m_strBase; }
public int getBaseSize()
{ return m_nBaseSize; }
// on permet d'accéder aux éléments
public String element(int nIndex)
{ return m_dataBase[nIndex]; }
}
Le code JSP qui suit utilise à peu près toutes les commandes présentées
précédemment.<HTML>
<BODY>
<%@ page language="java"%>
<jsp:useBean id="Base" class="DataBaseAccess" scope="page"/>
<jsp:setProperty name="Base" property="baseName" value="Test"/>
Présentation de la base
<B><jsp:getProperty name="Base" property="baseName"/></B> :<BR>
<font color="#0000FF">
<% for (int i=0; i<Base.getBaseSize(); i++)
{
%>
<%= Base.element(i) %><BR>
<% } %>
</font>
</BODY>
</HTML>
Notes :
- Dans getProperty et setProperty, 'name' représente le nom du bean et 'property' représente le nom de la propriété.
- 'scope' est l'attribut de portée. Il indique au bean de conserver ses informations pour la page uniquement (valeur par défaut) [scope="page"], la requête [scope="request"], la session [scope="session"] ou l'ensemble de l'application [scope="application"].
- On peut aussi remplacer <jsp:getProperty name="Base" property="baseName"/> par <%= Base.getBaseName() %>.)
Résultat :
Présentation de la base Test :En situation réelle, un tel objet pourrait servir à se connecter à une vraie base de données, et proposerait une série de services permettant de faire des requêtes en lecture ou en écriture.
Nom0
Nom1
Nom2