Connessione MySQL in Java

Nell'articolo vedremo come connettersi a MySQL tramite Java, separando però la classe della connessione vera e propria a quella per compiere operazioni sul database.

Così facendo creeremo un codice più pulito e riutilizzabile.

Ovviamente i miei esempi sono senz'altro migliorabili, ma penso sia un buon punto di partenza.

Prima di tutto abbiamo bisogno del driver per connettersi al db.

Java possiede i driver per la connessione con molti database.

Se usate NetBeans basta che cliccate col destro sul nome del progetto, poi Proprietà > Librerie > Aggiungi libreria > Driver JDBC per MySQL.

Se invece volete aggiungerlo a mano seguite questi passi:

• scaricatelo da qua
• scompattate il JAR del driver nella cartella dell'applicazione

A questo punto dovrebbe essere tutto pronto.

Andiamo a vedere il codice per la connessione:

import java.sql.*;
import javax.swing.*;

public class Connessione {

public static Connection getConnection() {
Connection conn = null;
try {
Class.forName("com.mysql.jdbc.Driver");
conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/banca?user=user&password=pass");
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, e.getMessage());
} catch (ClassNotFoundException e) {
JOptionPane.showMessageDialog(null, e.getMessage());
}
return conn;
}
}

Prima di tutto creo un oggetto Connection che mi servirà per inserire i dettagli della connessione.

Apro un blocco try/catch per per gestire le eccezioni.

Class.forName serve per caricare il driver appropriato.

Il metodo statico forName della classe Class restituisce una istanza della classe Java specificata nella stringa passata come parametro, che indica il nome completamente qualificato (cioè con il package a cui appartiene) della classe stessa.

In questo caso noi gli passiamo una stringa che rappresenta il diver da caricare.

La connessione con il database viene effettuata invocando il metodo statico getConnection della classe DriverManager che restituisce un oggetto di tipo Connection.

Come parametri gli passiamo:

• l'URL jdbc che ha la forma jdbc:<sub-protocollo>:<altri-parametri>; nello specifico gli dobbiamo fornire info riguardo a quale tipo di db ci connettiamo (mysql), l'url (loaclhost:3306), il database al quale ci connettiamo (banca)
• user
• password

Abbiamo poi due catch per gestire due eccezioni.

Infine il return che ci ritorna l'oggetto conn che verrà usato nelle altre classi.

Se avete capito bene la connessione possiamo passare alla classe per la lettura dei dati dal db.

Supponiamo che il database rappresenti i movimenti del nostro corrente bancario.

I campi sono pochi:

• entrate
• uscite
• causale
• data

import java.sql.*;
import javax.swing.*;

public class Leggi {

public static String leggi() {
String line = "";
int numcolonne = 0;
String nomecolonne = "";
Connection conn = null;
Statement stmt = null;
ResultSet rs = null;
ResultSetMetaData rsmd = null;
try {
conn = Connessione.getConnection();
stmt = conn.createStatement();
rs = stmt.executeQuery("select * from movimenti order by id");
rsmd = rs.getMetaData();
numcolonne = rsmd.getColumnCount();
for (int i = 1; i <= numcolonne; i++) {
nomecolonne += rsmd.getColumnLabel(i) + ": ";
}
String i = "";
String e = "";
String u = "";
String c = "";
String d = "";
while (rs.next()) {
i = rs.getString(1);
e = rs.getString(2);
u = rs.getString(3);
c = rs.getString(4);
d = rs.getString(5);
line += i + ": " + e + ", " + u + ", " + c + ", " + d + "\n";
}
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, e.getMessage());
} finally {
try {
rs.close();
stmt.close();
} catch (Exception e) {
JOptionPane.showMessageDialog(null, e.getMessage());
}
return nomecolonne + "\n" + line;
}
}
}

Inizializzo due String e un int che mi serviranno in seguito.

Poi abbiamo gli oggetti Connection, Statement, ResultSet e ResultSetMetadata che useremo nel blocco try/catch.

Connection richiamerà il metodo getConnection cretao prima; in qeusto modo userà direttamente quei parametri per connettersi.

stmt serve per creare uno Statement con la connessione creata.

Statement rappresenta l’oggetto che consente di eseguire un’ istruzione SQL e viene creato invocando il metodo createStatement() su un’istanza di connessione attiva con il database.

Statement ha due metodi:

• executeQuery per interrogazione dati
• updateQuery per inserimento, eliminazione e aggiornamento dati

Noi prendiamo in considerazione il primo.

Il metodo executeQuery di Statement restituisce un oggetto di tipo ResultSet, che è la struttura dati per un insieme di risultati (simile ad un cursore).

Con rs richiamiamo questo metodo passandogli come stringa la query da effettuare.

Un ResultSet è una tabella contenente il risultato di una query di selezione; come un cursore, un ResultSet è inizialmente posizionato prima della prima riga.

Il ResultSet può avanzare col metodo next(), che una volta invocato, sposta il cursore di una riga in avanti e restituisce false (booleano) se non ci sono più righe da analizzare, true altrimenti.

ResultSerMetaData è invece un oggetto che viene usato per reperire informazioni sui tipi e le proprietà delle colonne di un ResultSet.

Le righe

rsmd = rs.getMetaData();
numcolonne = rsmd.getColumnCount();

for (int i = 1; i <= numcolonne; i++) {
nomecolonne += rsmd.getColumnLabel(i) + ": ";
}

ci servono in sostanza per reperire e stampare le intestazioni delle colonne della tabella su cui effettuiamo la query.

getMetaData recupera il tipo, il numero e le proprietà delle colonne del ResultSet.

Apriamo un ciclo che si completa quando finiscono le colonne della tabella.

getColumnLabel restituisce l'alias della colonna.

Se non è disponibile, questo metodo restituisce il nome della colonna.

Accetta solo int, ma in fase di output restituisce il nome della colonna.

Tutta questa parte ci serve per stampare i dati:

String i = "";
String e = "";
String u = "";
String c = "";
String d = "";
while (rs.next()) {
i = rs.getString(1);
e = rs.getString(2);
u = rs.getString(3);
c = rs.getString(4);
d = rs.getString(5);
line += i + ": " + e + ", " + u + ", " + c + ", " + d + "\n";

In pratica colo ciclo while andiamo a scandagliare tutti i record della tabella.

Il metodo next restituisce true fino a che trova record; quando non li trova più si ferma.

Il metodo getString serve per scegliere quali colonne stampare.

Accetta sia int che String.

Se usate int dovete dirgli il numero della colonna che volete visualizzare; se scegliete String il nome tra virgolette.

line servere per aggregare il tutto.

Cosi avremo una riga per record cone le info che vogliamo.

Nel finally chiudo rs e stmt (e volendo anche conn se non ho altre operazione da fare) e uso return per farmi restituire il nome delle colonne (nomecolonne) e i vari record (line).

NOTE FINALI

Ho qualche cosa da aggiungere.

Ho già scritto un articolo su MySQL e Java, ma penso che questo sia migliore e più completo.

Suggerisco la lettura di entrambi per studiare le varie differenze.

Ho usato molti oggetti diversi, ma probabilmente non sono riuscito a spiegare tutto chiaramente.

Vi consiglio di integrare con le Api di Java 6.

In questo codice non c'è nulla che restituisca a video i risultati.

Questo perchè lo uso per riempire una JTextArea che si trova nel JFrame dal quale faccio tutte le operazioni.

Se volete dei risultati a video dovrete usare un metodo main dove richiamare questo metodo con JOptionPane.showMessageDialog o un System.out.