Sviluppo di Applicazioni Web con JSP e XML Parte I: Fast Track JSP

Se avete avuto l’opportunità di creare applicazioni web utilizzando le tecnologie come CGI (Common Gateway Interface) e servlet, si sono abituati all’idea di scrivere un programma per generare l’intera pagina (la statica e la dinamica parte) utilizzando lo stesso programma. Se siete alla ricerca di una soluzione in cui è possibile separare le due parti, non cercate oltre. Le pagine JavaServer (JSP) sono qui.

Le pagine JSP consentono di separare la presentazione front-end dalla logica di business (livelli middle e back-end). Si tratta di un grande Rapid Application Development (RAD) approccio alle applicazioni Web. Questa serie di articoli fornisce un tutorial pratico che spiega come sviluppare applicazioni Web moderne per il mercato di oggi e di domani. Questa serie inizia con questo articolo, che spiega i concetti ei vantaggi della tecnologia JSP, e poi vi mostra come utilizzare questa tecnologia emozionante, e come creare componenti riutilizzabili per la gestione di moduli.

Il Web dinamico

Il Web si è evoluto da un sistema di informazioni distribuite ipermediali basato sulla rete che offre informazioni statiche a un mercato per la vendita e l’acquisto di beni e servizi. Le applicazioni sempre più sofisticate per consentire questo mercato richiedono una tecnologia per presentare informazioni dinamiche.

Le soluzioni di prima generazione includevano CGI, che è un meccanismo per l’esecuzione di programmi esterni attraverso un server Web. Il problema con gli script CGI è la scalabilità; viene creato un nuovo processo per ogni richiesta.

Le soluzioni di seconda generazione includevano fornitori di server Web che fornivano plug-in e API per i loro server. Il problema è che le loro soluzioni erano specifiche per i loro prodotti server. Ad esempio, Microsoft ha fornito Active Server Pages (ASP) che ha reso più semplice la creazione di contenuti dinamici. Tuttavia, la loro soluzione ha funzionato solo con Microsoft IIS o Personal Web Server. Pertanto, se si voleva utilizzare ASP si doveva impegnarsi a prodotti Microsoft e non sarebbe godendo la libertà di selezionare il server web preferito e il sistema operativo!

Un’altra tecnologia di seconda generazione che è molto popolare nel calcolo aziendale è servlet. I servlet semplificano la scrittura di applicazioni lato server utilizzando la tecnologia Java. Il problema con CGI o servlet, tuttavia, è che devi seguire il ciclo di vita di scrittura, compilazione e distribuzione.

Le pagine JSP sono una soluzione di terza generazione che può essere combinata facilmente con alcune soluzioni di seconda generazione, creando contenuti dinamici e rendendo più facile e veloce la creazione di applicazioni basate sul Web che funzionano con una varietà di altre tecnologie: server web, browser web, server di applicazioni e altri strumenti di sviluppo.

JavaServer Pages (JSP)

La tecnologia JSP è una specifica aperta e liberamente disponibile sviluppata da Sun Microsystems come alternativa alla tecnologia Active Server Pages (ASP) di Microsoft e un componente chiave della specifica Java 2 Enterprise Edition (J2EE). Molti dei server applicativi disponibili in commercio (come BEA WebLogic, IBM WebSphere, Live JRun, Orion e così via) supportano già la tecnologia JSP.

JSP contro ASP

JSP e ASP offrono funzionalità simili. Entrambi utilizzano i tag per consentire il codice incorporato in una pagina HTML, il monitoraggio della sessione e la connessione al database. Alcune delle differenze banali sono:

• Le pagine ASP sono scritte in VBScript e le pagine JSP sono scritte nel linguaggio di programmazione Java. Pertanto, le pagine JSP sono indipendenti dalla piattaforma e le pagine ASP non lo sono.
• Le pagine JSP utilizzano la tecnologia JavaBeans come architettura dei componenti e le pagine ASP utilizzano componenti ActiveX.

Al di là di queste differenze banali, ci sono una serie di importanti differenze che possono aiutare nella scelta di una tecnologia per l’organizzazione:

• Velocità e scalabilità: sebbene le pagine ASP siano memorizzate nella cache, vengono sempre interpretate. Al contrario, le pagine JSP vengono compilate in servlet Java e caricate in memoria la prima volta che vengono chiamate ed eseguite per tutte le chiamate successive. Ciò conferisce alle pagine JSP un vantaggio di velocità e scalabilità rispetto alle pagine ASP.
• Tag estensibili: le pagine JSP hanno una funzionalità avanzata nota come tag estensibili. Questo meccanismo consente agli sviluppatori di creare tag personalizzati. In altre parole, i tag estensibili consentono di estendere la sintassi dei tag JSP pages. Non puoi farlo con le pagine ASP.
• Libertà di scelta: a meno che non si installa Chili!Soft ASP, le pagine ASP funzionano solo con Microsoft IIS e Personal Web Server. L’utilizzo di pagine ASP richiede un impegno per i prodotti Microsoft, mentre le pagine JSP non ti legano a nessun server Web o sistema operativo specifico. Le pagine JSP stanno diventando uno standard ampiamente supportato.

