Connettività del database Java - Java Database Connectivity

Java Database Connectivity ( JDBC ) è un'interfaccia di programmazione dell'applicazione (API) per il linguaggio di programmazione Java , che definisce come un client può accedere a un database . È una tecnologia di accesso ai dati basata su Java utilizzata per la connettività del database Java. Fa parte della piattaforma Java Standard Edition , di Oracle Corporation . Fornisce metodi per interrogare e aggiornare i dati in un database ed è orientato ai database relazionali . Un bridge da JDBC a ODBC abilita le connessioni a qualsiasi origine dati accessibile da ODBC nell'ambiente host della JVM ( Java virtual machine ).

Storia e realizzazione

Sun Microsystems ha rilasciato JDBC come parte di Java Development Kit (JDK) 1.1 il 19 febbraio 1997. Da allora fa parte della piattaforma Java, Standard Edition (Java SE).

Le classi JDBC sono contenute nel pacchetto Java java.sql e javax.sql.

A partire dalla versione 3.1, JDBC è stato sviluppato nell'ambito del Java Community Process . JSR 54 specifica JDBC 3.0 (incluso in J2SE 1.4), JSR 114 specifica le aggiunte JDBC Rowset e JSR 221 è la specifica di JDBC 4.0 (incluso in Java SE 6).

JDBC 4.1, è specificato da una release di manutenzione 1 di JSR 221 ed è incluso in Java SE 7.

JDBC 4.2, è specificato da una release di manutenzione 2 di JSR 221 ed è incluso in Java SE 8.

L'ultima versione, JDBC 4.3, è specificata da una release di manutenzione 3 di JSR 221 ed è inclusa in Java SE 9.

Funzionalità

JDBC ("Java Database Connectivity") consente l'esistenza di più implementazioni e l'utilizzo da parte della stessa applicazione. L'API fornisce un meccanismo per caricare dinamicamente i pacchetti Java corretti e registrarli con JDBC Driver Manager. Il Driver Manager viene utilizzato come factory di connessione per la creazione di connessioni JDBC.

Le connessioni JDBC supportano la creazione e l'esecuzione di istruzioni. Queste possono essere istruzioni di aggiornamento come CREATE , INSERT , UPDATE e DELETE di SQL oppure possono essere istruzioni di query come SELECT . Inoltre, le procedure memorizzate possono essere richiamate tramite una connessione JDBC. JDBC rappresenta le istruzioni utilizzando una delle seguenti classi:

• Statement – la dichiarazione viene inviata ogni volta al server del database.
• PreparedStatement– l'istruzione viene memorizzata nella cache e quindi il percorso di esecuzione è predeterminato sul server del database consentendone l'esecuzione più volte in modo efficiente.
• CallableStatement– utilizzato per l'esecuzione di stored procedure sul database.

Le istruzioni di aggiornamento come INSERT, UPDATE e DELETE restituiscono un conteggio degli aggiornamenti che indica quante righe sono state interessate nel database. Queste dichiarazioni non restituiscono altre informazioni.

Le istruzioni di query restituiscono una serie di risultati di riga JDBC. Il set di risultati di riga viene utilizzato per esplorare il set di risultati . Le singole colonne di una riga vengono recuperate per nome o per numero di colonna. Potrebbe esserci un numero qualsiasi di righe nel set di risultati. Il set di risultati di riga contiene metadati che descrivono i nomi delle colonne e i relativi tipi.

Esiste un'estensione all'API JDBC di base nel file javax.sql.

Le connessioni JDBC sono spesso gestite tramite un pool di connessioni anziché ottenute direttamente dal driver.

Esempi

Quando un'applicazione Java necessita di una connessione al database, DriverManager.getConnection()viene utilizzato uno dei metodi per creare una connessione JDBC. L'URL utilizzato dipende dal database specifico e dal driver JDBC. Inizierà sempre con il protocollo "jdbc:", ma il resto dipende dal fornitore specifico.

Connection conn = DriverManager.getConnection(
     "jdbc:somejdbcvendor:other data needed by some jdbc vendor",
     "myLogin",
     "myPassword");
try {
     /* you use the connection here */
} finally {
    //It's important to close the connection when you are done with it
    try { 
        conn.close();
    } catch (Throwable e) { /* Propagate the original exception
                                instead of this one that you want just logged */ 
        logger.warn("Could not close JDBC Connection",e);
    }
}

