Guarda questo.
PREMESSE:
Il mio esempio sotto presume che:
A) Ci sia una tabella chiamata
recensioni con le colonne:
-
id (tipo numerico, es. INTEGER in MySQL)
-
descrizione (tipo stringa, es. VARCHAR(100) in MySQL; il length a tua scelta)
-
prezzo (tipo numerico decimale, es. DOUBLE in MySQL)
-
data (tipo data, es. DATE in MySQL)
B) Ci sia una classe Java chiamata
Recensione che "modella" la tabella, fatta (abbozzata) così:
import java.sql.Date;
public class Recensione {
private int id;
private String descrizione;
private double prezzo;
private Date data;
// metodi getId() / setId() .....
// metodi getDescrizione() / setDescrizione() .....
// ... altri getter/setter nella forma tradizionale .....
}
C) Ci sia un metodo
DBconnection.getConnection() che ad ogni richiesta crea una NUOVA Connection (da chiudere sempre, quindi).
E che se getConnection() fallisce, esso lanci fuori un SQLException.
Con queste premesse, allora:
import java.sql.Connection;
import java.sql.Date;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
public class DaoRecensioni {
public List<Recensione> getRecensioni() throws SQLException {
Connection conn = DBconnection.getConnection();
try {
Statement stmt = conn.createStatement();
try {
ResultSet rs = stmt.executeQuery("SELECT * FROM recensioni");
try {
return extractRecensioni(rs);
} finally {
rs.close();
}
} finally {
stmt.close();
}
} finally {
conn.close();
}
}
private List<Recensione> extractRecensioni(ResultSet rs) throws SQLException {
List<Recensione> recensioni = new ArrayList<Recensione>();
while (rs.next()) {
recensioni.add(extractRecensione(rs));
}
return recensioni;
}
private Recensione extractRecensione(ResultSet rs) throws SQLException {
Recensione recensione = new Recensione();
recensione.setId(rs.getInt("id"));
recensione.setDescrizione(rs.getString("descrizione"));
recensione.setPrezzo(rs.getDouble("prezzo"));
recensione.setData(rs.getDate("data"));
return recensione;
}
}
Il getRecensioni() è nella forma "classica"/tradizionale con i try-finally "annidati" per garantire TUTTI i close.
Mentre i due extractRecensioni/extractRecensione servono solo per mettere a fattor comune la estrazione di N record e di 1 record. Potresti infatti avere più metodi (es. getRecensione(int id) oppure un getRecensioniPerAnno(int anno) ecc... che hanno bisogno di nuovo di quelle stesse "mappature". Questi due metodi non sono nulla di che ... semplicemente si tratta di "buon senso" nella programmazione per evitare ripetizioni.
Da Java 7 è stato introdotto un costrutto chiamato
try-with-resource che semplifica un po' la gestione di codice come quello con svariate risorse da "chiudere". Quindi da Java 7 il getRecensioni() si può anche riscrivere così:
public List<Recensione> getRecensioni() throws SQLException {
try (
Connection conn = DBconnection.getConnection();
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT * FROM recensioni");
) {
return extractRecensioni(rs);
}
}
In questo codice i close() dentro i giusti finally CI SONO ancora tutti. Semplicemente sono "nascosti" all'interno del costrutto
try-with-resource che è fatto apposta per semplificare questo aspetto.
Questo getRecensioni() è funzionalmente uguale al precedente. C'è una leggera differenza nel trattamento delle eccezioni ma dovresti leggere il Java Language Specification e te lo lascio come esercizio molto futuro ..
L'unica questione un po' spinosa (ma in JDBC purtroppo è così) sono le date, in generale la gestione dei valori temporali. Nell'esempio ho usato java.sql.Date ma si possono fare altre scelte.
Noti l'accuratezza di tutto quanto? Se non la noti, non so che farci e non saprei aiutarti molto oltre ....
P.S: il codice NON ho modo/tempo di provarlo ma in linea di massima dovrebbe essere corretto.