Java lezione 17

JSP
Le Java Server Page sono essenzialmente script Server-
Side inseriti all’interno dell’HTML.
Sono in pratica la risposta java a ASP e PHP con tutti i
vantaggi di un potente linguaggio O.O. ricco di risorse.
Sono oggi la miglior soluzione, in abbinamento alle
Servlet e ai JavaBean per le applicazioni Enterprise.

Perché usare JSP e non
Servlet
 Spesso in una servlet una parte significativa del codice consiste in istruzioni
out.println() per produrre codice HTML
 Le pagine JSP possono essere viste come una soluzione per scrivere
servlet partendo dal codice HTML
L’idea è quella di scrivere codice HTML e di includervi (attraverso speciali
marcatori) istruzioni
 A partire da questo codice viene generata una servlet automaticamente da
parte del Server Web (Tomcat ad esempio): in particolare se la JSP è alla
sua prima esecuzione viene generata la Servlet, viene compilata ed
eseguita. Alle esecuzioni successive viene verificata la versione e viene
ricostruita la servlet solo se ci sono state modifiche.

Esempio di JSP
<html>
<head>
<title>Servlet Semplice</title>
</head>
<body>
<h1>Questa servlet contiene tanto codice HTML</h1>
....
<h1>e un piccolo elemento dinamico:
<%= new java.util.Date() %> </h1>
</body>
</html>

Configurazioni
Le JSP rispetto alle Servlet non richiedono configurazioni particolari:
• basta copiare il file (con estensione obbligatoria .jsp) nella cartella Web,
senza apportare modifiche al file web.xml;
• Le Servlet generate automaticamente vengono generate nella cartella
work è quindi possibile vedere il codice generato. Si può in particolare
notare un metodo _jspService()

Scripting Element
Tre diversi tipi di scripting element:
– Espressioni: <%= espressione Java %>
sono tradotte in istruzioni di output da inserire nel corpo del metodo
_jspService()
In generale possimo dire che sono un modo sintetico per
scrivere una scriptlet con un metdo di stampa out.println(…)
– Scriplet: <%
codice java
%>
sono inserite nel corpo del metodo _jspService()
– Dichiarazioni : <%! codice %>
sono inserite nel corpo della classe del servlet, fuori dai metodi, sono dichiarazioini di
attributi o metodi di istanza della classe.

Esempio di dichiarazione
<HTML>
<HEAD>
<TITLE>Dichiarazioni</TITLE>
</HEAD>
<BODY>
<H1>Esempio Dichiarazioni</H1>
<%! private double converti(double a){
double b;
b= a*2.54;
return b;
}%>
… <H2> <%= converti(778) %> </H2>
</BODY>
</HTML>

