close

Pagine del server Java

Vai alla navigazione Vai alla ricerca
JSP
Estensione .jsp
Tipo MIME applicazione/jsp
Sviluppatore Fondazione Eclipse
Ultima uscita 3.1.0 (15 maggio 2022 ; 5 mesi fa ) ( 2022-05-15 )
Tipo di formato formato file , motore modello e specifiche tecniche
Standard(i) JSR 245
Sito web project.eclipse.org/… ​(  inglese)
 File multimediali su Wikimedia Commons

JSP ( JavaServer Pages ) è una tecnologia che consente agli sviluppatori Web di creare contenuti con componenti sia statici che dinamici. Una pagina JSP contiene due tipi di testo: dati di origine statici, che possono essere in uno dei formati di testo HTML , SVG , WML o XML , ed elementi JSP che costruiscono contenuto dinamico. Inoltre, le librerie di tag JSP, così come Expression Language (EL), possono essere utilizzate per incorporare codice Java nel contenuto statico delle pagine JSP.

Il codice della pagina JSP viene tradotto in codice servlet Java utilizzando il compilatore di pagine JSP Jasper e quindi compilato nel bytecode JVM ( Java Virtual Machine ) . I contenitori servlet in grado di eseguire pagine JSP sono scritti nel linguaggio Java indipendente dalla piattaforma. I JSP vengono caricati sul server e gestiti da una speciale struttura di pacchetti del server Java denominata Jakarta EE Web Application. In genere, le pagine sono impacchettate in archivi di file .war e .ear .

La tecnologia JSP è una tecnologia indipendente dalla piattaforma, portatile e facilmente estensibile per lo sviluppo di applicazioni web .

Versioni

Dalla versione 1.2, lo sviluppo di JavaServer Pages ha avuto luogo nell'ambito del Java Community Process . JSR 53 definisce gli standard JSP 1.2 e Servlet 2.3, mentre JSR 152 definisce la specifica JSP 2.0. Nel maggio 2006, la specifica JSP 2.1 è stata rilasciata sotto JSR 245 come parte di Java EE 5 . Il 10 dicembre 2009, la specifica JSP 2.2 è stata rilasciata come contenuto della versione JSR 245 .

JSP 1.0 e JSP 1.1

Queste versioni sono fondamentalmente diverse dalle versioni precedenti, che erano percepite come la risposta di Java ad ASP . Alcune delle caratteristiche principali delle versioni precedenti (come la possibilità di sviluppare librerie di tag) sono state rimosse o sostituite in base al principio della separazione tra codice e contenuto. Poiché è difficile navigare e separare il contenuto dal codice stesso in grandi volumi di codice sorgente , è nata l'idea di separarli (trasferirli) utilizzando tag JSP, come <jsp:useBean/>. Per implementare questa idea, i tag JSP sono stati divisi in tre gruppi logici: direttive, elementi di script e azioni.

JSP 1.2

JSP 1.2 estende la specifica JavaServer Pages 1.1 (JSP 1.1) come segue:

  • Richiede piattaforma Java 2 versione 1.2 o successiva;
  • Utilizza Servlet 2.3 come base della sua semantica;
  • Definisce la sintassi XML per le pagine JSP;
  • Fornisce la convalida della pagina JSP durante la fase di traduzione;
  • Specifica la pulizia della libreria delle variabili in fase di esecuzione;
  • Migliora il contratto del tag handler;
  • Fornisce un supporto migliorato per l' autorizzazione delle pagine ;
  • Migliora la codifica dei caratteri e il supporto per la localizzazione;
  • Rimuove il vincolo "svuota prima di includere" da JSP 1.1.

JSP 2.0

La nuova versione della specifica JSP aggiunge le seguenti funzionalità:

  • Expression Language (EL)  - un linguaggio di espressione che consente, tra le altre cose, agli sviluppatori di creare modelli in stile Velocity ;
  • Un modo più semplice e veloce per creare nuovi tag utilizzando i file .tag, ora non è necessario conoscere Java per creare nuovi tag;
  • Modo conveniente per gestire i bean nidificati ( JavaBeans );
  • Un modo più semplice e veloce per visualizzare i parametri variabili:
Ciao ,  $ { param . visitatore }  <%--  simile  a :  Ciao ,  <%= richiesta . getParameter ( "visitatore" ) ​​%>  --%>

JSP 2.1

La piattaforma Java EE 5 si concentra sul facile sviluppo utilizzando le annotazioni del linguaggio Java introdotte da J2SE 5.0 . JSP 2.1 supporta questo obiettivo definendo annotazioni di inserimento delle dipendenze su istruzioni JSP e listener di contesto.

Panoramica

JavaServer Pages (JSP) consente di separare la parte dinamica delle pagine dall'HTML statico . La parte dinamica è racchiusa in appositi tag "<% %>": 

 Il tuo  nome host : <% =  richiesta . getRemoteHost () %>

