jdbc
Creazione di una connessione al database

Sintassi

• DB_URL = "jdbc: DBMS: // DB_HOST: DB_PORT / DB_NAME"

• DBMS: Data Base Driver Manager, può essere qualsiasi DBMS (mysql, oracle, postgresql, sqlite, ...), esempio di mysql: "com.mysql.jdbc.Driver"

• DB_HOST: l'host di base del database, l'indirizzo IP dell'esempio del database: 10.6.0.1, il valore predefinito è localhost o 127.0.0.1

• DB_PORT: porta del database, ogni DBMS ha un esempio di porta defeaut mysql = 3306, postegesql = 5432

• DB_NAME: il nome del tuo database

• Per connetterti devi ottenere un riferimento all'oggetto di classe,

• Class.forName (DRIVER);

• E per connettersi al database, è necessario creare una connessione

• java.sql.Connection con = DriverManager.getConnection (DB_URL, DB_USER_NAME, DB_PASSWORD);

• DB_USER_NAME: il nome utente del tuo database

• DB_PASSWORD: la password del tuo database

Introduzione (SQL)

Da Java 6, il modo consigliato per accedere a un database basato su SQL in Java è tramite l'API JDBC (Java DataBase Connectivity).

Questa API è disponibile in due pacchetti: java.sql e javax.sql .

JDBC definisce le interazioni tra database in termini di Connections e Drivers .

Un Driver interagisce con il database e fornisce un'interfaccia semplificata per l'apertura e la gestione delle connessioni. La maggior parte delle varietà di server di database (PostgreSQL, MySQl, ecc.) Hanno i propri Drivers , che gestiscono l'installazione, la rimozione e la traduzione specifiche per quel server. Di solito i Drivers non sono accessibili direttamente; piuttosto, viene invece utilizzata l'interfaccia fornita dall'oggetto DriverManager .

L'oggetto DriverManager è essenzialmente il nucleo di JDBC. Fornisce un'interfaccia (principalmente) database-agnostica per creare Connections . Per le versioni precedenti dell'API JDBC, i Drivers specifici del database dovevano essere caricati prima che DeviceManager potesse creare una connessione a quel tipo di database.

Una Connection è, come suggerisce il nome, una rappresentazione di una connessione aperta al database. Connections sono indipendenti dal database e vengono create e fornite da DriverManager . Forniscono una serie di metodi di "scorciatoia" per tipi di query comuni, nonché un'interfaccia SQL raw.

Uso della connessione (e delle istruzioni)

Una volta ottenuta la Connection , la useremo principalmente per creare oggetti Statement . Statements rappresentano una singola transazione SQL; sono utilizzati per eseguire una query e recuperare i risultati (se presenti). Diamo un'occhiata ad alcuni esempi:

public void useConnection() throws SQLException{


    Connection conn = getConnection();

    //We can use our Connection to create Statements
    Statement state = conn.getStatement();

    //Statements are most useful for static, "one-off" queries
    
    String query = "SELECT * FROM mainTable";
    boolean sucess = state.execute(query);
    
    //The execute method does exactly that; it executes the provided SQL statement, and returns true if the execution provided results (i.e. was a SELECT) and false otherwise.

    ResultSet results = state.getResultSet();
    
    //The ResultSet object represents the results, if any, of an SQL statement.
    //In this case, the ResultSet contains the return value from our query statement.
    //A later example will examine ResultSets in more detail.

    ResultSet newResults = state.executeQuery(query)
    
    //The executeQuery method is a 'shortcut' method. It combines the execute and getResultSet methods into a single step.
    //Note that the provided SQL query must be able to return results; typically, it is a single static SELECT statement.
    //There are a number of similar 'shortcut' methods provided by the Statement interface, including executeUpdate and executeBatch

    //Statements, while useful, are not always the best choice. 
    
    String newQuery = "SELECT * FROM mainTable WHERE id=?";
    PreparedStatement prepStatement = conn.prepareStatement(newQuery);

    //PreparedStatements are the prefed alternative for variable statements, especially ones that are going to be executed multiple times

    for(int id:this.ids){

        prepStatement.setInt(1,id);
        //PreparedStatements allow you to set bind variables with a wide variety of set methods.
        //The first argument to any of the various set methods is the index of the bind variable you want to set. Note that this starts from 1, not 0. 

        ResultSet tempResults = prepStatement.executeQuery()
        //Just like Statements, PreparedStatements have a couple of shortcut methods. 
        //Unlike Statements, PreparedStatements do not not take a query string as an argument to any of their execute methods.
        //The statement that is executed is always the one passed to the Connector.prepareStatement call that created the PreparedStatement
    }

}

Creazione di una connessione usando java.sql.DriverManager

Per connettersi utilizzando java.sql.DriverManager è necessario un URL JDBC per connettersi al proprio database. Gli URL JDBC sono specifici del database, ma sono tutti della forma