A partire da Java SE 7 è possibile utilizzare l' istruzione try-with-resources di Java per semplificare il codice sopra:

try (Connection conn = DriverManager.getConnection(
     "jdbc:somejdbcvendor:other data needed by some jdbc vendor",
     "myLogin",
     "myPassword")) {
     /* you use the connection here */
}  // the VM will take care of closing the connection

Una volta stabilita una connessione, è possibile creare un'istruzione.

try (Statement stmt = conn.createStatement()) {
    stmt.executeUpdate("INSERT INTO MyTable(name) VALUES ('my name')");
}

Si noti che Connections, Statements e ResultSet spesso legano risorse del sistema operativo come socket o descrittori di file . Nel caso di connessioni a server di database remoti, ulteriori risorse sono impegnate sul server, ad esempio i cursori per i ResultSet attualmente aperti. È vitale per close()qualsiasi oggetto JDBC non appena ha svolto la sua parte; la raccolta dei rifiuti non dovrebbe essere invocata. Il costrutto try-with-resources di cui sopra è un modello di codice che lo ovvia.

I dati vengono recuperati dal database utilizzando un meccanismo di query del database. L'esempio seguente mostra la creazione di un'istruzione e l'esecuzione di una query.

try (Statement stmt = conn.createStatement();
    ResultSet rs = stmt.executeQuery("SELECT * FROM MyTable")
) {
    while (rs.next()) {
        int numColumns = rs.getMetaData().getColumnCount();
        for (int i = 1; i <= numColumns; i++) {
           // Column numbers start at 1.
           // Also there are many methods on the result set to return
           //  the column as a particular type. Refer to the Sun documentation
           //  for the list of valid conversions.
           System.out.println( "COLUMN " + i + " = " + rs.getObject(i));
        }
    }
}

Un esempio di una PreparedStatementquery, utilizzando conne classe dal primo esempio.

try (PreparedStatement ps =
    conn.prepareStatement("SELECT i.*, j.* FROM Omega i, Zappa j WHERE i.name = ? AND j.num = ?")
) {
    // In the SQL statement being prepared, each question mark is a placeholder
    // that must be replaced with a value you provide through a "set" method invocation.
    // The following two method calls replace the two placeholders; the first is
    // replaced by a string value, and the second by an integer value.
    ps.setString(1, "Poor Yorick");
    ps.setInt(2, 8008);

    // The ResultSet, rs, conveys the result of executing the SQL statement.
    // Each time you call rs.next(), an internal row pointer, or cursor,
    // is advanced to the next row of the result.  The cursor initially is
    // positioned before the first row.
    try (ResultSet rs = ps.executeQuery()) {
        while (rs.next()) {
            int numColumns = rs.getMetaData().getColumnCount();
            for (int i = 1; i <= numColumns; i++) {
                // Column numbers start at 1.
                // Also there are many methods on the result set to return
                // the column as a particular type. Refer to the Sun documentation
                // for the list of valid conversions.
                System.out.println("COLUMN " + i + " = " + rs.getObject(i));
            } // for
        } // while
    } // try
} // try

Se un'operazione di database non riesce, JDBC genera un file SQLException. In genere c'è ben poco che si può fare per recuperare da un tale errore, a parte registrarlo con il maggior numero di dettagli possibile. Si consiglia di tradurre l'eccezione SQLException in un'eccezione del dominio dell'applicazione (non selezionata) che alla fine si traduce in un rollback della transazione e in una notifica all'utente.

Un esempio di transazione di database :

boolean autoCommitDefault = conn.getAutoCommit();
try {
    conn.setAutoCommit(false);

    /* You execute statements against conn here transactionally */

    conn.commit();
} catch (Throwable e) {
    try { conn.rollback(); } catch (Throwable e) { logger.warn("Could not rollback transaction", e); }
    throw e;
} finally {
    try { conn.setAutoCommit(autoCommitDefault); } catch (Throwable e) { logger.warn("Could not restore AutoCommit setting",e); }
}

Per un esempio di CallableStatement(per chiamare le procedure memorizzate nel database), consultare la documentazione della Guida API JDBC .

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;

public class Mydb1 {
   static String URL = "jdbc:mysql://localhost/mydb";