Le pagine JSP hanno un'estensione .jspe sono posizionate nella stessa posizione delle normali pagine Web. La struttura di tali pagine può essere costituita da cinque costrutti: HTML , commenti, elementi di script, direttive e azioni. La pagina JSP viene compilata in un servlet con contenuto statico che viene inviato al flusso di output associato al metodo di servizio . Pertanto, alla prima richiesta, questo processo potrebbe causare un leggero ritardo. I commenti in un documento o in un programma non causano un rallentamento del programma, poiché vengono ignorati dal compilatore e dall'esecutore. Gli elementi dello script consentono di specificare il codice Java che in seguito diventerà parte del servlet finale, le direttive consentono di controllare l'intera struttura del servlet e le azioni servono a specificare i componenti esistenti utilizzati, oltre a controllare il comportamento del motore JSP . Per semplificare lo scripting, sono disponibili variabili predefinite come request, response, pageContext, session, out, application, config, page, exception. Un esempio di una pagina JSP che utilizza tutti i componenti JSP:

Esempio JSP con comments.JPG

Commenti

I commenti vengono utilizzati per spiegare il codice sorgente di un programma. Nelle pagine JSP, i commenti possono essere divisi in due gruppi:

  • Commenti sul codice sorgente JSP
  • Commenti di markup HTML .

I commenti del codice sorgente JSP sono contrassegnati da una sequenza speciale di caratteri: <%--all'inizio e --%>alla fine del commento. Questo tipo di commento viene rimosso quando viene compilata la pagina JSP. Esempio di commento JSP: 

<%-- 
	Visualizza il  catalogo  prodotti 
	e  il carrello corrente  . --%>

I commenti di markup HTML sono formattati secondo le regole del linguaggio HTML. Questo tipo di commento viene trattato come testo statico dal compilatore JSP e inserito nel documento HTML di output. Le espressioni JSP all'interno dei commenti HTML vengono eseguite. Esempio di commento HTML: 

<!--  Data di  creazione della  pagina :  <%=  new  java . utile . Data ()  %>  -->

Elementi dello script

La specifica JSP distingue tre tipi di elementi di script:

  • Dichiarazioni <%!una o più dichiarazioni%>
  • Espressioni <%=espressione singola%>
  • skriplets <%_%>

Le dichiarazioni sono comunemente usate per definire variabili, metodi, classi interne e altri costrutti Java validi a livello di classe. Le espressioni diventano argomenti per il metodo out.print(). Con l'aiuto di scriptlet , le parti funzionanti del codice Java vengono incorporate nelle pagine JSP.

Dichiarazioni JSP

Le dichiarazioni JSP ti permetteranno di definire variabili, metodi, classi interne e così via. Le dichiarazioni vengono utilizzate per definire i costrutti Java utilizzati nel programma. Poiché le dichiarazioni non vengono visualizzate, vengono generalmente utilizzate insieme alle espressioni JSP o agli scriptlet. Il frammento di codice JSP di esempio mostra il numero di richieste a questa pagina dall'avvio del server (o dall'ultima modifica e ricarica del servlet). Si noti che nell'esempio stiamo usando sia una dichiarazione che un'espressione e che all'interno del costrutto è presente un punto e virgola ( ; ) dopo la dichiarazione: 

<%!  privato  int  accessCount  =  0 ;  %> 
Numero  di  visite alla pagina dal caricamento del server : < %= ++ accessCount  % >

Espressioni JSP

Le espressioni JSP vengono utilizzate per inserire i valori Java direttamente nell'output. Le espressioni Java vengono valutate, convertite in una stringa e inserite nella pagina. Questi calcoli avvengono in fase di esecuzione (cioè quando viene richiesta la pagina), e quindi c'è pieno accesso alle informazioni sulla richiesta stessa. Nelle espressioni, puoi usare costanti, variabili, chiamate a vari metodi. Tutte le espressioni, indipendentemente dalla complessità del loro contenuto, restituiscono un singolo risultato o numero. Le pagine JSP si basano su JSP Writer , che prende qualsiasi risultato di un'espressione, lo converte in un tipo (testo) e lo memorizza nelString buffer . Ad esempio, il codice seguente visualizza la data e l'ora di una determinata richiesta di pagina: 

 Ora corrente :  <%=  nuovo  java . utile . Data ()  %> 
Il tuo nome host  : <% = richiesta . getRemoteHost () %>

Devi prestare attenzione a tre regole:

  • Le espressioni JSP devono contenere espressioni Java;
  • ogni espressione JSP deve contenere solo un'espressione Java;
  • Le espressioni JSP non devono terminare con un punto e virgola ( ;), a differenza delle dichiarazioni Java.

Script JSP

Gli scriptlet JSP consentono di inserire qualsiasi codice in un metodo servlet che verrà generato al momento del rendering della pagina, consentendo di utilizzare la maggior parte dei costrutti Java. Gli scriptlet hanno anche accesso alle stesse variabili predefinite delle espressioni. Pertanto, ad esempio, per visualizzare un valore su una pagina, è necessario utilizzare una variabile predefinita out. 

<%  
String  queryData  =  richiesta . getQueryString (); 
fuori . println ( "Dati della query aggiuntivi: "  +  queryData );  
%>

Il codice all'interno dello scriptlet viene inserito come è stato scritto. Tutto l'HTML statico (testo del modello) prima o dopo la conversione dello scriptlet utilizzando l'estensione print. Ad esempio, il seguente snippet JSP contiene testo misto di modello e scriptlet: 

