Comment démarrer une transaction dans JDBC?

Question

Connexion.setTransactionIsolation(int) met en garde:

Remarque: Si cette méthode est appelée lors d'une transaction, le résultat est la mise en œuvre définies.

Ce poser la question: comment voulez-vous commencer une transaction dans JDBC? Il est clair comment à la fin d'une transaction, mais pas comment la commencer.

Si une Connexion commence à l'intérieur d'une transaction, comment sommes-nous censés invoquer Connection.setTransaction(int) en dehors d'une transaction pour éviter une mise en œuvre spécifique de comportement?

Answer 1

Pour répondre à ma propre question:

• Les connexions JDBC commencer avec le mode auto-commit est activée, où chaque instruction SQL est implicitement délimité par une transaction.
• Les utilisateurs qui souhaitent exécuter plusieurs instructions par transaction devez activer l'auto-commit off.
• Changer le mode auto-commit déclenche un commit de la transaction en cours (s'il est actif).
• Connexion.setTransactionIsolation() ne peut être invoquée à tout moment si l'auto-commit est activé.
• Si l'auto-commit est désactivé, Connexion.setTransactionIsolation() ne peut être invoquée avant ou après une opération. En l'invoquant dans le milieu d'une transaction conduit à un comportement indéfini.

Sources:

• Javadoc
• JDBC Tutoriel

Answer 2

JDBC implicitement délimite chaque requête/mise à jour que vous effectuez sur le lien avec une transaction. Vous pouvez personnaliser ce comportement en appelant setAutoCommit(false) pour désactiver le mode auto-commit et appeler le commit/rollback() pour indiquer la fin d'une transaction. Pesudo code

try
{
  con.setAutoCommit(false);

   //1 or more queries or updates

   con.commit();
}
catch(Exception e)
{
   con.rollback();
}
finally
{
   con.close();
}

Maintenant, il y a un type dans la méthode que vous avez indiqué. Il devrait être setTransactionIsolation(int niveau) et n'est pas de l'api pour la démarcation des transactions. Il gère comment/quand les modifications apportées par une opération deviennent visibles pour les autres opérations simultanées, le "je" dans l'ACIDE (http://en.wikipedia.org/wiki/Isolation_(database_systems))

Answer 3

Je vous suggère de lire ceci , vous verrez

Par conséquent, le premier appel de setAutoCommit(false) et chaque appel de commit() implicitement marque le début de une transaction. Les Transactions peuvent être annulé avant ils sont commis par des l'appel

Edit:

Vérifiez la documentation officielle sur les Transactions JDBC

Lorsqu'une connexion est créée, elle est en mode auto-commit. Cela signifie que chaque instruction SQL est traitée comme une transaction et est automatiquement engagé juste après elle est exécutée. (Pour être plus précis, la valeur par défaut est pour une instruction SQL pour être validée lorsqu'il est terminé, pas quand il est exécuté. Une instruction est terminée lorsque tous les de ses ensembles de résultats et de mettre à jour les chiffres ont été récupérées. Dans presque tous les cas, cependant, une instruction est terminée, et, par conséquent, commis, juste après elle est exécutée).

La manière de permettre à deux ou plusieurs états à être regroupés en un la transaction est de désactiver le mode auto-commit. Ceci est démontré dans le code suivant, où le con d'une connexion active:

con.setAutoCommit(false);

Source: JDBC Transactions

Answer 4

En fait, cette page du tutoriel JDBC serait une meilleure lecture.
Vous obtiendrez votre connexion, définissez votre niveau d'isolement, puis effectuez vos mises à jour et tout ce qui est validé ou annulé.