   public static void main(String[] args) {
      try {
        Class.forName("com.mysql.jdbc.Driver");

        Connection conn = DriverManager.getConnection(URL, "root", "root");
        Statement stmt = conn.createStatement();
      
        String sql = "INSERT INTO emp1 VALUES ('pctb5361', 'kiril', 'john', 968666668)";
        stmt.executeUpdate(sql);
           
        System.out.println("Inserted records into the table...");
      } catch (Exception e) {
        e.printStackTrace();
      }
   }
}

Driver JDBC

I driver JDBC sono adattatori lato client (installati sulla macchina client, non sul server) che convertono le richieste dai programmi Java in un protocollo comprensibile dal DBMS.

tipi

I driver commerciali e gratuiti forniscono connettività alla maggior parte dei server di database relazionali. Questi driver rientrano in uno dei seguenti tipi:

• Digitare 1 che chiama il codice nativo del driver ODBC disponibile localmente. (Nota: in JDBC 4.2, il bridge JDBC-ODBC è stato rimosso)
• Tipo 2 che chiama la libreria nativa del fornitore del database sul lato client. Questo codice parla quindi al database sulla rete.
• Digitare 3 , il driver Java puro che dialoga con il middleware lato server che quindi dialoga con il database.
• Tipo 4 , il driver Java puro che utilizza il protocollo nativo del database.

Notare anche un tipo chiamato driver JDBC interno, un driver integrato con JRE nei database SQL abilitati per Java. Viene utilizzato per le stored procedure Java . Questo non rientra nello schema di classificazione sopra, anche se probabilmente assomiglierebbe a un driver di tipo 2 o di tipo 4 (a seconda che il database stesso sia implementato in Java o meno). Un esempio è il driver KPRB (Kernel Program Bundled) fornito con Oracle RDBMS . "jdbc:default:connection" offre un modo relativamente standard per effettuare tale connessione (almeno il database Oracle e Apache Derby lo supportano). Tuttavia, nel caso di un driver JDBC interno, il client JDBC viene effettivamente eseguito come parte del database a cui si accede e quindi può accedere ai dati direttamente anziché tramite i protocolli di rete.

fonti

• Oracle fornisce un elenco di alcuni driver e fornitori JDBC
• Simba Technologies fornisce un SDK per la creazione di driver JDBC personalizzati per qualsiasi origine dati relazionale personalizzata/proprietaria
• CData Software fornisce driver JDBC di tipo 4 per varie applicazioni, database e API Web.
• Driver JDBC RSSBus di tipo 4 per applicazioni, database e servizi web
• DataDirect Technologies fornisce una suite completa di veloci driver JDBC di tipo 4 per tutti i principali database pubblicizzati come di tipo 5
• Il software IDS fornisce un driver JDBC di tipo 3 per l'accesso simultaneo a tutti i principali database. Le funzionalità supportate includono la memorizzazione nella cache dei risultati, la crittografia SSL, l'origine dati personalizzata, dbShield
• JDBaccess è una libreria di persistenza Java per MySQL e Oracle che definisce le principali operazioni di accesso al database in un'API facilmente utilizzabile sopra JDBC
• JNetDirect fornisce una suite di driver JDBC ad alte prestazioni completamente certificati Sun J2EE.
• JDBCR4 è un programma di servizio scritto da Scott Klement per consentire l'accesso a JDBC da RPG su IBM i .
• HSQLDB è un RDBMS con un driver JDBC ed è disponibile con una licenza BSD.
• SchemaCrawler è un'API open source che sfrutta JDBC e rende i metadati del database disponibili come semplici vecchi oggetti Java (POJO)

Guarda anche

• Accesso ai dati GNU (GDA)
• JDBCFacade
• Connettività Open Database (ODBC)
• Mappatura relazionale a oggetti (ORM)

Riferimenti

link esterno

• Guida API JDBC Questa documentazione contiene esempi in cui le risorse JDBC non vengono chiuse in modo appropriato (ingestione di eccezioni primarie ed essere in grado di causare NullPointerExceptions) e presenta codice soggetto a SQL injection
• java.sqlDocumentazione API Javadoc
• javax.sql Documentazione API Javadoc
• Framework JDBC di O/R Broker Scala
• SqlTool Open source, riga di comando, utilità client JDBC generica. Funziona con qualsiasi database che supporti JDBC.
• Stringhe URL JDBC e informazioni correlate di Tutti i database.