Benvenuti al Tutorial sugli Esempi di JSP per principianti. Negli ultimi post, ho scritto molto su Java Servlet e ho ricevuto una risposta molto positiva dai nostri lettori. Quindi ho iniziato un’altra serie di tutorial su JSP e questo è il primo post della serie.
Tutorial sugli Esempi di JSP
In questo tutorial sugli esempi di JSP, esamineremo i concetti di base di JSP, i vantaggi di JSP rispetto ai Servlet, il ciclo di vita di JSP, le interfacce e le classi dell’API di JSP e dove possiamo posizionare i file JSP nell’applicazione web. Esamineremo anche i commenti di JSP, gli scriptlet, le direttive, le espressioni, le dichiarazioni e gli attributi di JSP in modo breve. Alcuni di questi argomenti sono molto importanti e li approfondiremo in dettaglio in futuri post.
Tutorial su JSP
- Cos’è JSP e perché ne abbiamo bisogno?
- Vantaggi di JSP rispetto ai Servlet?
- Ciclo di vita di una pagina JSP
- Metodi del ciclo di vita di JSP
- Esempio semplice di JSP con Eclipse e Tomcat
- Posizione dei file JSP nel file WAR dell’applicazione web
- Interfacce e classi API di JSP
- Interfaccia JspPage
- Interfaccia HttpJspPage
- Classe astratta JspWriter
- Classe astratta JspContext
- Classe astratta PageContext
- Classe astratta JspFactory
- Classe astratta JspEngineInfo
- Classe finale ErrorData
- Classe JspException
- Classe JspTagException
- Classe SkipPageException
-
Codice sorgente del Servlet trasformato da JSP e posizione del file di classe in Tomcat
-
Cosa è JSP e perché ne abbiamo bisogno?
JSP (JavaServer Pages) è una tecnologia lato server per creare applicazioni web dinamiche in Java. JSP può essere considerato come un’estensione della tecnologia servlet perché fornisce funzionalità per creare facilmente visualizzazioni utente. Una pagina JSP è composta da codice HTML e offre la possibilità di includere codice Java per il contenuto dinamico. Poiché le applicazioni web contengono molte schermate utente, le JSP sono molto utilizzate nelle applicazioni web. Per colmare il divario tra il codice Java e l’HTML in JSP, vengono fornite funzionalità aggiuntive come i Tag JSP, il Linguaggio di Espressione e i Tag Personalizzati. Questo rende facile la comprensione e aiuta uno sviluppatore web a sviluppare rapidamente le pagine JSP.
-
Vantaggi di JSP rispetto ai Servlet?
- Possiamo generare una risposta HTML anche da servlet, ma il processo è complicato e suscettibile di errori. Quando si tratta di scrivere una risposta HTML complessa, scriverla in una servlet può diventare un incubo. JSP ci aiuta in questa situazione e ci fornisce la flessibilità di scrivere una normale pagina HTML e includere il nostro codice Java solo dove è necessario.
- JSP fornisce funzionalità aggiuntive come librerie di tag, linguaggio di espressione, tag personalizzati che aiutano nello sviluppo più rapido delle viste degli utenti.
- Le pagine JSP sono facili da distribuire, dobbiamo solo sostituire la pagina modificata nel server e il contenitore si occupa della distribuzione. Per le servlet, è necessario ricompilare e distribuire l’intero progetto di nuovo. In realtà, le servlet e JSP si completano a vicenda. Dovremmo usare le servlet come controller lato server e per comunicare con le classi del modello, mentre le JSP dovrebbero essere utilizzate per il livello di presentazione.
-
Ciclo di vita della pagina JSP
Il ciclo di vita di una pagina JSP è gestito anche dal container. Di solito ogni container web che contiene il container dei servlet contiene anche il container JSP per la gestione delle pagine JSP. Le fasi del ciclo di vita delle pagine JSP sono le seguenti:
- Traduzione – Le pagine JSP non assomigliano alle normali classi Java, in realtà il container JSP analizza le pagine JSP e le traduce per generare il codice sorgente del servlet corrispondente. Se il nome del file JSP è home.jsp, di solito viene chiamato home_jsp.java.
- Compilazione – Se la traduzione ha successo, il container compila il file sorgente del servlet generato per generare il file di classe.
- Caricamento della classe – Una volta che la JSP viene compilata come classe servlet, il suo ciclo di vita è simile a quello del servlet e viene caricata in memoria.
- Creazione dell’istanza – Dopo che la classe JSP è caricata in memoria, il container istanzia il suo oggetto.
- Inizializzazione – La classe JSP viene quindi inizializzata e si trasforma da una classe normale a un servlet. Dopo l’inizializzazione, gli oggetti ServletConfig e ServletContext diventano accessibili alla classe JSP.
- Elaborazione della richiesta – Per ogni richiesta del client, viene generato un nuovo thread con ServletRequest e ServletResponse per elaborare e generare la risposta in HTML.
- Distruzione – Ultima fase del ciclo di vita della JSP in cui viene scaricata dalla memoria.
-
Metodi del ciclo di vita di JSP
I metodi del ciclo di vita di JSP sono:
- jspInit() dichiarato nell’interfaccia JspPage. Questo metodo viene chiamato solo una volta nel ciclo di vita di JSP per inizializzare i parametri di configurazione.
- _jspService(HttpServletRequest request, HttpServletResponse response) dichiarato nell’interfaccia HttpJspPage e gestisce le richieste del client.
- jspDestroy() dichiarato nell’interfaccia JspPage per scaricare JSP dalla memoria.
-
Esempio semplice di JSP con Eclipse e 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.
-
Interfaccia JspPage
L’interfaccia JspPage estende l’interfaccia Servlet e dichiara i metodi del ciclo di vita jspInit() e jspDestroy() delle pagine JSP.
-
Interfaccia HttpJspPage
L’interfaccia HttpJspPage descrive l’interazione che una classe di implementazione di una pagina JSP deve soddisfare quando si utilizza il protocollo HTTP. Questa interfaccia dichiara il metodo di servizio della pagina JSP per il protocollo HTTP come public void _jspService(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException.
-
Classe astratta JspWriter
Simile a PrintWriter nei servlet con il supporto aggiuntivo del buffering. Questa è una delle variabili implicite in una pagina JSP con il nome “out”. Questa classe estende java.io.Writer e il contenitore fornisce la propria implementazione per questa classe astratta e la utilizza durante la traduzione della pagina JSP in Servlet. Possiamo ottenere il suo oggetto utilizzando il metodo PageContext.getOut(). La classe concreta di Apache Tomcat per JspWriter è
org.apache.jasper.runtime.JspWriterImpl. -
Classe astratta JspContext
JspContext serve come classe di base per la classe PageContext e astrae tutte le informazioni non specifiche per i servlet. JspContext fornisce un meccanismo per ottenere JspWriter per l’output, un meccanismo per lavorare con attributi e API per gestire i diversi spazi dei nomi.
-
Classe astratta PageContext
PageContext estende JspContext per fornire informazioni di contesto utili quando JSP viene utilizzato per le applicazioni web. Un’istanza di PageContext fornisce accesso a tutti i namespace associati a una pagina JSP, fornisce accesso a diversi attributi di pagina, nonché a uno strato superiore dei dettagli di implementazione. Gli oggetti impliciti vengono aggiunti automaticamente al pageContext.
-
Classe astratta JspFactory
La classe JspFactory è una classe astratta che definisce una serie di metodi di fabbrica disponibili per una pagina JSP durante l’esecuzione per creare istanze di varie interfacce e classi utilizzate per supportare l’implementazione JSP.
-
Classe astratta JspEngineInfo
La classe JspEngineInfo è una classe astratta che fornisce informazioni sull’engine JSP corrente.
-
Classe finale ErrorData
Contiene informazioni su un errore, per le pagine di errore.
-
Classe JspException
Un’eccezione generica conosciuta dal contenitore JSP, simile a ServletException. Se le pagine JSP generano una JspException, viene utilizzato il meccanismo delle pagine di errore per presentare le informazioni sugli errori all’utente.
-
Classe JspTagException
Eccezione da utilizzare da un gestore di tag per indicare un errore irreversibile.
-
Classe SkipPageException
Eccezione per indicare che la pagina chiamante deve interrompere la valutazione. Lanciata da un gestore di tag semplice per indicare che il resto della pagina non deve essere valutato. Questa eccezione non dovrebbe essere lanciata manualmente in una pagina 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.
{
“error”: “Upstream error…”
}
Source:
https://www.digitalocean.com/community/tutorials/jsp-example-tutorial-for-beginners