JavaServer Pages: differenze tra le versioni
Contenuto cancellato Contenuto aggiunto
Funzionalità collegamenti suggeriti: 1 collegamento inserito. |
|||
| (199 versioni intermedie di oltre 100 utenti non mostrate) | |||
Riga 1:
{{Formato file
| nome = JSP
| icona =
| logo =
| immagine =
| didascalia =
| estensione = .jsp
| mime = application/jsp
| sviluppatore =
| proprietario =
| licenza =
| data_pubblicazione =
| ultima_versione =
| data_ultima_versione =
| genere =
| estensione_di =
| esteso_a =
| standard =
| aperto =
| sito = www.oracle.com/technetwork/java/jsp-138432.html
}}
In [[informatica]] '''JavaServer Pages''', di solito indicato con la sigla '''JSP''' (letto anche talvolta come '''Java Scripting Preprocessor'''), è una tecnologia di [[programmazione web]] in [[Java (linguaggio di programmazione)|Java]] per lo sviluppo della ''[[front-end|logica di presentazione]]'' (tipicamente secondo il pattern [[Model View Controller|MVC]]) di [[applicazione web|applicazioni web]], fornendo [[pagine web dinamiche|contenuti dinamici]] in formato [[HTML]] o [[XML]]. Si basa su un insieme di speciali [[Tag HTML|tag]], all'interno di una pagina HTML, con cui possono essere invocate [[funzione (informatica)|funzioni]] predefinite sotto forma di [[codice sorgente|codice]] [[Java (linguaggio di programmazione)|Java]] ([[JSTL]]) e/o funzioni [[JavaScript]]. In aggiunta, permette di creare librerie di nuovi tag che estendono l'insieme dei tag standard (JSP [[Custom Tag Library]]). Le librerie di tag JSP si possono considerare estensioni [[portabilità|indipendenti dalla piattaforma]] delle funzionalità di un [[server web]].
==Descrizione==
Nel contesto della [[piattaforma Java]], la tecnologia JSP è correlata con quella delle [[servlet]]: all'atto della prima invocazione, le pagine JSP vengono infatti [[compilatore|tradotte]] automaticamente da un [[compilatore JSP]] in [[servlet]]. Una pagina JSP può quindi essere vista come una rappresentazione ad alto livello di un servlet. Per via di questa dipendenza concettuale, anche l'uso della tecnologia JSP richiede la presenza, sul [[server web]], di un ''[[servlet container]]'', oltre che di un server specifico JSP detto ''[[JSP engine|motore JSP]]'' (che include il compilatore JSP); in genere, servlet container e motore JSP sono integrati in un unico prodotto (per esempio, ''[[Apache Tomcat|Tomcat]]'' svolge entrambe le funzioni).
JSP è una tecnologia alternativa rispetto a numerosi altri approcci alla generazione di pagine web dinamiche, per esempio [[PHP]], o [[Active Server Pages|ASP]] o la più tradizionale [[Common Gateway Interface|CGI]]. Differisce da queste tecnologie non tanto per il tipo di contenuti dinamici che si possono produrre, quanto per l'architettura interna del software che costituisce l'applicazione web (e, di conseguenza, sui tempi di sviluppo, la portabilità, la [[modificabilità]], le prestazioni, e altri aspetti di [[qualità del software]]).
=== Paradigma MVC ===
[[Sun Microsystems]] raccomanda di utilizzare il [[Design pattern|pattern]] [[Model-View-Controller]] con le pagine JSP in modo da dividere il [[livello di presentazione]] da quello dell'elaborazione della request e dalla memorizzazione dei dati. Le normali [[servlet]] o delle pagine JSP dedicate vengono utilizzate per processare i dati. Dopo che l'eleborazione è terminata, il controllo passa ad una pagina JSP che serve solo a visualizzare l'output. Quest'ultima pagina JSP dovrebbe contenere solo [[HTML]], [[XML]] e action e tag JSP; la pagina dovrebbe far uso dei [[JavaBean]]s per ottenere i dati.
In altri termini nello sviluppo di un'[[applicazione web]] la convenzione vuole che nelle JSP ci sia meno codice Java possibile e quello presente vada a richiamare codice Java nativo (oggetti e [[metodo (programmazione)|metodi]]) implementato in classi separate apposite dette appunto JavaBeans. Questa separazione consente infatti un facile [[riuso di codice]] dei Java beans una volta richiamato in un qualsiasi punto richiesto dell'applicazione web.
== Struttura di una pagina JSP ==
Una '''JSP''' è un documento di testo, scritto con una [[sintassi]] specifica, che rappresenta una [[pagina web]] di contenuto parzialmente o totalmente dinamico. Elaborando la pagina JSP, il motore JSP produce dinamicamente la pagina HTML finale che verrà presentata al [[web browser]] dell'utente. La pagina JSP può contenere tre tipi di elementi, a cui corrispondono tre diversi modi di elaborazione: ''contenuti statici'', ''direttive'' e ''script''.
=== Contenuti statici ===
I contenuti statici sono porzioni della pagina JSP che devono essere mantenute integralmente nella pagina web generata dinamicamente, senza alcuna elaborazione. Devono pertanto essere scritte nel linguaggio di tag di cui il client può usufruire direttamente, per esempio HTML (se il client è un browser), [[Wireless Markup Language|WML]] (se il client è un [[telefono cellulare|cellulare]] che accede alla pagina in [[Wireless Application Protocol|WAP]]) o XML (vari tipi di client).
=== Direttive ===
Le direttive JSP si possono interpretare come comandi rivolti al motore JSP. Questi comandi vengono eseguiti in una fase di ''[[preprocessore|preprocessing]]'', prima che siano elaborate le porzioni della pagina contenenti [[script]]. Le due direttive principali sono <code>include</code> e <code>page</code>.
* '''<code>include</code>''': ordina al motore JSP di includere un altro file in quello corrente. È un'operazione equivalente a quella di [[copia e incolla|copiare e incollare]] il contenuto del file indicato in quello corrente. (Una direttiva di questo tipo è simile a quella prevista dal [[preprocessore]] del [[C (linguaggio)|C]]/[[C++]]). Questa direttiva può essere usata, per esempio, per realizzare contenuti ricorrenti in diverse pagine di un [[sito web]].
:<code><nowiki><%@ include file="filedaincludere.ext" %></nowiki></code>
* '''<code>page</code>''': esistono numerose varianti della direttiva <code>page</code>, con scopi piuttosto diversi fra loro:
: '''<code>page import</code>''' corrisponde all'<code>'''import'''</code> Java, e indica quali [[classe (informatica)|classi]] saranno utilizzate nel resto del documento;
::<code><nowiki><%@ page import="java.util.*" %> //importa tutte le classi del package java.util</nowiki></code>
: '''<code>page contentType</code>''' indica in quale formato sia scritto il documento (per esempio HTML o XML)
::<code><nowiki><%@ page contentType="text/html" %></nowiki></code>
: '''<code>page errorPage</code>''' specifica la "pagina di errore" che deve essere visualizzata se l'elaborazione della pagina dinamica fallisse in seguito al verificarsi di qualche [[gestione delle eccezioni in Java|eccezione]]
: '''<code>page isErrorPage</code>''' indica se quella corrente è una pagina di errore
::<code><nowiki><%@ page isErrorPage=false %> //specifica che non è una pagina di errore</nowiki></code>
: '''<code>page isThreadSafe</code>''' indica se il servlet generato dalla pagina JSP è ''[[Thread safety|thread safe]]''
: '''<code>page taglib</code>''' indica che la pagina JSP fa uso di una [[libreria di tag]]. La libreria deve essere identificata tramite una [[Uniform Resource Identifier|URI]] (Uniform Resource Identifier)
::<code><nowiki><%@ taglib prefix="myprefix" uri="taglib/miataglib.tld" %></nowiki></code>
=== Scripting ===
La terza categoria di elementi presenti in una pagina JSP sono frammenti di [[codice sorgente]] (Java). Questi frammenti di codice sono quindi eseguiti dalla [[Java Virtual Machine]] e producono in output un testo, che va a contribuire al sorgente della pagina web in via di generazione. L'invocazione di codice Java è la chiave della generazione di pagine dinamiche in JSP; per esempio, le pagine JSP di un sito di [[commercio elettronico|acquisti ''online'']] potrebbero includere codice Java che verifica la disponibilità di un prodotto e genera in output una pagina che riporta questa informazione.
==== Dichiarazioni ====
La pagina JSP può includere dichiarazioni di [[variabile d'istanza|attributi]] e [[metodo (programmazione)|metodi]], introdotte dalla sequenza '''<%!'''. Tali attributi e metodi andranno a far parte della classe "servlet" generata dal compilatore JSP (la loro posizione all'interno del testo della pagina JSP è irrilevante). Lo sviluppatore che ha familiarità con la tecnologia servlet può sfruttare questa possibilità, per esempio, per fare ''[[overriding]]'' dei "metodi di life-cycle" dei servlet, come <code>jspInit</code>.
::<code><%! int serverInstanceVariable = 1; %></code>
==== Espressioni ====
Le espressioni sono introdotte dalla sequenza '''<%=''', e contengono una qualsiasi espressione Java. Durante l'elaborazione della pagina JSP, l'espressione viene valutata dal motore JSP, il risultato viene convertito in stringa, e la stringa inserita nel codice HTML/XML nel punto corrispondente a quello dove compare l'espressione stessa.
::<code><body></code>
::<code>Sei l'utente registrato nr. <%= registroUtenti.conta() %></code>
::<code></body></code>
==== Scriptlet ====
Gli scriptlet sono frammenti di codice immersi in un qualunque punto del testo. Concettualmente, si può immaginare che durante la costruzione della pagina web dinamica, il motore JSP includa senza elaborazioni i contenuti statici, procedendo dall'alto verso il basso nel documento, ed esegua immediatamente eventuali scriptlet incontrati durante l'operazione. Tecnicamente, questi scriptlet vengono inclusi nei metodi del servlet generato dalla pagina JSP, all'interno dei metodi che producono la risposta a una richiesta [[Hypertext Transfer Protocol|HTTP]].
==== Variabili implicite ====
Gli elementi di codice in una pagina JSP possono fare riferimento a un insieme di variabili predefinite:
: '''<code>out</code>''': rappresenta il [[Stream (informatica)|flusso]] di output su cui viene prodotta la pagina web. Si tratta di un oggetto di classe <code>JSPWriter</code>. Il suo uso è spesso implicito (per esempio nelle espressioni), ma all'occorrenza si può fare riferimento a questa variabile
: '''<code>page</code>''': rappresenta il servlet generato dalla pagina JSP
: '''<code>pageContext</code>''': un oggetto di classe <code>PageContext</code>, che contiene dati associati all'intera pagina. L'oggetto può essere trasferito da una pagina JSP a un'altra
: '''<code>request</code>''': l'oggetto di classe <code>HttpServletRequest</code> che rappresenta la richiesta [[Hypertext Transfer Protocol|HTTP]] che ha portato all'attivazione della pagina JSP/servlet
: '''<code>response</code>''': l'oggetto di classe <code>HttpServletResponse</code> che rappresenta la risposta HTTP da inviare
: '''<code>session</code>''': l'oggetto di classe <code>HttpSession</code> che rappresenta la sessione HTTP all'interno della quale è stata invocata la pagina JSP
: '''<code>application</code>''': permette di accedere e di memorizzare gli oggetti per renderli accessibili da qualsiasi utente e modificabili da ogni pagina
: '''<code>config</code>''': viene spesso lasciato inutilizzato, visto che le informazioni messe a disposizione da questo oggetto implicito sono generalmente settate e rilevate in automatico.
=== Azioni JSP ===
Le azioni JSP sono tag [[XML]] che consentono di controllare alcuni aspetti del comportamento del [[server web]]. Alcuni esempi sono i seguenti:
:'''<code><nowiki>jsp:include</nowiki></code>''': cede il controllo a un'altra pagina JSP, con ritorno del controllo a elaborazione terminata; simile a una [[chiamata di procedura]]
:'''<code><nowiki>jsp:forward</nowiki></code>''': cede il controllo, definitivamente, a un'altra pagina JSP
:'''<code><nowiki>jsp:param</nowiki></code>''': introduce un parametro aggiuntivo nel contesto di azioni come <code>include</code> e <code>forward</code>.
== Librerie di tag JSP ==
Oltre alle azioni predefinite, gli sviluppatori possono aggiungere ''action'' sviluppate da loro usando le API per l'estensioni dei tag JSP. Gli sviluppatori scrivono una classe Java che implementa una delle interfacce Tag e forniscono una descrizione XML della libreria in cui si specificano i tag e le classi java che li implementano.
Consideriamo il seguente codice:
<%@ taglib uri="mytaglib.tld" prefix="myprefix" %>
...
<myprefix:myaction> <%-- il tag di apertura %>
...
</myprefix:myaction> <%-- il tag di chiusura %>
...
Il compilatore JSP caricherà il file ''mytaglib.tld'' e vedrà che il tag 'myaction' è implementato dalla classe 'MyActionTag'. La prima volta che il tag viene usato nel file, verrà creata un'istanza di 'MyActionTag'. Quindi (e ogni volta che il tag viene usato), verrà invocato il metodo ''''doStartTag()'''' quando viene incontrato il tag di apertura. Viene esaminato il risultato del tag di apertura e si determina come processare il contenuto del tag. Il contenuto è il testo compreso fra il tag di apertura e quello di chiusura. Il metodo ''doStartTag()'' può restituire uno dei seguenti valori:
* SKIP_BODY - il contenuto del tag non verrà esaminato.
* EVAL_BODY_INCLUDE - processa il contenuto del tag.
* EVAL_BODY_TAG - processa il contenuto del TAG e invia il risultato nello stream di uscita.
'''NOTA''': se il tag estende la classe '''BodyTagSupport''' verrà invocato quando il corpo è stato processato appena prima di invocare il metodo '''doEndTag'''. Questo metodo viene usato per implementare costrutti di loop.
Quando viene incontrato il tag di chiusura, viene invocato il metodo '''doEndTag'''. Questo metodo può restituire uno dei seguenti valori.
* EVAL_PAGE - indica che il resto della pagina JSP deve essere processato.
* SKIP_PAGE - indica che non ci devono essere ulteriori elaborazioni. Il controllo lascia la pagina JSP. Viene impiegato per le azioni di forward.
Il tag MyAction su descritto potrebbe avere una implementazione simile a questa:
public class MyActionTag extends TagSupport {
//Releases all instance variables.
public void release() {...}
public MyActionTag() { ... }
//called for the start tag
public int doStartTag() { ... }
//called at the end tag
public int doEndTag() throws JspTagException { ... }
}
== Internazionalizzazione ==
L'internazionalizzazione delle pagine JSP viene ottenuta mediante la stessa tecnica utilizzata nelle normali applicazioni Java, ovvero usando i [[resource bundles]].
== Esempi ==
Il seguente frammento suggerisce come si potrebbe creare un'intestazione a diverse pagine web, facendo in modo che la presentazione possa variare in qualche dettaglio (per esempio, rendendo non cliccabile il link alla pagina corrente):
<jsp:include page="intestazione.jsp" > //includo una parte standard
<jsp:param name="questapagina" value="contatti"/> //fornisco informazioni specifiche
</jsp:include>
Il prossimo esempio illustra come gestire in modo uniforme l'inserimento di una [[applet]] in una pagina web. Prima dell'avvento del tag ''<OBJECT>'', non esisteva un metodo univoco per integrare le applet. Questo tag è abbastanza scarno e si spera che in futuro verrà integrato in modo da supportare attributi dinamici. Allo stato attuale, il tag non supporta chiamate dinamiche alla applet; per esempio, se si ha una applet che disegna un grafico che richiede che i punti siano passati come parametri, non si può usare il tag '''jsp:params''' a meno che i punti non siano costanti. Non è possibile quindi, iterare su un ResultSet per creare i tag jsp:param. Bisogna quindi gestire a mano ogni tag jsp:param; ognuno di questi tag comunque può avere un nome dinamico e un contenuto dinamico.
<jsp:plugin type=applet height="100%" width="100%"
archive="myjarfile.jar,myotherjar.jar"
codebase="/applets"
code="com.foo.MyApplet" >
<jsp:params>
<jsp:param name="enableDebug" value="true" />
</jsp:params>
<jsp:fallback>
Your browser does not support applets.
</jsp:fallback>
</jsp:plugin>
Nel seguente frammento, viene creato o reso accessibile un oggetto con nome ''myBean'' che appartiene alla classe ''MyBean'' del package ''com.foo'' e che sarà accessibile per tutta la durata della request. Questo significa che l'oggetto sarà accessibile e valido in tutte le pagine che vengono richiamate tramite i tag <jsp:include> e <jsp:forward> dalla pagina che per prima ha ricevuto la richiesta. L'attributo '''scope''' può avere i seguenti valori:
* request - l'attributo sarà valido in tutte per tutta la durata della request. Quando la request sarà stata processata da tutte le pagine JSP, l'oggetto sarà deverenziato.
* page - l'attributo sarà disponibile solo per la pagina corrente.
* session - l'attributo è disponibile per tutta la durata della sessione dell'utente.
* application - l'attributo è disponibile per ogni istanza e non viene mai dereferenziato. È lo stesso di definire una variabile statica o globale.
<jsp:useBean id="myBean" class="com.foo.MyBean" scope="request" />
<jsp:getProperty name="myBean" property="lastChanged" />
<jsp:setProperty name="myBean" property="lastChanged" value="<%= new Date()%>" />
== JSP 2.0 ==
La nuova versione della specifica JSP include nuove funzionalità tese ad incrementare la produttività dello sviluppatore. In dettaglio:
* un Expression Language (EL) che permette agli sviluppatori di creare template di stile (come quelli di [[Jakarta Velocity|Velocity]]);
* un metodo più semplice e veloce di creare nuovi tag.
== Voci correlate ==
* [[Active Server Pages|ASP]]
* [[Java EE]]
* [[Java Server Faces]]
* [[Servlet]]
* [[JHTML]]
* [[JavaScript]]
== Altri progetti ==
{{interprogetto}}
== Collegamenti esterni ==
* {{Collegamenti esterni}}
* {{cita web|http://www.oracle.com/technetwork/java/javaee/jsp/|Pagina ufficiale}}
* {{cita web|http://java.sun.com/developer/onlineTraining/JSPIntro/|Tutorial ufficiale Sun}}
* {{cita web | 1 = http://www.courses.coreservlets.com/Course-Materials/ | 2 = Tutorial e guide free | accesso = 12 ottobre 2006 | dataarchivio = 19 gennaio 2007 | urlarchivio = https://web.archive.org/web/20070119124040/http://courses.coreservlets.com/Course-Materials/ | urlmorto = sì }}
{{Portale|informatica}}
[[Categoria:Java EE]]
| |||