Comment démarrer une transaction dans JDBC?

Connection.setTransactionIsolation(int) avertit:

Remarque: Si cette méthode est appelée lors d’une transaction, le résultat est défini par l’implémentation.

Cela soulève la question: comment commencez-vous une transaction dans JDBC? Il est clair comment mettre fin à une transaction, mais pas comment commencer.

Si une Connection commence à l’intérieur d’une transaction, comment pouvons-nous invoquer Connection.setTransactionIsolation(int) dehors d’une transaction pour éviter un comportement spécifique à l’implémentation?

Répondre à ma propre question:

  • Les connexions JDBC démarrent avec le mode auto-commit activé, où chaque instruction SQL est implicitement démarquée avec une transaction.
  • Les utilisateurs qui souhaitent exécuter plusieurs instructions par transaction doivent désactiver la validation automatique .
  • La modification du mode de validation automatique déclenche une validation de la transaction en cours (si celle-ci est active).
  • Connection.setTransactionIsolation () peut être appelé à tout moment si la validation automatique est activée.
  • Si la validation automatique est désactivée, Connection.setTransactionIsolation () peut uniquement être appelé avant ou après une transaction. L’invoquer au milieu d’une transaction entraîne un comportement indéfini.

Sources:

  • Javadoc
  • Tutoriel JDBC

JDBC démarque implicitement chaque requête / mise à jour que vous effectuez sur la connexion à une transaction. Vous pouvez personnaliser ce comportement en appelant setAutoCommit (false) pour désactiver le mode de validation automatique et appeler la commande commit () / rollback () pour indiquer la fin d’une transaction. Code Pesudo

 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 montrée. Cela devrait être setTransactionIsolation (int level) et ce n’est pas l’api pour la démarcation des transactions. Il gère comment / quand les modifications apscopes par une opération deviennent visibles par d’autres opérations concurrentes, le “I” dans ACID (http://en.wikipedia.org/wiki/Isolation_(database_systems))

Je vous suggère de lire ceci, vous verrez

Par conséquent, le premier appel de setAutoCommit (false) et chaque appel de commit () marquent implicitement le début d’une transaction. Les transactions peuvent être annulées avant d’être validées en appelant

Modifier:

Vérifiez la documentation officielle sur les transactions JDBC

Lorsqu’une connexion est créée, elle est en mode de validation automatique. Cela signifie que chaque instruction SQL individuelle est traitée comme une transaction et est automatiquement validée juste après son exécution. (Pour être plus précis, une instruction SQL est validée par défaut lorsqu’elle est terminée, et non lorsqu’elle est exécutée. Une instruction est terminée lorsque tous ses jeux de résultats et ses comptes de mises à jour ont été récupérés. Dans presque tous les cas, cependant. , une déclaration est terminée et donc validée, juste après son exécution.)

La manière de regrouper deux ou plusieurs instructions dans une transaction consiste à désactiver le mode de validation automatique. Ceci est démontré dans le code suivant, où con est une connexion active:

con.setAutoCommit (false);

Source: Transactions JDBC

En fait, cette page du didacticiel JDBC serait une meilleure lecture.
Vous obtiendrez votre connexion, définissez votre niveau d’isolement, puis effectuez vos mises à jour et tout ce que vous souhaitez, puis validez ou annulez.

Cela répondra peut-être à votre question: vous ne pouvez avoir qu’une transaction par connexion. Si la validation automatique est activée (par défaut), chaque sélection, mise à jour et suppression démarrera et validera automatiquement (ou annulera) une transaction. Si vous désactivez la validation automatique, vous lancez une “nouvelle” transaction (cela signifie que la validation ou la restauration ne se fera pas automatiquement). Après quelques instructions, vous pouvez appeler commit ou rollback, ce qui termine la transaction en cours et en lance automatiquement une nouvelle. Vous ne pouvez pas ouvrir deux transactions sur une seule connexion JDBC sur JDBC pur.

Au début, vous pouvez exécuter manuellement une transaction si vous souhaitez laisser votre connexion en mode “setAutoCommit (true)” mais que vous souhaitez toujours une transaction:

  try (Statement statement = conn.createStatement()) { statement.execute("BEGIN"); try { // use statement ... statement.execute("COMMIT"); } catch (SQLException failure) { statement.execute("ROLLBACK"); } } 

Vous pouvez utiliser ces méthodes pour la transaction:

  1. vous devez créer l’object de connexion comme con
  2. con.setAutoCommit(false);
  3. vos questions
  4. si tout est vrai con.commit();
  5. sinon con.rollback();