Lezione 7 - Porte aperte sul web

Le JavaServer Pages - Lezione 7
I JavaBean
A cura di Giuseppe De Pietro ([email protected])
Contenuti
Nelle lezioni precedenti abbiamo visto gli elementi principali delle Java Server Pages, come
scambiare i dati tra client e server e come interagire con i database, operazioni comuni a tutte le
altre tecnologie lato server. Come comuni sono anche i problemi che si verificano con questo tipo di
programmazione:
• codice HTML mescolato a codice Java che non facilita la leggibilità di un documento
• mancanza assoluta della separazione della presentazione dei dati dalla logica gestionale.
Una pagina JSP compilata come finora abbiamo visto potrà risultare ostica sia ad un programmatore
Java (che avrà difficoltà a curare i tag HTML) sia ad un grafico che si ritroverà tra i tag HTML, del
codice per lui incomprensibile.
In questa lezione proporremo alcune soluzioni a questi problemi parlando dei JavaBean, ovvero i
componenti che distinguono le JSP dalle altre tecnologie.
Vedremo come creare dei semplici JavaBean e come farli interagire con un database.
Cosa sono i JavaBean
“JavaBeans components are Java classes that can be easily reused and composed together into
applications.” È la definizione iniziale fornita da Sun Microsystem (nelle specifiche J2EE) che ci
lascia capire di come nella progettazione dei JavaBean, la riusabilità e modularità siano concetti
essenziali.
I JavaBeans sono delle classi Java che devono rispettare le seguenti regole:
• avere un costruttore privo di argomenti o esserne addirittura privo, (quando una classe Java
non dichiara esplicitamente un costruttore, le viene fornito automaticamente uno privo di
argomenti).
• Possono avere delle proprietà a cui è possibile accedere con i classici metodi:
public void setPropertyName (PropertyType value);
per impostare la proprietà, mentre per ottenere un valore:
public PropertyType getPropertyName();
I metodi di accesso a queste proprietà devono essere pubblici, ma una proprietà non è detto
che debba per forza avere il metodo set ed il metodo get. Per esempio potrebbe essere di sola
lettura e quindi avere solo il metodo get.
Usare i JavaBean in un’applicazione Web
I JavaBean sono quindi delle classi Java, il cui codice sorgente sarà inserito in un file
nomeClasse.java. Con la compilazione di tale file se ne crea uno nuovo di nome nomeClasse.class.
Tutti i JavaBean compilati (quindi solo i file .class) per poter essere utilizzati dovranno essere
JSP – Lezione 7 – I JavaBean
1
inseriti nella directory WEB-INF/classes della nostra Web Application. Si riporta di seguito un
esempio di struttura di un’applicazione:
Per esempio il componente login.class è inserito in una sottocartella di nome mioPackage, di
conseguenza la classe login dovrà appartenere al package mioPackage (stesso discorso anche per il
componente mioBean.class).
La pagina jsp che vorrà utilizzare il JavaBean dovrà inserire al suo interno l’azione jsp:useBean che
unita alle altre due azioni jsp:setProperty e jsp:getProperty, permette la gestione completa del
componente. È possibile avere due sintassi:
<jsp:useBean id="nome" scope="valore" opzioni />
e
<jsp:useBean id="nome" scope=" valore " opzioni >
Codice di inizializzazione
</jsp:useBean>
a seconda della necessità di inserire o meno del codice da eseguire quando il bean viene istanziato.
Gli attributi
•
•
•
id: viene utilizzato per assegnare un nome identificativo all’istanza del bean. Tale nome sarà
utilizzato per accedere alle proprietà del componente all’interno della pagina JSP.
scope: indica l’ambito di visibilità del bean. Esso può assumere i seguenti valori:
o page: è il valore di default. Il bean esisterà solo all’interno della pagina che lo
istanzia. Esso verrà distrutto ogni volta che l’utente si sposta in una pagina
successiva e ricreato ogni volta che la pagina verrà richiesta.
o request: il bean sarà visibile all’interno della richiesta, questo significa che si potrà
accedere ad esso anche in pagine incluse dalle azioni jsp:include e jsp:forward.
o session: il bean sarà visibile all’interno di una stessa sessione utente.
o application: utilizzato per creare componenti comuni a tutta la web application,
quindi a tutti gli utenti.
opzioni: le opzioni sono attributi particolari che indicano delle modalità differenti di
funzionamento dell’azione jsp:useBean. Sono possibili le seguenti combinazioni:
o class: con questo attributo si specifica il nome della classe del bean da istanziare o,
se il bean esiste già, richiamare un’istanza precedentemente creata. È l’attributo che
di solito si utilizza.
o type: indica il tipo della classe bean o anche il tipo dell’interfaccia implementata dal
bean. Viene usato raramente e solo nei casi in cui si vuole accedere ad un bean già
istanziato e del tipo specificato.
JSP – Lezione 7 – I JavaBean
2
o beanName: insieme all’attributo type è utile in questi tre casi:
§ il bean non esiste, si crea una nuova istanza.
§ il bean esiste, si ottiene un riferimento all’oggetto già esistente.
§ Il bean è stato serializzato1, si caricano i dati salvati e si istanzia il bean.
Gestire le proprietà di un JavaBean
Per poter accedere alle proprietà di un bean si utilizza l’azione:
<jsp:getProperty name="IDnome" property="nomeProprietà"/>
Che equivale all’ espressione:
<%=Idnome.getNomeProprietà()%>
Mentre per impostare i valori della proprietà è possibile utilizzare varie sintassi.
Per assegnare un determinato valore ad una proprietà si utilizza:
<jsp:setProperty name="IDnome" property="nomeProprietà" value="valore"/>
Per assegnare ad una proprietà del bean il valore del parametro di una richiesta:
<jsp:setProperty name="IDnome" property="nomeProprietà" />
È necessario che il nome del parametro sia uguale al nome della proprietà. In caso di nomi diversi si
utilizza la seguente sintassi:
<jsp:setProperty name="IDnome" property="nomeProprietà"
param="nomeParametro"/>
Se si creano dei form con i nomi dei controlli uguali ai nomi delle proprietà del bean, esiste una
forma abbreviata che permette di impostare tutte le proprietà del bean in un’unica azione:
<jsp:setProperty name="IDnome" property="*" />
Se si modifica il codice di una classe JavaBean è necessario riavviare Tomcat affinchè le modifiche
abbiano effetto.
Un esempio reale
Per chiarire meglio i concetti sopra esposti e i vantaggi nell’utilizzo dei JavaBean, realizzeremo
un’applicazione che, dopo aver effettuato il login, darà la possibilità ad un utente autorizzato di
poter modificare i propri dati.
La struttura del database sarà quella illustrata nella lezione 6. Si partirà con il file esempio7_1.jsp
che conterrà un form di autenticazione utente in cui si richiederanno il nome utente e la password.
1
processo con cui si salva lo stato di un oggetto, mentre la deserializzazione è il processo con cui si ripristina un
oggetto precedentemente salvato.
JSP – Lezione 7 – I JavaBean
3
<%@ page language="java" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="IT">
<head>
<title>Usare i JavaBean</title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
</head>
<body>
<h2>I JavaBean</h2>
<form method="post" action="mostraDati.jsp">
<fieldset>
<legend>Login utente</legend>
<label for="userid">User id: </label>
<input type="text" name="userid" id="userid">
<br/>
<label for="password">Password: </label>
<input type="password" name="password" id="password">
<br/><br/>
<input type="submit" value="Login" name="invia">
</fieldset>
</form>
</body>
</html>
Creiamo il JavaBean che chiameremo Utente.java e il file compilato (da prompt dei comandi
digitare javac Utente.java) lo inseriamo nella cartella WEB-INF/classes/mieiBean della nostra
Web Application.
package mieiBean;
import java.sql.*;
public class Utente {
private String userid="";
private String password="";
private String cognome="";
private String nome="";
private String tipovia="";
private String indirizzo="";
private String numcivico="";
private String cap="";
private String citta="";
private String prov="";
private String idtipo="";
private String email="";
private String telefono="";
private String cellulare="";
private boolean utenteEsiste=false;
private String msgErrore="";
public String getCap() {
return cap;
}
public void setCap(String cap) {
this.cap = cap;
}
public String getCellulare() {
return cellulare;
}
JSP – Lezione 7 – I JavaBean
4
public void setCellulare(String cellulare) {
this.cellulare = cellulare;
}
public String getCitta() {
return citta;
}
public void setCitta(String citta) {
this.citta = citta;
}
public String getCognome() {
return cognome;
}
public void setCognome(String cognome) {
this.cognome = cognome;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getIdtipo() {
return idtipo;
}
public void setIdtipo(String idtipo) {
this.idtipo = idtipo;
}
public String getIndirizzo() {
return indirizzo;
}
public void setIndirizzo(String indirizzo) {
this.indirizzo = indirizzo;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
public String getNumcivico() {
return numcivico;
}
public void setNumcivico(String numcivico) {
this.numcivico = numcivico;
}
public String getPassword() {
return password;
}
/**
JSP – Lezione 7 – I JavaBean
5
public void setPassword(String password) {
this.password = password;
}
public String getProv() {
return prov;
}
public void setProv(String prov) {
this.prov = prov;
}
public String getTelefono() {
return telefono;
}
public void setTelefono(String telefono) {
this.telefono = telefono;
}
public String getTipovia() {
return tipovia;
}
public void setTipovia(String tipovia) {
this.tipovia = tipovia;
}
public String getUserid() {
return userid;
}
public void setUserid(String userid) {
this.userid = userid;
}
public boolean isUtenteEsiste() {
return utenteEsiste;
}
public void setUtenteEsiste(boolean utenteEsiste) {
this.utenteEsiste = utenteEsiste;
}
public String getMsgErrore() {
return msgErrore;
}
public boolean loadUtente() {
utenteEsiste=false;
if (password!=null && userid!=null){
PreparedStatement stmt = null;
ResultSet rs = null;
Connection cn=null;
try{
Class.forName("com.mysql.jdbc.Driver");
cn =
DriverManager.getConnection("jdbc:mysql://localhost/registro_online?user=root&p
assword=segreta");
String sql="SELECT * FROM utente WHERE UserID=? AND
password=?";
stmt = cn.prepareStatement(sql);
stmt.setString(1,userid);
JSP – Lezione 7 – I JavaBean
6
stmt.setString(1,userid);
stmt.setString(2,password);
rs = stmt.executeQuery();
if (rs.next()){
//utente esistente
utenteEsiste=true;
cognome=rs.getString("cognome");
nome=rs.getString("nome");
tipovia=rs.getString("tipovia");
indirizzo=rs.getString("indirizzo");
numcivico=rs.getString("numcivico");
cap=rs.getString("cap");
citta=rs.getString("citta");
prov=rs.getString("prov");
idtipo=rs.getString("idtipo");
email=rs.getString("email");
telefono=rs.getString("telefono");
cellulare=rs.getString("cellulare");
}
rs.close();
stmt.close();
cn.close();
}
catch (Exception e) {
msgErrore=e.getMessage();
}
}
return utenteEsiste;
}
public boolean saveUtente(){
utenteEsiste=false;
PreparedStatement stmt = null;
ResultSet rs = null;
Connection cn=null;
try{
Class.forName("com.mysql.jdbc.Driver");
cn =
DriverManager.getConnection("jdbc:mysql://localhost/registro_online?user=root&p
assword=segreta");
//inserisce i dati
String sql="UPDATE utente SET
password=?,cognome=?,nome=?,tipovia=?,indirizzo=?,numcivico=?,cap=?,citta=?,pro
v=?,idtipo=?,email=?,telefono=?,cellulare=? Where userid=?";
PreparedStatement stmtIns = cn.prepareStatement(sql);
stmtIns.setString(14,userid);
stmtIns.setString(1,password);
stmtIns.setString(2,cognome);
stmtIns.setString(3,nome);
stmtIns.setString(4,tipovia);
stmtIns.setString(5,indirizzo);
stmtIns.setString(6,numcivico);
stmtIns.setString(7,cap);
stmtIns.setString(8,citta);
stmtIns.setString(9,prov);
stmtIns.setString(10,idtipo);
stmtIns.setString(11,email);
stmtIns.setString(12,telefono);
stmtIns.setString(13,cellulare);
stmtIns.executeUpdate();
utenteEsiste=true;
rs.close();
cn.close();
JSP – Lezione 7 – I JavaBean
7
cn.close();
}
catch (Exception e){
msgErrore=e.getMessage();
}
return utenteEsiste;
}
}
Useremo il nostro Bean nella pagina mostraDati.jsp che a seconda del nome e della password
inseriti, caricherà i dati relativi all’utente. Il JavaBean avrà uno scope session, questo significa che
l’istanza del Bean esisterà finchè la sessione utente sarà attiva.
<%@ page language="java" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="IT">
<head>
<title>Usare i JavaBean</title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
</head>
<body>
<h2>I JavaBean</h2>
<% boolean utenteEsiste=false; %>
<%-- Creazione o recupero del JavaBean --%>
<jsp:useBean id="utente" scope="session" class="mieiBean.Utente" />
<jsp:setProperty name="utente" property="userid"/>
<jsp:setProperty name="utente" property="password"/>
<% utenteEsiste=utente.loadUtente();
if(utenteEsiste){
%>
<form method="post" action="salvaDati.jsp">
<fieldset>
<legend>Inserimento dati nuovo utente</legend>
<label for="userid">User ID: </label>
<input type="text" name="userid" id="userid"
value="<jsp:getProperty name='utente' property='userid'/>">
<br/>
<label for="password">Password: </label>
<input type="password" name="password" id="password"
value="<jsp:getProperty name='utente' property='password'/>">
<br/>
<label for="cognome">Cognome: </label>
<input type="text" name="cognome" id="cognome"
value="<jsp:getProperty name='utente' property='cognome'/>">
<br/>
<label for="nome">Nome: </label>
<input type="text" name="nome" id="nome"
value="<jsp:getProperty name='utente' property='nome'/>">
<br/>
<label for="tipovia">Tipo Via: </label>
<input type="text" name="tipovia" id="tipovia"
value="<jsp:getProperty name='utente' property='tipovia'/>">
<br/>
<label for="indirizzo">Indirizzo: </label>
<input type="text" name="indirizzo" id="indirizzo"
value="<jsp:getProperty name='utente' property='indirizzo'/>">
<br/>
JSP – Lezione 7 – I JavaBean
8
<label for="numcivico">N° Civico: </label>
<input type="text" name="numcivico" id="numcivico"
value="<jsp:getProperty name='utente' property='numcivico'/>">
<br/>
<label for="cap">Cap: </label>
<input type="text" name="cap" id="cap"
value="<jsp:getProperty name='utente' property='cap'/>">
<br/>
<label for="citta">Citt&agrave;: </label>
<input type="text" name="citta" id="citta"
value="<jsp:getProperty name='utente' property='citta'/>">
<br/>
<label for="prov">Provincia: </label>
<input type="text" name="prov" id="prov"
value="<jsp:getProperty name='utente' property='prov'/>">
<br/>
<label for="idtipoutente">Tipo utente: </label>
<% String tipoUtente=utente.getIdtipo(); %>
<select name="idtipo" id="idtipo">
<option value="STU" <%if(tipoUtente.equals("STU"))
out.write("SELECTED"); %>>Studente</option>
<option value="INS" <%if(tipoUtente.equals("INS"))
out.write("SELECTED"); %>>Insegnante</option>
<option value="GEN" <%if(tipoUtente.equals("GEN"))
out.write("SELECTED"); %>>Genitore</option>
<option value="ADM" <%if(tipoUtente.equals("ADM"))
out.write("SELECTED"); %>>Amministratore</option>
</select>
<br/>
<label for="email">E-Mail: </label>
<input type="text" name="email" id="email"
value="<jsp:getProperty name='utente' property='email'/>">
<br/>
<label for="telefono">Telefono: </label>
<input type="text" name="telefono" id="telefono"
value="<jsp:getProperty name='utente' property='telefono'/>">
<br/>
<label for="cellulare">Cellulare: </label>
<input type="text" name="cellulare" id="cellulare"
value="<jsp:getProperty name='utente' property='cellulare'/>">
<br/>
<br/>
<input type="submit" value="Invia" name="invia">
</fieldset>
</form>
<%
}
else {
out.write("Utente non trovato. " + utente.getMsgErrore());
}
%>
</body>
</html>
I dati visualizzati potranno essere modificati e il salvataggio degli aggiornamenti saranno effettuati
dalla pagina salvaDati.jsp:
JSP – Lezione 7 – I JavaBean
9
<%@ page language="java" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="IT">
<head>
<title>Usare i JavaBean</title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
</head>
<body>
<h2>I JavaBean</h2>
<% boolean utenteEsiste=false; %>
<jsp:useBean id="utente" class="mieiBean.Utente" scope="session"/>
<jsp:setProperty name="utente" property="*"/>
<% utenteEsiste=utente.saveUtente();
if(utenteEsiste){
out.write("Dati salvati correttamente");
}
else{
out.write("Si è verificato il seguente problema:" +
utente.getMsgErrore());
}
%>
<a href="mostraDati.jsp" title="Torna ai dati personali">Torna ai dati
personali</a>
</body>
</html>
Dall’esempio proposto risulta evidente come siano molto più comprensibili le pagine jsp che
utilizzano i bean, anziché inserire tutto il codice di gestione come scriptless.
JSP – Lezione 7 – I JavaBean
10