Direttive
Per le direttive, istruzioni inviate al servlet engine che descrivono il
codice che deve essere generato si utilizza <%@
Ad esempio per includere un file a tempo di traduzione
<%@ include file=“prova.jsp” %>
Altra direttive molto usate sono:
<%@ page import=“java.math.*, java.security.*” %>
<%@ page contentType=“application/vnd.ms-excel” %>
<%@ page errorPage = "errorpage.jsp" %> reindirizza
l’autput d’errore
<%@ page isErrorPage="true" %> imposta una pagina
come gestore errori
(le pagine d’errore possono utilizzare l’oggetto

Oggetti predefiniti
Nelle pagine JSP esistono alcuni oggetti predefiniti che possono
essere liberamente utilizzati:
– request
– response
– session
– out
– application
– config
(Leggendo infatti le Servlet generate automaticamente si nota che
questi oggetti vengono istanziati all’inizio del metodo doGet)

Lettura parametri
La lettura dei parametri provenienti da un’altra pagina, sia in
modalità GET, sia POST viene realizzata tramite il metodo:
String param=request.getParameter(“paremetro”);
In caso di assenza del parametro il metodo ritorna null

Uso del tag <jsp:
La maggior parte del comandi JSP possono essere
impartiti utilizzando il tag <jsp:xxxx>: questa
modalità prevede una sintassi totalmente xml per le
nostre pagine, inoltre permette di utilizzare
parametri aggiuntivi non possibili altrimenti:
Include
<jsp:include page="header.jsp" flush="true“>
<jsp:param name="employee" value=“Paola" />
<jsp:param name="title" value="Teacher" />
</jsp:include>
forward
<jsp:forward page="SamsHome.jsp">
<jsp:param name="employee" value="Bob" />
<jsp:param name="title" value="Senior Engineer"
/>
</jsp:forward>

JSP – Bean -Servlet
In applicazioni complesse vengono spesso a convinere Servlet e JSP ed è
particolarmente indicato l’uso di Java Beans che nascondono i dettagli
implementativi.
 La richiesta originale è processata da una servlet
 La Servlet elabora i dati della richiesta, recupera dati da un database, processa
le informazioni, etc.
 I risultati sono memorizzati in bean
 La richiesta è reindirizzata a una pagina JSP per formattare il risultato
 Possiamo usare pagine JSP differenti per presentazioni differenti

Java Bean
I Bean sono classi java che rispettano alcune regole più restrittive di
una classe comune:
1. Devono avere un costruttore senza parametri
2. Tutti gli attributi devono essere privati
3. I metodi di accesso agli attributi devono chiamarse getXXX() e
setXXX() con eccezione degli attributi boolenani per cui il
metodo di lettura sarà isXXX()

Uso dei bean da JSP
<jsp:useBean id="book1" class="coreservlets.Book" />
Che equivale a creare un istanza
<% coreservlets.Book book1 = new coreservlets.Book();
%>
L’uso del primo formato è però da preferire perché ci
consente di specificare altri parametri.
Particolarmente interessante è lo scope di un Bean che
consente rendere un bean condiviso tra più pagine.
Accesso alle proprietà di un Bean:
<jsp:getProperty name="book1" property="title" />
equivale a <%= book1.getTitle() %>
------------------------------------------------------
------
<jsp:setProperty name="book1"
property="title“ value="Core Servlets and JavaServer
Pages" />

Uso della proprietà scope
Uno dei vantaggi dell’uso della direttiva
<jsp:useBean è la possibilità di impostare uno scope
per il bean:
Lo scope di un bean può assumere i seguenti valori:
•page (valore di default)
il bean è locale, può essere posto nel
PageContext
•application
il bean è condiviso tra tutte le servlet:
appartiene al ServletContext
•session
il bean appartine al contesto locale della
sessione: HttpSession
•request
simile al page, ma può essere posto nel
ServletRequest per la durata della richiesta corrente

Uso della proprietà scope: esempio
<jsp:useBean id="counter“
class="coreservlets.AccessCountBean“ scope="application">
<jsp:setProperty name="counter“ property="firstPage“
value="Current Page Name" />
</jsp:useBean>
La pagina contenente il contataore è stata usata
<jsp:getProperty name="counter" property="accessCount" />
volte.package coreservlets;
public class AccessCountBean {
private String firstPage;
private int accessCount = 1;
public String getFirstPage() {return firstPage ;}
public void setFirstPage(String firstPage) { this.firstPage = firstPage;}
public int getAccessCount() {return(accessCount++);}
}

Note: setProperty
<jsp:useBean id="counter“
class="coreservlets.AccessCountBean“ scope="application">
<jsp:setProperty name="counter“ property="firstPage“
value=“SharedPage.jsp" />
</jsp:useBean>
Si noti che il tag <jsp:useBean id=“counter”…../> provoca la
creazione di un nuovo bean solo se non ne esiste un con lo
stesso ID, quindi le istruzioni soprastanti includendo nel
tag anche l’inizializzazione fanno si che se l’ID è già
presente non viene eseguita neppure l’inizializzazione.

Note: setProperty e request
SetProperty permette di assegnare esplicitamente un valore ad
una proprietà:
<jsp:setProperty name=“prodotto“ property=“name“
value=“PC" />
Ma essendo setProperty fortemente legato a request, è
possibile caricare una proprietà direttamente dal valore
proveniente dalla pagina precedente, come se si fosse
invocato un request.getParameter(“nome”);
<jsp:setProperty name=“prodotto“ property=“name“
param=“nome" />
Addirittura è possibile, avendo cura di dare ai parametri del
form gli stessi nomi degli attributi del bean, caricare
tutte le proprietà con un’unica istruzione:
<jsp:setProperty name=“prodotto“ property=“*" />

Custom Tags
Sono elementi personalizzati di JSP che incapsulano
alcune funzionalità ricorrenti. La distribuzione di
questi tags avviene tramite un così detto tag library.
La possibilità di realizzare tags customizzati ha
permesso la realizzazione di librerie standard come la
JSTL (java standard tags library) che permettono di
imparare un certo numero di tag di utility (il cui
codice è error-free e ottimizzato) e di utilizzarle in
tutte le applicazioni JSP.
<c:forEach var="item" items="$
{sessionScope.cart.items}">
...
</c:forEach>

Custom Tags
Creare un tag personalizzato comporta la scrittura
o la modifica di 4 file:
•Il file JSP: in cui il tag viene usato;
•Una classe java: che esegue la funzionalità
richiesta dal tag;
•Modifica del file web.xml: introducendo la chiave
<taglib>;
•Un file TLD: file descrittore del tag creato;

Custom Tags(file JSP)
Quindi è necessario creare il file jsp
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<%@ taglib uri=" http://myserver/myfolder/examples-taglib "
prefix="cjsp" %>
<TITLE><cjsp:esempio /></TITLE>
<LINK REL=STYLESHEET HREF="JSP-Styles.css“ TYPE="text/css">
</HEAD>
<BODY>
<H1><cjsp:esempio /></H1>
<cjsp:esempio />
</BODY>
</HTML>
(Si noti che l’URI deve corrispondere nei tre file web.xml, miotag.tld,
esempio.jsp)

Custom Tags (la classe java)
In primo luogo è necessario definire una classe da
porre nella cartella classes:
package utilility.tags;
import javax.servlet.jsp.*;
import javax.servlet.jsp.tagext.*;
import java.io.*;
/** Semplice tag che inserisce una stringa
* Il nome del TAG è definito nel Tag Library Descriptor (TLD)
* Tale file è puntato dalla direttiva taglib del file JSP.
*/
public class ExampleTag extends TagSupport
{
public int doStartTag()
{
try {
JspWriter out = pageContext.getOut();
out.print(“Esempio di custom-tag (utility.tags.ExampleTag)");
} catch(IOException ioe) {System.out.println("Error in
ExampleTag: " + ioe);}
return(SKIP_BODY);
}
}

Custom Tags(file TLD)
Poi è necessario definire un file descrittore (tag
library descriptor):
cjsp-taglib.tld (le varie versioni di Tomcat possono
avere sintassi diverse di questo file, comunque è
necessario prestare attenzione anche agli spazi).
<?xml version="1.0" encoding="ISO-8859-1" ?>
<!DOCTYPE taglib PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag
Library 1.2//EN"
"http://java.sun.com/j2ee/dtds/web-jsptaglibrary_1_2.dtd">
<taglib>
<tlib-version>1.0</tlib-version>
<jsp-version>1.2</jsp-version>
<short-name>cjsp</short-name>
<uri> http://myserver/myfolder/examples-taglib </uri>
<description>Un esempio di TAG customizzato</ description >
<tag>
<name>esempio</name>
<tag-class>utility.tags.ExampleTag</tag-class>
<body-content>EMPTY</body-content>
<description> Inserisce un testo in output</description>
</tag>
<!– Evetuali altri TAG... -->
</taglib>

Custom Tags(web.xml)
Introdurre un riferimento al TLD nel file web.xml
<taglib>
<taglib-uri>
http://myserver/myfolder/examples-taglib
</taglib-uri>
<taglib-location>
/WEB-INF/jsp/cjsp-taglib.tld
</taglib-location>
</taglib>
Nella versione 5 di Tomcat è necessario utilizzare la chiave <jsp-
config> in cui porre <taglib>

Assegnare attributi a TAG
1) File TLD
<tag>
<name>prime</name>
<tag-class>utility.tags.PrimeTag</tag-class>
<body-content>EMPTY</body-content>
<description >Produce un numero casuale.</description>
<attribute>
<name>length</name>
<required>false</required>
<rtexprvalue>false</rtexprvalue> indica se l’attributo può
essere una variabile JSP
</attribute>
</tag>
2)File Java
Metodo
setLength(String length)
{ this.length=Integer.parseInt(length);}
2)File JSP
<csajsp:prime length=“10" />
(attenzione anche all’ordine degli elementi nel file web.xml)
,

TAG Con il body
1) Il metodo doStartTag deve ritornare:
return(EVAL_BODY_TAG); // Include tag body
2) Potrebbe essere necessario un metodo per chiudere il TAG:
public int doEndTag() {
try { JspWriter out = pageContext.getOut();
out.print("</SPAN></TABLE>");
} catch(IOException ioe) {System.out.println("Error in HeadingTag: " +
ioe);}
return(EVAL_PAGE); // Continue with rest of JSP page
}

