jdbc
Een databaseverbinding tot stand brengen

Syntaxis

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

• DBMS: Data Base Driver Manager, dit kan elke DBMS zijn (mysql, oracle, postgresql, sqlite, ...), bijvoorbeeld mysql: "com.mysql.jdbc.Driver"

• DB_HOST: uw database base host, het IP-adres van uw database bijvoorbeeld: 10.6.0.1, de standaardinstelling is localhost of 127.0.0.1

• DB_PORT: databasepoort, elk DBMS heeft een defeaut-poort, bijvoorbeeld mysql = 3306, postegesql = 5432

• DB_NAME: de naam van uw database

• Om verbinding te maken, moet u een verwijzing naar het klasseobject verkrijgen,

• Class.forName (DRIVER);

• En om verbinding te maken met de database, moet u een verbinding maken

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

• DB_USER_NAME: de gebruikersnaam van uw database

• DB_PASSWORD: het wachtwoord van uw database

Introductie (SQL)

Sinds Java 6 is de aanbevolen manier om toegang te krijgen tot een op SQL gebaseerde database in Java via de JDBC (Java DataBase Connectivity) API.

Deze API wordt geleverd in twee pakketten: java.sql en javax.sql .

JDBC definieert database-interacties in termen van Connections en Drivers .

Een Driver samen met de database en biedt een vereenvoudigde interface voor het openen en beheren van verbindingen. De meeste databaseserversoorten (PostgreSQL, MySQl, enz.) Hebben hun eigen Drivers , die de installatie, afbouw en vertaling van die server afhandelen. Drivers zijn meestal niet rechtstreeks toegankelijk; in plaats daarvan wordt de interface van het object DriverManager gebruikt.

Het object DriverManager is in wezen de kern van JDBC. Het biedt een (meestal) database-agnostische interface om Connections te maken. Voor oudere versies van de JDBC API moesten database-specifieke Drivers 's worden geladen voordat DeviceManager een verbinding met dat type database kon maken.

Een Connection is, zoals de naam al aangeeft, een weergave van een open verbinding met de database. Connections zijn database-agnostisch en worden gemaakt en geleverd door de DriverManager . Ze bieden een aantal 'snelkoppelingsmethoden' voor veelgebruikte querytypen, evenals een onbewerkte SQL-interface.

De verbinding gebruiken (en verklaringen)

Zodra we de Connection , zullen we deze meestal gebruiken om Statement objecten te maken. Statements vertegenwoordigen een enkele SQL-transactie; ze worden gebruikt om een query uit te voeren en de resultaten op te halen (indien aanwezig). Laten we enkele voorbeelden bekijken:

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
    }

}

Een verbinding maken met java.sql.DriverManager

Om verbinding te maken via java.sql.DriverManager u een JDBC-url nodig om verbinding te maken met uw database. JDBC-URL's zijn database-specifiek, maar ze zijn allemaal van de vorm

jdbc:<subprotocol>:<subname>

Waar <subprotocol> het stuurprogramma of de database identificeert (bijvoorbeeld postgresql , mysql , firebirdsql , enz.), En <subname> is subprotocol-specifiek.

U moet de documentatie van uw database en JDBC-stuurprogramma controleren voor het specifieke URL-subprotocol en -formaat voor uw stuurprogramma.

Een eenvoudig voorbeeld om een verbinding met een database te maken met de URL jdbc:somedb://localhost/foobar :

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

We gebruiken hier een try-with-resources , zodat de verbinding automatisch wordt verbroken wanneer we hiermee klaar zijn, zelfs als er uitzonderingen zijn.

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");

Als alternatief kunt u ook een object Properties opgeven om verbinding te maken:

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
}

Of zelfs zonder eigenschappen, bijvoorbeeld als de database geen gebruikersnaam en wachtwoord nodig heeft:

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

Verbinding maken met MySQL

Om verbinding te maken met MySQL moet u het MySQL Connector / J-stuurprogramma gebruiken. Je kunt het downloaden van http://dev.mysql.com/downloads/connector/j/ of je kunt Maven gebruiken:

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

De basis JDBC-URL voor MySQL is:

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

Waar:

De ondersteunde URL is complexer dan hierboven weergegeven, maar dit volstaat voor de meeste 'normale' behoeften.

Verbinden gebruiken:

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();
}

Verbinding met een Microsoft Access-database met UCanAccess

UCanAccess is een puur Java JDBC stuurprogramma waarmee we kunnen lezen van en schrijven naar Access-databases zonder ODBC . Het gebruikt twee andere pakketten, Jackcess en HSQLDB , om deze taken uit te voeren.

Als het eenmaal is ingesteld ^* , kunnen we met gegevens in .accdb- en .mdb-bestanden werken met code zoals deze:

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));
}

^* Zie de volgende vraag voor meer informatie:

Een Access-database manipuleren vanuit Java zonder ODBC

Oracle JDBC-verbinding

Bestuurder:

• 12c R1
• 11 g R2

( Opmerking: de bestuurder is niet inbegrepen in Maven Central!)

Initialisatie van stuurprogrammaklasse:

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

Verbindings-URL

Ouder formaat, met SID

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

Nieuwer formaat, met servicenaam

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

Tnsnames houden van binnenkomst

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

RAC-clusterverbindingsreeks voor 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)))"

Voorbeeld

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