Codice - Corso Base Android

Laboratorio di Sistemi
Fondamenti di JSTL (parte 1)
Java (JSTL)
Adattamento da Wikipedia
XML
L'XML, acronimo di eXtensible Markup Language, ovvero “Linguaggio di marcatura estensibile”
è un metalinguaggio creato e gestito dal World Wide Web Consortium (W3C). È una
semplificazione e adattamento dell'SGML, da cui è nato nel 1988, e permette di definire la
grammatica di diversi linguaggi specifici derivati.
Rispetto all'HTML, l'XML ha uno scopo ben diverso: mentre il primo è un insieme di tag, (non è
un linguaggio di programmazione), creati principalmente per la descrizione e la formattazione
di pagine web e, più in generale, di ipertesti, il secondo è un metalinguaggio utilizzato per
creare nuovi linguaggi, atti a descrivere documenti strutturati. Mentre l'HTML ha un insieme
ben definito e ristretto di tag, con l'XML è invece possibile definirne di propri a seconda delle
esigenze.
L'XML è oggi molto utilizzato anche come mezzo per l'esportazione di dati tra diversi DBMS
(Data Base Management System).
Esempio
<?xml version="1.0" encoding="ISO-8859-1"?>
<utenti>
<utente>
<nome>Luca</nome>
<cognome>Ruggero</cognome>
<indirizzo>Milano</indirizzo>
</utente>
<utente>
<nome>Max</nome>
<cognome>Rossi</cognome>
<indirizzo>Roma</indirizzo>
</utente>
</utenti>
In genere i file XML hanno estensione .xml ed è possibile visualizzarli (con una formattazione
particolare) all'interno dei browser.
Java EE (Java Enterprise Edition)
J2EE (dall'inglese Java 2 Enterprise Edition) è la versione enterprise della piattaforma java.
Essa è costituita da un insieme di specifiche che definiscono le caratteristiche e le interfacce di
un insieme di tecnologie pensate per la realizzazione di applicazioni di tipo enterprise e mission
critical. Chiunque può realizzare una implementazione di tali specifiche e produrre application
server compatibili con le specifiche J2EE.
Dalla versione 5 il nome è stato modificato in Java EE.
Application Server
Un application server è un software che fornisce l'infrastruttura e le funzionalità di supporto,
sviluppo ed esecuzione di applicazioni e componenti server in un contesto distribuito. Si tratta
di un complesso di servizi orientati alla realizzazione di applicazioni multilivello ed enterprise,
con alto grado di complessità, spesso orientate per il web.
Allo stato attuale delle cose, le tecnologie su cui possono basarsi gli application server sono
due: Microsoft .NET e Java di Sun Microsystems. Essendo una specifica, quella Java annovera
numerose implementazioni sia commerciali (per esempio ColdFusion, JRun di Adobe e
WebLogic di BEA) che open source: Tomcat, JBoss, Geronimo, Zope, GlassFish ecc.
Gli standard di Java non sono unicamente frutto della Sun, ma sono il risultato di un rapporto
sinergico tra l'azienda americana e la partecipazione libera di sviluppatori in tutto il mondo. Gli
standard su cui si fonda la tecnologia .NET sono invece stabiliti direttamente da Microsoft.
JSTL-parte1.pdf
Pag. 1/12
Cozzetto ©
Laboratorio di Sistemi
Fondamenti di JSTL (parte 1)
Java (JSTL)
Nel mondo Java, gli application server compatibili con le specifiche della Sun sono detti
application server J2EE.
JSP (JavaServer Pages)
JavaServer Pages, di solito indicato con l'acronimo JSP è una tecnologia Java per lo sviluppo di
applicazioni Web che forniscono contenuti dinamici in formato HTML o XML. Si basa su un
insieme di speciali tag (come ad esempio jsp:useBean che vedremo in seguito) detti anche
azioni JSP con cui possono essere invocate funzioni predefinite o codice Java. In aggiunta,
permette di creare librerie di nuovi tag che estendono l'insieme dei tag standard. Le librerie di
tag JSP si possono considerare estensioni indipendenti dalla piattaforma delle funzionalità di un
Web server.
Nel contesto della piattaforma Java, la tecnologia JSP è correlata con quella delle servlet.
All'atto della prima invocazione, le pagine JSP vengono infatti tradotte automaticamente da un
compilatore JSP in servlet. Una pagina JSP può quindi essere vista come una rappresentazione
ad alto livello di una servlet. Per via di questa dipendenza concettuale, anche l'uso della
tecnologia JSP richiede la presenza, sul Web server, di un servlet container, oltre che di un
server specifico JSP detto motore JSP (che include il compilatore JSP); in genere, servlet
container e motore JSP sono integrati in un unico prodotto (per esempio, Tomcat svolge
entrambe le funzioni).
JSP è una tecnologia alternativa rispetto a numerosi altri approcci alla generazione di pagine
Web dinamiche, per esempio PHP, o ASP o la più tradizionale CGI. Differisce da queste
tecnologie non tanto per il tipo di contenuti dinamici che si possono produrre, quanto per
l'architettura interna del software che costituisce l'applicazione Web (e, di conseguenza, sui
tempi di sviluppo, la portabilità, la modificabilità, le prestazioni, e altri aspetti di qualità del
software).
JSTL (JavaServer Pages Tag Library)
JSTL è un componente della piattaforma Java EE (Enterprise Edition). Estende le specifiche
delle JSP aggiungendo delle librerie di tag JSP per i compiti più comuni, come l'elaborazione
dell'XML, l'esecuzione condizionale, l'esecuzione dei loop e l'internazionalizzazione
(i18n=internationalization). Le JSTL forniscono un modo per incorporare all'interno delle
pagine JSP la logica, senza usare direttamente nelle pagine web il codice Java. L'utilizzo di un
insieme standard di tag, piuttosto che l'interruzione o l'alternanza di codice Java e di tag HTML,
conduce a codice maggiormente mantenibile e consente una maggiore separazione dei compiti
tra lo sviluppo del codice applicativo e l'interfaccia utente.
Fine
I tag sono organizzati per categorie:
● Core (prefisso c) il cui compito è la gestione delle variabili e delle URL e del controllo
del flusso di esecuzione (elaborazione delle strutture selettive e delle strutture cicliche)
● XML (prefisso x), gestione dei file XML e dei nodi mediante le regole di trasformazione
Xpath. XPath è un linguaggio parte della famiglia XML che permette di individuare i nodi
all'interno di un documento XML. Le espressioni XPath, a differenza delle espressioni
XML, non servono a identificare la struttura di un documento, bensì a localizzarne con
precisione i nodi.
● Internazionalizzazione (i18n) (prefisso fmt), localizzazione, formattazione di valute,
numeri e date
● Database (prefisso sql), esecuzione di query di lettura e query di aggiornamento
● Funzioni (prefisso fn), collezioni e manipolazione di stringhe
JSTL-parte1.pdf
Pag. 2/12
Cozzetto ©
Laboratorio di Sistemi
Fondamenti di JSTL (parte 1)
Java (JSTL)
Fig. 1 – Mr Sang Shin, l'inventore delle JSTL
L'inventore delle JSTL è Sang Shin, un noto sviluppatore della Sun che tra l'altro è il gestore di
un sito web il cui titolo è tutto un programma http://www.javapassion.com, un sito di elearning ricco di materiale su Java e non solo. Sang Shin tiene sul sito dei corsi online in forma
gratuita, chiunque può scegliere il corso a cui è interessato e vi può partecipare previa
iscrizione. Alla fine del corso, viene rilasciato un attestato di partecipazione.
Per poter usare le librerie occorre inserire una direttiva taglib nella pagina secondo il seguente
schema:
Libreria
URI
Prefisso
Core
<%@ taglib prefix="c"
uri="http://java.sun.com/jsp/jstl/core"
%>
c
XML
<%@ taglib prefix="x"
x
uri="http://java.sun.com/jsp/jstl/xml" %>
I18N
<%@ taglib prefix="fmt"
fmt
uri="http://java.sun.com/jsp/jstl/fmt" %>
SQL
<%@ taglib prefix="sql"
uri="http://java.sun.com/jsp/jstl/sql" %>
Functions
<%@ taglib prefix="fn"
fn
uri="http://java.sun.com/jsp/jstl/functions
" %>
sql
Fig. 2 – Le librerie della JSTL
Piuttosto che fare un lungo elenco di tag, preferiamo riportare dei semplici esempi che
consentono di capire il funzionamento delle librerie. Per includere le JSTL nel nostro progetto
NetBeans (stiamo usando la versione 6.5), basta selezionare il progetto, poi col tasto destro
del mouse, scegliere Properties > (Categories) Library > Add Library... > JSTL 1.1.
Confermare su OK.
Tag della libreria Core
File prova1.jsp
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
JSTL-parte1.pdf
Pag. 3/12
Cozzetto ©
Laboratorio di Sistemi
Fondamenti di JSTL (parte 1)
Java (JSTL)
<title>Prova 1</title>
</head>
<body>
<h3>Prova 1</h3>
<c:set var="testo" value="Re Julien & Maurice" />
<c:out escapeXml="true" value="${testo}" />
<c:out escapeXml="false" value="${testo}" />
</body>
</html>
Benchè l'output all'utente appaia simile, tuttavia, osservando l'HTML prodotto, si nota che la
seconda & non è stata tradotta nella corrispondente entità & in virtù della presenza
dell'attributo escapeXml posto a false.
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Prova 1</title>
</head>
<body>
<h3>Prova 1</h3>
Re Julien & Maurice
Re Julien & Maurice
</body>
</html>
Nell'esempio prova1.jsp, si è fatto uso anche di una EL (Expression Language). L'EL è un
linguaggio di scripting che consente l'accesso a componenti Java (come i JavaBean) in maniera
più semplice rispetto all'uso di codice Java immerso nella pagina web.
JavaBean
Un JavaBean (o componente Java) è una normale classe Java che gode delle seguenti
proprietà:
1)
2)
3)
4)
Ha un costruttore “nullo” (cioè senza argomenti)
La classe implementa l'interfaccia Serializable
Tutti gli attributi sono privati
Per ogni attributo esiste un getter e un setter
Esempio:
/**
*
* Utente.java
*/
package it.itiscastelli.classi;
import java.io.Serializable;
JSTL-parte1.pdf
Pag. 4/12
Cozzetto ©
Laboratorio di Sistemi
Fondamenti di JSTL (parte 1)
Java (JSTL)
/**
* @author maurizio
*/
public class Utente implements Serializable {
private String nome;
private String cognome;
private String password;
private String ruolo;
public Utente() {
//
}
// seguono getter e setter
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
public String getCognome() {
return cognome;
}
public void setCognome(String cognome) {
this.cognome = cognome;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getRuolo() {
return ruolo;
}
public void setRuolo(String ruolo) {
this.ruolo = ruolo;
}
} // fine javabean Utente
File prova2.jsp
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
JSTL-parte1.pdf
Pag. 5/12
Cozzetto ©
Laboratorio di Sistemi
Fondamenti di JSTL (parte 1)
Java (JSTL)
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Prova 2</title>
</head>
<body>
<h3>Prova 2</h3>
<jsp:useBean id="mioUtente" class="it.itiscastelli.classi.Utente" scope="page" />
<jsp:setProperty
<jsp:setProperty
<jsp:setProperty
<jsp:setProperty
name="mioUtente"
name="mioUtente"
name="mioUtente"
name="mioUtente"
property="nome" value="Maurizio" />
property="cognome" value="Cozzetto" />
property="password" value="98JUY42" />
property="ruolo" value="admin" />
Dati dell'utente:<br/><br/>
<b>Nome:</b> <c:out value="${mioUtente.nome}" /><br/>
<b>Cognome:</b> <c:out value="${mioUtente.cognome}" /><br/>
<b>Password:</b> <c:out value="${mioUtente.password}" /><br/>
<b>Ruolo:</b> <c:out value="${mioUtente.ruolo}" /><br/>
</body>
</html>
Nell'esempio prova2.jsp, abbiamo fatto uso dell'azione standard jsp:useBean per creare un
JavaBean mentre abbiamo usato jsp:setProperty per impostare il valore delle proprietà del
JavaBean. Per leggere le proprietà, avremmo potuto usare l'azione standard jsp:getProperty
ma abbiamo preferito usare le EL.
File prova3.jsp
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Prova 3</title>
</head>
<body>
<h3>Prova 3</h3>
<%
it.itiscastelli.classi.Utente mioUtente = new it.itiscastelli.classi.Utente();
mioUtente.setNome("Maurizio");
mioUtente.setCognome("Cozzetto");
mioUtente.setPassword("98JUY42");
mioUtente.setRuolo("admin");
%>
Dati dell'utente:<br/><br/>
JSTL-parte1.pdf
Pag. 6/12
Cozzetto ©
Laboratorio di Sistemi
Fondamenti di JSTL (parte 1)
Java (JSTL)
<%
out.println("<b>Nome:</b> "+mioUtente.getNome()+"<br/>");
out.println("<b>Cognome:</b> "+mioUtente.getCognome()+"<br/>");
out.println("<b>Password:</b> "+mioUtente.getPassword()+"<br/>");
out.println("<b>Ruolo:</b> "+mioUtente.getRuolo()+"<br/>");
%>
</body>
</html>
Entrambi i programmi prova2.jsp e prova3.jsp producono un output simile
Fig. 3 – L'output prodotto dal programma prova2.jsp (confrontatelo con l'output prodotto dal
programma prova3.jsp)
Azioni c:if, c:choose, c:when, c:otherwise
File prova4.jsp
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Prova 4</title>
</head>
<body>
<h3>Prova 4</h3>
<c:set var="a" value="${33+42}" />
<c:set var="b" value="${33*42}" />
JSTL-parte1.pdf
Pag. 7/12
Cozzetto ©
Laboratorio di Sistemi
Fondamenti di JSTL (parte 1)
Java (JSTL)
<c:if test="${a>b}">
Il valore di a è maggiore di quello di b
</c:if>
</body>
</html>
Come si potrà vedere lanciando il programma, l'output è costituito solo dall'header h3. Questo
perchè l'azione c:if implementa la struttura selettiva con un solo ramo. Se vogliamo
implementare una struttura selettiva con due rami, dobbiamo ricorrere alle azioni c:choose,
c:when e c:otherwise come nel seguente esempio:
File prova5.jsp
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Prova 5</title>
</head>
<body>
<h3>Prova 5</h3>
<c:set var="a" value="${33+42}" />
<c:set var="b" value="${33*42}" />
<c:choose>
<c:when test="${a>b}">
Il valore di a è maggiore di quello di b
</c:when>
<c:otherwise>
Il valore di b è maggiore di quello di a
</c:otherwise>
</c:choose>
</body>
</html>
Le variabili inoltre possono essere deallocate con l'azione c:remove, mentre il confronto tra le
stringhe è possibile con l'operatore == (file prova6.jsp).
File prova6.jsp
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Prova 6</title>
</head>
<body>
<h3>Prova 6</h3>
JSTL-parte1.pdf
Pag. 8/12
Cozzetto ©
Laboratorio di Sistemi
Fondamenti di JSTL (parte 1)
Java (JSTL)
<c:set var="lingua" value="it" />
La variabile lingua contiene il valore <c:out value="${lingua}" />
<c:choose>
<c:when test="${lingua=='it'}">
La lingua è l'italiano
</c:when>
<c:when test="${lingua=='de'}">
La lingua è il tedesco
</c:when>
<c:when test="${lingua=='es'}">
La lingua è lo spagnolo
</c:when>
<c:when test="${lingua=='en'}">
La lingua è l'inglese
</c:when>
<c:otherwise>
Lingua sconosciuta
</c:otherwise>
</c:choose>
<c:remove var="lingua"/>
La variabile lingua contiene il valore <c:out value="${lingua}" />
</body>
</html>
Azione c:forEach
File prova7.jsp
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Prova 7</title>
</head>
<body>
<h3>Prova 7</h3>
<c:forEach var="i" begin="0" end="10">
Il valore di i è <c:out value="${i}"/><br/>
</c:forEach>
</body>
</html>
JSTL-parte1.pdf
Pag. 9/12
Cozzetto ©
Laboratorio di Sistemi
Fondamenti di JSTL (parte 1)
Java (JSTL)
Fig. 4 – L'output del programma prova7.jsp è prevedibile
Azione c:forEach sulle Collection
Possiamo usare l'azione c:forEach ciclando ripetutamente tra gli elementi di una Collection
(come un set o una mappa)
File prova8.jsp
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Prova 8</title>
</head>
<body>
<h3>Prova 8</h3>
<jsp:useBean id="madagascar2" class="it.itiscastelli.classi.Film" />
I personaggi del film <jsp:getProperty name="madagascar2" property="titolo" /><br/>
<c:forEach var="personaggio" items="${madagascar2.personaggi}">
Un personaggio del film Madagascar è <c:out value="${personaggio}"/><br/>
</c:forEach>
</body>
</html>
JSTL-parte1.pdf
Pag. 10/12
Cozzetto ©
Laboratorio di Sistemi
Fondamenti di JSTL (parte 1)
Java (JSTL)
File Film.java
/**
* Film.java
*/
package it.itiscastelli.classi;
import java.util.HashSet;
import java.util.Set;
public class Film {
private String titolo;
private String regista;
private String lingua;
private Set<String> personaggi;
public Film() {
titolo = "Madagascar 2";
regista = "Eric Darnell e Tom McGrath";
lingua = "italiana";
personaggi = new HashSet<String>();
personaggi.add("Alex");
personaggi.add("Melman");
personaggi.add("Marty");
personaggi.add("Gloria");
personaggi.add("Moto Moto");
personaggi.add("Re Julien & Maurice");
personaggi.add("I pinguini");
personaggi.add("Le scimmie");
}
public Set<String> getPersonaggi() {
return personaggi;
}
// seguono getter e setter
public String getTitolo() {
return titolo;
}
public void setTitolo(String titolo) {
this.titolo = titolo;
}
public String getRegista() {
return regista;
}
public void setRegista(String regista) {
this.regista = regista;
}
public String getLingua() {
return lingua;
}
JSTL-parte1.pdf
Pag. 11/12
Cozzetto ©
Laboratorio di Sistemi
Fondamenti di JSTL (parte 1)
Java (JSTL)
public void setLingua(String lingua) {
this.lingua = lingua;
}
public void setPersonaggi(Set<String> personaggi) {
this.personaggi = personaggi;
}
} // fine JavaBean Film
Fig. 5 – L'output del programma prova8.jsp
JSTL-parte1.pdf
Pag. 12/12
Cozzetto ©