Bienvenue dans le tutoriel d’exemple JSP pour les débutants. Dans les derniers articles, j’ai beaucoup parlé de Java Servlet et j’ai eu une très bonne réponse de nos lecteurs. J’ai donc commencé une autre série sur les tutoriels JSP et c’est le premier article de la série.
Tutoriel d’exemple JSP
Dans ce tutoriel d’exemple JSP, nous examinerons les bases de JSP, les avantages de JSP par rapport aux Servlets, le cycle de vie de JSP, les interfaces et classes API de JSP, et où nous pouvons placer les fichiers JSP dans l’application Web. Nous examinerons également brièvement les commentaires JSP, les scriptlets, les directives, les expressions, les déclarations et les attributs JSP. Certains de ces sujets sont très importants et nous les examinerons plus en détail dans les prochains articles.
Tutoriel JSP
- Qu’est-ce que JSP et pourquoi en avons-nous besoin?
- Avantages de JSP par rapport aux Servlets?
- Cycle de vie de la page JSP
- Méthodes de cycle de vie de JSP
- Exemple simple de JSP avec Eclipse et Tomcat
- Emplacement des fichiers JSP dans le fichier WAR de l’application Web
- Interfaces et classes de l’API JSP
- Interface JspPage
- Interface HttpJspPage
- Classe abstraite JspWriter
- Classe abstraite JspContext
- Classe abstraite PageContext
- Classe abstraite JspFactory
- Classe abstraite JspEngineInfo
- Classe finale ErrorData
- Classe JspException
- Classe JspTagException
- Classe SkipPageException
-
Code source du Servlet transformé en JSP et emplacement du fichier de classe dans Tomcat
-
Qu’est-ce que JSP et pourquoi avons-nous besoin de JSP?
JSP (JavaServer Pages) est une technologie côté serveur permettant de créer des applications web Java dynamiques. On peut considérer JSP comme une extension de la technologie servlet car elle offre des fonctionnalités pour créer facilement des vues utilisateur. Une page JSP se compose de code HTML et offre la possibilité d’inclure du code Java pour du contenu dynamique. Étant donné que les applications web contiennent de nombreuses interfaces utilisateur, les JSP sont largement utilisées. Pour combler le fossé entre le code Java et le HTML dans JSP, elle propose des fonctionnalités supplémentaires telles que les balises JSP, le langage d’expression, les balises personnalisées. Cela facilite la compréhension et aide un développeur web à développer rapidement des pages JSP.
-
Avantages de JSP par rapport aux Servlets?
- Nous pouvons générer une réponse HTML à partir de servlets, mais le processus est fastidieux et sujet aux erreurs. Lorsqu’il s’agit d’écrire une réponse HTML complexe, écrire dans un servlet peut être un cauchemar. JSP nous aide dans cette situation et nous offre la flexibilité d’écrire une page HTML normale et d’inclure notre code Java uniquement là où il est nécessaire.
- JSP offre des fonctionnalités supplémentaires telles que les bibliothèques de balises, le langage d’expression, les balises personnalisées qui facilitent le développement rapide des vues utilisateur.
- Les pages JSP sont faciles à déployer, il suffit de remplacer la page modifiée sur le serveur et le conteneur se charge du déploiement. Pour les servlets, nous devons recompiler et redéployer tout le projet. En réalité, les servlets et les JSP se complètent. Nous devrions utiliser les servlets comme contrôleur côté serveur et pour communiquer avec les classes de modèle, tandis que les JSP devraient être utilisées pour la couche de présentation.
-
Cycle de vie de la page JSP
Le cycle de vie JSP est également géré par le conteneur. Généralement, chaque conteneur web qui contient un conteneur de servlet contient également un conteneur JSP pour gérer les pages JSP. Les phases du cycle de vie des pages JSP sont les suivantes :
- Traduction – Les pages JSP ne ressemblent pas aux classes Java normales, en fait, le conteneur JSP analyse les pages JSP et les traduit pour générer le code source de servlet correspondant. Si le nom du fichier JSP est home.jsp, il est généralement nommé home_jsp.java.
- Compilation – Si la traduction réussit, alors le conteneur compile le fichier source de servlet généré pour générer un fichier de classe.
- Chargement de classe – Une fois que la JSP est compilée en tant que classe de servlet, son cycle de vie est similaire à celui du servlet et il est chargé en mémoire.
- Création d’instance – Après que la classe JSP est chargée en mémoire, son objet est instancié par le conteneur.
- Initialisation – La classe JSP est ensuite initialisée et elle se transforme d’une classe normale en servlet. Après l’initialisation, les objets ServletConfig et ServletContext deviennent accessibles à la classe JSP.
- Traitement de la demande – Pour chaque demande client, un nouveau thread est créé avec ServletRequest et ServletResponse pour traiter et générer la réponse HTML.
- Destruction – Dernière phase du cycle de vie JSP où elle est déchargée de la mémoire.
-
Méthodes du cycle de vie de JSP
Les méthodes du cycle de vie de JSP sont :
- jspInit() déclarée dans l’interface JspPage. Cette méthode est appelée une seule fois dans le cycle de vie de JSP pour initialiser les paramètres de configuration.
- _jspService(HttpServletRequest request, HttpServletResponse response) déclarée dans l’interface HttpJspPage et répondant à la gestion des demandes des clients.
- jspDestroy() déclarée dans l’interface JspPage pour décharger le JSP de la mémoire.
-
Exemple simple de JSP avec Eclipse et Tomcat
We can use Eclipse IDE for building dynamic web project with JSPs and use Tomcat to run it. Please read [Java Web Applications](/community/tutorials/java-web-application-tutorial-for-beginners#first-web-app-servlet) tutorial to learn how can we easily create JSPs in Eclipse and run it in tomcat. A simple JSP example page example is: `home.jsp`
```
<%@ page language="java" contentType="text/html; charset=US-ASCII"
pageEncoding="US-ASCII"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "https://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>First JSP</title>
</head>
<%@ page import="java.util.Date" %>
<body>
<h3>Hi Pankaj</h3><br>
<strong>Current Time is</strong>: <%=new Date() %>
</body>
</html>
```
If you have a simple JSP that uses only JRE classes, we are not required to put it as WAR file. Just create a directory in the tomcat webapps folder and place your JSP file in the newly created directory. For example, if your JSP is located at apache-`tomcat/webapps/test/home.jsp`, then you can access it in browser with URL `https://localhost:8080/test/home.jsp`. If your host and port is different, then you need to make changes in URL accordingly.
We can place JSP files at any location in the WAR file, however if we put it inside the WEB-INF directory, we wont be able to access it directly from client. We can configure JSP just like servlets in web.xml, for example if I have a JSP example page like below inside WEB-INF directory: `test.jsp`
```
<%@ page language="java" contentType="text/html; charset=US-ASCII"
pageEncoding="US-ASCII"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "https://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Test JSP</title>
</head>
<body>
Test JSP Page inside WEB-INF folder.<br>
Init Param "test" value =<%=config.getInitParameter("test") %><br>
HashCode of this object=<%=this.hashCode() %>
</body>
</html>
```
And I configure it in web.xml configuration as:
```
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xmlns="https://java.sun.com/xml/ns/javaee" xsi:schemaLocation="https://java.sun.com/xml/ns/javaee https://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" version="3.0">
<display-name>FirstJSP</display-name>
<servlet>
<servlet-name>Test</servlet-name>
<jsp-file>/WEB-INF/test.jsp</jsp-file>
<init-param>
<param-name>test</param-name>
<param-value>Test Value</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>Test</servlet-name>
<url-pattern>/Test.do</url-pattern>
</servlet-mapping>
<servlet>
<servlet-name>Test1</servlet-name>
<jsp-file>/WEB-INF/test.jsp</jsp-file>
</servlet>
<servlet-mapping>
<servlet-name>Test1</servlet-name>
<url-pattern>/Test1.do</url-pattern>
</servlet-mapping>
</web-app>
```
Then I can access it with both the URLs https://localhost:8080/FirstJSP/Test.do and https://localhost:8080/FirstJSP/Test1.do Notice that container will create two instances in this case and both will have their own servlet config objects, you can confirm this by visiting these URLs in browser. For Test.do URI, you will get response like below.
```
Test JSP Page inside WEB-INF folder.
Init Param "test" value =Test Value
HashCode of this object=1839060256
```
For Test1.do URI, you will get response like below.
```
Test JSP Page inside WEB-INF folder.
Init Param "test" value =null
HashCode of this object=38139054
```
Notice the init param value in second case is null because it's not defined for the second servlet, also notice the hashcode is different. If you will make further requests, the hashcode value will not change because the requests are processed by spawning a new thread by the container. Did you noticed the use of **config** variable in above JSP example but there is no variable declared, it's because its one of the 9 implicit objects available in JSP page, read more about them at [**JSP Implicit Objects**](/community/tutorials/jsp-implicit-objects "JSP Implicit Objects with Examples").
All the core JSP interfaces and classes are defined in `javax.servlet.jsp` package. Expression Language API interfaces are classes are part of `javax.servlet.jsp.el` package. JSP Tag Libraries interfaces and classes are defined in `javax.servlet.jsp.tagext` package. Here we will look into interfaces and classes of Core JSP API.
-
Interface JspPage
L’interface JspPage étend l’interface Servlet et déclare les méthodes du cycle de vie jspInit() et jspDestroy() des pages JSP.
-
Interface HttpJspPage
L’interface HttpJspPage décrit l’interaction qu’une classe d’implémentation de page JSP doit satisfaire lors de l’utilisation du protocole HTTP. Cette interface déclare la méthode de service de la page JSP pour le protocole HTTP comme public void _jspService(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException.
-
Classe abstraite JspWriter
Similaire à PrintWriter dans les servlets avec une fonctionnalité supplémentaire de prise en charge du buffering. Il s’agit d’une des variables implicites dans une page JSP avec le nom « out ». Cette classe étend java.io.Writer et le conteneur fournit sa propre implémentation pour cette classe abstraite et l’utilise lors de la traduction de la page JSP en Servlet. Nous pouvons obtenir son objet en utilisant la méthode PageContext.getOut(). La classe concrète Apache Tomcat pour JspWriter est
org.apache.jasper.runtime.JspWriterImpl. -
Classe abstraite JspContext
JspContext sert de classe de base pour la classe PageContext et abstrait toutes les informations qui ne sont pas spécifiques aux servlets. JspContext fournit un mécanisme pour obtenir le JspWriter pour la sortie, un mécanisme pour travailler avec les attributs et une API pour gérer les différents espaces de noms.
-
Classe abstraite PageContext
PageContext étend JspContext pour fournir des informations contextuelles utiles lors de l’utilisation de JSP pour les applications web. Une instance de PageContext donne accès à tous les espaces de noms associés à une page JSP, permet l’accès à plusieurs attributs de page, ainsi qu’une couche au-dessus des détails d’implémentation. Des objets implicites sont ajoutés automatiquement au pageContext.
-
Classe abstraite JspFactory
La classe JspFactory est une classe abstraite qui définit plusieurs méthodes de fabrique disponibles pour une page JSP à l’exécution dans le but de créer des instances de différentes interfaces et classes utilisées pour prendre en charge l’implémentation JSP.
-
Classe abstraite JspEngineInfo
La classe JspEngineInfo est une classe abstraite qui fournit des informations sur le moteur JSP actuel.
-
Classe ErrorData final
Contient des informations sur une erreur, pour les pages d’erreur.
-
Classe JspException
Une exception générique connue du conteneur JSP, similaire à ServletException. Si les pages JSP lèvent une JspException, le mécanisme errorpage est utilisé pour présenter les informations d’erreur à l’utilisateur.
-
Classe JspTagException
Exception à utiliser par un gestionnaire de balises pour indiquer une erreur irrécupérable.
-
Classe SkipPageException
Exception indiquant que la page appelante doit cesser l’évaluation. Lancée par un gestionnaire de balises simple pour indiquer que le reste de la page ne doit pas être évalué. Cette exception ne devrait pas être lancée manuellement dans une page JSP.
Since JSP is built on top of HTML, we can write comments in JSP file like html comments as `<-- This is HTML Comment -->` These comments are sent to the client and we can look it with view source option of browsers. We can put comments in JSP files as: `<%-- This is JSP Comment--%>` This comment is suitable for developers to provide code level comments because these are not sent in the client response.
Scriptlet tags are the easiest way to put java code in a JSP page. A scriptlet tag starts with `<%` and ends with `%>`. Any code written inside the scriptlet tags go into the `_jspService()` method. For example:
```
<%
Date d = new Date();
System.out.println("Current Date="+d);
%>
```
Since most of the times we print dynamic data in JSP page using _out.print()_ method, there is a shortcut to do this through JSP Expressions. JSP Expression starts with `<%=` and ends with `%>`. `<% out.print("Pankaj"); %>` can be written using JSP Expression as `<%= "Pankaj" %>` Notice that anything between `<%= %>` is sent as parameter to `out.print()` method. Also notice that scriptlets can contain multiple java statements and always ends with semicolon (;) but expression doesn't end with semicolon.
JSP Directives are used to give special instructions to the container while JSP page is getting translated to servlet source code. JSP directives starts with `<%@` and ends with `%>` For example, in above JSP Example, I am using _page_ directive to to instruct container JSP translator to import the Date class.
JSP Declarations are used to declare member methods and variables of servlet class. JSP Declarations starts with `<%!` and ends with `%>`. For example we can create an int variable in JSP at class level as `<%! public static int count=0; %>`
Once JSP files are translated to Servlet source code, the source code (.java) and compiled classes both are place in **Tomcat/work/Catalina/localhost/FirstJSP/org/apache/jsp** directory. If the JSP files are inside other directories of application, the directory structure is maintained. For JSPs inside WEB-INF directory, its source and class files are inside **Tomcat/work/Catalina/localhost/FirstJSP/org/apache/jsp/WEB\_002dINF** directory. Here is the source code generated for above test.jsp page. `test_jsp.java`
```
/*
* Generated by the Jasper component of Apache Tomcat
* Version: Apache Tomcat/7.0.32
* Generated at: 2013-08-21 03:40:59 UTC
* Note: The last modified time of this file was set to
* the last modified time of the source file after
* generation to assist with modification tracking.
*/
package org.apache.jsp.WEB_002dINF;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;
public final class test_jsp extends org.apache.jasper.runtime.HttpJspBase
implements org.apache.jasper.runtime.JspSourceDependent {
private static final javax.servlet.jsp.JspFactory _jspxFactory =
javax.servlet.jsp.JspFactory.getDefaultFactory();
private static java.util.Map<java.lang.String,java.lang.Long> _jspx_dependants;
private javax.el.ExpressionFactory _el_expressionfactory;
private org.apache.tomcat.InstanceManager _jsp_instancemanager;
public java.util.Map<java.lang.String,java.lang.Long> getDependants() {
return _jspx_dependants;
}
public void _jspInit() {
_el_expressionfactory = _jspxFactory.getJspApplicationContext(getServletConfig().getServletContext()).getExpressionFactory();
_jsp_instancemanager = org.apache.jasper.runtime.InstanceManagerFactory.getInstanceManager(getServletConfig());
}
public void _jspDestroy() {
}
public void _jspService(final javax.servlet.http.HttpServletRequest request, final javax.servlet.http.HttpServletResponse response)
throws java.io.IOException, javax.servlet.ServletException {
final javax.servlet.jsp.PageContext pageContext;
javax.servlet.http.HttpSession session = null;
final javax.servlet.ServletContext application;
final javax.servlet.ServletConfig config;
javax.servlet.jsp.JspWriter out = null;
final java.lang.Object page = this;
javax.servlet.jsp.JspWriter _jspx_out = null;
javax.servlet.jsp.PageContext _jspx_page_context = null;
try {
response.setContentType("text/html; charset=US-ASCII");
pageContext = _jspxFactory.getPageContext(this, request, response,
null, true, 8192, true);
_jspx_page_context = pageContext;
application = pageContext.getServletContext();
config = pageContext.getServletConfig();
session = pageContext.getSession();
out = pageContext.getOut();
_jspx_out = out;
out.write("\n");
out.write("<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"https://www.w3.org/TR/html4/loose.dtd\">\n");
out.write("<html>\n");
out.write("<head>\n");
out.write("<meta http-equiv=\"Content-Type\" content=\"text/html; charset=US-ASCII\">\n");
out.write("<title>Test JSP</title>\n");
out.write("</head>\n");
out.write("<body>\n");
out.write("Test JSP Page inside WEB-INF folder.<br>\n");
out.write("Init Param \"test\" value =");
out.print(config.getInitParameter("test") );
out.write("<br>\n");
out.write("HashCode of this object=");
out.print(this.hashCode() );
out.write("\n");
out.write("</body>\n");
out.write("</html>");
} catch (java.lang.Throwable t) {
if (!(t instanceof javax.servlet.jsp.SkipPageException)){
out = _jspx_out;
if (out != null && out.getBufferSize() != 0)
try { out.clearBuffer(); } catch (java.io.IOException e) {}
if (_jspx_page_context != null) _jspx_page_context.handlePageException(t);
else throw new ServletException(t);
}
} finally {
_jspxFactory.releasePageContext(_jspx_page_context);
}
}
}
```
Notice following points in above servlet code;
- The package of class starts with org.apache.jsp and if JSPs are inside other folders, it includes directory hierarchy too. Usually we dont care about it.
- The generates servlet class is final and can't be extended.
- It extends `org.apache.jasper.runtime.HttpJspBase` that is similar to HttpServlet except that it's internal to Tomcat JSP Translator implementation. HttpJspBase extends HttpServlet and implements HttpJspPage interface.
- Notice the local variables at the start of \_jspService() method implementation, they are automatically added by JSP translator and available for use in service methods, i.e in scriptlets.As a java programmer, sometimes it helps to look into the generated source for debugging purposes.
We can define init parameters for the JSP page as shown in above example and we can retrieve them in JSP using **config** implicit object, we will look into implicit objects in JSP in more detail in future posts.
We can override JSP init method for creating resources to be used by JSP service() method using JSP Declaration tags, we can override jspInit() and jspDestroy() or any other methods also. However we should never override \_jspService() method because anything we write in JSP goes into service method.
Apart from standard servlet attributes with request, session and context scope, in JSP we have another scope for attributes, i.e Page Scope that we can get from pageContext object. We will look it's importance in custom tags tutorial. For normal JSP programming, we don't need to worry about page scope.
C’est tout pour le tutoriel d’exemple JSP pour les débutants. J’espère que cela vous aide à comprendre les concepts de base des JSP et à vous lancer. Nous examinerons d’autres fonctionnalités des JSP dans les futurs articles.
Source:
https://www.digitalocean.com/community/tutorials/jsp-example-tutorial-for-beginners