<%  if  ( Math . random ()  <  0.5 )  {  %> 
     < B > Buona giornata < / ​​B >  ! <% } else { %> < B > Buona giornata </ ​​B > per te ! <% } %>

Dopo aver convertito lo scriptlet, il codice apparirà così: 

if  ( Math . random ()  <  0.5 )  {  
     out . println ( "<B>Buona</B> giornata!" ); 
}  altro  {  
     fuori . println ( "<B>Ti auguro una brutta giornata</B>!" ); 
}

Ciò significa che gli scriptlet non devono contenere snippet Java completi e che i blocchi lasciati aperti possono influenzare l' HTML statico al di fuori dello scriptlet.

Direttive JSP

La pagina JSP può inviare un messaggio al contenitore appropriato con le istruzioni su cosa fare. Questi messaggi sono chiamati direttive. Tutte le direttive iniziano con <%@, seguite dal nome della direttiva e uno o più attributi con valori e terminano con %>. Le direttive nella pagina JSP fanno sì che il contenitore invii una richiesta per eseguire un servizio specifico che non è dichiarato nel documento generato. La forma delle direttive può essere rappresentata come segue: 

<% @  attributo direttiva  = "valore" %>

Puoi anche combinare l'impostazione di più attributi su una singola direttiva: 

<% @  direttiva  attributo1 = "valore1"  
              attributo2 = "valore2" 
              ... attributoN 
              = " valoreN " %>

Ci sono tre tipi principali di direttive: page , che ti permette di fare cose come importare classi, cambiare la superclasse di un servlet e così via; include , che consente di inserire un file in una classe servlet durante la traduzione di un file JSP in un servlet; e taglib , che ti consente di estendere molti tag con i tuoi, che il contenitore JSP è in grado di interpretare.

Direttiva della pagina JSP

Come suggerisce il nome, questa direttiva fornisce gli attributi per la pagina JSP. Gli attributi definiti in questa direttiva sono incorporati nella pagina JSP data e in tutti i suoi elementi statici annidati, sia che siano stati inseriti con la direttiva includeo con l'azione jsp:include. La forma della direttiva è la pageseguente: 

<% @  attributo pagina  = " valore " %>

Prendiamo come esempio la voce seguente: 

<% @  importazione pagina  = ” java . utile . * , com . le mie classi . * ” buffer = ” 15 kb ” %>

Questa direttiva afferma che la pagina JSP importerà le classi da due pacchetti Java java.utile com.myclassesquindi specifica la dimensione della memoria buffer che dovrebbe essere utilizzata per elaborare la pagina JSP data.

Quindi, considera gli attributi della direttiva page:

  • import="пакет.class1, пакет.class2, ..., пакет.classN".Consente di specificare i pacchetti da importare. Questo è l'unico attributo che può essere utilizzato più volte nella stessa direttiva. L'elenco dovrebbe includere tutte le classi Java che si desidera utilizzare che non fanno parte dell'insieme originale di classi importate. Il set di origine contiene: java.lang.*, javax.servlet.*, javax.servlet.jsp.* и javax.servlet.http.*.Un esempio di utilizzo dell'attributo import:
<% @  page  import = "java.util.Date, javax.text.SimpleDateFormat, com.myclasses.*"  %>
  • language="java".Questo attributo ha lo scopo di impostare il linguaggio di programmazione utilizzato . Il valore predefinito è "java". Questo attributo è facoltativo, ma il problema può comunque sorgere se il provider JSP del contenitore utilizza altri linguaggi (come JavaScript ). Una voce di esempio per questo attributo è la seguente:
<% @  page  language = " java "  %>
  • extends="пакет.class".Specifica la superclasse (classe padre) per il servlet generato. Tipicamente, un servlet è un'estensione della classe originale. I programmatori esperti possono utilizzare questo attributo per creare le proprie superclassi. Un esempio di utilizzo di questo attributo potrebbe essere simile al seguente:
