Dieser Artikel stellt hauptsächlich die relevanten Informationen zu JDBC für das Erlernen der Java-Transaktionsverwaltung vor. Ich glaube, dass sie für jeden, der sie benötigt, einen gewissen Referenzwert haben.
Was ist eine Java-Transaktion?
Das übliche Konzept ist, dass Transaktionen sich nur auf Datenbanken beziehen.
Transaktionen müssen den von ISO/IEC festgelegten ACID-Grundsätzen entsprechen. ACID ist die Abkürzung für Atomizität, Konsistenz, Isolation und Haltbarkeit. Die Atomizität einer Transaktion bedeutet, dass jeder Fehler während der Transaktionsausführung dazu führt, dass alle von der Transaktion vorgenommenen Änderungen ungültig werden. Konsistenz bedeutet, dass beim Scheitern einer Transaktion alle von der Transaktion betroffenen Daten in den Zustand vor der Ausführung der Transaktion zurückversetzt werden sollten. Isolation bedeutet, dass Änderungen an Daten während der Transaktionsausführung für andere Transaktionen nicht sichtbar sind, bevor die Transaktion festgeschrieben wird. Persistenz bedeutet, dass der Status der übermittelten Daten korrekt sein sollte, wenn die Transaktionsausführung fehlschlägt.
Nach dem Verständnis eines Laien handelt es sich bei einer Transaktion um eine Reihe von atomaren Operationseinheiten. Entweder werden alle davon erfolgreich ausgeführt aus irgendeinem Grund falsch ausgeführt wurde, dann machen Sie alle zuvor ausgeführten Anweisungen rückgängig. Die einfachere Antwort lautet: Entweder sind alle Ausführungen erfolgreich, oder sie werden abgebrochen und nicht ausgeführt.
Was ist eine Java-Transaktion, da das Konzept der Transaktion aus der Datenbank stammt? Was ist die Verbindung?
Wenn ein Java-Anwendungssystem tatsächlich eine Datenbank betreiben möchte, wird dies über JDBC implementiert. Hinzufügung, Änderung und Löschung werden alle indirekt über entsprechende Methoden implementiert, und die Transaktionssteuerung wird entsprechend auch an den Java-Programmcode übertragen. Daher werden Datenbankoperationstransaktionen üblicherweise als Java-Transaktionen bezeichnet.
Eigenschaften von Transaktionen:
1) Atomarität: Transaktionen sind logische Arbeitseinheiten in der Datenbank und müssen für ihre atomare Arbeitseinheit sein Bei Datenänderungen werden entweder alle oder keine ausgeführt.
2) Konsistenz: Wenn eine Transaktion abgeschlossen ist, müssen alle Daten konsistent sein. In der entsprechenden Datenbank müssen alle Regeln auf Transaktionsänderungen angewendet werden, um die Integrität aller Daten zu wahren.
3) Isolation: Die Ausführung einer Transaktion kann nicht durch andere Transaktionen beeinflusst werden.
4) Haltbarkeit: Sobald eine Transaktion übermittelt wird, wird der Vorgang der Transaktion dauerhaft in der Datenbank gespeichert. Selbst wenn Sie zu diesem Zeitpunkt einen Rollback-Vorgang durchführen, werden die Änderungen nicht rückgängig gemacht.
Transaktion: Es handelt sich um eine Einheit zur Parallelitätskontrolle und eine benutzerdefinierte Abfolge von Vorgängen. Entweder werden alle oder keine dieser Vorgänge ausgeführt, und sie sind eine integrale Arbeitseinheit. Durch Transaktionen kann SQL Server eine Reihe logisch zusammenhängender Vorgänge miteinander verbinden, sodass der Server die Datenintegrität aufrechterhält. Eine Transaktion beginnt normalerweise mit „Begin Transaction“ und endet mit „Commit“ oder „Rollback“. Commint bedeutet Übermittlung, also alle Vorgänge zum Festschreiben einer Transaktion. Insbesondere werden alle Aktualisierungen der Daten in der Transaktion in die physische Datenbank auf der Festplatte zurückgeschrieben und die Transaktion endet normal. Rollback bedeutet Rollback, das heißt, während der Ausführung der Transaktion tritt ein Fehler auf und die Transaktion kann nicht fortgesetzt werden. Das System macht alle abgeschlossenen Vorgänge in der Datenbank in der Transaktion rückgängig und führt ein Rollback auf den Status durch, in dem die Transaktion gestartet wurde.
Auto-Commit-Transaktionen: Jede einzelne Anweisung ist eine Transaktion. Nach jeder Anweisung erfolgt ein implizites Commit. (Standard)
Explizite Transaktion: beginnt mit der Anzeige der Transaktion und endet mit dem Commit oder Rollback.
Implizite Transaktion: Wenn die Verbindung im impliziten Transaktionsmodus betrieben wird, startet die SQL Server-Datenbank-Engine-Instanz automatisch eine neue Transaktion, nachdem sie die aktuelle Transaktion festgeschrieben oder zurückgesetzt hat. Es ist nicht nötig, den Anfang der Dinge zu beschreiben, sondern einfach jede Transaktion festzuschreiben oder zurückzusetzen. Aber jede Transaktion endet immer noch explizit mit Commit oder Rollback. Nachdem die Verbindung den impliziten Transaktionsmodus auf „Öffnen“ festgelegt hat, wird automatisch eine implizite Transaktion gestartet, wenn die Datenbank-Engine-Instanz zum ersten Mal eine der folgenden Anweisungen ausführt: alter table, insert, create, open, delete , widerrufen, löschen, auswählen, abrufen, Tabelle abschneiden, gewähren, aktualisieren, die Transaktion bleibt gültig, bis eine Commit- oder Rollback-Anweisung ausgegeben wird. Nachdem die erste Transaktion festgeschrieben oder zurückgesetzt wurde, startet die Datenbank-Engine-Instanz automatisch eine neue Transaktion, wenn die Verbindung das nächste Mal eine der oben genannten Anweisungen ausführt. Diese Instanz generiert weiterhin implizite Transaktionsketten, bis der implizite Transaktionsmodus deaktiviert wird.
JDBC-Transaktionsverwaltung
So verwalten Sie Transaktionen bei Verwendung von JDBC. Schauen Sie sich den Code direkt an
Beispielcode
/**
* @Title: JDBCTrans.java
* @Package com.oscar999.trans
* @Description:
* @author XM
* @date Feb 14, 2017 4:38:27 PM
* @version V1.0
*/
package com.oscar999.trans;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
/**
* @author
*
*/
public class JDBCTrans {
public JDBCTrans() {
}
/**
*
* @param sHostName
* @param sPortNumber
* @param sSid
* @param userName
* @param password
* @return
* @throws SQLException
*/
public Connection getConnection(String sHostName, String sPortNumber, String sSid, String userName, String password) throws SQLException {
Connection conn = null;
String url = getOraclURL(sHostName, sPortNumber, sSid);
conn = DriverManager.getConnection(url,userName,password);
return conn;
}
/**
*
* @param conn
* @param sql
* @throws SQLException
*/
public void add(Connection conn, String sql) throws SQLException {
Statement stmt = null;
try {
stmt = conn.createStatement();
stmt.execute(sql);
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
if (stmt != null)
stmt.close();
}
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
String sHostName = "";
String sPortNumber = "";
String sSid = "";
String userName = "";
String password = "";
sHostName = "";
sPortNumber = "";
sSid = "";
userName = "";
password = "";
try {
Class.forName("oracle.jdbc.driver.OracleDriver");
} catch (ClassNotFoundException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
JDBCTrans jdbcTrans = new JDBCTrans();
Connection conn = null;
try {
conn = jdbcTrans.getConnection(sHostName, sPortNumber, sSid, userName, password);
conn.setAutoCommit(false);// can't insert, update
//1. add SQL
String addSQL = "insert into TEST_TABLE values('name1','value1')";
jdbcTrans.add(conn,addSQL);
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
/*if (conn != null)
{
try {
conn.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}*/
}
}
private String getOraclURL(String sHostName, String sPortNumber, String sSid) {
String url = "jdbc:oracle:thin:@" + sHostName + ":" + sPortNumber + ":" + sSid;
return url;
}
}Für den obigen Code lautet die Beschreibung wie folgt:
Wie viele Codes enthält der obige Code? Teil der Erklärung:
1 conn.setAutoCommit(false) Die Transaktion nach der Ausführung nicht festschreiben.
hat keine Auswirkung auf Select, aber bei Einfügen und Aktualisieren werden die Daten nicht geändert, wenn sie nicht übermittelt werden
2. conn.close(); 关闭Connection的代码有被Mark掉， 是想呈现conn.setAutoCommit(false)的效果。
原因是在 Connection Close的时候会执行一次Commit.
而如果Connection是在应用服务器中使用连接池的话， Connection就不会被Close, 也就不会执行Commit.
3. setAutoCommit(false) 用法大多数是在要执行多条语句才提交。
所以针对以上第三点， 更接近实际的状况的代码如示例代码2
示例代码2
/**
* @Title: JDBCTrans.java
* @Package com.oscar999.trans
* @Description:
* @author XM
* @date Feb 14, 2017 4:38:27 PM
* @version V1.0
*/
package com.oscar999.trans;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
/**
* @author
*
*/
public class JDBCTrans {
public JDBCTrans() {
}
/**
*
* @param sHostName
* @param sPortNumber
* @param sSid
* @param userName
* @param password
* @return
* @throws SQLException
*/
public Connection getConnection(String sHostName, String sPortNumber, String sSid, String userName, String password) throws SQLException {
Connection conn = null;
String url = getOraclURL(sHostName, sPortNumber, sSid);
conn = DriverManager.getConnection(url, userName, password);
return conn;
}
/**
*
* @param conn
* @param sql
* @throws SQLException
*/
public void add(Connection conn, String sql) throws SQLException {
Statement stmt = null;
try {
stmt = conn.createStatement();
stmt.execute(sql);
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
if (stmt != null)
stmt.close();
}
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
String sHostName = "";
String sPortNumber = "";
String sSid = "";
String userName = "";
String password = "";
sHostName = "";
sPortNumber = "";
sSid = "";
userName = "";
password = "";
try {
Class.forName("oracle.jdbc.driver.OracleDriver");
} catch (ClassNotFoundException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
JDBCTrans jdbcTrans = new JDBCTrans();
Connection conn = null;
try {
conn = jdbcTrans.getConnection(sHostName, sPortNumber, sSid, userName, password);
conn.setAutoCommit(false);// can't insert, update
// 1. add SQL 1
String addSQL = "insert into TEST_TABLE values('name1','value1')";
jdbcTrans.add(conn, addSQL);
//2. add SQL 2
addSQL = "insert into TEST_TABLE values('name2','value2')";
jdbcTrans.add(conn, addSQL);
conn.commit();
} catch (SQLException e) {
// TODO Auto-generated catch block
if(conn!=null){
try {
conn.rollback();
} catch (SQLException e1) {
e1.printStackTrace();
}
}
e.printStackTrace();
} finally {
if (conn != null) {
try {
conn.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
private String getOraclURL(String sHostName, String sPortNumber, String sSid) {
String url = "jdbc:oracle:thin:@" + sHostName + ":" + sPortNumber + ":" + sSid;
return url;
}
}这里需要说明的是： conn.rollback();
只要执行有异常，就要rollback , 这一步必不可少
如果没有在执行出现异常的时候进行回滚。如果在执行第一条语句之后出现异常，con既没有提交也没有回滚，表就会被锁住(如果oracle数据库就是行锁)，而这个锁却没有机会释放。
可能在执行con.close()的时候会释放锁，但还是如果应用服务器使用了数据库连接池，连接不会被断开。
总结
Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung des JDBC-Beispielcodes für das Erlernen der Java-Transaktionsverwaltung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
