Inhaltsverzeichnis
- Database für das Dokument
- Was ist JDBC?
- Auf welchen Grundsatze basiert die Verbindung zwischen Java mit der Database?
- Einige wichtigen Driver herunterladen
- Das Projekt erstellen um das Beispiel über JDBC zu beginnen
- Connection
- JDBC API zur Data-Abfragen benutzen
- Die Type von ResultSet
- Zum Beispiel: Insert der Data
- PreparedStatement
- CallableStatement
- Die Geschäft kontrollieren (Transaction)
- Die Implementierung eines Befehlsblock (Batch)
Die Anleitung zu Java JDBC
View more Tutorials:
- Database für das Dokument
- Was ist JDBC?
- Auf welchen Grundsatze basiert die Verbindung zwischen Java mit der Database?
- Einige wichtigen Driver herunterladen
- Das Projekt erstellen um das Beispiel über JDBC zu beginnen
- Connection
- JDBC API zur Data-Abfragen benutzen
- Die Type von ResultSet
- Zum Beispiel: Insert der Data
- PreparedStatement
- CallableStatement
- Die Geschäft kontrollieren (Transaction)
- Die Implementierung eines Befehlsblock (Batch)

Im Unterlagen führe ich die Benutzung der java Verbindung mit database. Database simplehr wird als die Beispiel Muster im Unterlagen gewählt. Sie können das Skript der Database Erstellung sehen bei ...
JDBC (Java Database Connectivity) ist eine Standard- API zur Zusammenwirkung mit den Datenbank Type. JDBC hat eine Collection von Class und Interface für die Applikation Java, um die Datenbank zu kontaktieren

Die grundlegenden Elemente vom JDBC API umfasst :
- DriverManager:
- ist eine Class, die die Data base drivers steuert .
- Driver:
- ist eine Interface, die die Kontakt mit der Datenbank bindet und die Kontakt mit Database steuert. Falls Driver geladet wird, braucht der Programmierer es aufzurufen.
- Connection :
- ist eine Interface mit aller method für die Kontakt mit database. Sie bezeichnet die Kontaktsinhalt. Alle Kontaktinformation mit den Datenbank wird durch den Objekt Connection .
- Statement :
- ist eine Interface für die Einpackung eines Befehl SQL zur Datenbank, die analysiert, zusammenfasst, geplant und durchgeführt wird .
- ResultSet:
- ResultSet vertretet die Collection der Datensatz durch die Ausführung der Abfrage
Java benutzt JDBC um mit Datenbank zu arbeiten.

Zum Beispiel: Wenn Sie mit der Datenbank Oracle aus java arbeiten, brauchen Sie Driver (Das ist die Class für die Steuerung der Verbindung der DatenBank, die Sie möchten). In JDBC API haben wir java.sql.Driver, es ist nur eine Interface und es ist in JDK vorhanden. Deshalb sollen Sie die Bibliothek Driver herunterladen, die der Database entspricht.
- Wie: Mit Oracle ist die Implementierungclass der Interface java.sql.Driver : oracle.jdbc.driver.OracleDriver
Sehen Sie das folgende Beispiel

Wir haben 2 Maßnahmen für den Umgang mit einer bestimmten Datenbank Type.
- M 1: Sie versorgen die Bibliothek Driver, die diese Datenbank Type steuert. Das ist die direkte Maßnahme. Wenn Sie DB oracle (oder die andere DB) benutzen, sollen Sie die Bibliothek für diese DB herunterladen.
- M 2: Meldung einer "ODBC DataSource", und Anwendung der Brücke JDBC-ODBC zur Verbindung mit jener "ODBC DataSource" . Die Brücke JDBC-ODBC ist im JDBC API.vorhanden

