Inzicht in transacties

JDBC-stuurprogramma downloaden

Transacties zijn groepen bewerkingen die worden gecombineerd tot logische werkeenheden. Ze worden gebruikt om de consistentie en integriteit van elke actie in een transactie te beheren en te behouden, ondanks fouten die zich in het systeem kunnen voordoen.

Met het Microsoft JDBC-stuurprogramma voor SQL Server kunnen transacties lokaal of gedistribueerd worden. Transacties kunnen ook isolatieniveaus gebruiken. Zie Isolatieniveaus begrijpen voor meer informatie over de isolatieniveaus die worden ondersteund door het JDBC-stuurprogramma.

Toepassingen moeten transacties beheren met behulp van Transact-SQL instructies of de methoden van het JDBC-stuurprogramma, maar niet beide. Het gebruik van zowel Transact-SQL-instructies als JDBC-API-methoden op dezelfde transactie kan leiden tot problemen, zoals een transactie kan niet worden doorgevoerd wanneer verwacht, een transactie wordt doorgevoerd of teruggedraaid en een nieuwe wordt onverwacht gestart, of 'Kan de transactie niet hervatten'-uitzonderingen.

Lokale transacties gebruiken

Een transactie wordt beschouwd als lokaal wanneer het een transactie met één fase is en wordt rechtstreeks door de database verwerkt. Het JDBC-stuurprogramma ondersteunt lokale transacties met behulp van verschillende methoden van de klasse SQLServerConnection , waaronder setAutoCommit, commit en rollback. Lokale transacties worden doorgaans expliciet beheerd door de toepassing of automatisch door de Toepassingsserver Java Platform, Enterprise Edition (Java EE).

In het volgende voorbeeld wordt een lokale transactie uitgevoerd die bestaat uit twee afzonderlijke instructies in het try blok. De instructies worden uitgevoerd op de tabel Production.ScrapReason in de voorbeelddatabase AdventureWorks2025 en pas doorgevoerd als er geen uitzonderingen optreden. Met de code in het catch blok wordt de transactie teruggedraaid als er een uitzondering wordt gegenereerd.

public static void executeTransaction(Connection con) {
    try {
        //Switch to manual transaction mode by setting
        //autocommit to false. Note that this starts the first 
        //manual transaction.
        con.setAutoCommit(false);
        Statement stmt = con.createStatement();
        stmt.executeUpdate("INSERT INTO Production.ScrapReason(Name) VALUES('Wrong size')");
        stmt.executeUpdate("INSERT INTO Production.ScrapReason(Name) VALUES('Wrong color')");
        con.commit(); //This commits the transaction and starts a new one.
        stmt.close(); //This turns off the transaction.
        System.out.println("Transaction succeeded. Both records were written to the database.");
    }
    catch (SQLException ex) {
        ex.printStackTrace();
        try {
            System.out.println("Transaction failed.");
            con.rollback();
        }
        catch (SQLException se) {
            se.printStackTrace();
        }
    }
}

Gedistribueerde transacties gebruiken

Een gedistribueerde transactie werkt gegevens bij op twee of meer netwerkdatabases terwijl de belangrijke atomische, consistente, geïsoleerde en duurzame (ACID) eigenschappen van transactieverwerking behouden blijven. Gedistribueerde transactieondersteuning is toegevoegd aan de JDBC-API in de JDBC 2.0 Optionele API-specificatie. Het beheer van gedistribueerde transacties wordt doorgaans automatisch uitgevoerd door de JTS-transactiebeheerder (Java Transaction Service) in een Java EE-toepassingsserveromgeving. Het Microsoft JDBC-stuurprogramma voor SQL Server ondersteunt echter gedistribueerde transacties onder een JTA-compatibel transactiebeheer (Java Transaction API).

Het JDBC-stuurprogramma kan naadloos worden geïntegreerd met Microsoft Distributed Transaction Coordinator (MS DTC) om echte gedistribueerde transactieondersteuning te bieden met SQL Server. MS DTC is een gedistribueerde transactiefaciliteit die wordt geleverd door Microsoft voor Microsoft Windows-systemen. MS DTC maakt gebruik van bewezen technologie voor transactieverwerking van Microsoft ter ondersteuning van XA-functies, zoals het volledige gedistribueerde doorvoerprotocol met twee fasen en het herstel van gedistribueerde transacties.

Zie XA-transacties begrijpen voor meer informatie over het gebruik van gedistribueerde transacties.

Zie ook

Transacties uitvoeren met het JDBC-stuurprogramma