Le Java Server Pages consentono la stesura di applicazioni in Java con molto semplicità, la stesssa semplicità a cui si è abituati quando si realizzano siti Web. Infatti il webmaster è abituato a realizzare un sito semplicemente scrivendo il testo HTML con un editor, e a salvarlo su disco in una particolare directory. Senza effettuare altre operazioni, tale pagina sarà immediatamente accessibile nel Web, grazie ad un server di pagine HTML, il Web Server. La programmazione invece ha solitamente un ciclo di vita più complesso: tipicamente dopo aver composto un file sorgente bisogna compilare, a volte collegare i componenti e infine lanciare in esecuzione l'applicazione. Utilizzando le servlet, che sono lo standard per realizzare applicazioni Web in Java, si ha un ciclo di sviluppo più simile alla programmazione tradizionale. Per rendere lo sviluppo più simile a quello delle pagine Web sono stati introdotto vari strumenti, che sono stati infine recepiti anche da Java con l'introduzione delle Java Server Pages.

Una Java Server Page è un file con estensione .jsp che contiene testo HTML inframezzato con dei tag speciali che contengono codice Java. Esiste un dibattito infinito se sia il caso o no di utilizzare questi sistemi di sviluppo, perché si considera che inserire codice in delle pagine che dovrebbero essere solo dei documenti rende il tutto abbastanta poco leggibile. Questo è in parte vero, ma è anche vero che la particolare natura delle applicazioni Web, che sono composte da tanti pezzi separati, invita all'uso di questa tecnica. Le Java Server Pages comunque consentono tramite l'uso di beans, la separazione tra pagine e codice. Pertanto se si preferisce è sempre possibile impostare una applicazione complessa con una architettura che separa la logica di programmazione dall'interfaccia utente. Ma per piccole e medie applicazioni, la possibilità di mescolare codice all'HTML è talvolta semplicemente la soluzione migliore.

I tag speciali delle JSP che iniziano con <%e terminano con %>possono contenere codice in Java. In questo modo è possibile incorporare facilmente quanto abbiamo visto prima per la connessione a database, ottenendo delle pagine Web dinamiche che visualizzano i dati di magazzino. Un aspetto importante delle JSP è che consentono di suddividere in più file le pagine e di riunirli in seguito in un unico file con delle inclusioni. A questo scopo esiste il tag

<%@ import file=nome-file %>

Questa possibilità sarà sfruttata per separare la parte comune a tutte le pagine da quella specifica per ogni pagina. In particolare ogni pagina avrà una intestazione e un piedino, che si occuperà tra le altre cose di stabilire la connessione al database. Per personalizzare il catalogo in generale sarà sufficiente personalizzare intestazione e piedino.

All'interno di una server page è sempre disponibile un oggetto outche permette di generare testo HTML da codice Java. Per esempio possiamo inserire il testo di un campo letto dal database come nel seguente esempio:

