Servlet e Java Server Pages
• Servlet sono ottime per programmare
applicazioni Server side complesse, ma poco
adatte a generazione di interfaccia utente
• JSP introdotte per facilitare stesura di
interfaccia utente
– permettono scrittura diretta di codice HTML,
anzichè richiedere inserimento di codice in
PrintWriter, riga per riga
– permettono di inserire codice java (scriptlets) per
implementare semplici operazioni
Laboratorio di Servizi Web - JSP Ardissono
1
Java Server Pages - I
• Volte a semplificare creazione e gestione di pagine
dinamiche (sintatticamente simili a PHP e ASP)
• Combinano markup statico (HTML) con tag di
scripting
http:130.192.241.1:10000/swebi/data.jsp
<%@page import="java.util.Date"%>
<html>
<body>
The current time is <%= (new Date()).toString() %>
</body>
</html>
data.jsp
Salvare temporaneamente data.jsp a root di contesto (swebi)
Laboratorio di Servizi Web - JSP Ardissono
2
Java Server Pages - II
• Basate su tecnologia Servlet
• Da JSP Web Container genera Servlet S equivalente
– S contiene package e imports necessari
– S implementa metodo doGet/doPost che crea pagina di
output di JSP (usa PrintWriter, definisce formato di
output, scrive su PrintWriter per generare codice HTML
statico, permette invocazione di metodi java)
• Generazione e compilazione avvengono a primo
richiamo di JSP da parte di client (translation time)
• Poi ogni richiamo di JSP causa esecuzione di S
(run time)
Laboratorio di Servizi Web - JSP Ardissono
3
Translation time e run time
usa
JSP
<JSP tags>
<java code>
JSP
<JSP tags>
<java code>
Prima richiesta
Web
browser
usa
Risposta generata
Traduzione
JSP
<JSP tags>
<java code>
Servlet
Richieste successive
Laboratorio di Servizi Web - JSP Ardissono
4
Espansione di JSP
• Web Container implementa interfaccia
javax.servlet.jsp.HttpJspPage
• Da pagina JSP Web Container genera Servlet che
estende implementazione di HttpJspPage
• javax.servlet.jsp.HttpJspPage
– public void jspInit(): metodo invocato da Web
Container a tempo di inizializzazione di servlet
generata
– public void jspDestroy(): invocato a tempo di
distruzione di servlet
– public void _jspService(HttpServletRequest request,
HttpServletResponse response) throws
ServletException, IOException: ad ogni HTTP request
Laboratorio di Servizi Web - JSP Ardissono
5
Struttura di una JSP
• A metà tra pagina statica e Servlet. Contiene
– codice java racchiuso tra <% e %>
– tag HTML e XML-like
– testo, ...
• Categorie di JSP tag
– JSP Directives
– Scripting elements
– Actions <%@page import="java.util.Date"%>
<html>
<body>
The current time is <%= (new Date()).toString() %>
</body>
</html>
data.jsp
Laboratorio di Servizi Web - JSP Ardissono
6
JSP directives
• <%@ directiveName attribute=“value”
attribute=“value” ... %>
– Es: <%@page import="java.util.Date"%>
• istruzioni che danno specifiche per generazione di
codice effettuata da Web Container quando crea
Servlet
• non producono output per generazione di risposta
a invocazione di JSP
• influenzano intera pagina JSP (non altre pagine di
applicazione)
• Directives: page, include, taglib
Laboratorio di Servizi Web - JSP Ardissono
7
JSP directives - page
• <%@ page attribute=“val” attribute=“val” ... %>
– Es: <%@page import="java.util.Date,java.rmi.*” session=“true”
isThreadSafe=“true” %>
• JSP può contenere + page directives ma ciascun attributo
(eccetto import) può comparire al più una volta
• Alcuni attributi (vd libro per gli altri)
– import: specifica classi da importare per esecuzine di JSP
– session: specifica se pagina partecipa ad HttpSession
• Se session=“true” pagina può usare oggetto implicito session per
accedere a dati di sessione utente
• se session=“false” non si gestisce sessione utente
• default: session=“true”
– errorPage: specifica URL di pagina JSP di applicazione
invocata in caso di eccezioni
Laboratorio di Servizi Web - JSP Ardissono
8
JSP directives - include - I
• <%@ include file=“fileName” %>
• specifica che durante generazione di Servlet il
Web Container deve includere risorsa specificata
• fileName: path relativo a contesto di applicazione
<%@page import="java.util.Date"%>
<html>
<body>
The current time is <%= (new Date()).toString() %>
<%@ include file=”JSP-EX/prova.html" %>
</body>
swebi
</html>
src
JSP-EX WEB-INF
Laboratorio di Servizi Web - JSP Ardissono
9
prova.html
Laboratorio di Servizi Web - JSP Ardissono
10
JSP directives - include - II
• Contenuto di file incluso è analizzato
sintatticamente a translation time
• si possono includere vari tipi di file: html, jsp, …
– Es: esempio.jsp contiene il seguente directive:
<@% include file=“JSP-EX/inclusa.jsp” %>
– inclusa.jsp contiene codice
<%@page import="java.util.Date"%>
<%= “data odierna: “ + new Date() %>
• se file modificato, non è garantito che Web
Container ricompili automaticamente JSP
Laboratorio di Servizi Web - JSP Ardissono
11
JSP directives - include - III
Servlet generata a partire da JSP (circa…)
public class esempio extends
javax.servlet.jsp.HttpJspPage ... {
public void _jspService(HttpServletRequest request,
HttpServletResponse response) throws … {
...
out.write(“<html>\r\n >head>\r\n …..
out.print(“data odierna: “ + new Date());
…
out.close(); }
...
}
Laboratorio di Servizi Web - JSP Ardissono
12
NB: packaging di JSP
• Potete organizzare le JSP in directory sotto vostro
contesto di applicazione ma
– directory deve essere leggibile e attraversabile
da tutti
– la prima JSP invocata per accedere ad
applicazione deve stare sotto swebi (se no web
container inserisce JSP-EX in path relativi)
swebi
src
JSP-EX WEB-INF
Laboratorio di Servizi Web - JSP Ardissono
13
JSP directives - taglib (cenni)
• <%@ taglib uri=“tagLibraryURI”
URI di descrittore
prefix=“tagPrefix” %>
Prefisso da usare per
identificare tag library
<myTag:tagname … />
di libreria di tag
•
• Directive taglib permette che pagina JSP utilizzi
tag extensions (custom tags)
• tag extensions: si definiscono tag associati a
codice java
• directive taglib specifica tag library contenente
codice java compilato che definisce tag da usare
Laboratorio di Servizi Web - JSP Ardissono
14
Scripting elements
• Permettono di inserire codice java in pagina JSP
– dichiarazioni di variabili
– dichiarazioni di metodi
– scriptlets: blocchi di codice eseguiti quando client
richiede pagina JSP
– espressioni
<%! int anno = 2003;
Dichiarazioni di
public String saluta(String name) {
variabili e metodi
return “Ciao, “ + name + “!!”; }
%>
<html><head>…</head>
Espressione
Espressione
<body>
<p> Ciao <%= saluta(“carissimo”)%>, siamo nel <%= anno %>
</body></html>
Laboratorio di Servizi Web - JSP Ardissono
15
Scripting elements: dichiarazioni di
variabili e metodi
•
•
•
•
<% dichiarazioni di variabili e metodi java %>
inserite come elementi globali in Servlet generata
variabili inizializzate quando Servlet inizializzata
non producono output
<%! int anno = 2003;
Dichiarazioni di
public String saluta(String name) {
variabili e metodi
return “Ciao, “ + name + “!!”; }
%>
<html><head>…</head>
<body>
<p> Ciao <%= saluta(“carissimo”)%>, siamo nel <%= anno %>
</body></html>
Laboratorio di Servizi Web - JSP Ardissono
16
Scripting elements: scriptlets - I
• <% statements java %>
• blocchi di codice java eseguiti a tempo di
processamento di richiesta HTTP
• possono produrre output per client
• se pagina contiene più scriptlets, questi vengono
combinati e Servlet generata li contiene
nell’ordine in cui appaiono in JSP
Laboratorio di Servizi Web - JSP Ardissono
17
Scripting elements: scriptlets - II
<html><head>…</head>
<body>
<h1> prova di scriptlet </h1>
<%
for (int i=0; i<5; i++) {
out.println(“ciao n. “ + i);
}
%>
</body></html>
testScriptlet.jsp
http:130.192.241.1:10000/swebi/JSP-EX/testScriptlet.jsp
Laboratorio di Servizi Web - JSP Ardissono
18
Scripting elements: scriptlets - III
In JSP si può inserire codice statico in scriptlets, utilizzando
statement complessi (con parentesi graffe)
Molto simile
<html><head>…</head>
a PHP e ASP.
<body>
Poco leggibile
<h1> prova di scriptlet complessa </h1>
<%
if (18>= request.getParameter(“age”)) {
%>
Sei maggiorenne, dunque puoi votare!!
<% } else { %>
Mi spiace, ancora non hai diritto di voto.
<% } %>
</body></html>
testScriptlet2.jsp
Laboratorio di Servizi Web - JSP Ardissono
19
Scripting elements: espressioni
• <%= espressione java da valutare %>
• Permettono di valutare espressioni java
(invocazione metodi, valutazione variabili) e
inviare risultato a client in output stream (String)
• Sono scriptlets abbreviate
<%! int anno = 2003;
public String saluta(String name) {
return “Ciao, “ + name + “!!”; }
%>
<html><head>…</head>
Espressione
Espressione
<body>
<p> Ciao <%= saluta(“carissimo”)%>, siamo nel <%= anno %>
</body></html>
Laboratorio di Servizi Web - JSP Ardissono
20
Scriptlets e JavaBeans
• Utile per applicazioni molto semplici
• Se si inserisce troppo codice in JSP
– pagine risultano difficili da leggere
– si perde separazione tra aspetti di interfaccia e di
sviluppo di logica applicativa (obiettivo iniziale di
sviluppo di JSP!)
• Introdotto uso di Java Beans per separare logica
applicativa da markup in JSP
– JSP include markup HTML e invocazione di metodi su
bean
– Java Bean implementa codice dei metodi (accesso a
DB, …)  meno codice java presente in JSP
Laboratorio di Servizi Web - JSP Ardissono
21
JSP: Architettura Model 1
1
request
4
response
Web
browser
Web
browser
Web
server
JSP
2
JavaBean
3
Web container
Laboratorio di Servizi Web - JSP Ardissono
22
JSP e java beans – acquisizione dati da form
• In JSP si può dichiarare che si utilizza istanza
di classe (JavaBean) per
– salvare parametri di richieste HTTP
– recuperare valore di tali parametri quando serve
• dati (parametri) acquisiti attraverso form in
JSP vengono “automaticamente” salvati in
properties del bean usato da JSP
• bean serve come raccoglitore di dati acquisiti
da form
Laboratorio di Servizi Web - JSP Ardissono
23
Esempio - form
parametro “login”
parametro “tipoInfo”:
no, nomi, cc
Invocazione di JSP che
usa javaBean (SimpleBean.java)
Laboratorio di Servizi Web - JSP Ardissono
24
Esempio - Estratto di JSP
Dichiarazione
bean usato
<jsp:useBean id=“sBean" scope="page"
class="application.other.SimpleBean"/>
<jsp:setProperty name=“sBean" property="*"/>
<HTML>
<HEAD>...</HEAD>
<BODY> …
<p><center>
Ciao
Salva valore dei parametri di richiesta
HTTP con nome = property di bean
<jsp:getProperty name=“sBean" property="login"/> !
</center>
Recupera valore property
</p>
per visualizzaz
<p>
Hai richiesto la seguente operazione:
<jsp:getProperty name=“sBean" property="tipoInfo"/>
</p>
Visualizza codice interno
</BODY></HTML>
di operaz scelta
Laboratorio di Servizi Web - JSP Ardissono
25
Esempio - Pagina visualizzata
Ciao liliana!
Hai richiesto la seguente operazione: nomi
Laboratorio di Servizi Web - JSP Ardissono
26
Esempio : SimpleBean.java
package …;
public class SimpleBean {
private String login;
private String tipoInfo;
public SimpleBean() { }
Properties con nome che
coincide con parametri di
HTTPServletRequest
public void setLogin(String login)
{this.login = login; }
public String getLogin()
{return login; }
• memorizza
login di utente
(login) e tipo di
info richieste da
utente
public void setTipoInfo(String tipoInfo)(tipoInfo)
{this.tipoInfo = tipoInfo;}
public String getTipoInfo()
{return tipoInfo;}
}
Laboratorio di Servizi Web - JSP Ardissono
27
Commenti
Bean associato a
singola JSP
(scope=“page”)
<jsp:useBean id=“sBean" scope="page"
class="application.other.SimpleBean"/>
<jsp:setProperty name=“sBean" property="*"/>
<HTML>
…
Salvataggio dati utente: istanza di bean salva variabili di stato
localmente ad esecuzione di JSP (se bean vivesse per
tutta la sessione utente lo potrebbero usare anche altre JSP
per recuperare variabili di stato (vd dopo)
Ciao
<jsp:getProperty name=“sBean" property="login"/> !
</center>
</p>
…..
Laboratorio di Servizi Web - JSP Ardissono
28
JSP e java beans – logica applicativa
• Istanza di Java Bean usata anche per eseguire
metodi di gestione di logica applicativa (in
base a dati forniti da utente via form HTML)
– definizione di metodi aggiuntivi rispetto a quelli di
gestione di properties associate ai parametri di
richieste HTTP
– Tali metodi sono invocati da JSP per gestire
richieste utente
Laboratorio di Servizi Web - JSP Ardissono
29
Java Bean
• Java Bean: Classe che definisce il bean deve
seguire standard di definizione dei javaBeans
– getXXX di ogni proprietà XXX del javaBean, per
leggere valore di property
– setXXX di ogni proprietà XXX del javaBean, per
assegnare valore a property
• Logica applicativa può essere implementata
definendo metodi di setXXX() e getXXX() che
effettuano i servizi necessari
Laboratorio di Servizi Web - JSP Ardissono
30
Gestione logica applicativa - esempio esteso
Ciao franca!
Hai richiesto la seguente operazione: nomi persone
(codice interno: nomi)
Formato esterno
tradotto da bean (logica
Valore parametro
applicativa)
“tipoInfo”
Laboratorio di Servizi Web - JSP Ardissono
31
Estratto di JSP – esempio esteso
<jsp:useBean id="opBean" scope="page"
class="application.other.OPBean"/>
<jsp:setProperty name="opBean" property="*"/>
<HTML>
<HEAD><TITLE>...</TITLE></HEAD>
<BODY> <h1> … </h1>
<p><center>
Ciao
<jsp:getProperty name="opBean" property="login"/> !
</center></p>
Invocazione metodo di
<p>
traduzione (logica app)
Hai richiesto la seguente operazione:
<jsp:getProperty name="opBean" property="operazione"/>
(codice interno <jsp:getProperty name="opBean" property="tipoInfo"/> )
</p>
</BODY></HTML>
Laboratorio di Servizi Web - JSP Ardissono
32
OPBean.java - I
package application.other;
public class OPBean {
private String login;
private String tipoInfo;
public OPBean() { }
Properties con nome che
coincide con parametri di
HTTPServletRequest
public void setLogin(String login)
{… }
public String getLogin()
{… }
public void setTipoInfo(String tipoInfo)
{… }
public String getTipoInfo()
{… }
Laboratorio di Servizi Web - JSP Ardissono
33
OPBean.java - II
Metodo di gestione
public String getOperazione() {
di logica applicativa
String out = "";
if (tipoInfo.equals("no")) out = "nessuna
informazione";
else if (tipoInfo.equals("nomi")) out = "nomi
persone";
else if (tipoInfo.equals("cc")) out = "conti
correnti bancari";
else out = "tipo di informazione non gestita";
return out; }
Logica applicativa (semplice, ma
potrebbe prevedere accesso a DB)
} //chiusura bean
NB: metodo usa altri valori inseriti da
utente e salvati in Java Bean (variabili di
stato)
Laboratorio di Servizi Web - JSP Ardissono
34
JSP Standard actions
• Tag predefiniti che influenzano comportamento di
JSP a run-time e risposta inviata a client.
Implementati da tutti i Web Container
• Associati a codice java che viene inserito da Web
Container quando genera Servlet per JSP
–
–
–
–
–
–
–
jsp:useBean (per invocare oggetti esterni: java bean)
jsp:setProperty (gestione properties di bean)
jsp:getProperty (interrogazione java beans)
jsp:param (parametri richieste HTTP)
jsp:include (inclusione risorse)
jsp:forward (forward a risorse)
jsp:plugin (inclusione applet)
Laboratorio di Servizi Web - JSP Ardissono
35
Standard actions - jsp:useBean
• Sintassi
<jsp:useBean id=”name" scope=”sc" bean_details />
• usata per istanziare JavaBean o per identificare istanza
di bean esistente e specificare identificatore
• scope: specifica visibilità di bean
– page: visibilità associata a richiesta specifica di pagina
– request: bean associato a richiesta HTTP  visibile ad altre
JSP incluse, o a cui si fa forward di richiesta
– session: associato a sessione utente
– application: visibile da tutte JSP di applicazione
Laboratorio di Servizi Web - JSP Ardissono
36
Uso di istanze di Java Bean in diverse JSP
<jsp:useBean id=”name" scope=”sc" bean_details />
• Se scope di Java Bean è session, istanza di java bean
creata da prima JSP invocata e usata da altre JSP
durante sessione utente
• Gestione di istanza di Java Bean
– Basata su id (“name”) associato a istanza di Java Bean
– Tutte le JSP devono usare stesso id con stesso scope
– Web Container cerca istanza di bean con id richiesto
nell’ambito dello scope specificato da JSP
• Se lo trova, lo usa come riferimento in esecuzione di JSP
• Altrimenti lo crea
Laboratorio di Servizi Web - JSP Ardissono
37
jsp:useBean – esempio I
<%-- informa.jsp : questo è un commento per JSP --%>
<jsp:useBean id="opBean" scope="page"
class="application.other.OPBean"/>
<jsp:setProperty name="opBean" property="*"/>
<HTML>
<HEAD><TITLE>...</TITLE></HEAD>
<BODY> <h1> … </h1>
<p><center>
Ciao
<jsp:getProperty name="opBean" property="login"/> ! Come stai?
</center></p>
<p>
Hai richiesto la seguente operazione:
<jsp:getProperty name="opBean" property="operazione"/>
(codice interno <jsp:getProperty name="opBean" property="tipoInfo"/> )
</p>
</BODY></HTML>
Laboratorio di Servizi Web - JSP Ardissono
38
jsp:useBean – esempio II
<%-- informa.jsp : questo è un commento per JSP --%>
Dichiarazione di bean di nome opBean
con proprietà di visibilità
<jsp:useBean id="opBean" scope="page" class="application.other.OPBean"/>
Salvo valore di tutti i parametri di
richiesta HTTP con nome = property di bean
<jsp:setProperty name="opBean" property="*"/>
<HTML>
<HEAD><TITLE>...</TITLE></HEAD>
<BODY>
<h1> … </h1>
...
Laboratorio di Servizi Web - JSP Ardissono
39
jsp:useBean – esempio III
...
<p><center>
Ciao
Recupero valore di property “login”
di bean (recupero parametro di richiesta…)
<jsp:getProperty name="opBean" property="login"/> ! Come stai?
</center></p>
<p>
Hai richiesto la seguente operazione:
NB: “operazione” non è parametro di richiesta
Invoco metodo di bean che “gestisce” richiesta
<jsp:getProperty name="opBean" property="operazione"/>
(codice interno <jsp:getProperty name="opBean" property="tipoInfo"/> )
</p>
</BODY></HTML>
Laboratorio di Servizi Web - JSP Ardissono
40
Standard actions - jsp:setProperty
• <jsp:setProperty name=”beanName" property_details />
• setta properties (semplici o indexate - array) di bean
• per settare proprietà di bean con nome = a parametri di
richiesta HTTP
– <jsp:setProperty name=”beanName" property=“*” />
• per settare properties specifiche (nome=parametro)
– <jsp:setProperty name=”beanName"
property=“propName” />
• property con nome  da parametri di richiesta HTTP
– <jsp:setProperty name=”beanName"
property=“propName” param=“paramName” />
• … vd libro
Laboratorio di Servizi Web - JSP Ardissono
41
Standard actions - jsp:getProperty
• <jsp:getProperty name=”beanName”
property=“prName” />
• recupera valore di property di bean (convertendolo in
String - toString(), valueOf())
• per recuperare valori di richieste salvate in bean
• per invocare metodi di gestione di logica applicativa
– <jsp:getProperty name="opBean"
property="operazione"/>
– invoca metodo getOperazione() di bean
Se istanza di Java Bean ha scope più ampio di
“page”, JSP può recuperare dati memorizzati in
precedenti passi di interazione con utente
Laboratorio di Servizi Web - JSP Ardissono
42
Standard actions - jsp:include - I
• <jsp:include page=”URL" flush=“true” />
• <jsp:include page=”URL" flush=“true” >
<jsp:param name=“parName” value=“parValue” />
</jsp:include>
Permette specifica di ulteriori
parametri rispetto a richiesta HTTP originale
• permette inserimento di risorsa statica o dinamica specificata
da URL in JSP
• inclusione risorsa effettuato a request processing time  meno
efficiente di directive include, ma adatto a includere risorse
che cambiano spesso
• NB: Buffer usato da printWriter per mantenere dati
temporanei da inviare a browser (si può scegliere dimensione
minima di buffer da imporre a Web Container, che può
allocare un buffer di tale dimensione o più grande)
Laboratorio di Servizi Web - JSP Ardissono
43
Standard actions - jsp:include - II
• pagina inclusa può accedere a JSPWriter object, non
può settare cookies o headers
• flush: specifica se buffer di output deve essere
ripulito prima di includere la pagina o meno
• flush: default=false. Se true, buffer “flushed” prima
di inclusione di pagina ( non si può fare forward ad
altre risorse o usare error pages)
• jsp:include  directive include
– con directive include, risorsa inclusa a translation time e
web container fa compilare la pagina ottenuta
– con jsp:include inclusione fatta a run time, no precedente
compilazione. Adatto a includere Servlet java
Laboratorio di Servizi Web - JSP Ardissono
44
Standard actions - jsp:param
• <jsp:param name=”parName" value=“parValue” />
• usato in jsp:include e jsp:forward per invocare
risorse aggiungendo parametri rispetto a quelli di
HttpServletRequest originale
• specifica nuovi attributi come coppie
<chiave, valore>
Laboratorio di Servizi Web - JSP Ardissono
45
Esempio di uso di java bean
• Sviluppiamo applicazione “Prova” che
– tramite form HTML permette a utente di richiedere 3
servizi: nessuna informazione (no), nomi persone
(nomi) o dati su conti correnti bancari (cc)
– Form HTML invoca (post) JSP di gestione dei servizi
– JSP invoca bean per gestire il servizio richiesto,
passando scelta utente come parametro, e raccoglie
risultato da visualizzare in pagina per browser utente
– bean traduce richiesta utente da codice interno a esterno
• Es: da cc a conti correnti bancari, da no a nessuna
informazione
– NB: metodi di bean potrebbero essere più
complessi, e.g., accesso a DB per recupero dati
Laboratorio di Servizi Web - JSP Ardissono
46
Invocazione JSP da form HTML
parametro “login”
parametro “tipoInfo”:
no, nomi, cc
<FORM METHOD="POST" ACTION="informa.jsp">
Laboratorio di Servizi Web - JSP Ardissono
47
Laboratorio di Servizi Web - JSP Ardissono
48
Esempio di inclusione di Servlet
<jsp:useBean id="opBean" scope="page" class="application.other.OPBean"/>
<jsp:setProperty name="opBean" property="*"/>
<HTML><HEAD> … </HEAD>
<BODY
...
<p><center>Ciao <jsp:getProperty name="opBean" property="login"/>!
Come stai?</center></p>
<p> Hai richiesto la seguente operazione:
<jsp:getProperty name="opBean" property="operazione"/>
(codice interno: <jsp:getProperty name="opBean" property="tipoInfo"/> )</p>
<p>Ecco il risultato: sto per invocare la servlet application.servlets.Informazioni.java!!
<jsp:include page="servlet/info" flush="true" /> </p>
Include senza parametri
<CENTER>
<INPUT TYPE="Submit" NAME="btnSubmit" VALUE="Submit request">
</CENTER>
</FORM>
</BODY></HTML>
Laboratorio di Servizi Web - JSP Ardissono
extra
49
Standard actions - jsp:forward - I
• <jsp:forward page=”URL” />
• <jsp:forward page=”URL">
<jsp:param name=“parName” value=“parValue” />
</jsp:forward>
Permette specifica di ulteriori
parametri rispetto a richiesta HTTP originale
• permette invio di richiesta ad altra risorsa di
applicazione (pagina HTML, JSP, Servlet)
• flusso di esecuzione passa a risorsa invocata
• buffer viene ripulito prima di forward (non si fa
merge di output delle due risorse)
• equivalente a metodo forward() di
javax.servlet.RequestDispatcher
Laboratorio di Servizi Web - JSP Ardissono
50
Standard actions - jsp:forward - II
<HTML><HEAD>...</HEAD>
<BODY>
...
<%
if (request.getParameter("login").equals(“raf”)) 
%>
<jsp:forward page=“wellcomeRAF.jsp” />
<% } else  %>
<%@ include file=“completeRegistration.html” %>
<% } %>
</BODY>
</HTML>
Laboratorio di Servizi Web - JSP Ardissono
51
Standard actions - jsp:plugin
• Permette di includere java applet in pagine generate
da JSP
• vd libro
Laboratorio di Servizi Web - JSP Ardissono
52
Oggetti Java impliciti
• request: rappresenta oggetto HttpServletRequest che
ha originato invocazione di metodo service().
Visibilità: a livello di singola richiesta HTTP
• response: oggetto HttpServletResponse che
rappresenta risposta a richiesta HTTP. Visibilità: a
livello di pagina
• session: oggetto HttpSession generato da connessione
di client. Visibilità: a livello di sessione
• config: oggetto ServletConfig associato a JSP
queste variabili (e altre) possono essere usate
esplicitamente in JSP perchè create a translation time
(anche ASP etc. hanno “request”, “session”, …)
Laboratorio di Servizi Web - JSP Ardissono
53
Commenti
• JSP adatte a sviluppo di interfaccia utente di
applicazioni
– facilitano specifica di layout di pagine
– nascondono in parte dettagli implementativi di
applicazioni web
• JSP non adatte a gestione di logica applicativa
– inserimento di troppo codice java in pagina JSP causa
poca leggibilità del codice
– compilazione di pagine evidenzia errori in codice di
pagine in modo indiretto (compilazione avviene su
Servlet espansa, non su JSP)  difficile fare debugging
Laboratorio di Servizi Web - JSP Ardissono
54
Architettura Model 1 – page centric
• In architettura Model 1 interfaccia utente
composta di una o più JSP
– utente carica JSP home page di servizio
– esecuzione JSP invoca metodi di JavaBean per
generare parti dinamiche di pagina da
visualizzare su browser utente
– pagina visualizzata include bottoni e link per
continuare interazione
– a seconda di azione utente, JSP opportuna viene
invocata
– continua in modo simile
Laboratorio di Servizi Web - JSP Ardissono
55
Model 2
• JSP hanno RequestDispatcher e offrono istruzioni
– include per includere risorse (pagina HTML, Servlet)
– forward per delegare risorse a gestione richiesta HTTP
• Per sviluppo di applicazioni complesse, meglio
combinare JSP e Servlet (e pagine statiche)
– JSP e pagine statiche per gestione interazione con utente
– Servlet per gestione di attività di backend
– combinazione basata su pattern Model View Controller
(Model 2)
• http://www.javaworld.com/javaworld/jw-12-1999/jw-12ssj-jspmvc.html
Laboratorio di Servizi Web - JSP Ardissono
56
JSP: Architettura Model 2
1
request
Web
server
(controller)
Servlet
3
5
response
(view)
JSP
(Model)
JavaBean
2
4
Web container
Laboratorio di Servizi Web - JSP Ardissono
57
Architettura Model 2
• Servlets per gestire logica applicativa
• JSP per generare presentation layer
• Servlet
– intercetta richieste utente (post, …)
– in base a valore di parametri di richiesta decide a quale
JSP forwardare richiesta
– crea java beans necessari a JSP
• JSP
– recupera oggetti e beans creati da Servlet
– estrae da oggetti contenuto dinamico da visualizzare in
pagina da inviare a browser utente
Laboratorio di Servizi Web - JSP Ardissono
58
Architettura Model 2 – Esempio
• Music without borders: negozio elettronico
• Interfaccia utente realizzata con diverse JSP
che generano porzioni diverse di interfaccia
– es: pagina principale include JSP di
visualizzazione di carrello spesa
– pagina di checkout (chiusura interazione)
• Servlet gestisce flusso di interazione
scegliendo JSP a cui forwardare richieste
utente ad ogni passo
Laboratorio di Servizi Web - JSP Ardissono
59
Music without borders – pagina principale - I
Laboratorio di Servizi Web - JSP Ardissono
60
Music without borders – pagina principale - II
<%@ page session="true" %>
<html><head><title>Music Without Borders</title></head><body>
<font face="Times New Roman,Times" size="+3">Music Without Borders</font>
<hr><p><center>
<form name="shoppingForm" action="/examples/servlet/ShoppingServlet"
method="POST">
<b>CD:</b>
<select name=CD>
<option>Yuan | The Guo Brothers | China | $14.95</option> …
<option>Ibuki | Kodo | Japan | $13.95</option>
</select>
<b>Quantity: </b><input type="text" name="qty" SIZE="3" value=1>
<input type="hidden" name="action" value="ADD">
<input type="submit" name="Submit" value="Add to Cart">
</form>
</center></p> <jsp:include page="Cart.jsp" flush="true"/> </body></html>
Include JSP di carrello spesa:
Laboratorio di Servizi Web - JSP 61
visualizza
prodotti
già
scelti
Ardissono
Music without borders – pagina principale - III
Laboratorio di Servizi Web - JSP Ardissono
62
Music without borders – pagina carrello - I
<%@ page session="true" import="java.util.*, shopping.CD" %>
<% Vector buylist = (Vector) session.getValue("shopping.shoppingcart");
if (buylist != null && (buylist.size() > 0)) { %>
<center>
<table border="0" cellpadding="0" width="100%" bgcolor="#FFFFFF">
<tr> <td><b>ALBUM</b></td> <td><b>ARTIST</b></td> …
<td><b>QUANTITY</b></td> <td></td> </tr>
<% for (int index=0; index < buylist.size();index++) {
CD anOrder = (CD) buylist.elementAt(index); %>
<tr> <td><b> <%= anOrder.getAlbum() %> </b></td>
….
<td><b> <%= anOrder.getQuantity() %> </b></td>
<td><form name="deleteForm“
action="/examples/servlet/ShoppingServlet“ method="POST">
<input type="submit" value="Delete">
<input type="hidden" name= "delindex" value='<%= index %>'>
<input type="hidden" name="action" value="DELETE"> </form> </td>
</tr>
<% } %>
Laboratorio di Servizi Web - JSP 63
<\table>
Ardissono
Music without borders – pagina carrello
<p>
<form name="checkoutForm"
action="/examples/servlet/ShoppingServlet" method="POST">
<input type="hidden" name="action" value="CHECKOUT">
<input type="submit" name="Checkout" value="Checkout">
</form>
</center>
<% } %>
NB: questo codice è vecchio,
parziale e potrebbe contenere
errori… vediamolo solo per
capire come si integrano
Servlet e JSP in Model 2
Laboratorio di Servizi Web - JSP Ardissono
64
Music without borders – Servlet (controller) - I
public class ShoppingServlet extends HttpServlet { … …
public void doPost (…) throws … {
HttpSession session = req.getSession(false);
if (session == null) {forward a pagina error.html);}
Vector buylist =
(Vector)session.getValue("shopping.shoppingcart");
String action = req.getParameter("action");
if (action.equals("DELETE")) {elimina item da carrello (buyList);}
else if (action.equals("ADD")) {aggiunge item a carrello;}
session.putValue("shopping.shoppingcart", buylist);
String url="/jsp/shopping/EShop.jsp";
Forward a pagina
ServletContext sc = getServletContext(); principale (Eshop.jsp)
RequestDispatcher rd = sc.getRequestDispatcher(url);
rd.forward(req, res); }
else if (action.equals(“CHECKOUT”) …
Laboratorio di Servizi Web - JSP Ardissono
65
Music without borders – Servlet (controller)
else if (action.equals("CHECKOUT")) {
amount = calcola prezzo da pagare;}
req.setAttribute("amount",amount);
String url="/jsp/shopping/Checkout.jsp";
ServletContext sc = getServletContext();
RequestDispatcher rd = sc.getRequestDispatcher(url);
rd.forward(req,res);
}
Invia controllo a pagina
} // fine servlet
Di checkout (Checkout.jsp)
Laboratorio di Servizi Web - JSP Ardissono
66
Scarica
  1. No category

JSP