<% @  page  extends = ” myPackage . Esempio Http "  %>
  • session="true|false".Questo attributo può essere impostato su true o false , che determina se la pagina JSP partecipa alla traduzione HTTP . Il valore true("true", l'impostazione predefinita) segnala che la variabile predefinita session(tipo HttpSession) deve essere associata a una sessione esistente, se presente, altrimenti viene creata e collegata una nuova sessione. Il valore false("false") specifica che le sessioni non verranno utilizzate e i tentativi di accedere alla variabile sessionrisulteranno in un errore durante la traduzione della pagina JSP nel servlet. Un esempio di utilizzo di questo attributo potrebbe essere simile al seguente:
<% @  sessione pagina  = " false " %>
  • buffer="размерkb|none".Questo attributo specifica la quantità di memoria buffer richiesta per l' oggetto JspWriter a cui fa riferimento la variabile predefinita out. Il valore predefinito dipende dalle impostazioni del server, ma dovrebbe essere maggiore di 8kb. Il valore viene fornito nella forma "sizekb" o "none". Se si imposta il valore della memoria buffer su none, il servlet non memorizzerà nulla nella memoria buffer e passerà il risultato scritto prima della variabile outdirettamente all'oggetto PrintWriterfornito con l'oggetto.Se ServletResponse.si imposta il valore della memoria buffer su un valore specifico valore, JspWritermemorizzerà i dati in questa memoria, con conseguente aumento delle prestazioni. A differenza di un oggetto , PrintWriterun oggetto JspWriterpuò generare eccezioni IOExceptions. Il valore iniziale della memoria buffer è 8kB. Una voce di esempio per questo attributo potrebbe essere simile a questa:
<% @  pagebuffer  = ” 12 kb ” % >
  • autoflush="true|false".Questo attributo può essere vero o falso . Il valore true("true" per impostazione predefinita) specifica che se la memoria del buffer va in overflow, verrà cancellata automaticamente. Un valore false("false"), usato raramente, specifica che un overflow del buffer deve generare un'eccezione ( IOExceptions). Di solito gli attributi e buffersono autoflushimpostati insieme in un'unica direttiva. Quando si imposta un valore di attributo, buffer="none"l'impostazione di un valore falseper un attributo non è autoflushvalida. Un esempio potrebbe assomigliare a questo:
<% @  buffer di pagina  = ” 16 kb ” autoflush = ” true ” %>
  • isThreadSafe="true|false".Questo attributo può essere vero o falso . Il valore true("true", l'impostazione predefinita) specifica la normale modalità di esecuzione del servlet, quando più richieste vengono elaborate contemporaneamente utilizzando un'unica istanza del servlet, in base al presupposto che l'autore abbia sincronizzato l'accesso alle variabili di questa istanza. Il valore false("false") segnala che il servlet deve ereditare SingleThreadModel(modello a thread singolo) in cui le richieste sequenziali o simultanee vengono gestite da istanze di servlet separate. In altre parole, il valore truefarà sì che il contenitore invii più richieste al servlet contemporaneamente, mentre il valore farà sì che il falsecontenitore invii le richieste una alla volta. Un esempio di utilizzo è simile al seguente:
<% @  page  isThreadSafe = ” false ”  %>
  • info="информация".Specifica una stringa che può essere recuperata quando si utilizza il metodo Servlet.getServletInfo().In genere, questo metodo restituisce informazioni sul servlet (come autore, versione e copyright). Una voce di esempio per questo attributo potrebbe essere simile a questa:
<% @  info pagina  = ” Autore : Petr Ivanovich ; versione : 1.0 " %>
  • errorPage="url".Specifica una pagina JSP che viene chiamata quando si verificano eventi Throwablesche non sono gestiti da questa pagina. Se si verifica un'eccezione in una pagina JSP e la pagina JSP non dispone del proprio codice per risolvere l'eccezione, il contenitore trasferirà automaticamente il controllo all'URL specificato come valore dell'attributo errorPage. Una voce di esempio è simile a questa:
<% @  page  errorPage = " / myweb / errori / mioerrore . jsp "  %>
  • isErrorPage="true|false".Questo attributo può essere vero o falso . Segnala se questa pagina può essere utilizzata per la gestione degli errori per altre pagine JSP o meno. Il valore predefinito è false"falso". Un esempio di utilizzo di questo attributo potrebbe essere simile al seguente:
<% @  page  isErrorPage = ” true ”  %>
  • contentType="MIME-Тип".Questo attributo imposta il MIMEtipo di output e, facoltativamente, puoi impostare la codifica dei caratteri nella risposta ( risposta HTML ). Il valore predefinito MIMEè text/html. Per chiarezza, possiamo usare il seguente esempio:
<% @  page  contentType = "testo/normale"  %>

Puoi ottenere lo stesso risultato usando uno scriptlet: 

<%  di risposta . setContentType ( "testo/semplice" );  %>

Direttiva include JSP

Questa direttiva consente di includere file in un servlet durante la traduzione di una pagina JSP. L'utilizzo della direttiva si presenta così: 

<% @  include  file = "URL relativo"  %>

L' URL fornito viene generalmente interpretato rispetto al JSP della pagina su cui si trova il collegamento, ma, come con qualsiasi altro URL relativo, puoi indicare al sistema la posizione della risorsa a cui sei interessato rispetto al server Web home directory anteponendo all'URL un carattere " / " . Il contenuto di un file include viene trattato come semplice testo JSP e può quindi includere elementi come HTML statico , elementi di script, direttive e azioni. Ad esempio, molti siti utilizzano una piccola barra di navigazione su ogni pagina. A causa dei problemi di utilizzo dei frame HTML , questo compito viene spesso risolto posizionando una piccola tabella nella parte superiore o nella metà sinistra della pagina, il cui codice HTML viene ripetuto più volte per ogni pagina del sito. La direttiva includeè il modo più naturale per svolgere questo compito, salvando lo sviluppatore dall'incubo di copiare HTML in ogni singolo file. Succede così: 

<! DOCTYPE  HTML  PUBLIC  "-//W3C//DTD HTML 4.0 Transitional//EN" > 
< html > 
< head > 
  < title > Pagina di prova  </ title > </ head > < body > <% @ include file = "/navbar .html" %>


     

  <!--  Un  frammento specifico di  questa  pagina  ...  -->

</ corpo > 
</ html >

Si noti che poiché la direttiva includeinclude file durante la traduzione della pagina, dopo aver apportato modifiche alla barra di navigazione, sarà necessario ritradurre tutte le pagine JSP che la utilizzano. Che in questo caso è un buon compromesso, visto che di norma la barra di navigazione cambia abbastanza raramente e il processo di connessione non perde di efficacia. Se i file inclusi cambiano abbastanza spesso, puoi usare invece l'azione jsp:include. Questa azione include il file durante l'accesso al JSP.

Direttiva taglib JSP

Come già saprai, nelle pagine JSP, gli elementi vengono scritti utilizzando i tag (segni convenzionali, etichette, marchi). L'insieme di tag che un container JSP può interpretare può essere esteso con le cosiddette librerie di tag. È inoltre possibile allegare azioni a un insieme esteso di tag, che si traduce in un'estensione del linguaggio JSP stesso. I tag possono essere suddivisi in tag standard e personalizzati. Un modo generalizzato di scrivere potrebbe assomigliare a questo: 

<% @  taglib  uri = ” URI  per la  libreria di  tag ”  prefisso = “ prefisso  carattere “  %>

La libreria di tag deve essere identificata da un indirizzo URI (un identificatore di risorsa univoco). L'URI può essere assoluto o relativo. L'identificatore di risorsa univoco identifica la posizione di una libreria di tag ( TLD ) che definisce i tag di quella libreria. Un esempio di voce di direttiva: 

<% @  taglib  uri = " http://www.moywebserver.ru/naydiznaki.tld " prefisso = "iskat" %>

Una pagina JSP può contenere un numero infinito di direttive taglib, ma a ciascuna direttiva deve essere assegnato un prefisso diverso che definisce il contenuto della libreria nella pagina. Come prefisso, puoi usare qualsiasi testo, parola. Sebbene una direttiva taglibpossa essere utilizzata ovunque in una pagina JSP, qualsiasi tag nativo utilizzato da queste direttive deve essere utilizzato dietro di essa.

Azioni

Le azioni JSP utilizzano costrutti di sintassi XML per controllare il funzionamento del motore servlet. Puoi includere dinamicamente un file, riutilizzare JavaBeans , indirizzare l'utente a un'altra pagina o generare HTML per un plug-in Java . Tutte queste azioni sono discusse in dettaglio di seguito. Ricorda che, come con tutti gli XML , i nomi di elementi e attributi fanno distinzione tra maiuscole e minuscole. Le azioni possono essere divise in due gruppi: standard e create (proprie, create dal programmatore). Sono consentite le seguenti azioni standard:

  • jsp:declaration  — Dichiarazione, simile a <% tag! … %>;
  • jsp:  scriptlet - Scriptlet, simile al tag <% ... %>;
  • jsp:expression  - Espressione, simile al tag <%= ... %>;
  • jsp:text  - Output di testo;
  • jsp:useBean  - Trova o crea una nuova istanza JavaBean;
  • jsp:setProperty  - Imposta le proprietà JavaBean;
  • jsp:getProperty  - Inserisci una proprietà JavaBean nel flusso di output;
  • jsp:include  - Include il file al momento della richiesta della pagina;
  • jsp:forward  - Reindirizza la richiesta a un'altra pagina;
  • jsp:param  - Aggiunge parametri all'oggetto della richiesta, come forward, include, plugin.;
  • jsp:plugin  - Genera codice (a seconda del tipo di browser utilizzato) che crea un tagOBJECToEMBEDper un plugin Java;
  • jsp:params  - Raggruppa i parametri all'interno del tag jsp:plugin;
  • jsp:fallback  - Specifica il contenuto che deve essere utilizzato dal browser client se il plug-in non si avvia. Utilizzato all'interno dell'elemento plugin.

jsp: azione useBean

Questa azione consente di caricare un JavaBean per un uso successivo in una pagina JSP. Questa funzione consente di riutilizzare le classi Java senza sacrificare i vantaggi forniti dai servlet JSP. Inoltre, questo è un modo per rimuovere gran parte dell'elaborazione Java dalla pagina JSP. Se si trasferisce l'elaborazione Java da una pagina JSP a un JavaBean, queste funzioni possono essere utilizzate in altre pagine JSP. La sintassi più semplice per specificare il bean da utilizzare è: 

< jsp : useBean  id = "name"  class = "package.class"  />

Tipicamente, questo significa "creare una nuova istanza di un oggetto della classe specificata da class e associarla a una variabile denominata da id ". Tuttavia, puoi impostare l' attributo scope (prende i valori page|request|session|application, pageper la pagina, requestper le richieste, sessionper le sessioni o le finestre di dialogo, applicationper l'applicazione), che è associato beannon solo alla pagina corrente. In questo caso, è utile ottenere riferimenti a esistenti beanse l'azione jsp:useBeancrea un'istanza di un nuovo oggetto solo se non esiste alcun oggetto con gli stessi valori id e scope . Ora che hai un bean, puoi modificarne le proprietà con un'azione jsp:setPropertyo utilizzando uno scriptlet per farlo e chiamando esplicitamente il metodo dell'oggetto con il nome della variabile specificato in precedenza tramite l' attributo id . Ricorda che con i bean , quando dici "questo bean ha una proprietà di tipo X denominata foo" intendi davvero "questa classe ha un metodo getFooche restituisce dati di tipo X e un altro metodo che accetta X setFoocome parametro". L'azione jsp:setPropertyè trattata più dettagliatamente nella sezione successiva, ma per ora dovresti ricordare che puoi impostare in modo esplicito il valore impostando l' attributo param per ottenere il valore dal parametro di query corrispondente, o semplicemente enumerare le proprietà per ottenere valori da parametri di query con gli stessi nomi delle proprietà. È possibile ottenere i valori delle proprietà esistenti utilizzando espressioni JSP o scriptlet chiamando il metodo appropriato getXxxo (più comunemente) utilizzando un'azione jsp:getProperty.

La classe assegnata al bean deve trovarsi nella normale directory di classe del server, non nella parte riservata alle classi che vengono ricaricate automaticamente dopo la modifica. Ad esempio, per Java Web Server, tutte le classi utilizzate devono essere collocate in una directory classeso in un file .jar nella directory lib, non nella directory servlets. Di seguito è riportato un semplice esempio che carica beane imposta/ottiene un semplice parametro stringa.

BeanTest.jsp 

<! DOCTYPE  HTML  PUBLIC  "-//W3C//DTD HTML 4.0 Transitional//EN" > < 
html > < 
head > < 
  title > Riutilizzo di JavaBeans  in JSP < / title > < / head > < body > < h1 > Riutilizzo di  JavaBeans in JSP </ h1 > < jsp : useBean id = "test" class = "hall.SimpleBean" /> < jsp : setProperty name = "test" property = "message" value = "Hello WWW" /> < p > Messaggio : < jsp : getProperty name = "test" property = "message" /> </ p > </ body > </ html >

SimpleBean.java 

 sala pacchetti ;

public  class  SimpleBean  { 
  private  String  message  =  "Testo messaggio non impostato" ;

  public  String  getMessage ()  { 
    return ( messaggio ); 
  } 
  public  void  setMessage ( Messaggio stringa  ) { this . messaggio = messaggio _ } }

Qualche dettaglio in più su come utilizzare jsp:useBean. Il modo più semplice per usarlo bean è usare il costrutto: 

   < jsp : useBean  id = "name"  class = "package.class"  />

per caricare beane quindi utilizzare jsp:setPropertye jsp:getPropertyper modificare e ottenere le sue proprietà (parametri). Tuttavia, ci sono altri due modi. Innanzitutto, puoi utilizzare il formato contenitore, ovvero: 

  < jsp : useBean  ... >  
    Corpo  
  </ jsp : useBean >

al fine di garantire che l'Ente venga eseguito solo quando un'istanza beanviene creata per la prima volta, e non quando ne viene trovata e utilizzata una esistente bean. Come discusso di seguito, beanspuò essere condiviso, quindi non tutte le espressioni jsp:useBeanrisultano in una nuova istanza di bean. In secondo luogo, oltre a id e class , ci sono altri tre attributi che puoi utilizzare: scope , type e beanName . Questi attributi sono descritti di seguito:

  • id  - Fornisce il nome della variabile che fa riferimento abean. Se può essere trovatobeancon gli stessi valori diidescope, viene utilizzato l'oggetto creato in precedenza invece di creare una nuova istanza;
  • class  : specifica il nome completo del pacchettobean;
  • ambito  : specifica l'ambito in cuibeandovrebbe essere disponibile. Può assumere quattro valori validi: page , request , session e application . Il valore predefinito è page , il che significa chebeanè disponibile solo nella pagina corrente (ospitata nellaPageContextpagina corrente). Il valore della richiesta significa chebeanè disponibile solo per la richiesta client corrente (ospitata nell'oggettoServletRequest). Il valore della sessione significa che l'oggetto è disponibile per tutte le pagine durante la vita di quella correnteHttpSession. Infine, l' applicazione del valore significa che è disponibile per tutte le pagine che utilizzano lo stessoServletContext. Il motivo per cui questo attributo è necessario è perchéjsp:useBeanprovoca la creazione di una nuova istanza dell'oggetto se non esiste alcun oggetto esistente con lo stessoidescope. In caso contrario, viene utilizzato un oggetto già esistente e tutti gli elementijsp:setParametero qualsiasi tra i tagjsp:useBeanvengono ignorati.
  • tipo  - indica il tipo della variabile che fa riferimento all'oggetto. Deve corrispondere al nome della classe, superclasse o interfaccia implementata. Il nome della variabile viene specificato tramite l'attributoid.
  • beanName  : fornisce il nomebeanche verrà utilizzato dal metodoinstantiate. È possibile specificaretypeebeanNamee omettere l'attributoclass.

