JavaServer Pages: differenze tra le versioni

Versione delle 20:35, 30 mag 2014

Versione attuale delle 14:02, 30 gen 2025

(34 versioni intermedie di 22 utenti non mostrate)

Riga 1:

{{Formato file

'''JavaServer Pages''', di solito indicato con l'[[acronimo]] '''JSP''' (letto anche talvolta come '''Java Scripting Preprocessor''') è una tecnologia di [[programmazione Web]] in [[Java (linguaggio)|Java]] per lo sviluppo della ''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)|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 [[Web server]].

| 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 [[Web 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 Webweb 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 Webweb (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 '''pagina JSP''' è un documento di testo, scritto con una [[sintassi]] specifica, che rappresenta una [[pagina Webweb]] 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 Webweb 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 Webweb]].

:<code><nowiki><%@ include file="filedaincludere.ext" %></nowiki></code>

Riga 28 ⟶ 55:

: '''<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 Webweb 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'']] potrebbepotrebbero 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>.

Riga 39 ⟶ 67:

==== 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 immersainserita nel codice HTML/XML nel punto corrispondente a quello dove comparivacompare 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 Webweb 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 [[Hyper TextHypertext 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 [[streamStream (informatica)|flusso]] di output su cui viene prodotta la pagina Webweb. 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 [[Hyper TextHypertext 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

Riga 58 ⟶ 87:

=== Azioni JSP ===

Le azioni JSP sono tag [[XML]] che consentono di controllare alcuni aspetti del comportamento del [[Web 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>.

== 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()%>" />

== Librerie di tag JSP ==

Riga 105 ⟶ 102:

</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 ''doStrtTagdoStartTag()'' può restituire uno dei seguenti valori:

* SKIP_BODY - il contenuto del tag non verrà esaminato.

* EVAL_BODY_INCLUDE - processa il contenuto del tag.

Riga 131 ⟶ 128:

== 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 ==

Riga 136 ⟶ 165:

* 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.

== 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.

== Voci correlate ==

Riga 148 ⟶ 172:

* [[Servlet]]

* [[JHTML]]

* [[JavaScript]]

== Altri progetti ==

{{interprogetto}}

== Collegamenti esterni ==

* {{Collegamenti esterni}}

* [http://www.oracle.com/technetwork/java/javaee/jsp/ Pagina ufficiale]

* [{{cita web|http://javawww.sunoracle.com/developertechnetwork/onlineTrainingjava/JSPIntrojavaee/ Tutorialjsp/|Pagina ufficiale Sun]}}

* [{{cita web|http://wwwjava.courses.coreservletssun.com/Course-Materialsdeveloper/ onlineTraining/JSPIntro/|Tutorial e guideufficiale free]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]]

<!--interwiki-->