Per un confronto più dettagliato tra pagine JSP e pagine ASP, vedere Confronto tra JSP e ASP.

Ambiente software

Per eseguire pagine JSP, è necessario un server Web con un contenitore Web conforme alle specifiche JSP e servlet. Il contenitore Web viene eseguito sul server Web e gestisce l’esecuzione di tutte le pagine JSP e servlet in esecuzione su quel server Web. Tomcat 3.2.1 è un’implementazione di riferimento completa per le specifiche Java Servlet 2.2 e JSP 1.1. Scarica e installa versioni binarie di Tomcat.

Per configurare Tomcat:

• Impostare la variabile di ambiente JAVA_HOME per puntare alla directory principale dell’installazione Java 2 Standard Edition (J2SE).
• Imposta la variabile di ambiente TOMCAT_HOME in modo che punti alla directory principale dell’installazione di Tomcat.
• Per avviare Tomcat, utilizzare TOMCAT_HOME/bin/startup.bat per Windows o startup.sh per UNIX.
  Per impostazione predefinita, inizierà l’ascolto sulla porta 8080.
• Salva i tuoi file .jsp in TOMCAT_HOME/webapps/examples/jspe le tue classi JavaBeans in TOMCAT_HOME/webapps/examples/web-inf/classes.

Nota: se si lavora in Windows, è possibile che si verifichi un errore di ambiente Out of space quando si tenta di avviare Tomcat. Ci sono due modi per risolvere questo problema: modificare l’impostazione di memoria iniziale della finestra DOS su un valore maggiore di 3200 o modificare la configurazione.file sys e aggiungere la seguente riga: SHELL=c:\PATHTO\command.com /E:4096 /P.

Come funzionano le pagine JSP

Una pagina JSP è fondamentalmente una pagina web con HTML tradizionale e bit di codice Java. L’estensione del file di una pagina JSP è “.jsp “piuttosto che”.html” o “.htm”, e questo dice al server che questa pagina richiede una gestione speciale che verrà eseguita da un’estensione del server o da un plug-in. Ecco un semplice esempio:

Esempio 1: data.spg

 <HTML><HEAD><TITLE>JSP Example</TITLE></HEAD><BODY BGCOLOR="ffffcc"><CENTER><H2>Date and Time</H2><% java.util.Date today = new java.util.Date();out.println("Today's date is: "+today);%></CENTER> </BODY> </HTML> 

Questo esempio contiene HTML tradizionale e un po ‘ di codice Java. Il tag <% identifica l’inizio di uno scriptlet e il tag %> identifica la fine di uno scriptlet. Quando date.jsp è richiesto da un browser web, si vede qualcosa di simile alla Figura 1.

Figura 1: Data di richiesta.jsp

Dietro le quinte

Quando questa pagina (date.jsp) viene chiamata, verrà compilata (dal motore JSP) in un servlet java. A questo punto il servlet viene gestito dal motore servlet proprio come qualsiasi altro servlet. Il motore servlet carica quindi la classe servlet (utilizzando un caricatore di classi) ed esegue per creare HTML dinamico da inviare al browser, come mostrato in Figura 2. Per questo esempio, il servlet crea un oggetto Date e lo scrive come stringa nell’oggetto out, che è un flusso di output nel browser.

Figura 2: Flusso di richiesta / risposta quando si chiama un JSP

La prossima volta che viene richiesta la pagina, il motore JSP esegue il servlet già caricato a meno che la pagina JSP non sia cambiata, nel qual caso viene automaticamente ricompilato in un servlet ed eseguito.

Elementi di scripting

Nell’esempio date.jsp viene utilizzato il nome completo della classe Date incluso il nome del pacchetto, che può diventare noioso. Se si desidera creare un’istanza di Date semplicemente utilizzando: Date today = new Date(); senza dover specificare il percorso completo della classe utilizzare la direttiva page come segue:

Esempio 2 :date2.spg

 <%@page import="java.util.*" %><HTML> <HEAD> <TITLE>JSP Example</TITLE> </HEAD> <BODY BGCOLOR="ffffcc"><CENTER> <H2>Date and Time</H2> <% java.util.Date today = new java.util.Date();out.println("Today's date is: "+today);%></CENTER></BODY> </HTML>