azione jsp:setProperty

È possibile utilizzare jsp:setPropertyil precedentemente descritto beans. Puoi farlo in due modi. Innanzitutto, puoi utilizzare jsp:setPropertydopo ma al di fuori dell'elemento jsp:useBean, come mostrato nell'esempio: 

< jsp : useBean  id = "myName"  ...  /> 
... 
< jsp : setProperty  name = "myName"  
                 property = "someProperty"  ...  />

In questo caso, viene jsp:setPropertyeseguito indipendentemente dal fatto che sia stata trovata un'istanza esistente beano che sia stata creata una nuova istanza. Un'altra opzione è quella di posizionare jsp:setPropertynel corpo dell'elemento jsp:useBean, come mostrato in un altro esempio: 

< jsp : useBean  id = "myName"  ...  > 
  ... 
  < jsp : setProperty  name = "myName"  
                   property = "someProperty"  ...  /> 
</ jsp : useBean >

Questo jsp:setPropertyviene fatto solo se è stata creata una nuova istanza dell'oggetto e non quando ne viene trovata una esistente. Un'azione jsp:setPropertyaccetta i seguenti quattro attributi:

  • nome  - Questo attributo obbligatorio viene utilizzato per impostarebeanle proprietà di cui verranno impostate. L'elementojsp:useBeandeve precedere l'uso dell'elementojsp:setProperty.
  • proprietà  - Questo attributo obbligatorio imposta la proprietà che desideri impostare. Tuttavia, esiste un caso speciale: il valore " * " significa che tutti i parametri di query i cui nomi corrispondono ai nomi delle proprietàbeanverranno passati al metodo di impostazione della proprietà corrispondente.
  • value  - Questo attributo facoltativo imposta il valore della proprietà. I valori di stringa vengono automaticamente convertiti in numeric, boolean , Boolean , byte , Byte , char e Character utilizzando il metodo standard dellavalueOfclasse corrispondente. Ad esempio, il valore"true"per la proprietàbooleanoBooleanverrà convertito utilizzando il metodoBoolean.valueOfe il valore "42" per la proprietàintoIntegerverrà convertito utilizzando il metodoInteger.valueOf. Non puoi utilizzare contemporaneamente gli attributi value e param , ma puoi scegliere di non usarli affatto. Vedere la descrizione dell'attributo param di seguito.
  • param  : questo attributo facoltativo imposta il parametro di query utilizzato per ottenere la proprietà. Se questo parametro è assente nella richiesta corrente, non si verifica alcuna azione: il sistema non passa il valorenullal metodo che imposta le proprietà. Pertanto, è accettabile utilizzare lebeanproprietà predefinite, sovrascrivendole solo se richiesto dai parametri della richiesta. Ad esempio, il frammento seguente indica quanto segue: "imposta la proprietà innumberOfItemsbase al valore del parametro di richiestanumItemse, se non è presente un parametro di questo tipo nella richiesta, non viene eseguita alcuna azione".