Unsere Frage: Was ist "ODBC DataSource" ?
ODBC - Open Database Connectivity: Das ist eine Open Bibliothek, kann die meisten unterschiedlichen Datenbank Typen verbinden und es ist umsonst. Es wird von Microsoft versorgt.
ODBC DataSource: In dem Betriebssystem Windows können Sie eine Verbindung ODBC mit einer DB melden. Und dann haben wir eine Data Source.
Im JDBC API ist eine Brücke verfügbar, damit JDBC mit ODBC Data Source kontaktieren kann
ODBC - Open Database Connectivity: Das ist eine Open Bibliothek, kann die meisten unterschiedlichen Datenbank Typen verbinden und es ist umsonst. Es wird von Microsoft versorgt.
ODBC DataSource: In dem Betriebssystem Windows können Sie eine Verbindung ODBC mit einer DB melden. Und dann haben wir eine Data Source.
Im JDBC API ist eine Brücke verfügbar, damit JDBC mit ODBC Data Source kontaktieren kann
In Bezug auf die Geschwindigkeit ist die Maßnahme 1 schneller als die Maßnahme 2 denn die M2 braucht die Verbindungsbrücke
Falls Sie die JDBC- ODBC nicht benutzen möchten, können Sie die direkte Verbindungsmaßnahme mit Database benutzen. In diesem Fall sollen Sie den jeder DB entsprechenden Driver herunterladen. Hier führe ich die Herunterladung eines Driver für die üblichen Database
- Oracle
- MySQL
- SQLServer
- ....
Sie können die Hinweise sehen bei:
In dem Ergebnis haben wir einige File:

Ein Projekt JavaJdbcTutorial:neu erstellen

Erstellen Sie den Ordner libs im Projekt und kopieren die direkte Verbindungsbibliothek der database Oracle, MySQL, SQL Server, die Sie heruntergeladet haben, in diesen Ordner. Sie können alle oder einer der Bibliothek nach der DB kopieren, die Sie benutzen
Beachten Sie: Sie brauchen einen gewöhnlich Database entsprechenden Driver herunterzuladen. Die Datenbank für das Beispiel im Dokument können Sie nehmen bei

Die Rechtsmaustaste in Projekt drücken und dann Properties wählen


Nun können Sie bereit mit einer der Database (Oracle, MySQL, SQL Server) arbeiten.
In diesem Dokument führe ich die Verbindung mit 3 Database Type
- MySQL
- SQLServer
- Oracle
Bei der Praxis arbeiten Sie nur mit einer DB Type, die mit Ihnen gewöhnlich ist

Wir erstellen die Class ConnectionUtils , um ein Objekt Connection für die Verbindung mit Database zu nehmen

