CORSO DI JSP
|
CORSO DI JSP |
|
Tecnologia JSPE' una tecnologia che consente di creare applicazioni web che mescolano contenuti statici (descritti con un qualsiasi markup language come HTML, VRML, XML, ...) con contenuti dinamici.
Le principali caratteristiche di questa tecnologia sono:
Cos'è una pagina JSP?E' un documento di testo in cui convivono elementi statici (HTML, XML, VRML, SVG, ...) ed elementi JSP che costituiscono il contenuto dinamico.
Da questo punto di vista non c'è nulla di diverso da altri linguaggi come PHP, APS, CF, DTML...
Ogni pagina può includere altri frammenti di codice, tramite il meccanismo di inclusione.
Vi sono due modi di scrivere in JSP: sintassi standard e sintassi XML. Per una tabella sinottica, si consulti l'allegato mentre per una visione più particolare si consulti questa scheda.
Esempio: una semplice applicazione JSP che fa uso di JavaBeans è quella che disegna una form utilizzando i beans per disegnare i singoli elementi di una form.
Il codice JSP è il seguente:
Leggiamolo un po' per volta.
La prima riga è una direttiva JSP che forza una importazione (le direttive iniziano con @) di un file.
Questa direttiva ci permette di utilizzare un JavaBean che è definito dentro alla classe Java form/FormTag. Tale classe risiede in /WEB-INF/classes/form/FormTag.class; per usare il javaBean occorre invocare:
Nelle tre righe successive invochiamo i metodi set del JavaBean (che vedremo in dettaglio tra poco) per inizializzare i valori dei campi del form. In sostanza, utilizziamo i JavaBean come dei mattoncini LEGO, ognuno definisce un campo della form, e attraverso la direttiva setProperty possiamo passare i parametri al Bean direttamente dalla pagina JSP.
Dopodiché, una volta impostati i valori da mettere nei campi, possiamo scrivere la form dentro all'HTML ma anziché scrivere il codice HTML, lasciamo che siano i JavaBeans a farlo al posto nostro (noi dobbiamo solo mettere i valori dei default per i campi):
Ora rivolgiamo l'attenzione al codice Java con cui sono scritti i Beans:
package form;
public class FormTag {
// JavaBean che realizza un form HTML
// utilizzando i JavaBean SubmitTag e TextTag
private String action;
private String formMethod;
private String numberValue;
private String code = new String("");
private TextTag textTag = new TextTag();
private SubmitTag submitTag = new SubmitTag();
// costruttore
public FormTag() {
}
// setters
public void setTextTag (String name, String value) {
textTag.setCode(name, value);
}
public void setSubmitTag (String value) {
submitTag.setCode(value);
}
public void setAction(String action) {
this.action = action;
}
public void setFormMethod(String formMethod) {
this.formMethod = formMethod;
}
public void setNumberValue(String numberValue) {
this.numberValue = numberValue;
}
public void setCode () {
textTag.setCode("number", this.numberValue);
submitTag.setCode("OK");
code = "<form action=\"" + this.action + "\" method=\"" + this.formMethod + "\">\n";
code+= ("\t" + textTag.getCode() + "\n\t" + submitTag.getCode() );
code+= "\n</form>";
}
// getters
public String getAction () {
return action;
}
public String getFormMethod () {
return formMethod;
}
public String getNumberValue () {
return numberValue;
}
public String getCode () {
this.setCode();
return code;
}
}
vediamo come funziona in backtracking a partire dall'invocazione della proprietà code dentro al codice JSP.
Questa riga implica l'invocazione del getter getCode che, come si può leggere qui sopra, invoca prima il costruttore setCode e poi ritorna il valore di code.
setCode invoca a sua volta i setter per i JavaBeans textTag e submitTag (che costruiscono rispettivamente la casella di testo e il pulsante di submit), e poi costruisce il testo HTML scrivendo:
Esercizio: modificare il codice e ricompilare le classi per poter passare l'etichetta del pulsante HTML da JSP (al momento è cablato nel codice).
Vi sono due modi di scrivere il codice JSP, uno secondo la sintassi JSP e uno secondo la sintassi XML. Le differenze sono riassunte in questo sinottico.
Una descrizione più dettagliata delle sintassi invece è in questo documento.
JSP e i database
Per lavorare con i database, JSP ha adottato la soluzione di passare sempre per un driver JDBC che converte le chiamate da JSP al database specifico utilizzando di volta in volta i driver per quel tipo di database.
Dunque, indipendentemente dal database che usiamo (fatta salva la differente sintassi SQL) non dovremo usare differenti set di librerie per i vari tipi di database (come accade con PHP) ma sempre e solo le API di JDBC.
Le API di JDBC sono definite nel package java.sql.
Fig. 6 - Connessione a database con JDBC
NB: i driver JDBC si trovano nel file classes12.jar che va messo in /WEB-INF/lib/ del package contenente la nostra applicazione.
Vi sono due modi di accedere al database.
Viene interrogato il database con una query (o viene eseguita una scrittura) utilizzando le istruzioni per ciclare sul recordset (o per scrivere sulle righe).
Si veda la pagina di esempio (pagina statica prodotta da un JSP)
Viene istanziato un JavaBean che fa esattamente le cose che prima si facevano con il JSP e con i tag XML <jsp:useBean > si accede al JavaBean ritornando la connessione che poi viene utilizzata nella pagina JSP.
Questo consente una maggiore chiarezza e modularità del codice (ad esempio, si può progettare il JavaBean in modo tale da riutilizzarlo per qualsiasi query, ed evitare di riscrivere codice ogni volta).
Si veda la pagina di esempio (pagina statica prodotta da un JSP)