Postup práce s JDBC je následující:

Koncepce je podobná jako ODBC (Microsoft Windows).

import java.sql.*;
public class TestJDBCMySQL { 
   public static void main(String[] args) { 
      String url = "jdbc:mysql://idealab.cs.uiowa.edu/WorksOn";
      String uid = "user";
      String pw = "testpw";
      try { // Load driver class
         Class.forName("com.mysql.jdbc.Driver");
      } catch (java.lang.ClassNotFoundException e) {
         System.err.println("ClassNotFoundException: " +e);
      }
      ...

   ...
   Connection con = null;
   try {
      con = DriverManager.getConnection(url, uid, pw);
      Statement stmt = con.createStatement();
      ResultSet rst = stmt.executeQuery("SELECT ename,salary FROM Emp");
      System.out.println("Employee Name,Salary");
      while (rst.next()) { 
         System.out.println(rst.getString("ename")+","+rst.getDouble("salary"));
      }
      con.close();
   } catch (SQLException ex) {
      System.err.println("SQLException: " + ex); }
   }
}

JDBC je velmi obecné rozhraní pro přístup k relačním databázím. Proto:

JDBC je rozloženo do balíků:

Klasickým způsobem práce s JDBC je tento postup:

	Varování
	Nesmíme uzavřít, dokud nedočteme ResultSet - jeho zbytek by se ztratil.

	Poznámka
	Také se obecně nelze v ResultSetu vracet.

	Poznámka
	Je nutné počítat s tím, že ResultSet neexistuje v jednu chvíli v paměti celý; je to virtuální přístupový bod k výsledkům, které se obecně postupně načítají/generují.

Implicitně se pro zřízené spojení nastaví režim "auto-commit", každý dotaz je uzavřen do samostatné transakce.

Chceme-li toto změnit (což je vzhledem k výkonu i vhodné), nastavíme con.setAutoCommit(false) a řídíme si transakce sami.

Řízení transakcí provádíme na daném spojení pomocí:

Příklad kódu s řízením transakce: první změna je potvrzena (commit), druhá zamítnuta (rollback):

con.setAutoCommit(false);