Tuttavia, un altro modo per fare la stessa cosa usando il tag <%= è scrivere:

Esempio 3:date3.spg

 <%@page import="java.util.*" %> <HTML> <HEAD> <TITLE>JSP Example</TITLE> </HEAD> <BODY BGCOLOR="#ffffcc"> <CENTER> <H2>Date and Time</H2> Today's date is: <%= new Date() %> </CENTER> </BODY> </HTML> 

Come puoi vedere, la stessa cosa può essere realizzata utilizzando diversi tag e tecniche. Ci sono diversi elementi di scripting JSP. Ecco alcune regole convenzionali che ti aiuteranno a utilizzare efficacemente gli elementi di scripting JSP:

• Usa <% ... %> per gestire dichiarazioni, espressioni o qualsiasi altro tipo di frammento di codice valido. Esempio 1 sopra è un esempio.
• Utilizzare la direttiva page come in <%@page ... %> per definire il linguaggio di scripting. Inoltre, può essere utilizzato per specificare import istruzioni. Ecco un esempio:
  <%@page language="java" import="java.util.*" %>.
• Usa <%! .... %> per dichiarare variabili o metodi. Ad esempio:
  <%! int x = 10; double y = 2.0; %>.
• Utilizzare <%= ... %> per definire un’espressione e lanciare il risultato come String. Ad esempio:
  <%= a+b %> o <%= new java.util.Date() %>.
• Utilizzare la direttiva include come in <%@ include ... %> per inserire il contenuto di un altro file nel file JSP principale. Ad esempio:
  <%@include file="copyright.html" %>.

Gestione dei moduli

Una delle parti più comuni delle applicazioni di e-commerce è un modulo HTML in cui l’utente inserisce alcune informazioni come nome e indirizzo. Utilizzando JSP, i dati del modulo (le informazioni che l’utente inserisce nel modulo) vengono memorizzati nell’oggetto request che viene inviato dal browser al contenitore JSP. La richiesta viene elaborata e il risultato viene inviato tramite l’oggetto response al browser. Questi due oggetti sono implicitamente disponibili per te.

Per dimostrare come gestire i moduli HTML utilizzando JSP, ecco un modulo di esempio con due campi: uno per nome e l’altro per e-mail. Come puoi vedere, il modulo HTML è definito in un file sorgente JSP. Il metodo request.getParameter viene utilizzato per recuperare i dati dal modulo in variabili create utilizzando i tag JSP.

La pagina process.jsp stampa un modulo o le informazioni fornite dall’utente in base ai valori dei campi del modulo. Se i valori del modulo sono null il modulo viene visualizzato, altrimenti vengono visualizzate le informazioni fornite dall’utente. Si noti che il modulo viene creato e gestito dal codice nello stesso file JSP.

Esempio 4: processo.spg

 <HTML> <HEAD> <TITLE>Form Example</TITLE> </HEAD> <BODY BGCOLOR="#ffffcc"> <% if (request.getParameter("name")==null && request.getParameter("email") == null) { %> <CENTER> <H2>User Info Request Form</H2> <FORM METHOD="GET" ACTION="/developer/technicalArticles/xml/WebAppDev/process.jsp"> <P> Your name: <input type="text" name="name" size=26> <P> Your email: <input type="text" name="email" size=26> <P> <input type="submit" value="Process"> </FORM> </CENTER> <% } else { %> <%! String name, email; %> <% name = request.getParameter("name"); email = request.getParameter("email"); %> <P> <B>You have provided the following info</B>: <P> <B>Name</B>: <%= name %><P> <B>Email</B>: <%= email %> <% } %> </BODY> </HTML> 

Se process.jsp è richiesto da un server Web, si vede qualcosa di simile alla Figura 3.

Figura 3: processo.jsp loaded

Inserisci il tuo nome ed e-mail e fare clic su Process per inviare il modulo per l’elaborazione, e si vede qualcosa di simile alla Figura 4.

Figura 4: Il modulo viene elaborato

Componenti riutilizzabili

Il modulo di esempio sopra è semplice nel senso che non è coinvolto molto codice. Quando è coinvolto più codice, è importante non mescolare la logica di business con la presentazione front-end nello stesso file. Separare la logica di business dalla presentazione consente di modificare entrambi i lati senza influire sull’altro. Tuttavia, il codice JSP di produzione dovrebbe essere limitato alla presentazione front-end. Quindi, come si implementa la parte logica di business?

