La tecnologia Java Server Pages permette di scrivere pagine web dinamiche, la cui esecuzione avviene cioè sul server, utilizzando Java come linguaggio di programmazione.
Come sappiamo una JSP viene compilata dal JSP Engine la prima volta che viene richiamata da un client e viene trasformata automaticamente in una Servlet, questo significa che a partire dal codice JSP viene ricavato del codice Java che viene a sua volta compilato per produrre la Servlet vera e propria in grado di rispondere alla chiamata HTTP.
Sappiamo che una pagina JSP non è altro che HTML “condito” con codice server-side, infatti abbiamo visto in precedenza l’esempio:
Esempio di pagina JSP
Oggi è il: <%= new java.util.Date() %>
/
Questo codice, salvato con il nome prova.jsp ed eseguito su Tomcat produce l’output che conosciamo, ma per poter far questo Tomcat lo trasforma dapprima in codice java e lo salva nella sua directory work.
Se andiamo a curiosare, infatti, troviamo il file prova$jsp.java con il seguente contenuto:package org.apache.jsp;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;
import org.apache.jasper.runtime.*;public class prova$jsp extends HttpJspBase {
static {
}
public prova$jsp() {
}private static boolean _jspx_inited = false;
public final void _jspx_init() throws org.apache.jasper.runtime.JspException
{
}public void _jspService(HttpServletRequest request, HttpServletResponse response)
throws java.io.IOException, ServletException {JspFactory _jspxFactory = null;
PageContext pageContext = null;
HttpSession session = null;
ServletContext application = null;
ServletConfig config = null;
JspWriter out = null;
Object page = this;
String _value = null;
try {if (_jspx_inited == false) {
synchronized (this) {
if (_jspx_inited == false) {
_jspx_init();
_jspx_inited = true;
}
}
}
_jspxFactory = JspFactory.getDefaultFactory();
response.setContentType(“text/html;charset=ISO-8859-1”);
pageContext = _jspxFactory.getPageContext(this, request, response, “”, true, 8192, true);application = pageContext.getServletContext();
config = pageContext.getServletConfig();
session = pageContext.getSession();
out = pageContext.getOut();out.write(“rn
rnEsempio di pagina JSP rn rn rnOggi è il: “);
out.print(new java.util.Date());
out.write(”rn rnrn”);
} catch (Throwable t) {
if (out != null && out.getBufferSize() != 0)
out.clearBuffer();
if (pageContext != null) pageContext.handlePageException(t);
} finally {
if (_jspxFactory != null) _jspxFactory.releasePageContext(pageContext);
}
}
}/
Queso codice, che come sappiamo è una Servlet, produce esattamente l’output che ci aspettiamo grazie a questo frammento:
out.write(“rn
rnEsempio di pagina JSP rn rn rnOggi è il: “);
out.print(new java.util.Date());
out.write(”rn rnrn”);
/
dove l’oggetto out, istanza della classe JspWriter, viene utilizzato per spedire testo al browser attraverso la HTTP Response.
Naturalmente quello che il browser riceve è semplice HTML, cioè qualcosa che è in grado di interpretare e di mostrare all’utente.
Grazie a questo meccanismo potentissimo siamo in grado di utilizzare le pagine JSP come gestori della componente di visualizzazione di un’applicazione web, mentre all’interno del codice della pagina possiamo usare alcuni metodi diversi per ottenere elaborazioni su server, questi sono:
- scrivere direttamente il codice java all’interno della JSP (come vedremo è un metodo da evitare)
- utilizzare i JavaBeans
- utilizzare le Tag Libraries
L’unione di Java Server Pages, Servlet, Tag Libraries e JavaBeans ci fornisce un’infrastruttura potentissima per lo sviluppo di applicazioni web e costituisce lo standard J2EE.