< jsp : setProperty  name = "orderBean" 
                 property = "numberOfItems" 
                 param = "numItems"  />

Se usi né valuené param, è come se avessi dato un nome che paramcorrisponde al nome property. È possibile applicare questo principio di utilizzo automatico delle proprietà della richiesta i cui nomi corrispondono ai nomi delle proprietà e andare oltre impostando il nome della proprietà su " * " e omettendo il valore ei parametri del parametro . In questo caso, il server elaborerà le proprietà valide ei parametri di query per la corrispondenza di nomi identici. Quello che segue è un esempio utilizzato beanper creare una tabella di numeri primi. Se esiste un parametro numDigitsnei dati della richiesta, viene passato a bean numDigits. Allo stesso modo per numPrimes. JspPrimes.jsp 

<! DOCTYPE  HTML  PUBLIC  "-//W3C//DTD HTML 4.0 Transitional//EN" > < 
html > < 
head > < 
  title > Riutilizzo di JavaBeans  in JSP < / title > < / head > < body > < h1 > Riutilizzo di  JavaBeans in JSP </ h1 >  


      

  < jsp : useBean  id = "primeTable"  class = "hall.NumberedPrimes"  /> 
  < jsp : setProperty  name = "primeTable"  property = "numDigits"  /> 
  < jsp : setProperty  name = "primeTable"  property = "numPrimes"  />

  < p > 
    Diversi  caratteri primi < jsp : getProperty  name = " primeTable "  property = "numDigits"  />  
    : < jsp : getProperty name = "primeTable" property = "numberedList" /> </ p > </ body > </ html >