È qui che entrano in gioco i JavaBeans. Questa tecnologia è un modello di componente portatile indipendente dalla piattaforma che consente agli sviluppatori di scrivere componenti e riutilizzarli ovunque. Nel contesto di JSP, JavaBeans contengono logica di business che restituisce i dati a uno script in una pagina JSP, che a sua volta formatta i dati restituiti dal componente JavaBean per la visualizzazione dal browser. Una pagina JSP utilizza un componente JavaBean impostando e ottenendo le proprietà che fornisce.

Quali sono i vantaggi

Ci sono diversi vantaggi nell’utilizzo di JavaBeans per aumentare le pagine JSP:

• Componenti riutilizzabili: diverse applicazioni saranno in grado di riutilizzare i componenti.
• Separazione tra logica di business e logica di presentazione: è possibile modificare il modo in cui i dati vengono visualizzati senza influire sulla logica di business.
• Proteggere la proprietà intellettuale mantenendo il codice sorgente sicuro.

Esempio: Utilizzo di JavaBeans con JSP

Ora, vediamo come modificare l’esempio process.jsp sopra per utilizzare JavaBeans. Nella forma precedente questi sono due campi: namee email. In JavaBeans, questi sono chiamati proprietà. Quindi, per prima cosa scrivi un componente JavaBean con i metodi setX e getX, dove X è il nome della proprietà. Ad esempio, se si dispone di metodi get e set: setName e getName, si dispone di una proprietà nota come name. L’esempio 5 mostra un componente FormBean.

I componenti validi devono essere in grado di interagire con altri componenti di fornitori diversi. Pertanto, per ottenere il riutilizzo dei componenti, ci sono due regole importanti (che sono imposte dall’architettura JavaBeans) da seguire:

1. La classe bean deve fornire un costruttore senza argomenti in modo che possa essere creato utilizzando Beans.instantiate.
2. La classe bean deve supportare la persistenza implementando l’interfaccia Serializableo Externalizable.

Esempio 5: FormBean.java

 package userinfo; import java.io.*; public class FormBean implements Serializable { private String name; private String email; public FormBean() { name = null; email = null; } public void setName(String name) { this.name = name; } public String getName() { return name; } public void setEmail(String email) { this.email = email; } public String getEmail() { return email; } } 

Per utilizzare il componente FormBean nel file JSP, è necessario creare un’istanza del componente bean. Questo viene fatto usando il tag <jsp:useBean>. La riga successiva <jsp:setProperty> viene eseguita quando il bean viene istanziato e utilizzato per inizializzare le proprietà del bean. In questo caso, entrambe le proprietà ( name e email) vengono impostate utilizzando una singola istruzione. In alternativa, è possibile impostare le proprietà una alla volta, ma prima è necessario recuperare la data del modulo. Ecco un esempio di come impostare la proprietà name :

 <%! String yourname, youremail; %> <% yourname = request.getParameter("name"); %> <jsp:setProperty name="formbean" property="name" value="<%=yourname%>"/> 

Una volta che le proprietà sono state inizializzate con i dati recuperati dal modulo, i valori delle proprietà vengono recuperati per la presentazione utilizzando <jsp:getProperty> nella parte else, come mostrato nell’esempio 6.

Esempio 6: processo2.spg

 <jsp:useBean class="userinfo.FormBean"/><jsp:setProperty name="formbean" property="*"/> <HTML> <HEAD><TITLE>Form Example</TITLE></HEAD><BODY BGCOLOR="#ffffcc"><% if (request.getParameter("name")==null && request.getParameter("email") == null) { %><CENTER><H2>User Info Request Form </H2><form method="GET" action="/developer/technicalArticles/xml/WebAppDev/process2.jsp"><P>Your name: <input type="text" name="name" size=27><p> Your email: <input type="text" name="email" size=27> <P> <input type="submit" value="Process"></FORM></CENTER><% } else { %><P><B>You have provided the following info</B>: <P> <B>Name</B>: <jsp:getProperty name="formbean"property="name"/> <P> <B>Email</B>: <jsp:getPropertyname="formbean" property="email"/> <% } %> </BODY> </HTML> 

Conclusione

Gli sviluppatori interessati a sviluppare applicazioni web di produzione di qualità dovrebbero familiarizzare con tecnologie applicabili non solo per il mercato di oggi, ma anche per quello di domani, vale a dire JSP e XML. Il prossimo articolo discuterà le funzionalità fornite dalla tecnologia JSP che sono ideali per lavorare con XML; e ti mostrerà come utilizzare efficacemente JSP con XML. JSP e XML costituiscono una combinazione eccellente per le applicazioni Web che condividono informazioni, poiché le pagine JSP hanno il supporto XML incorporato direttamente in esse sotto forma di librerie di tag personalizzate JSP. Restate sintonizzati per ulteriori informazioni su questo nel prossimo articolo di questa serie.