JDBC

JDBC - Java Database Connectivity

 Permite accesul la baze de date din aplicațiile Java

Aplicație Java JDBC API Driver Manager API

JDBC API - specificația Java pentru accesul

la baza de date ...
Oracle SQLS
Driver Manager API - Implementarea API a
driverului bazei de date
Clasificare drivere

Tipuri de drivere:
Nivel 1: Jdbc-Odbc – utilizează puntea Jdbc-Odbc prin mecanismul
ODBC de conectare la o bază de date
Nivel 2: nativ Java API – combină cod nativ cu cod Java pentru
convertirea cererilor JDBC în comenzi proprietar BD
Nivel 3: Database Midleware – drivere pure Java care folosesc un
server middleware pentru conversia cererilor JDBC in comenzi
DBMS. Serverul lucrează cu diverse tipuri de baze de date. Nu mai
există cod nativ pe partea de client
Nivel 4: Pure Java Driver – conectare directă la BD prin cod Java
utilizând un protocol specific bazei de date
 Aplicatie Java Aplicatie Java Aplicatie Java Aplicatie Java

JDBC Api JDBC Api JDBC Api JDBC Api

JDBC DriverManager JDBC DriverManager JDBC DriverManager JDBC DriverManager

Driver Java Driver Java Driver Java Driver Java

Driver ODBC Cod nativ Server Midleware

DBMS

Cod nativ
DBMS

DBMS
Accesarea unei baze de date utilizând JDBC

Elementele unei aplicații utilizând JDBC pentru conectare:

 Crearea conexiunii la baza de date
 Interogarea bazei de date
 Procesarea rezultatelor
 Închiderea conexiunii
 Crearea conexiunilor la baza de date
 Conexiunile se creează utilizând un protocol de conectare:
jdbc:subprotocol:BazaDeDate
Exemple:
"jdbc:odbc:legatura" - protocol de conectare pentru ODBC utilizand o legatura
ODBC configurata Windows
"jdbc:sqlserver://host\\server:1433;database=baza;user=sa;password=parola;"
"jdbc:mysql://host:3306/baza"
"jdbc:oracle:thin:@ip-host:1521:instanta"
'"dbc:derby://host:1527/sample"
unde host este ip-ul mașinii pe care este instalat serverul DB
Referințele la conexiuni sunt obținute prin invocarea metodelor statice
getConnection din DriverManager
public static Connection getConnection(String url) throws SQLException;
public static Connection getConnection(String url, String user,
String password) throws SQLException
Interogarea – Obiecte Statement

 Sunt obiecte utilizate pentru executarea instrucțiunilor SQL

 Interfața la bază este Statement:
public interface Statement; // Executarea instrucțiunilor statice

 Pentru executarea instrucțiunilor precompilate se utilizează

PreparedStatement:
public interface PreparedStatement extends Statement;

 Pentru executarea procedurilor stocate:

public interface CallableStatement extends PreparedStatement;
 Crearea obiectelor Statement
• Crearea obiectelor Statement se face prin următoarele metode ale interfeței
Connection:
Statement createStatement() throws SQLException;
Statement createStatement(int resultSetType, int resultSetConcurrency)
throws SQLException;
Statement createStatement(int resultSetType, int resultSetConcurrency,
int resultSetHoldability) throws SQLException;
• Comenzile Statement creează un rezultat, care pentru o interogare este o
structură tabelară care conține rezultatul interogării
• Rezultatul interogărilor este gestionat prin obiecte ResultSet
public interface ResultSet extends Wrapper, AutoCloseable;
• Obiectele ResultSet gestionează un cursor - pointer la rândurile structurii
tabelare rezultate prin interogare
• Proprietățile cursorului sunt definite prin parametrii metodelor
createStatement
 Semnificația parametrilor createStatement:
- resultSetType - tipul cursorului (deplasabil/nedeplasabil, senzitiv/nesenzitiv)
ResultSet.TYPE_FORWARD_ONLY; //nedeplasabil, nesenzitiv
ResultSet.TYPE_SCROLL_INSENSITIVE; //deplasabil, nesenzitiv
ResultSet.TYPE_SCROLL_SENSITIVE; //deplasabil, senzitiv
- resultSetConcurrency - permisiune modificări concurente (nu/da)
ResultSet.CONCUR_READ_ONLY; //nu permite acces concurențial
ResultSet.CONCUR_UPDATABLE ; //permite acces concurențial
- resultSetHoldability - menținere cursor după efectuarea (comiterea)
tranzacțiilor (nu/da)
ResultSet.HOLD_CURSORS_OVER_COMMIT; // menține cursorul
ResultSet.CLOSE_CURSORS_AT_COMMIT; //închide cursorul
 Menținerea cursorului (holdability) poate fi reglementată și prin
metode Connection:
void setHoldability (int holdability) throws SQLException; // se
specifică unul din cei doi parametrii

 Testarea cursorului:
int getHoldability() throws SQLException; // rezultatul este unul din cei
doi parametrii
Gruparea comenzilor - Tranzacții

Gruparea comenzilor prin obiectele Statement

 void addBatch(String sql) throws SQLException; //metoda Statement prin
care se adaugă la obiectul curent comanda specificata
 void clearBatch() throws SQLException; //Șterge comenzile din lista de
comenzi
 int[] executeBatch() throws SQLException; // Executare comenzi
adăugate. Întoarce un int pentru fiecare comanda in ordinea adăugării lor.
Respectiva valoare poate fi:
>=0 in funcție de numărul tuplurilor afectate(vezi executeUpdate),
SUCCESS_NO_INFO - comanda s-a executat cu succes dar nu se cunoaște
numărul tuplurilor afectate
EXECUTE_FAILED - execuția comenzii a eșuat. Executarea comenzilor
următoare poate fi întrerupta sau nu la eșec (in functie de driver)
Modul commit este legat de efectul definitiv al comenzilor. Este
gestionat prin următoarele metode Connection:

 void setAutoCommit(boolean autoCommit) throws SQLException;

//stabilește modul commit (true, false). Implicit este true, adică orice
comanda este executata individual si definitiv
 boolean getAutoCommit() throws SQLException ; //întoarce modul
commit existent
 void commit() throws SQLException ; // declanșează salvarea
permanenta a modificărilor apărute in DB.
 void rollback() throws SQLException;//anularea modificărilor
Metodele commit si rollback marchează terminarea tranzacției curente.
 Niveluri de izolare pentru tranzacții

 Asigura izolarea tranzacțiilor unele fata de celelalte si partajarea

resurselor intre utilizatori concurenți astfel încât să fie evitate
anomaliile în baza de date. Metode de stabilire/citire nivel:
 void setTransactionIsolation(int level) throws SQLException
 int getTransactionIsolation() throws SQLException

Anomalii de executie concurenta a tranzactiilor

 Citire improprie (dirty read). Această anomalie poate să apară
atunci când una din tranzacții este abandonată, iar altă tranzacție
concurentă a utilizat articolele modificate, înainte de readucerea
acestora la valoarea inițială.
 Citire irepetabilă (nonrepetable read). Poate să apară dacă o
tranzacție T1 citește un articol de două ori, iar între cele două citiri, o
altă tranzacție T2 a modificat chiar acel articol. În această situație
tranzacția T1 primește două valori diferite ale aceluiași articol.
 Citire fantomă (phantom read). Apare atunci când o tranzacție
prelucrează un set de linii rezultat al unei interogări. Dacă în timpul acestei
prelucrări o alta tranzacție a inserat sau a șters o linie care satisface
condiția interogării respective, atunci pot sa apară sau sa dispară linii din
mulțimea de linii rezultat - linii fantomă.

Niveluri de izolare:
 static final int TRANSACTION_NONE; // nu sunt permise tranzacțiile
 static final int TRANSACTION_READ_UNCOMMITTED; // fără izolare
 static final int TRANSACTION_READ_COMMITTED; // Este legat de