Manipolazione del BODY
Il caso si voglia elaborare il contenuto del body non basta più estendere
TagSupport, ma si deve estendere BodyTagSupport:
public class FilterTag extends BodyTagSupport {
public int doAfterBody()
{
BodyContent body = getBodyContent();
String filteredBody
=ServletUtilities.filter(body.getString());
try { JspWriter out = body.getEnclosingWriter();
out.print(filteredBody);
} catch(IOException ioe) {System.out.println("Error in FilterTag:
" + ioe);}
return(SKIP_BODY);
}
}
Il metodo doAfterBody permette di elaborare il body, che viene letto
preventivamente tramite getBodyContent.
La classe BodyContent incapsula alcuni metodi tra cui getString(), gerReader()
e getEnclosingWriter();

Manipolazione del BODY
Il file TLD deve prevedere il tag <body-content>JSP</body-content>
<tag>
<name>filter</name>
<tag-class>coreservlets.tags.FilterTag</tag-class>
<body-content>JSP</body-content>
<description>Replaces HTML-specific characters in
body.</description>
</tag>

Java lezione 17

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Ähnlich wie Java lezione 17

Ähnlich wie Java lezione 17 (20)

Mehr von Sergio Ronchi

Mehr von Sergio Ronchi (20)

Java lezione 17