JavaServer Pages (JSP) è una tecnologia per lo sviluppo di pagine Web che supportano il contenuto dinamico che aiuta gli sviluppatori a inserire codice Java nelle pagine HTML facendo uso di speciali tag JSP, la maggior parte dei quali inizia con <% e finisce con%>.
JSP offre diversi vantaggi come elencato di seguito:
Le prestazioni sono notevolmente migliori perché JSP consente di incorporare elementi dinamici nelle pagine HTML stesse.
I JSP vengono sempre compilati prima di essere elaborati dal server a differenza di CGI / Perl che richiede al server di caricare un interprete e lo script di destinazione ogni volta che viene richiesta la pagina.
Le JavaServer Pages sono costruite sopra l'API Java Servlet, quindi come i Servlet, JSP ha anche accesso a tutte le potenti API Java Enterprise, inclusi JDBC, JNDI, EJB, JAXP ecc.
Le pagine JSP possono essere utilizzate in combinazione con servlet che gestiscono la logica di business, il modello supportato dai motori dei modelli servlet Java.
I vantaggi di JSP sono duplici.
Innanzitutto, la parte dinamica è scritta in Java, non in Visual Basic o in un altro linguaggio specifico di MS, quindi è più potente e più facile da usare.
In secondo luogo, è portabile su altri sistemi operativi e server Web non Microsoft.
È più conveniente scrivere (e modificare!) HTML normale che avere molte istruzioni println che generano l'HTML. Altri vantaggi sono:
Incorporamento del codice Java nelle pagine HTML.
Indipendenza dalla piattaforma.
Creazione di applicazioni Web basate su database.
Funzionalità di programmazione lato server.
SSI in realtà è inteso solo per semplici inclusioni, non per programmi "reali" che utilizzano dati di moduli, effettuano connessioni a database e simili.
JavaScript può generare HTML dinamicamente sul client ma difficilmente può interagire con il server Web per eseguire attività complesse come l'accesso al database e l'elaborazione delle immagini, ecc.
L'HTML normale, ovviamente, non può contenere informazioni dinamiche.
Un ciclo di vita JSP è costituito dai seguenti passaggi:
Compilation- Quando un browser richiede un JSP, il motore JSP verifica prima se è necessario compilare la pagina. Se la pagina non è mai stata compilata o se il JSP è stato modificato dall'ultima volta che è stato compilato, il motore JSP compila la pagina.
Il processo di compilazione prevede tre passaggi:
Analisi del JSP.
Trasformare il JSP in un servlet.
Compilazione del servlet.
Initialization - Quando un contenitore carica un JSP, richiama il metodo jspInit () prima di soddisfare qualsiasi richiesta
Execution- Ogni volta che un browser richiede un JSP e la pagina è stata caricata e inizializzata, il motore JSP richiama il metodo _jspService () nel JSP. Il metodo _jspService () di un JSP viene richiamato una volta per richiesta ed è responsabile della generazione della risposta per quella richiesta e questo metodo è anche responsabile della generazione di risposte a tutti e sette i metodi HTTP, ad es. GET, POST, DELETE ecc.
Cleanup - La fase di distruzione del ciclo di vita JSP rappresenta quando un JSP viene rimosso dall'uso da un contenitore. Il metodo jspDestroy () è l'equivalente JSP del metodo destroy per i servlet.
Uno scriptlet può contenere un numero qualsiasi di istruzioni in linguaggio JAVA, dichiarazioni di variabili o metodi o espressioni valide nel linguaggio di scripting della pagina.
Di seguito è riportata la sintassi di Scriptlet:
<% code fragment %>Una dichiarazione dichiara una o più variabili o metodi che è possibile utilizzare nel codice Java successivamente nel file JSP. È necessario dichiarare la variabile o il metodo prima di utilizzarlo nel file JSP.
<%! declaration; [ declaration; ]+ ... %>Un elemento espressione JSP contiene un'espressione del linguaggio di scripting che viene valutata, convertita in una stringa e inserita nel punto in cui viene visualizzata l'espressione nel file JSP.
L'elemento espressione può contenere qualsiasi espressione valida in base alla specifica del linguaggio Java ma non è possibile utilizzare un punto e virgola per terminare un'espressione.
La sua sintassi è:
<%= expression %>Il commento JSP contrassegna il testo o le istruzioni che il contenitore JSP deve ignorare. Un commento JSP è utile quando si desidera nascondere o "commentare" una parte della pagina JSP.
Di seguito è riportata la sintassi dei commenti JSP:
<%-- This is JSP comment --%>Una direttiva JSP influisce sulla struttura complessiva della classe servlet. Di solito ha la seguente forma:
<%@ directive attribute = "value" %>I tag della direttiva types sono i seguenti:
<%@ page ... %> - Definisce gli attributi dipendenti dalla pagina, come il linguaggio di scripting, la pagina di errore e i requisiti di buffering.
<%@ include ... %> - Include un file durante la fase di traduzione.
<%@ taglib ... %> - Dichiara una libreria di tag, contenente azioni personalizzate, utilizzata nella pagina.
Le azioni JSP utilizzano costrutti nella sintassi XML per controllare il comportamento del motore servlet. È possibile inserire dinamicamente un file, riutilizzare i componenti JavaBeans, inoltrare l'utente a un'altra pagina o generare HTML per il plug-in Java.
La sua sintassi è la seguente:
<jsp:action_name attribute = "value" />jsp: include, jsp: useBean, jsp: setProperty, jsp: getProperty, jsp: forward, jsp: plugin, jsp: element, jsp: attribute, jsp: body, jsp: text
I letterali sono i valori, come un numero o una stringa di testo, scritti letteralmente come parte del codice di un programma. Il linguaggio delle espressioni JSP definisce i seguenti letterali:
Boolean - vero e falso
Integer - come in Java
Floating point - come in Java
String- con virgolette singole e doppie; "è sottoposto a escape come \", 'è sottoposto a escape come \' e \ è preceduto da \\.
Null - null
Il pageviene utilizzata per fornire istruzioni al contenitore che riguardano la pagina JSP corrente. Puoi scrivere direttive sulla codepage ovunque nella tua pagina JSP.
La direttiva Page contiene i seguenti 13 attributi.
language
extends
import
session
isThreadSafe
info
errorPage
isErrorpage
contentType
isELIgnored
buffer
autoFlush
isScriptingEnabled
L'attributo buffer specifica le caratteristiche di buffering per l'oggetto risposta di output del server.
Quando il buffer è impostato su "nessuno" , l'output del servlet viene immediatamente indirizzato all'oggetto di output della risposta.
Il autoFlush l'attributo specifica se l'output memorizzato nel buffer deve essere scaricato automaticamente quando il buffer viene riempito o se deve essere sollevata un'eccezione per indicare l'overflow del buffer.
Un valore di true (impostazione predefinita) indica lo scarico automatico del buffer e un valore di false genera un'eccezione.
Il contentTypel'attributo imposta la codifica dei caratteri per la pagina JSP e per la pagina di risposta generata. Il tipo di contenuto predefinito è text / html, che è il tipo di contenuto standard per le pagine HTML.
Il errorPagel'attributo indica al motore JSP quale pagina visualizzare se si verifica un errore durante l'esecuzione della pagina corrente. Il valore dell'attributo errorPage è un URL relativo.
L' attributo isErrorPage indica che il JSP corrente può essere utilizzato come pagina di errore per un altro JSP.
Il valore di isErrorPage è vero o falso. Il valore predefinito dell'attributo isErrorPage è false.
Il extends l'attributo specifica una superclasse che il servlet generato deve estendere.
Il importl'attributo ha la stessa funzione e si comporta come l'istruzione import di Java. Il valore per l'opzione di importazione è il nome del pacchetto che si desidera importare.
Il info l'attributo consente di fornire una descrizione del JSP.
Il isThreadSafeopzione contrassegna una pagina come thread-safe. Per impostazione predefinita, tutti i JSP sono considerati thread-safe. Se si imposta l'opzione isThreadSafe su false, il motore JSP si assicura che solo un thread alla volta stia eseguendo il JSP.
Il language attributo indica il linguaggio di programmazione utilizzato nello script della pagina JSP.
Il sessionattributo indica se la pagina JSP utilizza o meno sessioni HTTP. Un valore true significa che la pagina JSP ha accesso a un oggetto di sessione incorporato e un valore false significa che la pagina JSP non può accedere all'oggetto di sessione integrato.
Il isELIgnored L'opzione offre la possibilità di disabilitare la valutazione delle espressioni EL (Expression Language).
Il valore predefinito dell'attributo è true, il che significa che le espressioni, $ {...}, vengono valutate come dettato dalla specifica JSP. Se l'attributo è impostato su false, le espressioni non vengono valutate, ma piuttosto trattate come testo statico.
Il isScriptingEnabled attributo determina se gli elementi di scripting possono essere utilizzati.
Il valore predefinito (true) abilita scriptlet, espressioni e dichiarazioni. Se il valore dell'attributo è impostato su false, verrà generato un errore in fase di traduzione se JSP utilizza scriptlet, espressioni (non EL) o dichiarazioni.
La direttiva include viene utilizzata per includere un file durante la fase di traduzione. Questa direttiva indica al contenitore di unire il contenuto di altri file esterni con il JSP corrente durante la fase di traduzione. Puoi inserire nel codice direttive ovunque nella tua pagina JSP.
La forma d'uso generale di questa direttiva è la seguente:
<%@ include file = "relative url" >La direttiva taglib segue la seguente sintassi:
<%@ taglib uri = "uri" prefix = "prefixOfTag">Il valore dell'attributo uri si risolve in una posizione che il contenitore comprende
L' attributo prefix informa un contenitore su quali bit di markup sono azioni personalizzate.
La direttiva taglib segue la seguente sintassi:
<%@ taglib uri = "uri" prefix = "prefixOfTag" >Id attribute- L'attributo id identifica in modo univoco l'elemento Action e consente di fare riferimento all'azione all'interno della pagina JSP. Se l'azione crea un'istanza di un oggetto, il valore id può essere utilizzato per fare riferimento ad esso tramite l'oggetto implicito PageContext
Scope attribute- Questo attributo identifica il ciclo di vita dell'elemento Action. L'attributo id e l'attributo scope sono direttamente correlati, poiché l'attributo scope determina la durata dell'oggetto associato all'id. L'attributo scope ha quattro possibili valori: (a) page, (b) request, (c) session e (d) application.
Questa azione ti consente di inserire file nella pagina che viene generata. La sintassi è simile a questa:
<jsp:include page = "relative URL" flush = "true" />Dove page è l'URL relativo della pagina da includere.
Flush è l'attributo booleano che determina se la risorsa inclusa ha il suo buffer svuotato prima di essere inclusa.
non mi piace il include directive, che inserisce il file nel momento in cui la pagina JSP viene tradotta in un servlet, include action inserisce il file nel momento in cui viene richiesta la pagina.
Il useBeanl'azione è abbastanza versatile. Prima cerca un oggetto esistente utilizzando le variabili id e scope. Se un oggetto non viene trovato, prova a creare l'oggetto specificato.
Il modo più semplice per caricare un bean è il seguente:
<jsp:useBean id = "name" class = "package.class" />Il setPropertyaction imposta le proprietà di un Bean. Il fagiolo deve essere stato definito in precedenza prima di questa azione.
Il getProperty azione viene utilizzata per recuperare il valore di una determinata proprietà e lo converte in una stringa e infine lo inserisce nell'output.
Il forward azione termina l'azione della pagina corrente e inoltra la richiesta a un'altra risorsa come una pagina statica, un'altra pagina JSP o un servlet Java.
La semplice sintassi di questa azione è la seguente:
<jsp:forward page = "Relative URL" />Il pluginazione viene utilizzata per inserire componenti Java in una pagina JSP. Determina il tipo di browser e inserisce i tag <object> o <embed> secondo necessità.
Se il plug-in necessario non è presente, scarica il plug-in e quindi esegue il componente Java. Il componente Java può essere un applet o un JavaBean.
L'attributo scope identifica il ciclo di vita dell'elemento Action. Ha quattro possibili valori: (a) pagina, (b) richiesta, (c) sessione e (d) applicazione.
Gli oggetti impliciti JSP sono gli oggetti Java che il contenitore JSP mette a disposizione degli sviluppatori in ogni pagina e lo sviluppatore può chiamarli direttamente senza essere esplicitamente dichiarato. Gli oggetti impliciti JSP sono anche chiamati variabili predefinite.
richiesta, risposta, uscita, sessione, applicazione, configurazione, pageContext, pagina, eccezione
L'oggetto richiesta è un'istanza di un oggetto javax.servlet.http.HttpServletRequest. Ogni volta che un client richiede una pagina, il motore JSP crea un nuovo oggetto per rappresentare quella richiesta.
L'oggetto richiesta fornisce metodi per ottenere informazioni di intestazione HTTP inclusi dati di moduli, cookie, metodi HTTP ecc.
Utilizzo del metodo getHeaderNames () di HttpServletRequest per leggere le informazioni sull'intestazione HTTP. Questo metodo restituisce un'enumerazione che contiene le informazioni di intestazione associate alla richiesta HTTP corrente.
L'oggetto risposta è un'istanza di un oggetto javax.servlet.http.HttpServletRequest. Proprio come il server crea l'oggetto richiesta, crea anche un oggetto per rappresentare la risposta al client.
L'oggetto risposta definisce anche le interfacce che si occupano della creazione di nuove intestazioni HTTP. Attraverso questo oggetto il programmatore JSP può aggiungere nuovi cookie o timbri di data, codici di stato HTTP ecc.
Il out L'oggetto implicito è un'istanza di un oggetto javax.servlet.jsp.JspWriter e viene utilizzato per inviare contenuto in una risposta.
Il JspWriterobject contiene la maggior parte degli stessi metodi della classe java.io.PrintWriter. Tuttavia, JspWriter ha alcuni metodi aggiuntivi progettati per gestire il buffering. non mi piace ilPrintWriter oggetto, JspWriter genera IOExceptions.
L'oggetto sessione è un'istanza di javax.servlet.http.HttpSession e viene utilizzato per tenere traccia della sessione del client tra le richieste del client
L'oggetto dell'applicazione è un wrapper diretto attorno all'oggetto ServletContext per il Servlet generato e in realtà un'istanza di un oggetto javax.servlet.ServletContext.
Questo oggetto è una rappresentazione della pagina JSP attraverso il suo intero ciclo di vita. Questo oggetto viene creato quando la pagina JSP viene inizializzata e verrà rimosso quando la pagina JSP viene rimossa dal metodo jspDestroy ().
L'oggetto config è un'istanza di javax.servlet.ServletConfig ed è un wrapper diretto attorno all'oggetto ServletConfig per il servlet generato.
Questo oggetto consente al programmatore JSP di accedere ai parametri di inizializzazione del servlet o del motore JSP come i percorsi o le posizioni dei file, ecc.
L'oggetto pageContext è un'istanza di un oggetto javax.servlet.jsp.PageContext. L'oggetto pageContext viene utilizzato per rappresentare l'intera pagina JSP.
Questo oggetto memorizza i riferimenti agli oggetti richiesta e risposta per ogni richiesta. Gli oggetti application, config, session e out vengono derivati accedendo agli attributi di questo oggetto.
L'oggetto pageContext contiene anche informazioni sulle direttive emesse alla pagina JSP, incluse le informazioni sul buffer, errorPageURL e l'ambito della pagina.
Questo oggetto è un riferimento effettivo all'istanza della pagina. Può essere pensato come un oggetto che rappresenta l'intera pagina JSP.
L'oggetto pagina è in realtà un sinonimo diretto per l'oggetto this.
L'oggetto eccezione è un wrapper contenente l'eccezione generata dalla pagina precedente. Viene in genere utilizzato per generare una risposta appropriata alla condizione di errore.
Il metodo GET invia le informazioni utente codificate aggiunte alla richiesta della pagina. La pagina e le informazioni codificate sono separate dal? Personaggio.
Il metodo POST impacchetta le informazioni esattamente allo stesso modo dei metodi GET, ma invece di inviarle come stringa di testo dopo un? nell'URL lo invia come messaggio separato. Questo messaggio arriva al programma di backend sotto forma di input standard che puoi analizzare e utilizzare per la tua elaborazione.
JSP gestisce automaticamente l'analisi dei dati del modulo utilizzando i seguenti metodi a seconda della situazione:
getParameter() - Chiami il metodo request.getParameter () per ottenere il valore di un parametro del form.
getParameterValues() - Chiama questo metodo se il parametro appare più di una volta e restituisce più valori, ad esempio la casella di controllo.
getParameterNames() - Chiama questo metodo se desideri un elenco completo di tutti i parametri nella richiesta corrente.
getInputStream() - Chiama questo metodo per leggere il flusso di dati binari proveniente dal client.
I filtri JSP sono classi Java che possono essere utilizzate nella programmazione JSP per i seguenti scopi:
Per intercettare le richieste di un client prima che acceda a una risorsa nel back-end.
Per manipolare le risposte dal server prima che vengano rispedite al client.
I filtri vengono definiti nel file del descrittore di distribuzione web.xml e quindi mappati ai nomi servlet o JSP o ai pattern URL nel descrittore di distribuzione dell'applicazione.
Quando il contenitore JSP avvia la tua applicazione web, crea un'istanza di ogni filtro che hai dichiarato nel descrittore di distribuzione. I filtri vengono eseguiti nell'ordine in cui sono dichiarati nel descrittore di distribuzione.
I cookie sono file di testo memorizzati sul computer client e vengono conservati per vari scopi di tracciamento delle informazioni.
I cookie sono solitamente impostati in un'intestazione HTTP (sebbene JavaScript possa anche impostare un cookie direttamente su un browser) .Se il browser è configurato per memorizzare i cookie, manterrà queste informazioni fino alla data di scadenza. Se l'utente punta il browser su una qualsiasi pagina che corrisponde al percorso e al dominio del cookie, rinvierà il cookie al server.
L'impostazione dei cookie con JSP prevede tre passaggi:
Creating a Cookie object - Chiami il costruttore di cookie con un nome di cookie e un valore di cookie, entrambi stringhe.
Setting the maximum age - Utilizza setMaxAge per specificare per quanto tempo (in secondi) il cookie deve essere valido.
Sending the Cookie into the HTTP response headers - Utilizza response.addCookie per aggiungere cookie nell'intestazione della risposta HTTP
Per leggere i cookie, è necessario creare un array di oggetti javax.servlet.http.Cookie chiamando il metodo getCookies () di HttpServletRequest. Quindi scorrere l'array e utilizzare i metodi getName () e getValue () per accedere a ciascun cookie e al valore associato.
Eliminare i cookie è molto semplice. Se desideri eliminare un cookie, devi semplicemente seguire i tre passaggi seguenti:
Leggere un cookie già esistente e salvarlo nell'oggetto Cookie.
Imposta l'età dei cookie su zero utilizzando setMaxAge() metodo per eliminare un cookie esistente.
Aggiungi di nuovo questo cookie nell'intestazione della risposta.
La gestione della sessione può essere ottenuta utilizzando:
Cookies - Un webserver può assegnare un ID di sessione univoco come cookie a ogni web client e per le successive richieste del client possono essere riconosciuti utilizzando il cookie ricevuto.
Hidden Form Fields - Un server web può inviare un campo modulo HTML nascosto insieme a un ID sessione univoco come segue:
<input type = "hidden" name = "sessionid" value = "12345">URL Rewriting- Nella riscrittura degli URL vengono aggiunte alcune informazioni extra alla fine di ogni URL che identifica la sessione. Questa riscrittura dell'URL può essere utile quando un cookie è disabilitato.
The session Object - JSP utilizza l'interfaccia HttpSession fornita da servlet che fornisce un modo per identificare un utente attraverso più di una richiesta di pagina o visita a un sito Web e per memorizzare le informazioni su quell'utente.
Ciò implica che quando il modulo viene inviato, il nome e il valore specificati verranno inclusi nel metodo GET o POST.
Quando hai finito con i dati della sessione di un utente, hai diverse opzioni:
Remove a particular attribute- Puoi chiamare il metodo public void removeAttribute (String name) per eliminare il valore associato a una particolare chiave.
Delete the whole session- Puoi chiamare il metodo public void invalidate () per scartare un'intera sessione.
Setting Session timeout- È possibile chiamare il metodo public void setMaxInactiveInterval (int interval) per impostare il timeout per una sessione individualmente.
Log the user out - I server che supportano i servlet 2.4, puoi chiamare logout per disconnettere il client dal server Web e invalidare tutte le sessioni appartenenti a tutti gli utenti.
web.xml Configuration - Se si utilizza Tomcat, oltre ai metodi sopra menzionati, è possibile configurare il timeout della sessione nel file web.xml come segue.
Per caricare un singolo file dovresti utilizzare un singolo tag <input ... /> con attributo type = "file". Per consentire il caricamento di più file, includi più di un tag di input con valori diversi per l'attributo name.
Puoi codificarlo nel tuo programma o questo nome di directory potrebbe anche essere aggiunto usando una configurazione esterna come un elemento context-param in web.xml.
Il reindirizzamento della pagina viene generalmente utilizzato quando un documento si sposta in una nuova posizione e abbiamo bisogno di inviare il client a questa nuova posizione o può essere a causa del bilanciamento del carico o per semplice randomizzazione.
L'elemento <jsp: forward> inoltra l'oggetto richiesta contenente le informazioni sulla richiesta del client da un file JSP a un altro file. Il file di destinazione può essere un file HTML, un altro file JSP o un servlet, purché si trovi nello stesso contesto dell'applicazione del file JSP di inoltro.
sendRedirect invia una risposta di reindirizzamento temporaneo HTTP al browser e il browser crea una nuova richiesta per andare alla pagina reindirizzata.
Un contatore di visite ti dice il numero di visite su una particolare pagina del tuo sito web.
Per implementare un contatore di visite è possibile utilizzare l'oggetto Application Implicit e i metodi associati getAttribute () e setAttribute ().
Questo oggetto è una rappresentazione della pagina JSP attraverso il suo intero ciclo di vita. Questo oggetto viene creato quando la pagina JSP viene inizializzata e verrà rimosso quando la pagina JSP viene rimossa dal metodo jspDestroy ().
Puoi seguire i passaggi seguenti:
Definisci una tabella di database con un singolo conteggio, diciamo hitcount. Assegnagli un valore zero.
Con ogni hit, leggi la tabella per ottenere il valore di hitcount.
Aumenta il valore di hitcount di uno e aggiorna la tabella con un nuovo valore.
Visualizza il nuovo valore di hitcount come conteggio totale degli accessi alla pagina.
Se vuoi contare gli hit per tutte le pagine, implementa la logica precedente per tutte le pagine.
Considera una pagina web che mostra il punteggio del gioco in tempo reale o lo stato del mercato azionario o la razione di cambio di valuta. Per tutti questi tipi di pagine, è necessario aggiornare regolarmente la pagina Web utilizzando il pulsante di aggiornamento o ricarica con il browser.
JSP semplifica questo lavoro fornendo un meccanismo in cui è possibile creare una pagina Web in modo tale che venga aggiornata automaticamente dopo un determinato intervallo.
Il modo più semplice per aggiornare una pagina Web è utilizzare il metodo setIntHeader () dell'oggetto risposta. Di seguito è riportata la firma di questo metodo:
public void setIntHeader(String header, int headerValue)Questo metodo restituisce l'intestazione "Aggiorna" al browser insieme a un valore intero che indica l'intervallo di tempo in secondi.
La libreria JSTL (JavaServer Pages Standard Tag Library) è una raccolta di utili tag JSP che incapsula le funzionalità principali comuni a molte applicazioni JSP.
JSTL supporta attività strutturali comuni come iterazioni e condizionali, tag per la manipolazione di documenti XML, tag di internazionalizzazione e tag SQL. Fornisce inoltre un framework per l'integrazione di tag personalizzati esistenti con tag JSTL.
I tipi di tag JSTL sono:
Core Tags
Formatting tags
SQL tags
XML tags
JSTL Functions
Il tag <c: set> è una versione compatibile con JSTL dell'azione setProperty. Il tag è utile perché valuta un'espressione e utilizza i risultati per impostare un valore di un oggetto JavaBean o java.util.Map.
Il tag <c: remove> rimuove una variabile da un ambito specificato o dal primo ambito in cui viene trovata la variabile (se non viene specificato alcun ambito).
Il tag <c: catch> cattura qualsiasi Lanciabile che si trova nel suo corpo e facoltativamente lo espone. Semplicemente viene utilizzato per la gestione degli errori e per affrontare il problema con maggiore garbo.
Il tag <c: if> valuta un'espressione e ne visualizza il contenuto solo se l'espressione restituisce true.
<C: choose> funziona come un'istruzione switch Java in quanto consente di scegliere tra una serie di alternative. Dove l'istruzione switch ha istruzioni case, il tag <c: choose> ha tag <c: when>. Un'istruzione a switch ha una clausola default per specificare un'azione predefinita e in modo simile <c: choose> ha <otherwise> come clausola predefinita.
I tag <c: forEach>, <c: forTokens> esistono come una buona alternativa all'incorporamento di un ciclo Java for, while o do-while tramite uno scriptlet.
Il tag <c: param> consente di specificare il parametro di richiesta dell'URL corretto con l'URL e esegue la codifica URL necessaria.
Il tag <c: redirect> reindirizza il browser a un URL alternativo fornendo automaticamente la riscrittura URL, supporta URL relativi al contesto e supporta il tag <c: param>.
Il tag <c: url> formatta un URL in una stringa e lo memorizza in una variabile. Questo tag esegue automaticamente la riscrittura dell'URL quando necessario.
I tag di formattazione JSTL vengono utilizzati per formattare e visualizzare testo, data, ora e numeri per i siti Web internazionalizzati. Di seguito è riportata la sintassi per includere la libreria di formattazione nel tuo JSP:
<%@ taglib prefix = "fmt" uri = "http://java.sun.com/jsp/jstl/fmt" %>La libreria di tag SQL JSTL fornisce tag per l'interazione con database relazionali (RDBMS) come Oracle, mySQL o Microsoft SQL Server.
Di seguito è riportata la sintassi per includere la libreria SQL JSTL nel tuo JSP:
<%@ taglib prefix = "sql" uri = "http://java.sun.com/jsp/jstl/sql" %>I tag XML JSTL forniscono un modo incentrato su JSP per creare e manipolare documenti XML. Di seguito è riportata la sintassi per includere la libreria XML JSTL nel tuo JSP.
<%@ taglib prefix = "x" uri = "http://java.sun.com/jsp/jstl/xml" %>Un tag personalizzato è un elemento del linguaggio JSP definito dall'utente. Quando una pagina JSP contenente un tag personalizzato viene tradotta in un servlet, il tag viene convertito in operazioni su un oggetto chiamato tag handler. Il contenitore Web quindi richiama quelle operazioni quando viene eseguito il servlet della pagina JSP.
JSP Expression Language (EL) consente di accedere facilmente ai dati dell'applicazione archiviati nei componenti JavaBeans. JSP EL consente di creare espressioni sia (a) aritmetiche che (b) logiche. Una semplice sintassi per JSP EL è:
${expr}Qui expr specifica l'espressione stessa.
Il linguaggio delle espressioni JSP supporta i seguenti oggetti impliciti:
pageScope - Variabili con ambito dall'ambito della pagina
requestScope - Variabili con ambito dall'ambito della richiesta
sessionScope - Variabili con ambito dall'ambito della sessione
applicationScope - Variabili con ambito dall'ambito dell'applicazione
param - Richiedi parametri come stringhe
paramValues - Richiedi parametri come raccolte di stringhe
headerHTTP - richiedere intestazioni come stringhe
headerValues - Intestazioni delle richieste HTTP come raccolte di stringhe
initParam - Parametri di inizializzazione del contesto
cookie - Valori dei cookie
pageContext - L'oggetto JSP PageContext per la pagina corrente
Possiamo disabilitare l'uso dell'attributo isELIgnored della direttiva della pagina -
<%@ page isELIgnored = "true|false" %>Se è vero, le espressioni EL vengono ignorate quando appaiono in testo statico o attributi di tag. Se è falso, le espressioni EL vengono valutate dal contenitore.
Checked exceptions- L'eccezione verificata è un'eccezione che è tipicamente un errore dell'utente o un problema che non può essere previsto dal programmatore. Ad esempio, se un file deve essere aperto, ma il file non può essere trovato, si verifica un'eccezione. Queste eccezioni non possono essere semplicemente ignorate al momento della compilazione.
Runtime exceptions- Un'eccezione di runtime è un'eccezione che probabilmente avrebbe potuto essere evitata dal programmatore. A differenza delle eccezioni controllate, le eccezioni di runtime vengono ignorate al momento della compilazione.
Errors- Queste non sono affatto eccezioni, ma problemi che sorgono al di fuori del controllo dell'utente o del programmatore. Gli errori vengono generalmente ignorati nel codice perché raramente puoi fare qualcosa per un errore. Ad esempio, se si verifica un overflow dello stack, si verificherà un errore. Vengono ignorati anche al momento della compilazione.
Possiamo usare l'attributo errorPage della direttiva page per avere eccezioni di runtime non rilevate inoltrate automaticamente a una pagina di elaborazione degli errori.
Esempio: <% @ page errorPage = "error.jsp"%>
Reindirizzerà il browser alla pagina JSP error.jsp se viene rilevata un'eccezione non rilevata durante l'elaborazione della richiesta. All'interno di error.jsp, dovrà indicare che si tratta di una pagina di elaborazione degli errori, utilizzando la direttiva: <% @ page isErrorPage = "true"%>
Internazionalizzazione significa consentire a un sito web di fornire diverse versioni di contenuti tradotti nella lingua o nazionalità del visitatore.
Localizzazione significa aggiungere risorse a un sito web per adattarlo a una particolare regione geografica o culturale, ad esempio la traduzione in hindi a un sito web.
Questa è una particolare regione culturale o geografica. Di solito viene indicato come un simbolo della lingua seguito da un simbolo del paese separati da un trattino basso. Ad esempio "en_US" rappresenta la lingua inglese per gli Stati Uniti.
<% - comment -%> è un commento JSP e viene ignorato dal motore JSP.
<! - comment -> è un commento HTML e viene ignorato dal browser.
SÌ. La tecnologia JSP è estendibile attraverso lo sviluppo di azioni personalizzate, o tag, che sono incapsulati in librerie di tag.
Le risorse statiche dovrebbero essere sempre incluse utilizzando JSP include directive. In questo modo, l'inclusione viene eseguita una sola volta durante la fase di traduzione. Tieni presente che dovresti sempre fornire un URL relativo per l'attributo file. Sebbene sia possibile includere anche risorse statiche utilizzando l'azione, ciò non è consigliabile poiché l'inclusione viene quindi eseguita per ogni richiesta.
Sì. Tuttavia, a differenza di Servlet, non è necessario implementare metodi specifici del protocollo HTTP come doGet () o doPost () all'interno della pagina JSP. È possibile ottenere i dati per gli elementi di input FORM tramite l'oggetto implicito della richiesta all'interno di uno scriptlet o di un'espressione.
Utilizzare i seguenti modi per passare il controllo di una richiesta da un servlet a un altro o da un jsp a un altro:
Il metodo forward dell'oggetto RequestDispatcher per passare il controllo.
Utilizzando il metodo response.sendRedirect .
No. Dovresti utilizzare solo un oggetto JSPWriter (fornito sotto forma di oggetto implicito out) per rispondere ai client.
Un JSPWriter può essere visualizzato come una versione bufferizzata dell'oggetto stream restituito da response.getWriter (), sebbene da una prospettiva implementativa non lo sia.
<% @ page session = "false">
Utilizzo del tag <% jsp: param>.
Possiamo sovrascrivere i metodi jspinit () e jspDestroy () ma non _jspService ().
Il metodo _jspService () verrà scritto dal contenitore, quindi qualsiasi metodo che non deve essere sovrascritto dall'utente finale viene tipicamente scritto iniziando con '_'. Questo è il motivo per cui non sovrascriviamo il metodo _jspService () in nessuna pagina JSP.
Causa un errore di compilazione, poiché non è possibile dichiarare due variabili con lo stesso nome. Ciò accade perché, quando una pagina viene inclusa staticamente, l'intero codice della pagina inclusa diventa parte della nuova pagina. in questo momento ci sono due dichiarazioni di variabile "a". Quindi errore di compilazione.
Lo scripting viene disabilitato impostando l'elemento scripting-invalid del descrittore di distribuzione su true. È un sottoelemento di jsp-property-group. I suoi valori validi sono veri e falsi. La sintassi per disabilitare lo scripting è la seguente:
<jsp-property-group>
<url-pattern>*.jsp</url-pattern>
<scripting-invalid>true</scripting-invalid>
</jsp-property-group>Se vogliamo rendere i nostri dati disponibili per l'intera applicazione, dobbiamo utilizzare l'ambito dell'applicazione.
In JSP, possiamo eseguire l'inclusione nei seguenti modi:
By include directive - Ad esempio -
<%@ include file = ”header.jsp” %>By include action - Ad esempio -
<%@ include file = ”header.jsp” %>By using pageContext implicit object Ad esempio:
<% pageContext.include(“/header.jsp”); %>By using RequestDispatcher object - Ad esempio -
<%
RequestDispatcher rd = request.getRequestDispatcher(“/header.jsp”);
Rd.include(request,response);
%>I motori JSP creeranno sempre un'istanza di una nuova istanza del gestore di tag ogni volta che viene rilevato un tag in una pagina JSP. Viene mantenuto un pool di istanze di tag che vengono riutilizzate ove possibile. Quando viene rilevato un tag, il motore JSP proverà a trovare un'istanza di tag che non è in uso e utilizzerà la stessa, quindi la rilascerà.
JavaBeans e fondamenti di taglib sono stati introdotti per la riusabilità. Ma di seguito sono riportate le principali differenze tra loro:
I Taglib servono per la generazione di elementi di presentazione mentre i JavaBeans sono utili per memorizzare informazioni e stato.
Utilizza tag personalizzati per implementare azioni e JavaBeans per presentare le informazioni.