paradigma citirilor improprii - Dirty Reads. Nivelul trebuie sa înlăture
aceste situații. Soluție: nu sunt citite date care au fost modificate si nu s-au
definitivat modificările prin commit()
 static final int TRANSACTION_REPEATABLE_READ; // Este legat
de paradigma “citirilor nerepetabile” - Non-Repeatable Reads.
Comenzi identice de citire dau rezultate diferite in cadrul aceleiași
tranzacții. Soluție: interzice unei tranzacții sa citească din nou date
dintr-un rând care a fost modificat definitiv prin commit() de către o
alta tranzacție.
 static final int TRANSACTION_SERIALIZABLE; // Elimina si
riscurile create de problema “fantomei” -Phantom Reads. Problema
fantomei apare când o tranzacție inserează/șterge înregistrări
selectabile într-o selecție a altei tranzacții. Soluție: izolarea completa
- tranzacțiile sunt serializate.
 Comenzi precompilate

Sunt comenzi compilate si memorate in stare compilata la nivelul serverului DB.

Executarea lor nu mai necesita recompilare. Sunt folosite pentru executarea
repetata a unor operațiuni.
PreparedStatement prepareStatement(String sql) throws SQLException
PreparedStatement prepareStatement(String sql, int resultSetType,
int resultSetConcurrency) throws SQLException
PreparedStatement prepareStatement(String sql, int resultSetType,
int resultSetConcurrency, int resultSetHoldability) throws SQLException

preparedStatement inst=con.prepareStatement(“update jurnal set cod=? Where

cont=?”);
inst.setString(1,”0001”);
inst.setString(2,”3011”);
inst.executeUpdate();
Executarea procedurilor stocate:
CallableStatement prepareCall(String sql, int resultSetType,
int resultSetConcurrency, int resultSetHoldability) throws
SQLException
CallableStatement prepareCall(String sql, int resultSetType,
int resultSetConcurrency) throws SQLException
CallableStatement prepareCall(String sql) throws SQLException
Procesarea rezultatelor

Procesarea rezultatelor unei interogări se face prin comenzi ResultSet.

 boolean next() throws SQLException; // trecere la rând nou

 boolean absolute(int row) throws SQLException; // poziționare
absoluta pe rândul specificat
 boolean relative(int rows) throws SQLException; // poziționare
relativa pe un rând (fata de poziția curenta)
 boolean previous() throws SQLException; // trecere la precedent
 void afterLast() throws SQLException; // după ultimul rând
 boolean first() throws SQLException; // pe primul rând
 boolean last() throws SQLException ;// pe ultimul
 void beforeFirst() throws SQLException; // înaintea primului rând
 boolean isLast() throws SQLException;// este sau nu ultimul rând
 boolean isFirst() throws SQLException;// este sau nu primul
 boolean isAfterLast() throws SQLException ;// este sau nu după
ultimul
 boolean isBeforeFirst() throws SQLException; // este sau nu
înaintea primului
 Procesarea rezultatelor

 void deleteRow() throws SQLException ; // ștergere rând

 void refreshRow() throws SQLException ; // actualizare rând curent cu
valorile din DB. Nu poate fi aplicat rândului de inserție.
 void updateRow() throws SQLException ; //actualizare valori din DB cu cele
din randul curent
 void insertRow() throws SQLException; // adăugare valori din rândul de
inserție la DB
 void moveToInsertRow() throws SQLException;// trecere pe rândul de
inserție
 void moveToCurrentRow() throws SQLException ; // Se aplică pe rândul de
inserție si are ca efect trecerea pe rândul curent (cel pe care se afla cursorul
înainte de inserție)
 Tip getTip(int columnIndex) throws SQLException; // preluare valoare din
rând conform cu tipul si numărul coloanei
 Tip getTip(String columnLabel) throws SQLException;// preluare valoare din
rând conform cu tipul si numele coloanei
 void updateTip(int columnIndex, Tip x) throws SQLException; // actualizare
rând cu valoarea specificată pentru coloana specificată
 void updateTip(String columnLabel, Tip x) throws SQLException;// idem
 Maparea intre tipuri

 Într-o aplicație JDBC se lucrează cu trei tipuri de date: tipurile Java, tipurile
