Java Server Pages - JSP
Introduzione
È la tecnologia Java per lo sviluppo di applicazioni
Web mediante l’utilizzo di “pagine dinamiche”
Sono pagine Web (HTML o XHTML) che risiedono
sul server Web
possono contenere codice Java attraverso l’utilizzo di opportuni
tags, e componenti JavaBean
Il codice Java viene compilato al momento della
prima invocazione della pagina JSP e genera una
servlet
Java Servlet è la tecnologia sottostante ma JSP facilita la
creazione di interfacce umane
Il codice della Servlet è nel documento HTML
Servlet vs JSP
Servlet: richiede una dettagliata conoscenza della
programmazione Java per lo sviluppo ed il mantenimento di
tutti gli aspetti dell’applicazione Web, dato che il codice di
esecuzione della richiesta ed il codice HTML risiedono nello
stesso punto
Servlet: cambiare il comportamento dell’applicazione o
aggiungere supporto a nuovi tipi di client richiede una
modifica del codice della servlet ed una sua ri-compilazione
Servlet: è difficile trovare vantaggio dai tool per lo sviluppo
di pagine Web quando si progetta l’interaccia
dell’applicazione. ll codice HTML associato alla servlet deve
essere inserito manualmente nel codice delle Servlet:
Time-consuming
Error-prone
Boring
Servlet vs JSP (2)
Servlet: si prestano meglio alla realizzazione di
applicazioni service-oriented (Web service endpoints
sono implementati come servlet)
JSP: separa il processamento delle richieste (codice di
business logic) dalla presentazione dell’informazione
JSP: separando la request processing e la business
logic dalla presentazione è possibile dividere lo
sviluppo di tasks tra le persone aventi differenti skills
Web designer per l'interfaccia (presentazione)
Programmatori per la logica dell'applicazione
Esempio JSP
<!DOCTYPE ...>
<HMTL>
<HEAD>
<TITLE>Data e ora</TITLE>
</HEAD>
<BODY>
<p>
Data e ora corrente:<br>
<b><%= new java.util.Date() %></b>
</p>
</BODY>
</HMTL>
Espressione JSP in linguaggio
Java che verrà interpretata
dal JSP container e sostituita
alla data e ora correnti.
Esempio JSP(2)
Traduzione della JSP in Servlet:
class JSPDate extends HttpJSPServlet {
public void _jspService (HttpServletRequest req,
HttpServletResponse res) {
PrintWriter out = res.getWriter() ;
out.println(“<html>”) ;
out.println() ;
out.println(“<head>”) ;
out.println(“<title>Data e Ora</title>”) ;
out.println(“</head>”) ;
out.println(“<body>”) ;
out.println(“<p>”) ;
out.println(“Data e ora corrente :<br>”) ;
Esempio JSP(3)
out.print(“<b>”) ;
out.print(new java.util.Date()) ;
out.println(“</b>”) ;
out.println(“</p>”) ;
out.println(“</body>”) ;
out.println() ;
out.println(“</html>”) ;
Commenti:
Classe derivata da un ipotetica classe HTTPJspServlet che sarà una
sottoclasse di HttpServlet e implementa l’interfaccia HttpJspPage che
contiene il metodo _jsp Service che è l’equivalente del metodo
service() delle normali servlet
●
Funzionamento di una JSP
prova.jsp
Read
Get prova.jsp
provaServlet.java
Generate
Compile
<html>prova</html>
Execute
provaServlet.class
1. il client richiede la pagina “prova”
2. Il server legge la pagina prova.jsp
3. Il server genera la servlet provaServlet.java
4. Il server compila la servlet.java ottenendo una classe eseguibile
5. Il server esegue la servlet
6. La risposta viene inviata la client
8
Ciclo di vita di una JSP
Init()
Esecuzione
(doGet o
altro)
Si
No
Si
No
Si
No
Si
No
Si
Si
Req#3
Req#4
No
No
No
No
Si
No
Si
No
Si
Si
Req#5
Pagina modificata
Servlet
instanziata
Req#2
Server restarted
Servlet
compilata
Prima scrittura della pagina
Pagina JSP
tradotta in
servlet
Req#1
Req#6
Si
No
Si
No
Si
No
Si
No
Si
si
Elementi di una JSP
Template text
Commenti JSP
Elementi di scripting
Codice java da inserire nella servlet risultante
Direttive JSP
Controllano la struttura della servlet risultante
JSP actions
Controllano il comportamento del JSP engine
Elementi sintattici
Template text: tutte le parti di testo che non sono
definite come elementi JSP sono copiate nella
pagina di risposta (i commenti HTML sono
considerati come normale elemento di testo)
Commenti JSP:
Sitassi: <%-- commento --%>
Vengono eliminati dal container in fase di
compilazione/traduzione della pagina
Elementi di Scripting
Porzioni di codice in uno scripting language
specificato nelle direttive (di default Java)
Scriptlet con sintassi <% code %>; possono contenere variabili locali valide
solo per una singola esecuzione della Servlet (prodotta in seguito alla
compilazione della JSP)
Declaration con sintassi <%! declaration [declaration] ...%>;
sono metodi o variabili la cui durata è quella della Servlet (conservano il loro
valore per tutte le esecuzioni della servlet)
Expression: con sintassi <%=expression %>; l’espressione viene valutata
e scritta nella pagina di risposta della JSP
Esempio
Direttiva page:
specifica di importare
<head>
package Java
JSP declaration:
<title>Data e ora</title>
genera due oggetti
</head>
di tipo DateFormat
<html>
<%@ page import = "java.util.*, java.text.*" %>
<%!
String DateFormat = "EEEE d MMMM yyyy";
DateFormat dateFormat = new SimpleDateFormat(DateFormat);
DateFormat timeFormat = new SimpleDateFormat("H:mm"); Scriptlet: crea un
oggetto di tipo Date
%>
il cui valore cambia
ad ogni esecuzione
<% Date dateTime = new Date(); %>
<body> < style = "font-size: 16pt;">
Oggi &grave; <%= dateFormat.format(dateTime) %><br>
e sono le ore <%= timeFormat.format(dateTime) %>
</body>
</html>
expresion
Direttive JSP: page
page: Definisce attributi e parametri dipendenti dalla pagina, come ad
esempio il linguaggio di scripting usato, la pagine di errore, requisiti di
buffering. Eseguita nella fase di traduzione della pagina JSP.
Attributi:
language: indica il linguaggio di script usato negli script
elements. Default value Java, altri linguaggi supportati dipendono
dal container
import: serve ad importare package all’interno della JSP,
equivalente alla import declaration del linguaggio Java (ma si
possono specificare più package contemporaneamente)
buffer: indica se l’output stream deve essere bufferizzato e la
dimensione minima del buffer (8KB di default). Utile nel caso di
ridirezione richiesta a runtime quando dei dati sono stati già inviati
in output (come nel caso di error pages)
errorpage: Indica la pagina a cui si viene reindirizzati in caso di
eccezioni. Ha un valore espresso da un URL.
Direttive JSP
include: serve ad inserire il contenuto di un file
all’interno di una pagina JSP. Eseguita a translation time ed
il contenuto inserito è statico (anche se può contenere
elementi dinamici)
Attributi:
file: contiene l’URL del file che deve essere inserito all’interno della JSP
taglib: permette di utilizzare degli action element non
standard inclusi in tag library
Attributi:
uri: è l’URI che identifica la tag library
Direttive JSP (3)
Elemento
Descrizione
Definisce attributi dipendenti dalla
pagina, come ad esempio il
linguaggio di scripting usato, la
<%@ page
pagine di errore, requisiti di
import="java.util.*,
com.foo.*" buffer="16k" %> buffering
<%@ page … %>
<%@ include … %>
Include un file durante la fase di
traduzione
<%@ include
file="copyright.html" %>
<%@ taglib … %>
Dichiara una libreria di tag,
contenente azioni custom diverse
da quelle definite dagli action
element standard ed usate nella
pagina
16
Action Element
Sono istruzioni che vengono eseguite in fase di
processing (i.e. al momento dell’elaborazione della
risposta) e si traducono in istruzioni Java nel metodo
service() della Servlet corrispondente
Sono tag XML dunque indipendenti dal linguaggio
Si possono dividere in due categorie:
Action per l’uso di componenti JavaBeans
Action per compiere operazioni su pagine JSP in fase di
processing
JSP e JavaBeans
I componenti JavaBeans sono il mezzo migliore per inserire
contenuti dinamici in una pagina JSP.
Gli script “sporcano” la pagina JSP (utilizzo di simboli
speciali non usati in HTML o XML)
e.g. <%@ page import = "java.util.*, java.text.*" %>
Sono interfacciati nella JSP per mezzo delle action all’interno di
tag specifici in una sintassi “designer-friendly”
e.g. <jsp:usebean id = “dateTime” class =
dates.DateTime” / >
JSP e JavaBeans - esempio
<html>
<head>
<title>Data e ora</title>
</head>
<%@ page import = "java.util.*, java.text.*" %>
<%!
String DateFormat = "EEEE d MMMM yyyy";
DateFormat dateFormat = new SimpleDateFormat(DateFormat);
DateFormat timeFormat = new SimpleDateFormat("H:mm");
%>
<% Date dateTime = new Date(); %>
< body style = "font-size: 16pt;">
Oggi e’: <%= dateFormat.format(dateTime) %><br>
e sono le ore <%= timeFormat.format(dateTime) %>
</body>
</html>
RUGGERO RUSSO
19
JSP e JavaBeans - esempio
<html>
<head>
<title>Data e ora</title>
</head>
<jsp:usebean id= “dateTime” class = “date.DateTime” />
<body style = “font-size: 16pt;”>
Oggi è <jsp:getProperty name = “dateTime” property
= “date”/ > <br>
e sono le ore < jsp:getProperty name = “dateTime” property
= “time”/>
</body>
</html>
RUGGERO RUSSO
20
JSP e JavaBeans - esempio
Tutto il codice che prima era sparso
per la pagina JSP ora è incapsulato
nella classe Java che esegue le
specifiche dei JavaBeans
Import java.util.*;
Import java.text.*;
Public class DateTime {
DateFormat dateFormat = new SimpleDateFormat (“EEEE d
MMMM yyyy”);
DateFormat timeFormat = new SimpleDateFormat (“H:mm”);
public String getDate () {
Date date = new Date();
return dateFormat.format (date);
}
public String getTime() {
Date date =new Date()
return timeFormat.format(date);
}
}
RUGGERO RUSSO
21
Gestione degli Errori
Errori in fase di traduzione-compilazione.
Si traducono con l’invio di un Server error (errore 500)da
parte del server HTTP
Viene generata una pagina in cui sono indicati gli errori di
sinatssi JSP e/o di compilazione Java per errori negli script
element
Errori in fase di processing (runtime errors).
Si risolvono nella generazione di eccezioni java
Possono essere gestiti dal programmatore
direttamente nella pagina
Utilizzando bean inseriti nella pagina
Possono essere lasciati alla gestione di default del JSP
container
Possono essere gestiti tramite una error page
RUGGERO RUSSO
24