jdbc:<subprotocol>:<subname>

Dove <subprotocol> identifica il driver o il database (ad esempio postgresql , mysql , firebirdsql , ecc.) E <subname> è specifico del subprotocollo.

È necessario controllare la documentazione del database e del driver JDBC per il sottoprotocollo URL specifico e il formato per il driver.

Un semplice esempio per creare una connessione a un database con l'url jdbc:somedb://localhost/foobar :

try (Connection connection = DriverManager.getConnection(
        "jdbc:somedb://localhost/foobar", "anna", "supersecretpassword")) {
    // do something with connection
}

Usiamo un try-with-resources qui così la connessione viene automaticamente chiusa quando abbiamo finito con esso, anche se si verificano eccezioni.

Connection connection = DriverManager.getConnection(
        "jdbc:somedb://localhost/foobar", "anna", "supersecretpassword");
try {
    // do something with connection
} finally {
    // explicitly close connection
    connection.close();
}

Class.forName("org.example.somedb.jdbc.Driver");

In alternativa puoi anche fornire un oggetto Properties per connetterti:

Properties props = new Properties();
props.setProperty("user", "anna");
props.setProperty("password", "supersecretpassword");
// other, database specific, properties
try (Connection connection = DriverManager.getConnection(
        "jdbc:somedb://localhost/foobar", props)) {
    // do something with connection
}

O anche senza proprietà, ad esempio se il database non ha bisogno di nome utente e password:

try (Connection connection = DriverManager.getConnection(
        "jdbc:somedb://localhost/foobar")) {
    // do something with connection
}

Creare una connessione a MySQL

Per connettersi a MySQL è necessario utilizzare il driver MySQL Connector / J. Puoi scaricarlo da http://dev.mysql.com/downloads/connector/j/ oppure puoi utilizzare Maven:

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.39</version>
</dependency>

L' URL JDBC di base per MySQL è:

jdbc:mysql://<hostname>[:<port>]/<database>[?<propertyName>=<propertyValue>[&<propertyName>=<propertyValue>]...]

Dove:

L'URL supportato è più complesso di quello mostrato sopra, ma questo è sufficiente per la maggior parte delle esigenze "normali".

Per connetterti usa:

try (Connection connection = DriverManager.getConnection(
        "jdbc:mysql://localhost/foobardb", "peter", "nicepassword")) {
    // do something with connection
}

// Load the MySQL Connector/J driver
Class.forName("com.mysql.jdbc.Driver");

Connection connection = DriverManager.getConnection(
        "jdbc:mysql://localhost/foobardb", "peter", "nicepassword");
try {
    // do something with connection
} finally {
  // explicitly close connection
  connection.close();
}

Connessione a un database Microsoft Access con UCanAccess

UCanAccess è un puro driver JDBC Java che ci consente di leggere e scrivere su database Access senza utilizzare ODBC . Usa due altri pacchetti, Jackcess e HSQLDB , per eseguire queste attività.

Una volta che è stato impostato ^* , possiamo lavorare con i dati in file .accdb e .mdb usando un codice come questo:

import java.sql.*;

Connection conn=DriverManager.getConnection("jdbc:ucanaccess://C:/__tmp/test/zzz.accdb");
Statement s = conn.createStatement();
ResultSet rs = s.executeQuery("SELECT [LastName] FROM [Clients]");
while (rs.next()) {
    System.out.println(rs.getString(1));
}

^* Per maggiori dettagli vedi la seguente domanda:

Manipolazione di un database di Access da Java senza ODBC

Connessione JDBC Oracle

autista:

• 12c R1
• 11g R2

( Nota: il driver non è incluso in Maven Central!)

Inizializzazione della classe driver:

    Class.forName("oracle.jdbc.driver.OracleDriver");

URL di connessione

Formato precedente, con SID

"jdbc:oracle:thin:@<hostname>:<port>:<SID>"

Formato più recente, con Nome servizio

"jdbc:oracle:thin:@//<hostname>:<port>/<servicename>"

Tnsnames come entrata

"jdbc:oracle:thin:@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCPS)(HOST=<hostname>)(PORT=<port>))"
    +"(CONNECT_DATA=(SERVICE_NAME=<servicename>)))"

Stringa di connessione cluster RAC per failover

"jdbc:oracle:thin:@(DESCRIPTION=(ADDRESS_LIST=(LOAD_BALANCE=OFF)(FAILOVER=ON)"
    +"(ADDRESS=(PROTOCOL=TCP)(HOST=<hostname1>)(PORT=<port1>))"
    +"(ADDRESS=(PROTOCOL=TCP)(HOST=<hostname2>)(PORT=<port2>)))"
    +"(CONNECT_DATA=SERVICE_NAME=<servicename>)(SERVER=DEDICATED)))"

Esempio

connection = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:orcl", "HR", "HRPASS");