JDBC, tipurile SQL (in dialectul corespunzător).
 Tipurile JDBC sunt descrise in clasa java.sql.Types sub forma de câmpuri
statice int - BOOLEAN, DATE, DOUBLE etc.
 Corespondenta dintre tipuri se face voluntar prin codul aplicației cunoscând
semnificația tipurilor.
 Prin metoda de instanță a clasei ResultSetMetaData:
int getColumnType(int column) throws SQLException;
se poate obtine un tip din Types corespunzator coloanei investigate.
Tipul data:
public class java.sql.Date extends java.util.Date; // clasa destinata sa modeleze
data calendaristica in aplicațiile JDBC
public static Date valueOf(String s); // convertește un String de forma "yyyy-[M]M-
[d]d" in data JDBC
public String toString(); // convertește o data într-un sir in format "yyyy-[M]M-[d]d"
Opretatiuni CRUD (Create Read Update Delete) pe ResultSet
 Inserare de noi rânduri
Trecerea pe rândul de insert
r.moveToInsertRow();
Operațiuni de inițializare câmpuri
r.updateTip(nrColoana, valoare);
…
Adăugarea rândului
r.insertRow();
 Actualizare
r.absolute(i); // trecere pe rândul i
r.updateTip(nrColoana, valoare); // actualizare pe coloana nrColoana
…
r.updateRow(); // inserarea noilor valori
 Ștergere
r.absolute(i); // trecere pe rândul dorit
r.deleteRow(); // ștergere
 Accesul la metadate
 Accesul la metadate prin Connection - sunt furnizate informații despre baza de
date (structura, tabele/viziuni, catalog etc.)
 String getCatalog() throws SQLException
 void setCatalog(String catalog) throws SQLException
 DatabaseMetaData getMetaData() throws SQLException

 ResultSet getCatalogs() throws SQLException

 ResultSet getTables(String catalog, String schemaPattern,
String tableNamePattern, String[] types) throws SQLException

 Accesul la metadate prin ResultSet - sunt furnizate informații despre setul

interogat (coloane, tipuri, dimensiuni câmp etc.)
 ResultSetMetaData getMetaData() throws SQLException

 int getColumnCount() throws SQLException

 String getColumnName(int column) throws SQLException
 int getColumnType(int column) throws SQLException
 String getColumnTypeName(int column) throws SQLException
 int getColumnDisplaySize(int column) throws SQLException
Surse de date

 DataSource – o interfață prin care sunt generate conexiuni la o

sursă fizică de date
 Implementări:
 Conexiuni obișnuite
 Pool Connections – conexiuni reutilizabile create cu scopul
economisirii resurselor
 Avantajele utilizării obiectelor DataSource
 Păstrarea codului Java al aplicației in cazul modificărilor sursei
fizice de date sau a driverelor
 Capacități de conectare sporite (pool connection, tranzactii
distribuite)
Implementari DataSource

 Există implementări pentru interfața DataSource ale unor drivere

(Microsoft SQL Server JDBC Driver , Oracle etc.)
 Implementarea Microsoft SQL Server JDBC Driver este realizată
prin clasa SQLServerDataSource
 Metode SQLServerDataSource :
public void setServerName(java.lang.String serverName)
public void setUser(java.lang.String user)
public void setPassword(java.lang.String password)
public void setDatabaseName(java.lang.String databaseName)
public void setPortNumber(int portNumber)
public java.sql.Connection getConnection() throws
java.sql.SQLException
 Implementarea Oracle: OracleDataSource
 Metode:
public void setServerName(java.lang.String sn)
public void setServiceName(java.lang.String svcname)
public void setUser(java.lang.String userName)
public void setPassword(java.lang.String pd)
public void setPortNumber(int pn)
public void setDriverType(java.lang.String dt); //thin sau oci
public void setNetworkProtocol(java.lang.String np); // exp: tcp
public java.sql.Connection getConnection() throws
java.sql.SQLException