Dieser Artikel beschreibt die Java -Implementierung von Transaktionen, Bankübertragungen und Waren in und aus Lagern, die auf JDBC basieren. Teilen Sie es für Ihre Referenz wie folgt weiter:
1. Transfergeschäft
Wenn die Übertragung 2 SQL -Anweisungen ausführen muss (Aktualisierungsaktualisierungen) und beide erfolgreich sind, wird die Transaktion eingereicht. Wenn einer fehlschlägt, rollen beide die Transaktion zurück.
2. Eine Transaktion sollte 4 Attribute haben : Atomizität, Konsistenz, Isolation und Persistenz. Diese vier Attribute werden normalerweise als Säureattribute bezeichnet.
① Atomizität. Eine Transaktion ist eine untrennbare Arbeitseinheit, und alle in der Transaktion enthaltenen Vorgänge werden entweder durchgeführt oder nicht.
② Konsistenz. Eine Transaktion muss darin bestehen, die Datenbank von einem konsistenten Zustand in einen anderen zu ändern. Konsistenz hängt eng mit der Atomizität zusammen.
③ Isolation. Die Ausführung einer Transaktion kann durch andere Transaktionen nicht beeinträchtigt werden. Das heißt, die Operationen innerhalb einer Transaktion und die verwendeten Daten werden aus anderen gleichzeitigen Transaktionen isoliert, und die gleichzeitig durchgeführten Transaktionen können sich nicht ineinander stören.
④ Haltbarkeit. Die Beständigkeit wird auch als Beständigkeit bezeichnet, was bedeutet, dass ihre Änderungen an den Daten in der Datenbank dauerhaft sein sollten, sobald eine Transaktion festgelegt ist. Andere nachfolgende Operationen oder Misserfolge sollten keine Auswirkungen auf sie haben.
3. Hier finden Sie eine Demo -Beschreibung, die den Übertragungsvorgang als Fall unter Verwendung des Übertragungsvorgangs unter Verwendung der Aufmerksamkeitspunkte wie folgt unter Verwendung des Übertragungsvorgangs ist:
(1) Für eine SQL -Anweisungsoperation muss keine manuelle Transaktionsübermittlung erforderlich sind
(2) Der Abfragevorgang erfordert keine manuelle Transaktionsübermittlung.
(3) Aktualisieren, Einfügen und Löschen erfordern jedoch eine manuelle Transaktionsübermittlung
(4) Wenn das Gleichgewicht negativ ist, können Sie zuerst die Ergebnisse abfragen und dann ein Urteil fällen und dann arbeiten
(5) con.setAutoCommit(false); Starten Sie die Transaktion manuell; con.commit(); die Transaktion manuell begehen; con.rollback(); Transaktionsrollback -Betrieb
4. Erstellen Sie zuerst eine Datentabelle oder zwei Datentabellen. Erstellen Sie hier zwei Datentabellen für die Klarheit der Demonstration.
5. Erstellen Sie eine Datenbank- und Datentabelle und schreiben Sie dann die Werkzeugklassenbasisao.java
Paket com.bie.utils; import Java.sql.connection; Import Java.sql.drivermanager; Import Java.SQL.PrepararedStatement; Import Java.SQL.Resultset; Import Java.sql.sqLexception; Für eine Verbindung zur Datenbank*/public class -basiertAo {private static String driver = "com.mysql.jdbc.driver"; private statische String url = "JDBC: MySQL: /// Test"; private statische String user = "root"; private statische String -Passwort = "123456"; /*** * Methode zur Verbindung zur Datenbank * @return * @throws classNotFoundException * @throws SQLEXception */public static Connection getcon () löst classNotFoundException, SQLEXception {class.Forname (Treiber); // Lade des Datenbank -Treibersystems. Verbindung con = driverManager.getConnection (URL, Benutzer, Passwort); System.out.println ("Datenbankverbindung erfolgreich"); return con; }/ *** * Methode zum Schließen der Datenbank * @param con * @param ps * @param rs */ public static void close (Verbindungscon, PrepedStatement PS, Ergebnisset RS) {if (rs! = Null) {// die Ressource schließen, um Ausnahmevertrieb zu vermeiden {rs.close (); } catch (SQLEXception e) {// Todo automatisch generierter Fangblock e.printstacktrace (); }} if (ps! = null) {try {ps.close (); } catch (SQLEXception e) {// Todo automatisch generierter Fangblock e.printstacktrace (); }} if (con! = null) {try {con.close (); } catch (SQLEXception e) {// Todo automatisch generierter Fangblock e.printstacktrace (); }}} / *** * stimmen Sie der Methode des Hinzufügens, Löschens und Änderns von * @param sql * @param arr * @return * / public static boolean Addupdatedelete (String SQL, Object [] arr) {Connection Con = Null; PrepedStatement ps = null; Versuchen Sie {con = basiertao.getCon (); // Schritt 1: Operation, um eine Verbindung zur Datenbank zu verbinden. }} int count = ps.executeUpDate (); // Schritt 4: Führen Sie die SQL -Anweisung if (count> 0) {return true aus; } else {return false; }} catch (classNotFoundException e) {// Todo automatisch generierter Fangblock e.printstacktrace (); } catch (SQLEXception e) {// Todo automatisch generierter Fangblock e.printstacktrace (); } return false; } /*public static void main (String [] args) {try {basiertao.getCon (); } catch (classNotFoundException e) {// Todo automatisch generierter Catch-Block e.printstacktrace (); } catch (SQLEXception e) {// Todo automatisch generierter Fangblock e.printstacktrace (); }}*/}6. Der Test wird direkt in der Hauptmethode durchgeführt, daher habe ich Userdao zum Testen geschrieben und nur den Effekt angesehen.
Paket com.bie.dao; import Java.sql.connection; Import Java.sql.PreeParedStatement; Import Java.Sql.SqLexception; * HINWEIS: * (1) Für eine SQL -Anweisungsoperation ist keine manuelle Transaktionsuntermission erforderlich * (2) Abfragebetrieb erfordert keine manuelle Transaktionsübermittlung. PrepedStatement ps1 = null; PrepedStatement ps2 = null; Versuchen Sie {// Schritt 1: Der Betrieb der Verbindung mit der Datenbank con = basiertao.getCon (); // Die Transaktion wird standardmäßig automatisch übermittelt, sodass der Standard der Fall ist. Wechseln Sie nun zu falsch, und die Standard -automatische Transaktion ist verboten //con.setAutocommit(True); // Transaktion 1: Wenn auf False festgelegt wird, muss die Transaktion manuell eingereicht werden. // Schritt 2: Die aktualisierte SQL-Anweisung String SQL = "Aktualisieren Sie bank_a usera_rmb = usera_rmb-500 wobei usera_id = 1"; String SQL2 = "BANK_B SETENBENSETENB_RMB = UserB_RMB+500 wobei userb_id = 1"; // Schritt 3: Precompile SQL PS1 = con.Parestatement (SQL); // Schritt 4: Führen Sie die SQL -Anweisung aus. Obwohl SQL ausgeführt wurde, wurde es nicht angehalten und in der Datenbank ps1.executeUpdate () bestanden. // Schritt 3: Precompile SQL2 PS2 = con.Preparestatement (SQL2); // Schritt 4: SQL2 ausführen. Obwohl SQL2 ausgeführt wird, wurde es nicht angehalten und in der Datenbank ps2.executeUpdate () bestanden. System.out.println ("erfolgreich übertragen ..."); // Transaktion 2: Die Transaktion manuell begehen. Wenn beide Hinrichtungen erfolgreich sind, begehen Sie die Transaktion con.commit (); } catch (classNotFoundException e) {e.printstacktrace (); Versuchen Sie {// Transaktion 3: Wenn eine Ausnahme geworfen wird, rollen Sie die Transaktionskon.Rollback () zurück; } catch (sqlexception e1) {e1.printstacktrace (); }} catch (sqlexception e) {e.printstacktrace (); } endlich {// Schließen Sie die Ressource, um Ausnahmen zu vermeiden, basierend AOO.CLOSE (CON, PS1, NULL); Basiertao.close (null, ps2, null); }}}Der Demo -Effekt ist wie folgt:
For more information about Java related content, please check out the topics of this site: "Summary of Java's skills to operate databases using JDBC", "Summary of Java+MySQL database programming", "Tutorial on Java Data Structure and Algorithm", "Summary of Java File and Directory Operation Skills", "Summary of Java Operation DOM Node Skills" and "Summary of Java Cache Betriebsfähigkeiten "
Ich hoffe, dieser Artikel wird für Java -Programme aller hilfreich sein.