<% out.print(rs.getString("nome") ; %>

Poiché questo caso è molto frequente, è possibile ottenere lo stesso risultato utilizzando la seguente sintassi:

<%= rs.getString("nome") %>

In questo caso si inserisce dentro il tag speciale solamente una espressione e non più una serie di comandi. L'ultimo componente tecnico che ci occorre per la realizzazione dalla prima parte del nostro catalogo è l'accesso ai parametri di una pagina. Ogni pagina Web può infatti essere richiamata passando dei parametri. Per esempio una pagina può essere richiamata con un indirizzo

http://www.ditta.it/catalog/prodotto.jsp?id=4&cat=7

In questo indirizzo possiamo individuare prima del carattere '?' l'indirizzo effettivo della pagina, e dopo i parametri. I parametri vengono comunemente chiamati query string. La query string può avere un formato qualsiasi. E' sempre disponibile in una server page anche un oggetto request i cui metodi permettono di esaminare i dettagli della richiesta, tra cui l'origine della richiesta e, appunto, la query string. Nei casi più semplici si può utilizzare un unico parametro senza nome, accedendo direttamente all'intera query string con

request.getQueryString()

Quando si gestiscono dei moduli la query string solitamente assume una forma più complessa.

In generale si tratta di una serie di variabili a cui sono stati assegnati dei valori; i vari assegnamenti vengono separati dal carattere '&'. Esistono altri aspetti della codifica che non ci interessa approfondire qui perché vengono gestiti automaticamente dal sistema. Queste variabili possono essere accedute direttamente utilizzando:

request.getParameter("id")
request.getParameter("cat")

Quanto detto finora ci consente finalmente di esaminare il funzionamento del catalogo.

Implementazione

Nel listato 1 possiamo osservare il codice della prima pagina, che visualizza la pagina iniziale mostrata in figura 1.

<%@ include file="head.inc" %>

<%@ page import="java.sql.*" %>

<h1 align=center>Catalogo Prodotti</h1>

<hr height=2 noshade>

<!-- Ricerca ------------------------------------------------------------>

<form action=cerca.jsp>
<table align=center>
<tr><td colspan=2 align=center>
Inserisci la stringa da cercare:<br>
<input type=text size=20 name=cerca>
</td></tr>

<tr>
<td colspan=2 align=center><input  type=button value="Cerca" border=0
  onClick="if(form.cerca.value.length==0) alert('Cosa cerco?'); 
           else form.submit(); return true;">
&nbsp;<input type=reset value="Annulla">
</td></tr>
</table>
</form>

<!-- Categorie ------------------------------------------------------------>

<p>
<h1 align="center">Categorie di prodotti</h1>
<hr height=2 noshade>
<center>
<table>
<% ResultSet rs = 
   stat.executeQuery("SELECT idCategoria,nome from categorie ORDER BY nome");
   while(rs.next()) { 
 %>
<tr><td>
 <a href='categoria.jsp?<%=rs.getString("idCategoria")%>'>
   <%=rs.getString("nome")%></a>
</tr></td>
<% }
   rs.close(); 
 %>
</table>

<%@ include file="foot.inc" %>

Come si può notare, vengono inclusi due file, head.inc e foot.inc, ma non si nota il codice che stabilisce la connessione, che è invece mostrato nel listato 2.

<!-- file: head.inc - intestazione ----->
<html>
<head>
<% Class.forName("com.ibm.as400.access.AS400JDBCDriver");
   Connection con = 
   DriverManager.getConnection("jdbc:as400://192.168.1.2/ignis",
    "ignis", "test");
   Statement stat = con.createStatement(); %>
<title>Catalogo</title></head>
<body bgcolor=#ffffff><center><img src=netshop.jpg></center>
<font face="Helvetica">

<!-- file:foot.inc - piedino ------>

</font>
<hr noshade>
<% stat.close(); con.close(); %>
<font size=-1>&copy; 2000 ePrometeus srl</font>
</body></html>

Poiché la connessione al database è uguale per tutte le pagine, è stato spostata nei due file suddetti, che si occupano anche di inserire intestazioni e piedini standard. Comunque il metodo adottato in questo caso richiede che ad ogni richiesta venga instaurata una connessione a database e venga creato uno Statement. Questa soluzione, se accettabile in casi semplici, è in realtà molto inefficiente, soprattutto considerando che la connessione al database può anche essere molto dispendiosa in termini di tempo. Fortunatamente è possibile porvi rimedio, al prezzo però di rendere il discorso molto più complicato. Nel prossimo articolo introdurremo alcuni elementi supplementari delle JSP che ci aiuteranno ad ottimizzare la gestione delle interazioni con il database.

Possiamo dunque vedere come venga effettivamente realizzata la visualizzazione delle categorie. Per esempio, dopo aver ottenuto una connessione al database, viene creata una lista di link come segue:

<table>
<% ResultSet rs = 
   stat.executeQuery(
    "SELECT idCategoria,nome from categorie ORDER BY nome");
   while(rs.next()) { 
 %>
<tr><td>
 <a href='categoria.jsp?<%=rs.getString("idCategoria")%>'>
   <%=rs.getString("nome")%></a>
</tr></td>
<% }  
   rs.close(); %>
</table>

Si noterà pertanto che viene inframezzato ad arte codice e HTML con lo scopo esplicito di creare una serie di link come questi:

 <a href='categoria.jsp?3'> Carne</a>
 <a href='categoria.jsp?1'> Frutta</a>
 <a href='categoria.jsp?5'> Latticini</a>

Seguendo i link, viene chiamata la pagina indicata (che è sempre la stessa) passando un parametro che è, a seconda dei casi, l'identificatore numerico di una categoria o di un prodotto. Nel listato 3 sono mostrati le parti di codice più significative che consentono la visualizzazione delle varie parti del catalogo.

<!-- File: categoria.jsp -/----------------------------------------->
<% String StringaQuery 
    = "SELECT nome FROM categorie WHERE idCategoria="
    +request.getQueryString();

ResultSet rs = stat.executeQuery(StringaQuery);
while(rs.next()){
    out.print("<h1 align=\"center\">Categoria: "
    +rs.getString("nome")+"</h1>");
} %>

<!-- File: prodotto.jsp -------------------------------------------->
<TABLE>
<% String StringaQuery 
    = "SELECT * FROM prodotti WHERE idProdotto="
    +request.getQueryString();
ResultSet rs = stat.executeQuery(StringaQuery);
while(rs.next()){
 out.print("<h3 align=\"center\">"+rs.getString("nome")+"</h3>");
 out.print("<tr><td>Codice prodotto</td><td>"
    +rs.getString("idProdotto")+"</td>");
 out.print("<tr><td>Quantit&agrave ["
    +rs.getString("Unita_misura")+"]</td><td>"
    +rs.getString("quantita")+"</td>");
 out.print("<tr><td>Prezzo </td><td>"
    +rs.getString("prezzo")+"</td>");
}%>
</TABLE>

<!-- File: cerca.jsp ----------------------------------------------->
<table>
<% String parola = request.getQueryString().substring(6);
String StringaQuery = 
 "SELECT idProdotto, nome FROM prodotti WHERE nome LIKE \"%"+parola+"%\"";
ResultSet rs = stat.executeQuery(StringaQuery);
while(rs.next()){
  out.print("<tr>");
  out.print("<td><a href='prodotto.jsp?"+rs.getString("idProdotto")+"'>"
    +rs.getString("nome")+"</a>");
}
rs.close(); %>