jsp: azione getProperty

Questo elemento determina il valore della proprietà bean, lo converte in una stringa e lo invia al flusso di output. Per eseguire un'azione è necessario impostare due attributi: il nome bean, che è preimpostato nell'azione jsp:useBean, e il nome della proprietà il cui valore deve essere determinato. Di seguito è riportato un esempio di come utilizzare questa azione: 

< jsp : useBean  id = "itemBean"  ...  /> 
... 
< UL > 
  < LI > Numero  di elementi :  
      < jsp : getProperty  name = "itemBean"  property = "numItems"  / 
  > < LI > Prezzo  unitario  : < jsp : getProperty name = "itemBean" property = "unitCost" /> </ UL >

jsp:include azione

Questa azione consente di inserire il contenuto dei file nella pagina generata. Sintassi dell'azione: 

< jsp : include  page = "URL relativo"  flush = "true"  />

A differenza della direttiva include, che inserisce un file durante la fase di traduzione JSP della pagina, questa azione inserisce il file quando viene richiesta la pagina. Ciò si traduce in una certa perdita di efficienza ed elimina la possibilità di codice JSP nel file incollato, ma fornisce un vantaggio significativo in termini di flessibilità.

Un esempio di inserimento del contenuto di quattro file in una pagina JSP: 

<! DOCTYPE  HTML  PUBLIC  "-//W3C//DTD HTML 4.01//EN"  "http://www.w3.org/TR/html4/strict.dtd" > 
< html > 
< head > 
  < title > News </ title > 
