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 HTMLL’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 exception)

Oggetti predefinitiNelle 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 parametriLa 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

Modello:

Java BeanI Bean sono classi java che rispettano alcune regole più

restrittive di una classe comune:1. Devono avere un costruttore senza parametri2. Tutti gli attributi devono essere privati3. 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" />equivale a<% book1.setTitle("Core Servlets and JavaServer Pages"); %>

Uso della proprietà scopeUno 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

•applicationil bean è condiviso tra tutte le servlet:

appartiene al ServletContext•session

il bean appartine al contesto locale della sessione: HttpSession

•requestsimile 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 requestSetProperty 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 TagsSono 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>(Ad esempio questo tag permette di scorrere il

carrello della spesa)

Custom TagsCreare 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);}

}

(Nota SKIP_BODY dev’essere ritornato dai TAG che non gestiscono il corpo)

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>

(Alcuni tool, come NetBean, generano automaticamente questo file)

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 TAG1) 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 JavaMetodo 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 body1) 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 BODYIl 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 BODYIl 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

Software

Transcript of Java lezione 17