// inserts first two messages
for (int i = 0; i < messages.length-1; i++) {
   stmt.executeUpdate(
          "INSERT INTO MESSAGES VALUES (" ... ")");
      
con.commit();

// inserts last message ?
stmt.executeUpdate(
          "INSERT INTO MESSAGES VALUES (" ... ")");
// no. last message will not be inserted!
con.rollback();  

Na rychlé a nenáročné vyzkoušení databázových věcí v Javě můžeme použít volně dostupný javový systém řízení báze dat HSQLDB (dříve HypersonicSQL), http://hsqldb.sf.net.

Všechny demoprogramy dostupné ve zdrojové podobě jsou bez úprav učené pro HSQLDB.

HSQLDB může pracovat ve třech režimech:

Předpřipravené příkazy (Prepared Statements) jsou prostředkem, jak efektivně provádět často opakované SQL dotazy, např.:

Technicky předpřipravený dotaz vypadá tak, že na místě dosazovaného parametru je znak ?.

Pomocí set-metod se daný formální parametr ("otazník") nahradí skutečnou hodnotou a pak se příkaz spustí.

Příklad:

// příprava příkazu
PreparedStatement pstmt = con.prepareStatement(
        "SELECT E.FIRSTNAME, E.SURNAME, M.CREATED, M.TEXT " +
        "FROM EMPLOYEES AS E, MESSAGES AS M " +
        "WHERE E.SURNAME = ?"
        +" AND E.ID = M.TO " +
        "ORDER BY M.CREATED DESC");

// naplnění parametrů
pstmt.setString(1, "Novak");

// vlastní provedení
ResultSet result = pstmt.executeQuery();

Uložené procedury - Stored Procedures - jsou vzdáleně podobné předpřípraveným příkazům, jsou však zcela v server-side režii.

Běží tedy vzdáleně přímo na serveru.

Jsou výhodné nejen z hlediska výkonu, ale i údržby - jsou centralizovaně uložené, lze je lépe měnit při změnách datového modelu, konfigurace DB atd.

Podporuje-li to daný DBMS, můžeme řádky vrácených tabulek modifikovat:

ResultSet result = stmt.executeQuery(
   "SELECT TEXT " +
   "FROM MESSAGES " +
   "WHERE ID > 10");

// posuň se na pátý řádek výsledku
result.absolute(5);

// změň hodnotu atributu/pole
result.updateString("TEXT", "Zmeneny text zpravy"); 

// proveď změny
result.updateRow();

DBMS poskytne základní informace o

voláními, jako jsou:

DatabaseMetaData dbmd = con.getMetaData();

// základní údaje o DBMS
System.out.println(
   "DBMS: " +
   dbmd.getDatabaseProductName()  + ", " +
   dbmd.getDatabaseProductVersion() );

// údaje o driveru
System.out.println(
   "Driver: " +
   dbmd.getDriverName()  + ", " +
   dbmd.getDriverVersion() );

// dostupné funkce DBMS
   System.out.println("String functions: "+dbmd.getStringFunctions());
   System.out.println("TimeDate functions: "+dbmd.getTimeDateFunctions());
   System.out.println("Numeric functions: "+dbmd.getNumericFunctions());
   System.out.println("System functions: "+dbmd.getSystemFunctions());

Moderní přístup k datovým zdrojům je založen na přidání další úrovně adresovací abstrakce:

	Poznámka
	JNDI služba je obvykle ve správě aplikačního (webového) serveru (Tomcat, jboss...)

JDO je Java-centrická alternativa k tradičním způsobům zajištění perzistence dat:

JDO je specifikace, která prochází tzv. Java Community Process (JCP) Program, blíže viz http://jcp.org.

Mají na ni tedy vliv i nezávislí vývojáři.

Její aktuální platná verze je 1.0.1, připravuje se 2.0.

Specifikace JDO 1.0.1 má 200 stran.

Motivací pro JDO bylo dát pohodlnější techniku (než JDBC a serializace) pro zachycení stavu běžných javových objektů v programu a možnost jeho obnovy.

Existuje několik open-source i komerčních implementací JDO:

Alternativou pro pohodlnou serializaci mnoha typů objektů do XML je např. open-source balík XStream, viz dále.

Javová třída může implementovat rozhraní java.io.Serializable, které

Při serializaci se standardně

Tak lze zajistit serializaci skutečně jen potřebných složek stavu objektu, zbytek se po deserializaci může "dopočítat".

	Poznámka
	Typický příklad: symetrickou matici (např. podle hlavní diagonály) neukládáme celou, ale jen "jednu polovinu".

Požadujeme-li speciální chování (např. kvůli serializaci návazných/odkazovaných objektů), můžeme v objektu poskytnout metody:

Potřebujeme-li serializaci javových objektů jen na prosté účely typu

pak je XStream pravděpodobně nejlepší volbou, pokud nám nevadí nepodpora non-ASCII znaků...

XStream je extrémně jednoduše a přímočaře použitelné API pro serializaci jakýchkoli objektů do XML.

Není třeba psát žádné popisovače, stačí vybrat objekt a poslat ho metodě toXML objektu serializátoru org.codehaus.xstream.XStream.

Vytvoříme pole se zadaným počtem prvků, postupně do něj vřadíme nově vytvořené objekty Person a toto pole serializujeme.

public static int LEN = 10000;
public static void main(String[] args) {
   Person[] people = new Person[LEN];
   XStream xs = new XStream();
   xs.alias("person", Person.class);
   for(int i = 0; i < LEN; i++) {
      people[i] = new Person("Clovek "+i, i, i * 10);
   }
   // serialize
   String xml = xs.toXML(people);
   System.out.println(xml);

// uncomment the following code to test deserialization
/*
   Person[] secondPeople = (Person[])xs.fromXML(xml);
   for(int i = 0; i < secondPeople.length; i++) {
      increaseSalary(secondPeople[i], 20);
   }
*/
}

Vytvořený soubor vypadá takto:

<person-array>
  <person>
    <name>Clovek 0</name>
    <age>0</age>
    <salary>0.0</salary>
  </person>
  <person>
    <name>Clovek 1</name>
    <age>1</age>
    <salary>10.0</salary>
  </person>
  <person>
    <name>Clovek 2</name>
    <age>2</age>
    <salary>20.0</salary>
  </person>
  ...

Hibernate