ConnectionUtils.java
package org.o7planning.tutorial.jdbc; import java.sql.Connection; import java.sql.SQLException; public class ConnectionUtils { public static Connection getMyConnection() throws SQLException, ClassNotFoundException { // Using Oracle // You may be replaced by other Database. return OracleConnUtils.getOracleConnection(); } // // Test Connection ... // public static void main(String[] args) throws SQLException, ClassNotFoundException { System.out.println("Get connection ... "); // Get a Connection object Connection conn = ConnectionUtils.getMyConnection(); System.out.println("Get connection " + conn); System.out.println("Done!"); } }
OracleConnUtils.java
package org.o7planning.tutorial.jdbc; import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; public class OracleConnUtils { // Connect to Oracle. public static Connection getOracleConnection() throws SQLException, ClassNotFoundException { String hostName = "localhost"; String sid = "db11g"; String userName = "simplehr"; String password = "1234"; return getOracleConnection(hostName, sid, userName, password); } public static Connection getOracleConnection(String hostName, String sid, String userName, String password) throws ClassNotFoundException, SQLException { // Declare the class Driver for ORACLE DB // This is necessary with Java 5 (or older) // Java6 (or newer) automatically find the appropriate driver. // If you use Java> 5, then this line is not needed. Class.forName("oracle.jdbc.driver.OracleDriver"); String connectionURL = "jdbc:oracle:thin:@" + hostName + ":1521:" + sid; Connection conn = DriverManager.getConnection(connectionURL, userName, password); return conn; } }
MySQLConnUtils.java
package org.o7planning.tutorial.jdbc; import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; public class MySQLConnUtils { // Connect to MySQL public static Connection getMySQLConnection() throws SQLException, ClassNotFoundException { String hostName = "localhost"; String dbName = "simplehr"; String userName = "root"; String password = "1234"; return getMySQLConnection(hostName, dbName, userName, password); } public static Connection getMySQLConnection(String hostName, String dbName, String userName, String password) throws SQLException, ClassNotFoundException { // Declare the class Driver for MySQL DB // This is necessary with Java 5 (or older) // Java6 (or newer) automatically find the appropriate driver. // If you use Java> 5, then this line is not needed. Class.forName("com.mysql.jdbc.Driver"); String connectionURL = "jdbc:mysql://" + hostName + ":3306/" + dbName; Connection conn = DriverManager.getConnection(connectionURL, userName, password); return conn; } }
SQLServerConnUtils_JTDS.java
package org.o7planning.tutorial.jdbc; import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; public class SQLServerConnUtils_JTDS { // Connect to SQLServer // (Using JDBC Driver of JTDS library) public static Connection getSQLServerConnection() throws SQLException, ClassNotFoundException { String hostName = "localhost"; String sqlInstanceName = "SQLEXPRESS"; String database = "simplehr"; String userName = "sa"; String password = "1234"; return getSQLServerConnection(hostName, sqlInstanceName, database, userName, password); } // Connect to SQLServer & using JTDS library public static Connection getSQLServerConnection(String hostName, String sqlInstanceName, String database, String userName, String password) throws ClassNotFoundException, SQLException { // Declare the class Driver for SQLServer DB // This is necessary with Java 5 (or older) // Java6 (or newer) automatically find the appropriate driver. // If you use Java> 5, then this line is not needed. Class.forName("net.sourceforge.jtds.jdbc.Driver"); // Example: // jdbc:jtds:sqlserver://localhost:1433/simplehr;instance=SQLEXPRESS String connectionURL = "jdbc:jtds:sqlserver://" + hostName + ":1433/" + database + ";instance=" + sqlInstanceName; Connection conn = DriverManager.getConnection(connectionURL, userName, password); return conn; } }
SQLServerConnUtils_SQLJDBC.java
package org.o7planning.tutorial.jdbc; import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; public class SQLServerConnUtils_SQLJDBC { // Connect to SQLServer // (Using JDBC Driver: SQLJDBC) public static Connection getSQLServerConnection() throws SQLException, ClassNotFoundException { String hostName = "localhost"; String sqlInstanceName = "SQLEXPRESS"; String database = "simplehr"; String userName = "sa"; String password = "1234"; return getSQLServerConnection(hostName, sqlInstanceName, database, userName, password); } // // Connect to SQLServer & using SQLJDBC Library. public static Connection getSQLServerConnection(String hostName, String sqlInstanceName, String database, String userName, String password) throws ClassNotFoundException, SQLException { // Declare the class Driver for SQLServer DB // This is necessary with Java 5 (or older) // Java6 (or newer) automatically find the appropriate driver. // If you use Java> 5, then this line is not needed. Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver"); // jdbc:sqlserver://ServerIp:1433/SQLEXPRESS;databaseName=simplehr String connectionURL = "jdbc:sqlserver://" + hostName + ":1433" + ";instance=" + sqlInstanceName + ";databaseName=" + database; Connection conn = DriverManager.getConnection(connectionURL, userName, password); return conn; } }
ODBCConnUtils.java
package org.o7planning.tutorial.jdbc; import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; public class ODBCConnUtils { // Connect to ODBC Data Source named "simplehr-ds". public static Connection getJdbcOdbcConnection() throws SQLException, ClassNotFoundException { String odbcDataSourceName = "simplehr-ds"; String userName = "simplehr"; String password = "simplehr"; return getJdbcOdbcConnection(odbcDataSourceName, userName, password); } public static Connection getJdbcOdbcConnection(String odbcDataSourceName, String userName, String password) throws SQLException, ClassNotFoundException { // Declare the class Driver for JDBC-ODBC Bridge // This is necessary with Java 5 (or older) // Java6 (or newer) automatically find the appropriate driver. // If you use Java> 5, then this line is not needed. Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); String connectionURL = "jdbc:odbc:" + odbcDataSourceName; Connection conn = DriverManager.getConnection(connectionURL, userName, password); return conn; } }
Sie können die Class ConnectionUtils ändern, um mit einer gewöhnlichen Database zu verbinden. Und Starten Sie die Class um die Verbindung zu testen
Beachten Sie: Falls Sie MySQL oder SQL Server anwenden, blockieren 2 Database standardmäßig die Verbindung von einer IP Addresse. Sie brauchen die Konfiguration, um dies zu ermöglichen. Sie können die Hinweise in der Unterlagen von der Installation und Konfiguration MySQL, SQL Server in o7planning lesen
Die Installation und die Konfiguration der MySQL Community:Die Installation und die Konfiguration der SQL Server:

Das ist die Image von Daten in der Tabelle Employee. Sehen wir ein Beispiel, wie Java die Daten nimmt

ResultSet ist ein Java Objekt. Es wird zurückgegeben wenn Sie die Daten abfragen (query). Verwenden Sie ResultSet.next() um den Cursor auf die nächsten Datensätze zu bewegen . In einem Datensatz verwenden Sie die Method ResultSet.getXxx() um die Wert in die Spalte abzurufen. Die Spalte wird nach der Reihenfolge 1,2,3 ... markiert
** ResultSet **
public String getString(int columnIndex) throws SQLException; public boolean getBoolean(int columnIndex) throws SQLException; public int getInt(int columnIndex) throws SQLException; public double getDouble(int columnIndex) throws SQLException; ... public String getString(String columnLabel) throws SQLException; public boolean getBoolean(String columnLabel) throws SQLException; public int getInt(String columnLabel) throws SQLException; public double getDouble(String columnLabel) throws SQLException; ....
Sehen Sie das Beispiel
QueryDataExample.java
package org.o7planning.tutorial.jdbc.basic; import java.sql.Connection; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; import org.o7planning.tutorial.jdbc.ConnectionUtils; public class QueryDataExample { public static void main(String[] args) throws ClassNotFoundException, SQLException { // Get Connection Connection connection = ConnectionUtils.getMyConnection(); // Create statement Statement statement = connection.createStatement(); String sql = "Select Emp_Id, Emp_No, Emp_Name from Employee"; // Execute SQL statement returns a ResultSet object. ResultSet rs = statement.executeQuery(sql); // Fetch on the ResultSet // Move the cursor to the next record. while (rs.next()) { int empId = rs.getInt(1); String empNo = rs.getString(2); String empName = rs.getString("Emp_Name"); System.out.println("--------------------"); System.out.println("EmpId:" + empId); System.out.println("EmpNo:" + empNo); System.out.println("EmpName:" + empName); } // Close connection. connection.close(); } }
Das Ergebnis von dem Beispiel:

Sie kannten ResultSet durch die oben Beispiele. Bei der Zustimmung der Daten kann ResultSet standardmäßig nur vom oben nach unten, vom links nach rechts laufen. Das bedeutet, dass Sie mit der Default ResultSet nicht rufen können
- ResultSet.previous() : zurück einen Datensatz.
- Auf dem gleichen Datensatz können Sie ResultSet.getXxx(4) und dann ResultSet.getXxx(2). nicht rufen
public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException; // Example: Statement statement = connection.createStatement( ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY); // ResultSet can scroll & readonly ResultSet rs = statement.executeQuery(sql);
resultSetType | Die Bedeutung |
TYPE_FORWARD_ONLY | - ResultSet erlaubt nur vom oben nach unten, vom links nach rechts abzufragen.das ist das standardmäßige Typ vom ResultSet. |
TYPE_SCROLL_INSENSITIVE | - ResultSet erlaubt vorwärts und rückwärts, rechts und links zu scrollen, aber ist nicht sensitiv mit die Änderungen der Data. d.h während des Browsen eines Rekord und des Wiederbrowsen des Rekord nimmt es die Änderungen der Rekord nicht. |
TYPE_SCROLL_SENSITIVE | - ResultSet erlaubt vorwärts und rückwärts, rechts und links zu scrollen und ist sensitiv mit der Änderung der Data |
resultSetConcurrency | Die Bedeutung |
CONCUR_READ_ONLY | - Sie lesen nur die Daten beim Browsen der Daten mit diesem Typ von ResultSet |
CONCUR_UPDATABLE | - Sie können nur die Daten bei der Mauszeigersposition ändern wenn Sie die Daten mit diesem Typ vom ResultSet, z.B update die Wert einer Spalte |
ScrollableResultSetExample.java
package org.o7planning.tutorial.jdbc.basic; import java.sql.Connection; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; import org.o7planning.tutorial.jdbc.ConnectionUtils; public class ScrollableResultSetExample { public static void main(String[] args) throws ClassNotFoundException, SQLException { // Get a Connection Connection connection = ConnectionUtils.getMyConnection(); // Create a Statement object // can be srolled, but not sensitive to changes under DB. // ResultSet is readonly (Cannot update) Statement statement = connection.createStatement( ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY); String sql = "Select Emp_Id, Emp_No, Emp_Name from Employee"; // Execute statement, return ResultSet. ResultSet rs = statement.executeQuery(sql); // Jump the cursor to last record. boolean last = rs.last(); System.out.println("last : "+ last); if(last) { // Print out data of last record System.out.println("EmpId:" + rs.getInt(1)); System.out.println("EmpNo:" + rs.getString(2)); System.out.println("EmpName:" + rs.getString(3)); } System.out.println("--------------------"); // Move cursor to previous record boolean previous =rs.previous(); System.out.println("Previous 1: "+ previous); // Move cursor to previous record previous =rs.previous(); System.out.println("Previous 2: "+ previous); // Fetch in the ResultSet while (rs.next()) { // Get value of column 2 String empNo = rs.getString(2); // Then get the value of column 1. int empId = rs.getInt(1); String empName = rs.getString("Emp_Name"); System.out.println("--------------------"); System.out.println("EmpId:" + empId); System.out.println("EmpNo:" + empNo); System.out.println("EmpName:" + empName); } // Close connection. connection.close(); } }
Das Ergebnis von dem Beispiel

InsertDataExample.java
package org.o7planning.tutorial.jdbc.basic; import java.sql.Connection; import java.sql.SQLException; import java.sql.Statement; import org.o7planning.tutorial.jdbc.ConnectionUtils; public class InsertDataExample { public static void main(String[] args) throws ClassNotFoundException, SQLException { // Get Connection Connection connection = ConnectionUtils.getMyConnection(); Statement statement = connection.createStatement(); String sql = "Insert into Salary_Grade (Grade, High_Salary, Low_Salary) " + " values (2, 20000, 10000) "; // Execute statement // executeUpdate(String) using for Insert, Update, Delete statement. int rowCount = statement.executeUpdate(sql); System.out.println("Row Count affected = " + rowCount); } }
Das Ergebnis von dem Beispiel

PreparedStatement ist eine untergeordnete Interface von Statement.
PreparedStatement wird benutzt, um die Befehl SQL vorzubereiten und mehrmals wieder zu benutzen. Das hilft dem Programm bei der schnellen Durchführung
PreparedStatement wird benutzt, um die Befehl SQL vorzubereiten und mehrmals wieder zu benutzen. Das hilft dem Programm bei der schnellen Durchführung
PrepareStatementExample.java
package org.o7planning.tutorial.jdbc.pareparedstatement; import java.sql.Connection; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; import org.o7planning.tutorial.jdbc.ConnectionUtils; public class PrepareStatementExample { public static void main(String[] args) throws ClassNotFoundException, SQLException { // Get a connection Connection connection = ConnectionUtils.getMyConnection(); // Create a SQL statement with two parameters (?) String sql = "Select emp.Emp_Id, emp.Emp_No, emp.Emp_Name," + " emp.Dept_Id from Employee emp " + " where emp.Emp_Name like ? and emp.Dept_Id = ? "; // Create a PreparedStatement object. PreparedStatement pstm = connection.prepareStatement(sql); // Set value for the first parameter (First '?') pstm.setString(1, "%S"); // Set value for the second parameter (Second '?') pstm.setInt(2, 20); ResultSet rs = pstm.executeQuery(); while (rs.next()) { System.out.println(" ---- "); System.out.println("EmpId : " + rs.getInt("Emp_Id")); System.out.println("EmpNo : " + rs.getString(2)); System.out.println("EmpName : " + rs.getString("Emp_Name")); } System.out.println(); System.out.println("Set other parameters .."); // Reuse PreparedStatement // Set other values pstm.setString(1, "KI%"); pstm.setInt(2,10); // Execute statement. rs = pstm.executeQuery(); while (rs.next()) { System.out.println(" ---- "); System.out.println("EmpId : " + rs.getInt("Emp_Id")); System.out.println("EmpNo : " + rs.getString(2)); System.out.println("EmpName : " + rs.getString("Emp_Name")); } } }
Das Ergebnis von dem Beispiel

CallableStatement wird gebaut, um einen Verfahren (procedure) oder eine Funktion (function) von SQL zu rufen
// Statement call procedure from Java String sql = "{call procedure_name(?,?,?)}"; // Statement call function from Java. String sql ="{? = call function_name(?,?,?)}";
Um ein Beispiel mit CallableStatement zu machen, brauchen wir eine Funktion oder einen Verfahren in DB. Mit Oracle, MySQL oder SQL Server können Sie einen Verfahren (procedure) wie folgend schnell erstellen
- ORACLE
Get_Employee_Info
-- This procedure retrieves information of an employee, -- Input parameter: p_Emp_ID (Integer) -- There are four output parameters v_Emp_No, v_First_Name, v_Last_Name, v_Hire_Date Create Or Replace Procedure Get_Employee_Info(p_Emp_Id Integer ,v_Emp_No Out Varchar2 ,v_First_Name Out Varchar2 ,v_Last_Name Out Varchar2 ,v_Hire_Date Out Date) Is Begin v_Emp_No := 'E' || p_Emp_Id; -- v_First_Name := 'Michael'; v_Last_Name := 'Smith'; v_Hire_Date := Sysdate; End Get_Employee_Info;
- MySQL
Get_Employee_Info
-- This procedure retrieves information of an employee, -- Input parameter: p_Emp_ID (Integer) -- There are four output parameters v_Emp_No, v_First_Name, v_Last_Name, v_Hire_Date CREATE PROCEDURE get_Employee_Info(p_Emp_ID Integer, out v_Emp_No Varchar(50) , out v_First_Name Varchar(50) , Out v_Last_name Varchar(50) , Out v_Hire_date Date) BEGIN set v_Emp_No = concat( 'E' , Cast(p_Emp_Id as char(15)) ); -- set v_First_Name = 'Michael'; set v_Last_Name = 'Smith'; set v_Hire_date = curdate(); END
- SQL Server
Get_Employee_Info
-- This procedure retrieves information of an employee, -- Input parameter: p_Emp_ID (Integer) -- There are four output parameters v_Emp_No, v_First_Name, v_Last_Name, v_Hire_Date CREATE PROCEDURE Get_Employee_Info @p_Emp_Id Integer , @v_Emp_No Varchar(50) OUTPUT, @v_First_Name Varchar(50) OUTPUT, @v_Last_Name Varchar(50) OUTPUT, @v_Hire_Date Date OUTPUT AS BEGIN set @v_Emp_No = 'E' + CAST( @p_Emp_Id as varchar) ; -- set @v_First_Name = 'Michael'; set @v_Last_Name = 'Smith'; set @v_Hire_date = getdate(); END
CallableStatementExample.java
package org.o7planning.tutorial.jdbc.callablestatement; import java.sql.CallableStatement; import java.sql.Connection; import java.sql.Date; import java.sql.SQLException; import org.o7planning.tutorial.jdbc.ConnectionUtils; public class CallableStatementExample { public static void main(String[] args) throws ClassNotFoundException, SQLException { // Get a connection Connection connection = ConnectionUtils.getMyConnection(); String sql = "{call get_Employee_Info(?,?,?,?,?)}"; // Create a CallableStatement object. CallableStatement cstm = connection.prepareCall(sql); // Set parameter value for first question mark // (p_Emp_ID) cstm.setInt(1, 10); // Registers the OUT parameter for 2st question mark. // (v_Emp_No) cstm.registerOutParameter(2, java.sql.Types.VARCHAR); // Registers the OUT parameter for 3rd question mark. // (v_First_Name) cstm.registerOutParameter(3, java.sql.Types.VARCHAR); // Registers the OUT parameter for 4th question mark. // (v_Last_Name) cstm.registerOutParameter(4, java.sql.Types.VARCHAR); // Registers the OUT parameter for 5th question mark. // (v_Hire_Date) cstm.registerOutParameter(5, java.sql.Types.DATE); // Execute statement. cstm.executeUpdate(); String empNo = cstm.getString(2); String firstName = cstm.getString(3); String lastName = cstm.getString(4); Date hireDate = cstm.getDate(5); System.out.println("Emp No: " + empNo); System.out.println("First Name: " + firstName); System.out.println("Last Name: " + lastName); System.out.println("Hire Date: " + hireDate); } }
Das Ergebnis von dem Beispiel

Transaction ist ein wichtiger Begriff in SQL.
Zum Beispiel : Die Person A überweisen einen Betrag von 1000$ auf das Konto der Person B. Deshalb passieren 2 Prozesse in Database:
Zum Beispiel : Die Person A überweisen einen Betrag von 1000$ auf das Konto der Person B. Deshalb passieren 2 Prozesse in Database:
- Das Konto der Person A vermindert 1000$
- Das Konto der Person B steigert 1000$.
TransactionExample.java
package org.o7planning.tutorial.transaction; import java.sql.Connection; import java.sql.SQLException; import org.o7planning.tutorial.jdbc.ConnectionUtils; public class TransactionExample { private static void doJob1(Connection conn) { // Todo something here. } private static void doJob2(Connection conn) { // Todo something here. } public static void main(String[] args) throws ClassNotFoundException, SQLException { // Get a connection Connection connection = ConnectionUtils.getMyConnection(); // Set auto-commit to false connection.setAutoCommit(false); try { // Do something related to the DB. doJob1(connection); doJob2(connection); // Explicitly commit statements to apply changes connection.commit(); } // Handling exception catch (Exception e) { e.printStackTrace(); // Rollback changes connection.rollback(); } // Close connection. connection.close(); } }
BatchExample.java
package org.o7planning.tutorial.transaction; import java.sql.Connection; import java.sql.SQLException; import java.sql.Statement; import org.o7planning.tutorial.jdbc.ConnectionUtils; public class BatchExample { public static void main(String[] args) throws SQLException, ClassNotFoundException { Connection conn = ConnectionUtils.getMyConnection(); try { // Create statement object Statement stmt = conn.createStatement(); // Set auto-commit to false conn.setAutoCommit(false); // Create SQL statement to insert into Employee table. String sql1 = "Update Employee emp set emp.Salary = emp.Salary + 100 " + " where emp.Dept_Id = 10 "; // Add above SQL statement in the batch. stmt.addBatch(sql1); // Create one more SQL statement String sql2 = "Update Employee emp set emp.Salary = emp.Salary + 20 " + " where emp.Dept_Id = 20 "; // Add above SQL statement in the batch. stmt.addBatch(sql2); // Create one more SQL statement String sql3 = "Update Employee emp set emp.Salary = emp.Salary + 30 " + " where emp.Dept_Id = 30 "; // Add above SQL statement in the batch. stmt.addBatch(sql3); // Create an int[] to hold returned values int[] counts = stmt.executeBatch(); System.out.println("Sql1 count = " + counts[0]); System.out.println("Sql2 count = " + counts[1]); System.out.println("Sql3 count = " + counts[2]); // Explicitly commit statements to apply changes conn.commit(); } catch (Exception e) { e.printStackTrace(); conn.rollback(); } } }
Das Ergebni von dem Beispiel

BatchExample2.java
package org.o7planning.tutorial.transaction; import java.sql.Connection; import java.sql.Date; import java.sql.PreparedStatement; import java.sql.SQLException; import java.util.UUID; import org.o7planning.tutorial.jdbc.ConnectionUtils; public class BatchExample2 { public static void main(String[] args) throws ClassNotFoundException, SQLException { Connection conn = ConnectionUtils.getMyConnection(); try { String sql = "Insert into Timekeeper(Timekeeper_Id, Date_Time, In_Out, Emp_Id) " + " values (?,?,?,?) "; // Create statement object PreparedStatement stmt = conn.prepareStatement(sql); // Set auto-commit to false conn.setAutoCommit(false); // Set values for parameters stmt.setString(1, UUID.randomUUID().toString()); stmt.setDate(2, new Date(System.currentTimeMillis())); stmt.setString(3, "I"); stmt.setInt(4, 7839); // Add to batch stmt.addBatch(); // Set other values for parameters. stmt.setString(1, UUID.randomUUID().toString()); stmt.setDate(2, new Date(System.currentTimeMillis())); stmt.setString(3, "I"); stmt.setInt(4, 7566); // Add to batch. stmt.addBatch(); // Create an int[] to hold returned values int[] counts = stmt.executeBatch(); System.out.println("counts[0] = " + counts[0]); System.out.println("counts[1] = " + counts[1]); // Explicitly commit statements to apply changes conn.commit(); } catch (Exception e) { e.printStackTrace(); conn.rollback(); } } }
Das Ergebnis von dem Beispiel
