Java-databasanslutning - Java Database Connectivity

Java Database Connectivity ( JDBC ) är ett applikationsprogrammeringsgränssnitt (API) för programmeringsspråket Java , som definierar hur en klient kan komma åt en databas . Det är en Java-baserad datatillgångsteknik som används för Java-databasanslutning. Det är en del av Java Standard Edition- plattformen, från Oracle Corporation . Det ger metoder för att fråga och uppdatera data i en databas och är inriktat på relationsdatabaser . En JDBC-till- ODBC- brygga möjliggör anslutningar till vilken som helst ODBC-tillgänglig datakälla i Java-virtuell maskin (JVM) värdmiljö.

Historia och implementering

Sun Microsystems släppte JDBC som en del av Java Development Kit (JDK) 1.1 den 19 februari 1997. Sedan dess har det varit en del av Java Platform, Standard Edition (Java SE).

JDBC-klasserna finns i Java-paketet java.sql och javax.sql.

Från och med version 3.1 har JDBC utvecklats under Java Community Process . JSR 54 specificerar JDBC 3.0 (ingår i J2SE 1.4), JSR 114 anger JDBC Rowset-tillägg, och JSR 221 är specifikationen för JDBC 4.0 (ingår i Java SE 6).

JDBC 4.1, specificeras av en underhållsversion 1 av JSR 221 och ingår i Java SE 7.

JDBC 4.2, specificeras av en underhållsversion 2 av JSR 221 och ingår i Java SE 8.

Den senaste versionen, JDBC 4.3, specificeras av en underhållsversion 3 av JSR 221 och ingår i Java SE 9.

Funktionalitet

JDBC ('Java Database Connectivity') tillåter att flera implementeringar existerar och kan användas av samma applikation. API: n tillhandahåller en mekanism för dynamisk laddning av rätt Java-paket och registrering av dem hos JDBC Driver Manager. Driver Manager används som en anslutningsfabrik för att skapa JDBC-anslutningar.

JDBC-anslutningar stöder skapande och utförande av uttalanden. Dessa kan vara uppdateringsuttalanden som SQL: s CREATE , INSERT , UPDATE och DELETE , eller så kan de vara frågeställningar som SELECT . Dessutom kan lagrade procedurer åberopas via en JDBC-anslutning. JDBC representerar uttalanden med en av följande klasser:

• Statement - Uttalandet skickas till databasservern varje gång.
• PreparedStatement- Uttrycket cachas och sedan bestäms exekveringsvägen på databasservern så att den kan köras flera gånger på ett effektivt sätt.
• CallableStatement- används för att utföra lagrade procedurer i databasen.

Uppdateringsuttalanden som INSERT, UPDATE och DELETE returnerar ett uppdateringsantal som anger hur många rader som påverkades i databasen. Dessa uttalanden ger ingen annan information.

Frågeställningar returnerar en resultatuppsättning för JDBC-rad. Radresultatsatsen används för att gå över resultatuppsättningen . Enskilda kolumner i en rad hämtas antingen med namn eller med kolumnnummer. Det kan finnas valfritt antal rader i resultatuppsättningen. Radresultatuppsättningen har metadata som beskriver namnen på kolumnerna och deras typer.

Det finns en tillägg till det grundläggande JDBC API i javax.sql.

JDBC-anslutningar hanteras ofta via en anslutningspool i stället för att erhållas direkt från drivrutinen.

Exempel

När en Java-applikation behöver en databasanslutning används en av DriverManager.getConnection()metoderna för att skapa en JDBC-anslutning. Webbadressen som används beror på den specifika databasen och JDBC-drivrutinen. Det börjar alltid med protokollet "jdbc:", men resten är upp till den specifika leverantören.

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

Från och med Java SE 7 kan du använda Java: s försök med resurser för att göra ovanstående kod enklare:

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

När en anslutning har upprättats kan ett uttalande skapas.

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

Observera att anslutningar, uttalanden och resultatsatser ofta knyter samman operativsystemresurser som uttag eller filbeskrivare . När det gäller anslutningar till fjärrdatabasservrar är ytterligare resurser bundna på servern, t.ex. markörer för för närvarande öppna ResultSets. Det är viktigt för close()alla JDBC-objekt så snart det har spelat sin roll; sopuppsamling bör inte åberopas. Ovanstående försök med resurser är ett kodmönster som undanröjer detta.

Data hämtas från databasen med hjälp av en databasfrågemekanism. Exemplet nedan visar hur du skapar ett uttalande och kör en fråga.

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

Ett exempel på en PreparedStatementfråga som använder connoch klassar från första exemplet.

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