</ head > 
< body > 
  < h1 > News </ h1 > 
  < p > Ecco alcuni  estratti dai  nostri  quattro  articoli più  popolari  : </ p > < ol > < li >< jsp : include page = "news/Item1. html" flush = "true" /></ li > < li >< jsp : include page = "news/Item2.html" flush = "true" /></ li > < li >< jsp : include page = " news/ Item3.html" flush = "true" /></ li > < li >< jsp : include page = "news/Item4.html" flush = "true" /></ li > </ ol > </ corpo > </ html >

jsp: azione in avanti

Questa azione consente di passare la richiesta a un'altra pagina HTML statica, servlet o pagina JSP. A differenza di un'azione jsp:include, l'elaborazione della pagina corrente termina. Utilizza un attributo page, che deve contenere un URL relativo , in base al quale viene ordinato l'oggetto request. jsp:paramÈ possibile aggiungere altri parametri ai parametri della query originale passati a un'altra pagina utilizzando un'azione . Il valore dell'attributo pagepuò essere un valore statico o un valore calcolato durante la richiesta, come mostrato nei due esempi seguenti: 

< jsp : forward  page = "/utils/errorReporter.jsp"  /> 
< jsp : forward  page = "<%= someJavaExpression %>"  />

Inoltre, utilizzando un'azione jsp:forward, puoi trasferire il controllo su un'altra pagina, ma con la condizione che prima di chiamare questa azione non sia stato scritto nulla nella memoria del buffer in uscita (altrimenti verrà generata un'eccezione IllegalStateException).

jsp:param action e jsp:params action

Questa azione fornisce informazioni sul tipo di nome/valore. Questa azione viene utilizzata principalmente insieme alle azioni già familiari jsp:includee jsp:forward. Inoltre, può essere utilizzato anche insieme all'azione jsp:plugin. In altri casi, l'uso di questa azione non ha importanza. Utilizzato jsp:paramcon le azioni jsp:includee jsp:forwardpassa l'oggetto originale a nuove pagine request, che verranno estese con i nuovi parametri. Se specifichi nuovi valori per parametri già esistenti, saranno i nuovi valori che avranno la precedenza. Usando un'azione jsp:params, puoi impostare più parametri contemporaneamente

jsp: azione plug -in

Questa azione consente di inserire l' elemento OBJECT o EMBED (a seconda del tipo di browser in uso) necessario per eseguire le applet che utilizzano il plug-in Java. In altre parole, questa azione serve a generare l'HTML per incorporare l'API Java nella pagina JSP. Allo stesso modo, puoi incollare l'URL per scaricare i moduli per l'API Java da JavaSoft, che offre la possibilità di eseguire applet all'interno del browser. Il modulo di iscrizione per questa azione è simile al seguente: 

< jsp : plugin 
   type = "bean|applet" 
   code = "class file" 
   codebase = "CodeBase object" 
   align = "location" 
   archive = "lista archivio" 
   height = "height" 
   hspace = "spazio orizzontale" 
   jreversion = "versione" 
   name = "nome componente" 
   vspace = "spazio verticale" 
   width = "larghezza" 
   nspluginurl = "url" 
   iepluginurl = "url" > 
   < jsp : params > 
      < jsp : param  name = "name1"  value = "value1"  /> 
      < jsp : nome parametro  = "nome2" valore = "valore2" /> ... < jsp : nome parametro = "nomeN" valore = "valoreN" /> </ jsp : parametri > < jsp : fallback > </ jsp : fallback > </ jsp : plugin >

Diamo un'occhiata a un esempio di utilizzo di questa azione nel codice dell'applet: 

< jsp : plugin  type = "applet"  code = "Blink.class"  width = 300  height = 100 > 
   < jsp : params > 
      < jsp : param  name = lbl  value = "Sì, è più delizioso del semplice pane affettato! "  /> 
      < jsp : param  name = speed  value = "4"  /> 
   < jsp : params > 
   < jsp : fallback > Il tuo  browser  per qualche  motivo sconosciuto  non può eseguire questa applet </ fallback > </ jsp : plugin >

Un esempio di una pagina JSP che utilizza la sintassi XML 

<? versione xml  = "1.0" codifica = "UTF-8" ?> < jsp : root xmlns : jsp = "http://java.sun.com/JSP/Page" versione = "2.0" > < jsp : direttiva . page contentType = "application/xhtml+xml; charset=UTF-8" /> < jsp : output doctype - root - element = "html" doctype - public = "-//W3C//DTD XHTML 1.1//EN" doctype - system = "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd" omit - xml - dichiarazione = "true" /> < html xmlns = "http://www.w3.org/ 1999/xhtml" > < head > < meta http - equiv = "Content-Type" content = "text/html; charset=UTF-8" /> < title > Page title </ title > </ head > < body > < h1 > Intestazione </ h1 > < p > Testo </ p > < jsp : scriptlet > out . print ( Calendario . getInstance ( request . getLocale ()). getFirstDayOfWeek () == Calendario . DOMENICA ? "Nel tuo paese, la settimana inizia di domenica" : "Nel tuo paese, la settimana non inizia di domenica" ); </ jsp : scriptlet > </ body > </ html > </ jsp : root >

Vedi anche

Collegamenti

Fonte - https://ru.wikipedia.org/w/index.php?title=JavaServer_Pages&oldid=125787257