Apache Commons DBUtils - Guida rapida
La libreria Apache Commons DbUtils è un insieme piuttosto piccolo di classi, progettate per semplificare l'elaborazione delle chiamate JDBC senza perdite di risorse e per avere un codice più pulito. Poiché la pulizia delle risorse JDBC è piuttosto noiosa e soggetta a errori, le classi DBUtils aiutano ad astrarre il codice boilerplate, in modo che gli sviluppatori possano concentrarsi solo sulle operazioni relative al database.
Vantaggi di DBUtils
I vantaggi dell'utilizzo di Apache Commons DBUtils sono spiegati di seguito:
No Resource Leakage - Le classi DBUtils garantiscono che non si verifichi alcuna perdita di risorse.
Clean & Clear code - Le classi DBUtils forniscono codice pulito e chiaro per eseguire le operazioni del database senza la necessità di scrivere un codice di pulizia o di prevenzione della perdita di risorse.
Bean Mapping - La classe DBUtils supporta la compilazione automatica di javabeans da un set di risultati.
Principi di progettazione di DBUtils
I principi di progettazione di Apache Commons DBUtils sono i seguenti:
Small - La libreria DBUtils è di dimensioni molto ridotte con meno classi, quindi è facile da capire e utilizzare.
Transparent- La libreria DBUtils non sta facendo molto lavoro dietro le quinte. Richiede semplicemente query ed esegue.
Fast - Le classi della libreria DBUtils non creano molti oggetti in background ed è abbastanza veloce nelle esecuzioni delle operazioni di database.
Per iniziare a sviluppare con DBUtils, devi configurare il tuo ambiente DBUtils seguendo i passaggi mostrati di seguito. Partiamo dal presupposto che tu stia lavorando su una piattaforma Windows.
Installa Java
Installa J2SE Development Kit 5.0 (JDK 5.0) dal sito ufficiale Java .
Assicurati che le seguenti variabili di ambiente siano impostate come descritto di seguito:
JAVA_HOME - Questa variabile di ambiente dovrebbe puntare alla directory in cui è stato installato JDK, ad esempio C: \ Program Files \ Java \ jdk1.5.0.
CLASSPATH - Questa variabile di ambiente dovrebbe avere percorsi appropriati impostati, ad esempio C: \ Program Files \ Java \ jdk1.5.0_20 \ jre \ lib.
PATH - Questa variabile di ambiente dovrebbe puntare al bin JRE appropriato, ad esempio C: \ Program Files \ Java \ jre1.5.0_20 \ bin.
È possibile che tu abbia già impostato queste variabili, ma solo per assicurarti, ecco come verificare.
Vai al pannello di controllo e fai doppio clic su Sistema. Se sei un utente di Windows XP, è possibile che tu debba aprire Prestazioni e manutenzione prima di vedere l'icona Sistema.
Vai alla scheda Avanzate e fai clic sulle variabili d'ambiente.
Ora controlla se tutte le variabili sopra menzionate sono impostate correttamente.
Installa database
La cosa più importante di cui avrai bisogno, ovviamente è un vero database in esecuzione con una tabella che puoi interrogare e modificare.
Installa un database più adatto a te. Puoi avere molte scelte e le più comuni sono:
MySQL DB:MySQL è un database open source. Puoi scaricarlo dal sito ufficiale di MySQL . Si consiglia di scaricare l'installazione completa di Windows.
Inoltre, scarica e installa MySQL Administrator e MySQL Query Browser . Questi sono strumenti basati su GUI che renderanno il tuo sviluppo molto più semplice.
Infine, scarica e decomprimi MySQL Connector / J (il driver MySQL JDBC) in una comoda directory. Ai fini di questo tutorial supporremo che tu abbia installato il driver in C: \ Programmi \ MySQL \ mysql-connector-java-5.1.8.
Di conseguenza, imposta la variabile CLASSPATH su C: \ Programmi \ MySQL \ mysql-connector-java-5.1.8 \ mysql-connector-java-5.1.8-bin.jar. La versione del driver può variare in base all'installazione.
PostgreSQL DB:PostgreSQL è un database open source. Puoi scaricarlo dal sito ufficiale di PostgreSQL .
L'installazione di Postgres contiene uno strumento di amministrazione basato su GUI chiamato pgAdmin III. I driver JDBC sono inclusi anche come parte dell'installazione.
Oracle DB- Oracle DB è un database commerciale venduto da Oracle. Partiamo dal presupposto che tu abbia il supporto di distribuzione necessario per installarlo.
L'installazione di Oracle include uno strumento di amministrazione basato su GUI chiamato Enterprise Manager. I driver JDBC sono inclusi anche come parte dell'installazione.
Installa i driver del database
Il JDK più recente include un driver Bridge JDBC-ODBC che rende la maggior parte dei driver ODBC (Open Database Connectivity) disponibili ai programmatori che utilizzano l'API JDBC.
Attualmente, la maggior parte dei fornitori di database fornisce driver JDBC appropriati insieme all'installazione del database. Quindi, non dovresti preoccuparti di questa parte.
Imposta credenziali database
Per questo tutorial useremo il database MySQL. Quando installi uno dei database di cui sopra, il suo ID amministratore è impostato suroot e fornisce la possibilità di impostare una password di tua scelta.
Utilizzando l'ID e la password root è possibile creare un altro ID utente e una password oppure è possibile utilizzare l'ID e la password root per l'applicazione JDBC.
Esistono varie operazioni di database come la creazione e l'eliminazione del database, che richiederebbero ID e password dell'amministratore.
Per il resto del tutorial JDBC, utilizzeremo il database MySQL con username come ID e password come password.
Se non disponi di privilegi sufficienti per creare nuovi utenti, puoi chiedere al tuo amministratore di database (DBA) di creare un ID utente e una password per te.
Crea database
Per creare il file emp database, utilizzare i seguenti passaggi:
Passo 1
Apri un file Command Prompt e passare alla directory di installazione come segue:
C:\>
C:\>cd Program Files\MySQL\bin
C:\Program Files\MySQL\bin>Note: Il percorso per mysqld.exepuò variare a seconda della posizione di installazione di MySQL sul sistema. È inoltre possibile controllare la documentazione su come avviare e arrestare il server del database.
Passo 2
Avvia il server database eseguendo il seguente comando, se non è già in esecuzione.
C:\Program Files\MySQL\bin>mysqld
C:\Program Files\MySQL\bin>Passaggio 3
Crea il file emp database eseguendo il seguente comando:
C:\Program Files\MySQL\bin> mysqladmin create emp -u root -p
Enter password: ********
C:\Program Files\MySQL\bin>Crea tabella
Per creare il file Employees tabella nel database emp, utilizzare i seguenti passaggi:
Passo 1
Apri un file Command Prompt e passare alla directory di installazione come segue:
C:\>
C:\>cd Program Files\MySQL\bin
C:\Program Files\MySQL\bin>Passo 2
Accedi al database come segue:
C:\Program Files\MySQL\bin>mysql -u root -p
Enter password: ********
mysql>Passaggio 3
Crea la tabella Employee come segue -
mysql> use emp;
mysql> create table Employees
-> (
-> id int not null,
-> age int not null,
-> first varchar (255),
-> last varchar (255)
-> );
Query OK, 0 rows affected (0.08 sec)
mysql>Crea record di dati
Infine crei alcuni record nella tabella Employee come segue:
mysql> INSERT INTO Employees VALUES (100, 18, 'Zara', 'Ali');
Query OK, 1 row affected (0.05 sec)
mysql> INSERT INTO Employees VALUES (101, 25, 'Mahnaz', 'Fatma');
Query OK, 1 row affected (0.00 sec)
mysql> INSERT INTO Employees VALUES (102, 30, 'Zaid', 'Khan');
Query OK, 1 row affected (0.00 sec)
mysql> INSERT INTO Employees VALUES (103, 28, 'Sumit', 'Mittal');
Query OK, 1 row affected (0.00 sec)
mysql>Per una comprensione completa del database MySQL, studia il Tutorial MySQL .
Scarica Commons DBUtils Archive
Scarica l'ultima versione del file jar Apache Common DBUtils da commons-dbutils-1.7-bin.zip , MySql connector mysql-connector-java-5.1.28-bin.jar , Apache Commons DBCP commons-dbcp2-2.1.1-bin. zip , Apache Commons Pool commons-pool2-2.4.3-bin.zip e Apache Commons Logging commons-logging-1.2-bin.zip . Al momento della stesura di questo tutorial, abbiamo scaricato commons-dbutils-1.7-bin.zip , mysql-connector-java-5.1.28-bin.jar , commons-dbcp2-2.1.1-bin.zip , commons-pool2 -2.4.3-bin.zip , commons-logging-1.2-bin.zip e copiato nella cartella C: \> Apache.
| OS | Nome dell'archivio |
|---|---|
| finestre | commons-dbutils-1.7-bin.zip |
| Linux | commons-dbutils-1.7-bin.tar.gz |
| Mac | commons-dbutils-1.7-bin.tar.gz |
Imposta l'ambiente Apache Common DBUtils
Impostare il APACHE_HOMEvariabile di ambiente in modo che punti alla posizione della directory di base in cui è archiviato il jar di Apache sulla macchina. Supponendo, abbiamo estratto commons-dbutils-1.7-bin.zip nella cartella Apache su vari sistemi operativi come segue.
| OS | Produzione |
|---|---|
| finestre | Imposta la variabile d'ambiente APACHE_HOME su C: \ Apache |
| Linux | esportare APACHE_HOME = / usr / local / Apache |
| Mac | export APACHE_HOME = / Library / Apache |
Imposta la variabile CLASSPATH
Impostare il CLASSPATHvariabile di ambiente in modo che punti alla posizione del jar IO comune. Supponendo che abbiate memorizzato commons-dbutils-1.7-bin.zip nella cartella Apache su vari sistemi operativi come segue.
| OS | Produzione |
|---|---|
| finestre | Impostare la variabile d'ambiente CLASSPATH su% CLASSPATH%;% APACHE_HOME% \ commons-dbutils-1.7.jar; mysql-connector-java-5.1.28.jar; commons-dbcp2-2.1.1.jar; commons-pool2-2.4. 3.jar; commons-logging-1.2.jar; |
| Linux | export CLASSPATH = $ CLASSPATH: $ APACHE_HOME / commons-dbutils-1.7.jar: mysql-connector-java-5.1.28.jar: commons-dbcp2-2.1.1: commons-pool2-2.4.3.jar: commons-logging -1.2.jar. |
| Mac | export CLASSPATH = $ CLASSPATH: $ APACHE_HOME / commons-dbutils-1.7.jar: mysql-connector-java-5.1.28: commons-dbcp2-2.1.1.jar: commons-pool2-2.4.3.jar; commons-logging -1.2.jar. |
Ora sei pronto per iniziare a sperimentare con DBUtils. Il prossimo capitolo fornisce un esempio di esempio sulla programmazione DBUtils.
Questo capitolo fornisce un esempio di come creare una semplice applicazione JDBC utilizzando la libreria DBUtils. Questo ti mostrerà come aprire una connessione al database, eseguire una query SQL e visualizzare i risultati.
Tutti i passaggi menzionati in questo esempio di modello verranno spiegati nei capitoli successivi di questo tutorial.
Creazione dell'applicazione JDBC
Ci sono i seguenti sei passaggi coinvolti nella creazione di un'applicazione JDBC:
Import the packages- Richiede di includere i pacchetti contenenti le classi JDBC necessarie per la programmazione del database. Molto spesso, usandoimport java.sql.* sarà sufficiente.
Register the JDBC driver - Richiede l'inizializzazione di un driver, in modo da poter aprire un canale di comunicazione con il database.
Open a connection - Richiede l'utilizzo di DriverManager.getConnection() metodo per creare un oggetto Connection, che rappresenta una connessione fisica con il database.
Execute a query - Richiede l'utilizzo di un oggetto di tipo Statement per la creazione e l'invio di un'istruzione SQL al database.
Extract data from result set - Richiede di utilizzare l'appropriato ResultSet.getXXX() metodo per recuperare i dati dal set di risultati.
Clean up the environment - Richiede la chiusura esplicita di tutte le risorse del database anziché fare affidamento sulla raccolta dati inutili di JVM.
Codice d'esempio
Questo esempio di esempio può fungere da modello, quando sarà necessario creare la propria applicazione JDBC in futuro.
Questo codice di esempio è stato scritto in base all'ambiente e alla configurazione del database eseguita nel capitolo precedente.
Copia e incolla il seguente esempio in MainApp.java, compila ed esegui come segue:
MainApp.java
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import org.apache.commons.dbutils.DbUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.ResultSetHandler;
import org.apache.commons.dbutils.handlers.BeanHandler;
public class MainApp {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
static final String DB_URL = "jdbc:mysql://localhost:3306/emp";
// Database credentials
static final String USER = "root";
static final String PASS = "admin";
public static void main(String[] args) throws SQLException {
Connection conn = null;
QueryRunner queryRunner = new QueryRunner();
//Step 1: Register JDBC driver
DbUtils.loadDriver(JDBC_DRIVER);
//Step 2: Open a connection
System.out.println("Connecting to database...");
conn = DriverManager.getConnection(DB_URL, USER, PASS);
//Step 3: Create a ResultSet Handler to handle Employee Beans
ResultSetHandler<Employee> resultHandler = new BeanHandler<Employee>(Employee.class);
try {
Employee emp = queryRunner.query(conn,
"SELECT * FROM employees WHERE first=?", resultHandler, "Sumit");
//Display values
System.out.print("ID: " + emp.getId());
System.out.print(", Age: " + emp.getAge());
System.out.print(", First: " + emp.getFirst());
System.out.println(", Last: " + emp.getLast());
} finally {
DbUtils.close(conn);
}
}
}Employee.java
Il programma è dato di seguito -
public class Employee {
private int id;
private int age;
private String first;
private String last;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getFirst() {
return first;
}
public void setFirst(String first) {
this.first = first;
}
public String getLast() {
return last;
}
public void setLast(String last) {
this.last = last;
}
}Ora compiliamo l'esempio sopra come segue:
C:\>javac MainApp.java Employee.java
C:\>Quando corri MainApp, produce il seguente risultato:
C:\>java MainApp
Connecting to database...
ID: 103, Age: 28, First: Sumit, Last: Mittal
C:\>Il seguente esempio dimostrerà come creare un record utilizzando la query di inserimento con l'aiuto di DBUtils. Inseriremo un record nella tabella dei dipendenti.
Sintassi
La sintassi per creare una query è fornita di seguito:
String insertQuery ="INSERT INTO employees(id,age,first,last) VALUES (?,?,?,?)";
int insertedRecords = queryRunner.update(conn, insertQuery,104,30, "Sohan","Kumar");Dove,
insertQuery - Inserisci query con segnaposto.
queryRunner - Oggetto QueryRunner per inserire l'oggetto dipendente nel database.
Per comprendere i concetti sopra menzionati relativi a DBUtils, scriviamo un esempio che eseguirà una query di inserimento. Per scrivere il nostro esempio, creiamo un'applicazione di esempio.
| Passo | Descrizione |
|---|---|
| 1 | Aggiorna il file MainApp.java creato nel capitolo DBUtils - Prima applicazione . |
| 2 | Compilare ed eseguire l'applicazione come spiegato di seguito. |
Di seguito è riportato il contenuto del file Employee.java.
public class Employee {
private int id;
private int age;
private String first;
private String last;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getFirst() {
return first;
}
public void setFirst(String first) {
this.first = first;
}
public String getLast() {
return last;
}
public void setLast(String last) {
this.last = last;
}
}Di seguito è riportato il contenuto del file MainApp.java file.
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import org.apache.commons.dbutils.DbUtils;
import org.apache.commons.dbutils.QueryRunner;
public class MainApp {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
static final String DB_URL = "jdbc:mysql://localhost:3306/emp";
// Database credentials
static final String USER = "root";
static final String PASS = "admin";
public static void main(String[] args) throws SQLException {
Connection conn = null;
QueryRunner queryRunner = new QueryRunner();
DbUtils.loadDriver(JDBC_DRIVER);
conn = DriverManager.getConnection(DB_URL, USER, PASS);
try {
int insertedRecords = queryRunner.update(conn,
"INSERT INTO employees(id,age,first,last) VALUES (?,?,?,?)",
104,30, "Sohan","Kumar");
System.out.println(insertedRecords + " record(s) inserted");
} finally {
DbUtils.close(conn);
}
}
}Una volta che hai finito di creare i file sorgente, eseguiamo l'applicazione. Se tutto va bene con la tua applicazione, stamperà il seguente messaggio:
1 record(s) inserted.Il seguente esempio dimostrerà come leggere un record utilizzando la query di lettura con l'aiuto di DBUtils. Leggeremo un record dalla tabella dei dipendenti.
Sintassi
La sintassi per la query di lettura è menzionata di seguito:
ResultSetHandler<Employee> resultHandler = new BeanHandler<Employee>(Employee.class);
Employee emp = queryRunner.query(conn, "SELECT * FROM employees WHERE first=?", resultHandler, "Sumit");Dove,
resultHandler - Oggetto ResultSetHandler per mappare il set di risultati all'oggetto Employee.
queryRunner - Oggetto QueryRunner per leggere un oggetto dipendente dal database.
Per comprendere i concetti sopra menzionati relativi a DBUtils, scriviamo un esempio che eseguirà una query di lettura. Per scrivere il nostro esempio, creiamo un'applicazione di esempio.
| Passo | Descrizione |
|---|---|
| 1 | Aggiorna il file MainApp.java creato nel capitolo DBUtils - Prima applicazione . |
| 2 | Compilare ed eseguire l'applicazione come spiegato di seguito. |
Di seguito è riportato il contenuto del file Employee.java.
public class Employee {
private int id;
private int age;
private String first;
private String last;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getFirst() {
return first;
}
public void setFirst(String first) {
this.first = first;
}
public String getLast() {
return last;
}
public void setLast(String last) {
this.last = last;
}
}Di seguito è riportato il contenuto del file MainApp.java file.
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import org.apache.commons.dbutils.DbUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.ResultSetHandler;
import org.apache.commons.dbutils.handlers.BeanHandler;
public class MainApp {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
static final String DB_URL = "jdbc:mysql://localhost:3306/emp";
// Database credentials
static final String USER = "root";
static final String PASS = "admin";
public static void main(String[] args) throws SQLException {
Connection conn = null;
QueryRunner queryRunner = new QueryRunner();
//Step 1: Register JDBC driver
DbUtils.loadDriver(JDBC_DRIVER);
//Step 2: Open a connection
System.out.println("Connecting to database...");
conn = DriverManager.getConnection(DB_URL, USER, PASS);
//Step 3: Create a ResultSet Handler to handle Employee Beans
ResultSetHandler<Employee> resultHandler =
new BeanHandler<Employee>(Employee.class);
try {
Employee emp = queryRunner.query(conn,
"SELECT * FROM employees WHERE id=?", resultHandler, 104);
//Display values
System.out.print("ID: " + emp.getId());
System.out.print(", Age: " + emp.getAge());
System.out.print(", First: " + emp.getFirst());
System.out.println(", Last: " + emp.getLast());
} finally {
DbUtils.close(conn);
}
}
}Una volta che hai finito di creare i file sorgente, eseguiamo l'applicazione. Se tutto va bene con la tua applicazione, verrà stampato il seguente messaggio:
ID: 104, Age: 30, First: Sohan, Last: KumarIl seguente esempio dimostrerà come aggiornare un record utilizzando la query di aggiornamento con l'aiuto di DBUtils. Aggiorneremo un record nella tabella dei dipendenti.
Sintassi
La sintassi per la query di aggiornamento è la seguente:
String updateQuery = "UPDATE employees SET age=? WHERE id=?";
int updatedRecords = queryRunner.update(conn, updateQuery, 33,104);Dove,
updateQuery - Aggiorna query con segnaposto.
queryRunner - Oggetto QueryRunner per aggiornare l'oggetto dipendente nel database.
Per comprendere i concetti sopra menzionati relativi a DBUtils, scriviamo un esempio che eseguirà una query di aggiornamento. Per scrivere il nostro esempio, creiamo un'applicazione di esempio.
| Passo | Descrizione |
|---|---|
| 1 | Aggiorna il file MainApp.java creato nel capitolo DBUtils - Prima applicazione . |
| 2 | Compilare ed eseguire l'applicazione come spiegato di seguito. |
Di seguito è riportato il contenuto del file Employee.java.
public class Employee {
private int id;
private int age;
private String first;
private String last;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getFirst() {
return first;
}
public void setFirst(String first) {
this.first = first;
}
public String getLast() {
return last;
}
public void setLast(String last) {
this.last = last;
}
}Di seguito è riportato il contenuto del file MainApp.java file.
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import org.apache.commons.dbutils.DbUtils;
import org.apache.commons.dbutils.QueryRunner;
public class MainApp {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
static final String DB_URL = "jdbc:mysql://localhost:3306/emp";
// Database credentials
static final String USER = "root";
static final String PASS = "admin";
public static void main(String[] args) throws SQLException {
Connection conn = null;
QueryRunner queryRunner = new QueryRunner();
DbUtils.loadDriver(JDBC_DRIVER);
conn = DriverManager.getConnection(DB_URL, USER, PASS);
try {
int updatedRecords = queryRunner.update(conn,
"UPDATE employees SET age=? WHERE id=?", 33,104);
System.out.println(updatedRecords + " record(s) updated.");
} finally {
DbUtils.close(conn);
}
}
}Una volta che hai finito di creare i file sorgente, eseguiamo l'applicazione. Se tutto va bene con la tua applicazione, stamperà il seguente messaggio:
1 record(s) updated.Il seguente esempio dimostrerà come eliminare un record utilizzando Elimina query con l'aiuto di DBUtils. Elimineremo un record nella tabella dei dipendenti.
Sintassi
La sintassi per la query di eliminazione è menzionata di seguito:
String deleteQuery = "DELETE FROM employees WHERE id=?";
int deletedRecords = queryRunner.delete(conn, deleteQuery, 33,104);Dove,
deleteQuery - DELETE query con segnaposto.
queryRunner - Oggetto QueryRunner per eliminare l'oggetto dipendente nel database.
Per comprendere i concetti sopra menzionati relativi a DBUtils, scriviamo un esempio che eseguirà una query di eliminazione. Per scrivere il nostro esempio, creiamo un'applicazione di esempio.
| Passo | Descrizione |
|---|---|
| 1 | Aggiorna il file MainApp.java creato nel capitolo DBUtils - Prima applicazione . |
| 2 | Compilare ed eseguire l'applicazione come spiegato di seguito. |
Di seguito è riportato il contenuto del file Employee.java.
public class Employee {
private int id;
private int age;
private String first;
private String last;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getFirst() {
return first;
}
public void setFirst(String first) {
this.first = first;
}
public String getLast() {
return last;
}
public void setLast(String last) {
this.last = last;
}
}Di seguito è riportato il contenuto del file MainApp.java file.
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import org.apache.commons.dbutils.DbUtils;
import org.apache.commons.dbutils.QueryRunner;
public class MainApp {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
static final String DB_URL = "jdbc:mysql://localhost:3306/emp";
// Database credentials
static final String USER = "root";
static final String PASS = "admin";
public static void main(String[] args) throws SQLException {
Connection conn = null;
QueryRunner queryRunner = new QueryRunner();
DbUtils.loadDriver(JDBC_DRIVER);
conn = DriverManager.getConnection(DB_URL, USER, PASS);
try {
int deletedRecords = queryRunner.update(conn,
"DELETE from employees WHERE id=?", 104);
System.out.println(deletedRecords + " record(s) deleted.");
} finally {
DbUtils.close(conn);
}
}
}Una volta che hai finito di creare i file sorgente, eseguiamo l'applicazione. Se tutto va bene con la tua applicazione, stamperà il seguente messaggio:
1 record(s) deleted.Il org.apache.commons.dbutils.QueryRunnerclass è la classe centrale nella libreria DBUtils. Esegue query SQL con strategie collegabili per la gestione dei ResultSet. Questa classe è thread-safe.
Dichiarazione di classe
Di seguito è riportata la dichiarazione per la classe org.apache.commons.dbutils.QueryRunner -
public class QueryRunner
extends AbstractQueryRunnerUtilizzo
Step 1 - Crea un oggetto di connessione.
Step 2 - Utilizzare i metodi dell'oggetto QueryRunner per eseguire operazioni sul database.
Esempio
L'esempio seguente dimostrerà come leggere un record utilizzando la classe QueryRunner. Leggeremo uno dei record disponibili nella tabella dei dipendenti.
Sintassi
ResultSetHandler<Employee> resultHandler = new BeanHandler<Employee>(Employee.class);
Employee emp =
queryRunner.query(conn, "SELECT * FROM employees WHERE first=?", resultHandler, "Sumit");Dove,
resultHandler - Oggetto ResultSetHandler per mappare il set di risultati all'oggetto Employee.
queryRunner - Oggetto QueryRunner per leggere l'oggetto dipendente dal database.
Per comprendere i concetti sopra menzionati relativi a DBUtils, scriviamo un esempio che eseguirà una query di lettura. Per scrivere il nostro esempio, creiamo un'applicazione di esempio.
| Passo | Descrizione |
|---|---|
| 1 | Aggiorna il file MainApp.java creato nel capitolo DBUtils - Prima applicazione . |
| 2 | Compilare ed eseguire l'applicazione come spiegato di seguito. |
Di seguito è riportato il contenuto del file Employee.java.
public class Employee {
private int id;
private int age;
private String first;
private String last;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getFirst() {
return first;
}
public void setFirst(String first) {
this.first = first;
}
public String getLast() {
return last;
}
public void setLast(String last) {
this.last = last;
}
}Di seguito è riportato il contenuto del file MainApp.java file.
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import org.apache.commons.dbutils.DbUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.ResultSetHandler;
import org.apache.commons.dbutils.handlers.BeanHandler;
public class MainApp {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
static final String DB_URL = "jdbc:mysql://localhost:3306/emp";
// Database credentials
static final String USER = "root";
static final String PASS = "admin";
public static void main(String[] args) throws SQLException {
Connection conn = null;
QueryRunner queryRunner = new QueryRunner();
//Step 1: Register JDBC driver
DbUtils.loadDriver(JDBC_DRIVER);
//Step 2: Open a connection
System.out.println("Connecting to database...");
conn = DriverManager.getConnection(DB_URL, USER, PASS);
//Step 3: Create a ResultSet Handler to handle Employee Beans
ResultSetHandler<Employee> resultHandler = new BeanHandler<Employee>(Employee.class);
try {
Employee emp = queryRunner.query(conn,
"SELECT * FROM employees WHERE id=?", resultHandler, 103);
//Display values
System.out.print("ID: " + emp.getId());
System.out.print(", Age: " + emp.getAge());
System.out.print(", First: " + emp.getFirst());
System.out.println(", Last: " + emp.getLast());
} finally {
DbUtils.close(conn);
}
}
}Una volta che hai finito di creare i file sorgente, eseguiamo l'applicazione. Se tutto va bene con la tua applicazione, verrà stampato il seguente messaggio.
ID: 103, Age: 28, First: Sumit, Last: MittalIl org.apache.commons.dbutils.AsyncQueryRunnerclass aiuta a eseguire query SQL di lunga durata con supporto asincrono. Questa classe è thread-safe. Questa classe supporta gli stessi metodi di QueryRunner ma restituisce oggetti Callable che possono essere utilizzati in seguito per recuperare il risultato.
Dichiarazione di classe
Di seguito è riportata la dichiarazione per la classe org.apache.commons.dbutils.AsyncQueryRunner -
public class AsyncQueryRunner
extends AbstractQueryRunnerUtilizzo
Step 1 - Crea un oggetto di connessione.
Step 2 - Utilizzare i metodi dell'oggetto AsyncQueryRunner per eseguire operazioni sul database.
Esempio
L'esempio seguente mostrerà come aggiornare un record usando la classe AsyncQueryRunner. Aggiorneremo uno dei record disponibili nella tabella dei dipendenti.
Sintassi
String updateQuery = "UPDATE employees SET age=? WHERE id=?";
future = asyncQueryRunner.update(conn,
"UPDATE employees SET age=? WHERE id=?", 33,103);Dove,
updateQuery - Aggiorna query con segnaposto.
asyncQueryRunner - Oggetto asyncQueryRunner per aggiornare l'oggetto dipendente nel database.
future - Oggetto futuro per recuperare il risultato in un secondo momento.
Per comprendere i concetti sopra menzionati relativi a DBUtils, scriviamo un esempio che eseguirà una query di aggiornamento in modalità asincrona. Per scrivere il nostro esempio, creiamo un'applicazione di esempio.
| Passo | Descrizione |
|---|---|
| 1 | Aggiorna il file MainApp.java creato nel capitolo DBUtils - Prima applicazione . |
| 2 | Compilare ed eseguire l'applicazione come spiegato di seguito. |
Di seguito è riportato il contenuto del file Employee.java.
public class Employee {
private int id;
private int age;
private String first;
private String last;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getFirst() {
return first;
}
public void setFirst(String first) {
this.first = first;
}
public String getLast() {
return last;
}
public void setLast(String last) {
this.last = last;
}
}Di seguito è riportato il contenuto del file MainApp.java file.
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import org.apache.commons.dbutils.AsyncQueryRunner;
import org.apache.commons.dbutils.DbUtils;
import org.apache.commons.dbutils.QueryRunner;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
public class MainApp {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
static final String DB_URL = "jdbc:mysql://localhost:3306/emp";
// Database credentials
static final String USER = "root";
static final String PASS = "admin";
public static void main(String[] args) throws
SQLException, InterruptedException,
ExecutionException, TimeoutException {
Connection conn = null;
AsyncQueryRunner asyncQueryRunner = new AsyncQueryRunner( Executors.newCachedThreadPool());
DbUtils.loadDriver(JDBC_DRIVER);
conn = DriverManager.getConnection(DB_URL, USER, PASS);
Future<Integer> future = null;
try {
future = asyncQueryRunner.update(conn,
"UPDATE employees SET age=? WHERE id=?", 33,103);
Integer updatedRecords = future.get(10, TimeUnit.SECONDS);
System.out.println(updatedRecords + " record(s) updated.");
} finally {
DbUtils.close(conn);
}
}
}Una volta che hai finito di creare i file sorgente, eseguiamo l'applicazione. Se tutto va bene con la tua applicazione, verrà stampato il seguente messaggio.
1 record(s) updated.Il org.apache.commons.dbutils.ResultSetHandler l'interfaccia è responsabile della conversione dei ResultSet in oggetti.
Dichiarazione di classe
Di seguito è riportata la dichiarazione per la classe org.apache.commons.dbutils.ResultSetHandler -
public interface ResultSetHandler<T>Utilizzo
Step 1 - Crea un oggetto di connessione.
Step 2 - Crea l'implementazione di ResultSetHandler.
Step 3 - Passa resultSetHandler all'oggetto QueryRunner ed effettua operazioni sul database.
Esempio
L'esempio seguente dimostrerà come mappare un record utilizzando la classe ResultSetHandler. Leggeremo uno dei record disponibili nella tabella Employee.
Sintassi
Employee emp = queryRunner.query(conn, "SELECT * FROM employees WHERE first=?", resultHandler, "Sumit");Dove,
resultHandler - Oggetto ResultSetHandler per mappare il set di risultati all'oggetto Employee.
queryRunner - Oggetto QueryRunner per leggere l'oggetto dipendente dal database.
Per comprendere i concetti sopra menzionati relativi a DBUtils, scriviamo un esempio che eseguirà una query di lettura. Per scrivere il nostro esempio, creiamo un'applicazione di esempio.
| Passo | Descrizione |
|---|---|
| 1 | Aggiorna il file MainApp.java creato nel capitolo DBUtils - Prima applicazione . |
| 2 | Compilare ed eseguire l'applicazione come spiegato di seguito. |
Di seguito è riportato il contenuto del file Employee.java.
public class Employee {
private int id;
private int age;
private String first;
private String last;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getFirst() {
return first;
}
public void setFirst(String first) {
this.first = first;
}
public String getLast() {
return last;
}
public void setLast(String last) {
this.last = last;
}
}Di seguito è riportato il contenuto del file MainApp.java file.
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.util.Arrays;
import org.apache.commons.dbutils.DbUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.ResultSetHandler;
public class MainApp {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
static final String DB_URL = "jdbc:mysql://localhost:3306/emp";
// Database credentials
static final String USER = "root";
static final String PASS = "admin";
public static void main(String[] args) throws SQLException {
Connection conn = null;
QueryRunner queryRunner = new QueryRunner();
//Step 1: Register JDBC driver
DbUtils.loadDriver(JDBC_DRIVER);
//Step 2: Open a connection
System.out.println("Connecting to database...");
conn = DriverManager.getConnection(DB_URL, USER, PASS);
//Step 3: Create a ResultSet Handler to handle Employee Beans
ResultSetHandler<Object[]> handler = new ResultSetHandler<Object[]>() {
public Object[] handle(ResultSet rs) throws SQLException {
if (!rs.next()) {
return null;
}
ResultSetMetaData meta = rs.getMetaData();
int cols = meta.getColumnCount();
Object[] result = new Object[cols];
for (int i = 0; i < cols; i++) {
result[i] = rs.getObject(i + 1);
}
return result;
}
};
try {
Object[] result = queryRunner.query(conn, "SELECT * FROM employees WHERE id=?",
handler, 103);
//Display values
System.out.print("Result: " + Arrays.toString(result));
} finally {
DbUtils.close(conn);
}
}
}Una volta che hai finito di creare i file sorgente, eseguiamo l'applicazione. Se tutto va bene con la tua applicazione, verrà stampato il seguente messaggio.
Connecting to database...
Result: [103, 33, Sumit, Mittal]Il org.apache.commons.dbutils.BeanHandlerè l'implementazione dell'interfaccia ResultSetHandler ed è responsabile della conversione della prima riga del ResultSet in un JavaBean. Questa classe è thread-safe.
Dichiarazione di classe
Di seguito è riportata la dichiarazione per la classe org.apache.commons.dbutils.BeanHandler -
public class BeanHandler<T>
extends Object implements ResultSetHandler<T>Utilizzo
Step 1 - Crea un oggetto di connessione.
Step 2 - Ottieni l'implementazione di ResultSetHandler come oggetto BeanHandler.
Step 3 - Passa resultSetHandler all'oggetto QueryRunner ed effettua operazioni sul database.
Esempio
L'esempio seguente dimostrerà come leggere un record utilizzando la classe BeanHandler. Leggeremo uno dei record disponibili nella tabella Employees e lo mapperemo al bean Employee.
Sintassi
Employee emp = queryRunner.query(conn, "SELECT * FROM employees WHERE first=?", resultHandler, "Sumit");Dove,
resultHandler - Oggetto BeanHandler per mappare il set di risultati all'oggetto Employee.
queryRunner - Oggetto QueryRunner per leggere l'oggetto dipendente dal database.
Per comprendere i concetti sopra menzionati relativi a DBUtils, scriviamo un esempio che eseguirà una query di lettura. Per scrivere il nostro esempio, creiamo un'applicazione di esempio.
| Passo | Descrizione |
|---|---|
| 1 | Aggiorna il file MainApp.java creato nel capitolo DBUtils - Prima applicazione . |
| 2 | Compilare ed eseguire l'applicazione come spiegato di seguito. |
Di seguito è riportato il contenuto del file Employee.java.
public class Employee {
private int id;
private int age;
private String first;
private String last;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getFirst() {
return first;
}
public void setFirst(String first) {
this.first = first;
}
public String getLast() {
return last;
}
public void setLast(String last) {
this.last = last;
}
}Di seguito è riportato il contenuto del file MainApp.java file.
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import org.apache.commons.dbutils.DbUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.ResultSetHandler;
import org.apache.commons.dbutils.handlers.BeanHandler;
public class MainApp {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
static final String DB_URL = "jdbc:mysql://localhost:3306/emp";
// Database credentials
static final String USER = "root";
static final String PASS = "admin";
public static void main(String[] args) throws SQLException {
Connection conn = null;
QueryRunner queryRunner = new QueryRunner();
//Step 1: Register JDBC driver
DbUtils.loadDriver(JDBC_DRIVER);
//Step 2: Open a connection
System.out.println("Connecting to database...");
conn = DriverManager.getConnection(DB_URL, USER, PASS);
//Step 3: Create a ResultSet Handler to handle Employee Beans
ResultSetHandler<Employee> resultHandler
= new BeanHandler<Employee>(Employee.class);
try {
Employee emp = queryRunner.query(conn,
"SELECT * FROM employees WHERE first=?", resultHandler, "Sumit");
//Display values
System.out.print("ID: " + emp.getId());
System.out.print(", Age: " + emp.getAge());
System.out.print(", First: " + emp.getFirst());
System.out.println(", Last: " + emp.getLast());
} finally {
DbUtils.close(conn);
}
}
}Una volta che hai finito di creare i file sorgente, eseguiamo l'applicazione. Se tutto va bene con la tua applicazione, verrà stampato il seguente messaggio.
ID: 103, Age: 28, First: Sumit, Last: MittalIl org.apache.commons.dbutils.BeanListHandlerè l'implementazione dell'interfaccia ResultSetHandler ed è responsabile della conversione delle righe del ResultSet in un elenco di Java Bean. Questa classe è thread-safe.
Dichiarazione di classe
Di seguito è riportata la dichiarazione per la classe org.apache.commons.dbutils.BeanListHandler -
public class BeanListHandler<T>
extends Object implements ResultSetHandler<List<T>>Utilizzo
Step 1 - Crea un oggetto di connessione.
Step 2 - Ottieni l'implementazione di ResultSetHandler come oggetto BeanListHandler.
Step 3 - Passa resultSetHandler all'oggetto QueryRunner ed effettua operazioni sul database.
Esempio
L'esempio seguente dimostrerà come leggere un elenco di record utilizzando la classe BeanListHandler. Leggeremo i record disponibili nella tabella Employees e li mapperemo all'elenco dei bean Employee.
Sintassi
List<Employee> empList = queryRunner.query(conn, "SELECT * FROM employees", resultHandler);Dove,
resultHandler - Oggetto BeanListHandler per mappare i set di risultati a un elenco di oggetti Employee.
queryRunner - Oggetto QueryRunner per leggere l'oggetto dipendente dal database.
Per comprendere i concetti sopra menzionati relativi a DBUtils, scriviamo un esempio che eseguirà una query di lettura. Per scrivere il nostro esempio, creiamo un'applicazione di esempio.
| Passo | Descrizione |
|---|---|
| 1 | Aggiorna il file MainApp.java creato nel capitolo DBUtils - Prima applicazione . |
| 2 | Compilare ed eseguire l'applicazione come spiegato di seguito. |
Di seguito è riportato il contenuto del file Employee.java.
public class Employee {
private int id;
private int age;
private String first;
private String last;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getFirst() {
return first;
}
public void setFirst(String first) {
this.first = first;
}
public String getLast() {
return last;
}
public void setLast(String last) {
this.last = last;
}
}Di seguito è riportato il contenuto del file MainApp.java file.
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.List;
import org.apache.commons.dbutils.DbUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.ResultSetHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
public class MainApp {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
static final String DB_URL = "jdbc:mysql://localhost:3306/emp";
// Database credentials
static final String USER = "root";
static final String PASS = "admin";
public static void main(String[] args) throws SQLException {
Connection conn = null;
QueryRunner queryRunner = new QueryRunner();
//Step 1: Register JDBC driver
DbUtils.loadDriver(JDBC_DRIVER);
//Step 2: Open a connection
System.out.println("Connecting to database...");
conn = DriverManager.getConnection(DB_URL, USER, PASS);
//Step 3: Create a ResultSet Handler to handle List of Employee Beans
ResultSetHandler<List<Employee>> resultHandler = new BeanListHandler<Employee>(Employee.class);
try {
List<Employee> empList = queryRunner.query(conn, "SELECT * FROM employees", resultHandler);
for(Employee emp: empList ) {
//Display values
System.out.print("ID: " + emp.getId());
System.out.print(", Age: " + emp.getAge());
System.out.print(", First: " + emp.getFirst());
System.out.println(", Last: " + emp.getLast());
}
} finally {
DbUtils.close(conn);
}
}
}Una volta che hai finito di creare i file sorgente, eseguiamo l'applicazione. Se tutto va bene con la tua applicazione, verrà stampato il seguente messaggio.
ID: 100, Age: 18, First: Zara, Last: Ali
ID: 101, Age: 25, First: Mahnaz, Last: Fatma
ID: 102, Age: 30, First: Zaid, Last: Khan
ID: 103, Age: 28, First: Sumit, Last: MittalIl org.apache.commons.dbutils.ArrayListHandlerè l'implementazione dell'interfaccia ResultSetHandler ed è responsabile della conversione delle righe del ResultSet in un oggetto []. Questa classe è thread-safe.
Dichiarazione di classe
Di seguito è riportata la dichiarazione per la classe org.apache.commons.dbutils.ArrayListHandler -
public class ArrayListHandler
extends AbstractListHandler<Object[]>Utilizzo
Step 1 - Crea un oggetto di connessione.
Step 2 - Ottieni l'implementazione di ResultSetHandler come oggetto ArrayListHandler.
Step 3 - Passa resultSetHandler all'oggetto QueryRunner ed effettua operazioni sul database.
Esempio
L'esempio seguente dimostrerà come leggere un elenco di record utilizzando la classe ArrayListHandler. Leggeremo i record disponibili nella tabella Employees come oggetto [].
Sintassi
List<Object> result = queryRunner.query(conn, "SELECT * FROM employees", new ArrayListHandler());Dove,
resultHandler - Oggetto ArrayListHandler per mappare i set di risultati all'elenco di oggetti [].
queryRunner - Oggetto QueryRunner per leggere l'oggetto dipendente dal database.
Per comprendere i concetti sopra menzionati relativi a DBUtils, scriviamo un esempio che eseguirà una query di lettura. Per scrivere il nostro esempio, creiamo un'applicazione di esempio.
| Passo | Descrizione |
|---|---|
| 1 | Aggiorna il file MainApp.java creato nel capitolo DBUtils - Prima applicazione . |
| 2 | Compilare ed eseguire l'applicazione come spiegato di seguito. |
Di seguito è riportato il contenuto del file Employee.java.
public class Employee {
private int id;
private int age;
private String first;
private String last;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getFirst() {
return first;
}
public void setFirst(String first) {
this.first = first;
}
public String getLast() {
return last;
}
public void setLast(String last) {
this.last = last;
}
}Di seguito è riportato il contenuto del file MainApp.java file.
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Arrays;
import java.util.List;
import org.apache.commons.dbutils.DbUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.ArrayListHandler;
public class MainApp {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
static final String DB_URL = "jdbc:mysql://localhost:3306/emp";
// Database credentials
static final String USER = "root";
static final String PASS = "admin";
public static void main(String[] args) throws SQLException {
Connection conn = null;
QueryRunner queryRunner = new QueryRunner();
//Step 1: Register JDBC driver
DbUtils.loadDriver(JDBC_DRIVER);
//Step 2: Open a connection
System.out.println("Connecting to database...");
conn = DriverManager.getConnection(DB_URL, USER, PASS);
try {
List<Object[]> result = queryRunner.query(conn, "SELECT * FROM employees"
, new ArrayListHandler());
for(Object[] objects : result) {
System.out.println(Arrays.toString(objects));
}
} finally {
DbUtils.close(conn);
}
}
}Una volta che hai finito di creare i file sorgente, eseguiamo l'applicazione. Se tutto va bene con la tua applicazione, verrà stampato il seguente messaggio.
[100, 18, Zara, Ali]
[101, 25, Mahnaz, Fatma]
[102, 30, Zaid, Khan]
[103, 28, Sumit, Mittal]Il org.apache.commons.dbutils.MapListHandlerè l'implementazione dell'interfaccia ResultSetHandler ed è responsabile della conversione delle righe del ResultSet in un elenco di mappe. Questa classe è thread-safe.
Dichiarazione di classe
Di seguito è riportata la dichiarazione per la classe org.apache.commons.dbutils.MapListHandler -
public class MapListHandler
extends AbstractListHandler<Map<String,Object>>Utilizzo
Step 1 - Crea un oggetto di connessione.
Step 2 - Ottieni l'implementazione di ResultSetHandler come oggetto MapListHandler.
Step 3 - Passa resultSetHandler all'oggetto QueryRunner ed effettua operazioni sul database.
Esempio
L'esempio seguente dimostrerà come leggere un elenco di record utilizzando la classe MapListHandler. Leggeremo i record disponibili nella tabella Employees come elenco di mappe.
Sintassi
List<Map<String, Object>> result = queryRunner.query(conn, "SELECT * FROM employees", new MapListHandler());Dove,
resultHandler - Oggetto MapListHandler per mappare i set di risultati a un elenco di mappe.
queryRunner - Oggetto QueryRunner per leggere l'oggetto dipendente dal database.
Per comprendere i concetti sopra menzionati relativi a DBUtils, scriviamo un esempio che eseguirà una query di lettura. Per scrivere il nostro esempio, creiamo un'applicazione di esempio.
| Passo | Descrizione |
|---|---|
| 1 | Aggiorna il file MainApp.java creato nel capitolo DBUtils - Prima applicazione . |
| 2 | Compilare ed eseguire l'applicazione come spiegato di seguito. |
Di seguito è riportato il contenuto del file Employee.java.
public class Employee {
private int id;
private int age;
private String first;
private String last;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getFirst() {
return first;
}
public void setFirst(String first) {
this.first = first;
}
public String getLast() {
return last;
}
public void setLast(String last) {
this.last = last;
}
}Di seguito è riportato il contenuto del file MainApp.java file.
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;
import org.apache.commons.dbutils.DbUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.MapListHandler;
public class MainApp {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
static final String DB_URL = "jdbc:mysql://localhost:3306/emp";
// Database credentials
static final String USER = "root";
static final String PASS = "admin";
public static void main(String[] args) throws SQLException {
Connection conn = null;
QueryRunner queryRunner = new QueryRunner();
//Step 1: Register JDBC driver
DbUtils.loadDriver(JDBC_DRIVER);
//Step 2: Open a connection
System.out.println("Connecting to database...");
conn = DriverManager.getConnection(DB_URL, USER, PASS);
try {
List<Map<String, Object>> result = queryRunner.query(
conn, "SELECT * FROM employees", new MapListHandler());
System.out.println(result);
} finally {
DbUtils.close(conn);
}
}
}Una volta che hai finito di creare i file sorgente, eseguiamo l'applicazione. Se tutto va bene con la tua applicazione, verrà stampato il seguente messaggio.
Connecting to database...
[{id=100, age=18, first=Zara, last=Ali},
{id=101, age=25, first=Mahnaz, last=Fatma},
{id=102, age=30, first=Zaid, last=Khan},
{id=103, age=33, first=Sumit, last=Mittal}]Possiamo creare il nostro gestore personalizzato implementando l'interfaccia ResultSetHandler o estendendo qualsiasi implementazione esistente di ResultSetHandler. Nell'esempio riportato di seguito, abbiamo creato un gestore personalizzato, EmployeeHandler estendendo la classe BeanHandler.
Per comprendere i concetti sopra menzionati relativi a DBUtils, scriviamo un esempio che eseguirà una query di lettura. Per scrivere il nostro esempio, creiamo un'applicazione di esempio.
| Passo | Descrizione |
|---|---|
| 1 | Aggiorna il file MainApp.java creato nel capitolo DBUtils - Prima applicazione . |
| 2 | Compilare ed eseguire l'applicazione come spiegato di seguito. |
Di seguito è riportato il contenuto del file Employee.java.
public class Employee {
private int id;
private int age;
private String first;
private String last;
private String name;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getFirst() {
return first;
}
public void setFirst(String first) {
this.first = first;
}
public String getLast() {
return last;
}
public void setLast(String last) {
this.last = last;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}Di seguito è riportato il contenuto del file EmployeeHandler.java file.
import java.sql.ResultSet;
import java.sql.SQLException;
import org.apache.commons.dbutils.handlers.BeanHandler;
public class EmployeeHandler extends BeanHandler<Employee> {
public EmployeeHandler() {
super(Employee.class);
}
@Override
public Employee handle(ResultSet rs) throws SQLException {
Employee employee = super.handle(rs);
employee.setName(employee.getFirst() +", " + employee.getLast());
return employee;
}
}Di seguito è riportato il contenuto del file MainApp.java file.
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import org.apache.commons.dbutils.DbUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.ResultSetHandler;
import org.apache.commons.dbutils.handlers.BeanHandler;
public class MainApp {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
static final String DB_URL = "jdbc:mysql://localhost:3306/emp";
// Database credentials
static final String USER = "root";
static final String PASS = "admin";
public static void main(String[] args) throws SQLException {
Connection conn = null;
QueryRunner queryRunner = new QueryRunner();
DbUtils.loadDriver(JDBC_DRIVER);
conn = DriverManager.getConnection(DB_URL, USER, PASS);
EmployeeHandler employeeHandler = new EmployeeHandler();
try {
Employee emp = queryRunner.query(conn,
"SELECT * FROM employees WHERE first=?", employeeHandler, "Sumit");
//Display values
System.out.print("ID: " + emp.getId());
System.out.print(", Age: " + emp.getAge());
System.out.print(", Name: " + emp.getName());
} finally {
DbUtils.close(conn);
}
}
}Una volta che hai finito di creare i file sorgente, eseguiamo l'applicazione. Se tutto va bene con la tua applicazione, verrà stampato il seguente messaggio.
ID: 103, Age: 28, Name: Sumit, MittalNel caso in cui i nomi delle colonne in una tabella di database e i nomi degli oggetti javabean equivalenti non siano simili, è possibile mapparli utilizzando l'oggetto BasicRowProcessor personalizzato. Vedi l'esempio sotto.
Per comprendere i concetti sopra menzionati relativi a DBUtils, scriviamo un esempio che eseguirà una query di lettura. Per scrivere il nostro esempio, creiamo un'applicazione di esempio.
| Passo | Descrizione |
|---|---|
| 1 | Aggiorna il file MainApp.java creato nel capitolo DBUtils - Prima applicazione . |
| 2 | Compilare ed eseguire l'applicazione come spiegato di seguito. |
Di seguito è riportato il contenuto del file Employee.java.
public class Employee {
private int id;
private int age;
private String first;
private String last;
private String name;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getFirst() {
return first;
}
public void setFirst(String first) {
this.first = first;
}
public String getLast() {
return last;
}
public void setLast(String last) {
this.last = last;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}Di seguito è riportato il contenuto del file EmployeeHandler.java file.
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.BeanProcessor;
import org.apache.commons.dbutils.BasicRowProcessor;
public class EmployeeHandler extends BeanHandler<Employee> {
public EmployeeHandler() {
super(Employee.class, new BasicRowProcessor(new BeanProcessor(mapColumnsToFields())));
}
@Override
public Employee handle(ResultSet rs) throws SQLException {
Employee employee = super.handle(rs);
employee.setName(employee.getFirst() +", " + employee.getLast());
return employee;
}
public static Map<String, String> mapColumnsToFields() {
Map<String, String> columnsToFieldsMap = new HashMap<>();
columnsToFieldsMap.put("ID", "id");
columnsToFieldsMap.put("AGE", "age");
return columnsToFieldsMap;
}
}Di seguito è riportato il contenuto del file MainApp.java file.
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import org.apache.commons.dbutils.DbUtils;
import org.apache.commons.dbutils.QueryRunner;
public class MainApp {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
static final String DB_URL = "jdbc:mysql://localhost:3306/emp";
// Database credentials
static final String USER = "root";
static final String PASS = "admin";
public static void main(String[] args) throws SQLException {
Connection conn = null;
QueryRunner queryRunner = new QueryRunner();
DbUtils.loadDriver(JDBC_DRIVER);
conn = DriverManager.getConnection(DB_URL, USER, PASS);
EmployeeHandler employeeHandler = new EmployeeHandler();
try {
Employee emp = queryRunner.query(conn,
"SELECT * FROM employees WHERE first=?", employeeHandler, "Sumit");
//Display values
System.out.print("ID: " + emp.getId());
System.out.print(", Age: " + emp.getAge());
System.out.print(", Name: " + emp.getName());
} finally {
DbUtils.close(conn);
}
}
}Una volta che hai finito di creare i file sorgente, eseguiamo l'applicazione. Se tutto va bene con la tua applicazione, verrà stampato il seguente messaggio.
ID: 103, Age: 28, Name: Sumit, MittalFinora, abbiamo utilizzato l'oggetto di connessione durante l'utilizzo di QueryRunner. Possiamo anche usare l'origine dati in modo invisibile. L'esempio seguente dimostrerà come leggere un record utilizzando la query di lettura con l'aiuto di QueryRunner e dell'origine dati. Leggeremo un record dalla tabella dei dipendenti.
Sintassi
QueryRunner queryRunner = new QueryRunner( dataSource );
Employee emp = queryRunner.query("SELECT * FROM employees WHERE first=?", resultHandler, "Sumit");Dove,
dataSource - Oggetto DataSource configurato.
resultHandler - Oggetto ResultSetHandler per mappare il set di risultati all'oggetto Employee.
queryRunner - Oggetto QueryRunner per leggere l'oggetto dipendente dal database.
Per comprendere i concetti sopra menzionati relativi a DBUtils, scriviamo un esempio che eseguirà una query di lettura. Per scrivere il nostro esempio, creiamo un'applicazione di esempio.
| Passo | Descrizione |
|---|---|
| 1 | Aggiorna il file MainApp.java creato nel capitolo DBUtils - Prima applicazione . |
| 2 | Compilare ed eseguire l'applicazione come spiegato di seguito. |
Di seguito è riportato il contenuto del file Employee.java.
public class Employee {
private int id;
private int age;
private String first;
private String last;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getFirst() {
return first;
}
public void setFirst(String first) {
this.first = first;
}
public String getLast() {
return last;
}
public void setLast(String last) {
this.last = last;
}
}Di seguito è riportato il contenuto del file CustomDatasource.java.
import javax.sql.DataSource;
import org.apache.commons.dbcp2.BasicDataSource;
public class CustomDataSource {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
static final String DB_URL = "jdbc:mysql://localhost:3306/emp";
// Database credentials
static final String USER = "root";
static final String PASS = "admin";
private static DataSource datasource;
private static final BasicDataSource basicDataSource;
static {
basicDataSource = new BasicDataSource();
basicDataSource.setDriverClassName(JDBC_DRIVER);
basicDataSource.setUsername(USER);
basicDataSource.setPassword(PASS);
basicDataSource.setUrl(DB_URL);
}
public static DataSource getInstance() {
return basicDataSource;
}
}Di seguito è riportato il contenuto del file MainApp.java file.
import java.sql.SQLException;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.ResultSetHandler;
import org.apache.commons.dbutils.handlers.BeanHandler;
public class MainApp {
public static void main(String[] args) throws SQLException {
DbUtils.loadDriver(JDBC_DRIVER);
QueryRunner run = new QueryRunner(CustomDataSource.getInstance());
ResultSetHandler<Employee> resultHandler = new BeanHandler<Employee>(Employee.class);
Employee emp = queryRunner.query("SELECT * FROM employees WHERE id=?",
resultHandler, 103);
//Display values
System.out.print("ID: " + emp.getId());
System.out.print(", Age: " + emp.getAge());
System.out.print(", First: " + emp.getFirst());
System.out.println(", Last: " + emp.getLast());
}
}Una volta che hai finito di creare i file sorgente, eseguiamo l'applicazione. Se tutto va bene con la tua applicazione, verrà stampato il seguente messaggio.
ID: 103, Age: 33, First: Sumit, Last: Mittal