Om en databasåtgärd misslyckas höjer JDBC en SQLException. Det finns vanligtvis mycket lite man kan göra för att återhämta sig från ett sådant fel, förutom att logga det med så mycket detalj som möjligt. Det rekommenderas att SQLException översätts till ett undantag för en applikationsdomän (en okontrollerad) som så småningom resulterar i en återföring av en transaktion och ett meddelande till användaren.

Ett exempel på en databastransaktion :

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

För ett exempel på a CallableStatement(för att anropa lagrade procedurer i databasen), se dokumentationen för JDBC API-guide .

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

JDBC-drivrutiner

JDBC-drivrutiner är adaptrar på klientsidan (installerade på klientmaskinen, inte på servern) som konverterar förfrågningar från Java-program till ett protokoll som DBMS kan förstå.

Typer

Kommersiella och gratis drivrutiner ger anslutning till de flesta relationsdatabasservrar. Dessa drivrutiner faller i en av följande typer:

• Typ 1 som anropar inbyggd kod för den lokalt tillgängliga ODBC-drivrutinen. (Obs! I JDBC 4.2 har JDBC-ODBC-bryggan tagits bort)
• Skriv 2 som anropar databasleverantörens inbyggda bibliotek på en klientsida. Den här koden pratar sedan med databasen via nätverket.
• Skriv 3 , den rena Java-drivrutinen som pratar med serverns mittprogram som sedan pratar med databasen.
• Skriv 4 , den rena Java-drivrutinen som använder databasens inbyggda protokoll.

Observera också en typ som kallas en intern JDBC-drivrutin - en drivrutin inbäddad med JRE i Java-aktiverade SQL-databaser. Den används för Java-lagrade procedurer . Detta passar inte in i klassificeringsschemat ovan, även om det sannolikt skulle likna antingen en typ 2- eller typ 4-drivrutin (beroende på om själva databasen är implementerad i Java eller inte). Ett exempel på detta är KPRB-drivrutinen (Kernel Program Bundled) som levereras med Oracle RDBMS . "jdbc: default: connection" erbjuder ett relativt standardiserat sätt att skapa en sådan anslutning (åtminstone Oracle-databasen och Apache Derby stöder den). I fallet med en intern JDBC-drivrutin körs JDBC-klienten faktiskt som en del av databasen som nås, och kan så komma åt data direkt snarare än genom nätverksprotokoll.

Källor

• Oracle ger en lista över några JDBC-drivrutiner och leverantörer
• Simba Technologies levererar ett SDK för att bygga anpassade JDBC-drivrutiner för alla anpassade / patenterade relationsdatakällor
• CData Software levererar typ 4 JDBC-drivrutiner för olika applikationer, databaser och webb-API: er.
• RSSBus Type 4 JDBC-drivrutiner för applikationer, databaser och webbtjänster
• DataDirect Technologies tillhandahåller en omfattande serie snabba JDBC-drivrutiner av typ 4 för alla större databaser som de annonserar som typ 5
• IDS-programvaran ger en JDBC-drivrutin av typ 3 för samtidig åtkomst till alla större databaser. Funktioner som stöds inkluderar resultatcache, SSL-kryptering, anpassad datakälla, dbShield
• JDBaccess är ett Java-persistensbibliotek för MySQL och Oracle som definierar större databasåtkomståtgärder i ett lättanvändbart API ovanför JDBC
• JNetDirect tillhandahåller en serie Sun J2EE-certifierade högpresterande JDBC-drivrutiner.
• JDBCR4 är ett serviceprogram skrivet av Scott Klement för att ge åtkomst till JDBC från RPG på IBM i .
• HSQLDB är en RDBMS med en JDBC-drivrutin och är tillgänglig under en BSD-licens.
• SchemaCrawler är ett API med öppen källkod som utnyttjar JDBC och gör databasmetadata tillgängliga som vanliga gamla Java-objekt (POJOs)

Se även

• GNU Data Access (GDA)
• JDBCFacade
• Open Database Connectivity (ODBC)
• Objektrelationell kartläggning (ORM)

Referenser

externa länkar

• JDBC API-guide Den här dokumentationen har exempel där JDBC-resurserna inte är stängda på lämpligt sätt (sväljer primära undantag och kan orsaka NullPointerExceptions) och har kod som är benägen för SQL-injektion
• java.sqlAPI Javadoc- dokumentation
• javax.sql API Javadoc-dokumentation
• O / R Broker Scala JDBC-ramverk
• SqlTool Öppen källkod, kommandorad, generiskt JDBC-klientverktyg. Fungerar med vilken JDBC-stödjande databas som helst.
• JDBC URL-strängar och relaterad information om alla databaser.