jdbc
Tworzenie połączenia z bazą danych

Składnia

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

• DBMS: Menedżer sterowników bazy danych, może to być dowolny DBMS (mysql, oracle, postgresql, sqlite, ...), przykład mysql: „com.mysql.jdbc.Driver”

• DB_HOST: Twój podstawowy host bazy danych, adres IP Twojej przykładowej bazy danych: 10.6.0.1, wartością domyślną jest localhost lub 127.0.0.1

• DB_PORT: Port bazy danych, każdy DBMS ma port defeaut przykład mysql = 3306, postegesql = 5432

• DB_NAME: nazwa Twojej bazy danych

• Aby się połączyć, należy uzyskać odwołanie do obiektu klasy,

• Class.forName (DRIVER);

• Aby połączyć się z bazą danych, musisz utworzyć połączenie

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

• DB_USER_NAME: nazwa użytkownika twojej bazy danych

• DB_PASSWORD: hasło do bazy danych

Wprowadzenie (SQL)

Od wersji Java 6 zalecanym sposobem dostępu do bazy danych SQL w Javie jest interfejs API JDBC (Java DataBase Connectivity).

Ten interfejs API jest dostępny w dwóch pakietach: java.sql i javax.sql .

JDBC definiuje interakcje z bazą danych pod względem Connections i Drivers .

Driver wchodzi w interakcję z bazą danych i zapewnia uproszczony interfejs do otwierania i zarządzania połączeniami. Większość odmian serwerów baz danych (PostgreSQL, MySQl itp.) Ma własne Drivers , które obsługują konfigurację, usuwanie i tłumaczenie specyficzne dla tego serwera. Zwykle nie ma bezpośredniego dostępu do Drivers ; zamiast tego używany jest interfejs zapewniony przez obiekt DriverManager .

Obiekt DriverManager jest zasadniczo rdzeniem JDBC. Zapewnia (głównie) niezależny od bazy danych interfejs do tworzenia Connections . W przypadku starszych wersji interfejsu JDBC API Drivers specyficzne dla bazy danych musiały zostać załadowane, aby DeviceManager mógł utworzyć połączenie z tym typem bazy danych.

Connection jest, jak sama nazwa wskazuje, reprezentacją otwartego połączenia z bazą danych. Connections są niezależne od bazy danych i są tworzone i dostarczane przez DriverManager . Zapewniają szereg metod „skrótowych” dla popularnych typów zapytań, a także surowy interfejs SQL.

Korzystanie z połączenia (i instrukcji)

Po uzyskaniu Connection będziemy go w większości wykorzystywać do tworzenia obiektów Statement . Statements reprezentują pojedynczą transakcję SQL; służą do wykonania zapytania i pobrania wyników (jeśli istnieją). Spójrzmy na kilka przykładów:

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
    }

}

Tworzenie połączenia za pomocą java.sql.DriverManager

Aby połączyć się za pomocą java.sql.DriverManager , potrzebujesz adresu URL JDBC, aby połączyć się z bazą danych. Adresy URL JDBC są specyficzne dla bazy danych, ale wszystkie mają formę

jdbc:<subprotocol>:<subname>

Gdzie <subprotocol> identyfikuje sterownik lub bazę danych (na przykład postgresql , mysql , firebirdsql itp.), A <subname> jest specyficzny dla <subname> .

Należy sprawdzić dokumentację bazy danych i sterownika JDBC pod kątem konkretnego podprotoku adresu URL i formatu sterownika.

Prosty przykład utworzenia połączenia z bazą danych za pomocą jdbc:somedb://localhost/foobar URL jdbc:somedb://localhost/foobar :

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

Używamy tutaj metody wypróbowania zasobów , więc połączenie jest automatycznie zamykane, gdy skończymy z nim, nawet jeśli wystąpią wyjątki.

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

Alternatywnie możesz także podać obiekt Properties do połączenia:

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
}

Lub nawet bez właściwości, na przykład jeśli baza danych nie potrzebuje nazwy użytkownika i hasła:

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

Tworzenie połączenia z MySQL

Aby połączyć się z MySQL, musisz użyć sterownika MySQL Connector / J. Możesz go pobrać ze strony http://dev.mysql.com/downloads/connector/j/ lub możesz użyć Maven:

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

Podstawowy adres URL JDBC dla MySQL to:

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

Gdzie:

Obsługiwany adres URL jest bardziej złożony niż pokazano powyżej, ale wystarcza to w przypadku większości „normalnych” potrzeb.

Aby połączyć, użyj:

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

Połączenie z bazą danych Microsoft Access za pomocą UCanAccess

UCanAccess to czysty JDBC Java JDBC , który pozwala nam czytać i pisać w bazach danych Access bez korzystania z ODBC . Do wykonania tych zadań wykorzystuje dwa inne pakiety, Jackcess i HSQLDB .

Po skonfigurowaniu ^* możemy pracować z danymi w plikach .accdb i .mdb przy użyciu następującego kodu:

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

^* Aby uzyskać więcej informacji, zobacz następujące pytanie:

Manipulowanie bazą danych Access z Java bez ODBC

Połączenie Oracle JDBC

Kierowca:

• 12c R1
• 11 g R2

( Uwaga: sterownik nie znajduje się w Maven Central!)

Inicjalizacja klasy sterownika:

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

URL połączenia

Starszy format, z SID

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

Nowszy format z nazwą usługi

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

Tnsnames jak entry

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

Ciąg połączenia klastra RAC do przełączania awaryjnego

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

Przykład

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