{"id":183,"date":"2024-01-23T23:19:11","date_gmt":"2024-01-23T22:19:11","guid":{"rendered":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=183"},"modified":"2024-01-24T23:20:08","modified_gmt":"2024-01-24T22:20:08","slug":"die-transactional-annotation-in-spring-jpa","status":"publish","type":"post","link":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=183","title":{"rendered":"Die @Transactional-Annotation in Spring\/JPA"},"content":{"rendered":"\n

Die @Transactional<\/code>-Annotation in einer Spring Boot-Anwendung spielt eine zentrale Rolle bei der Verwaltung von Transaktionen im Zusammenhang mit der Java Persistence API (JPA). Dieser Artikel wird sich ausf\u00fchrlich mit der Verwendung dieser Annotation in einer Spring Boot JPA-Anwendung befassen, insbesondere mit den verschiedenen Propagation-Varianten und Isolation-Levels, die sie bietet.<\/p>\n\n\n\n

Einf\u00fchrung in @Transactional<\/h2>\n\n\n\n

Die @Transactional<\/code>-Annotation wird in Spring verwendet, um Transaktionsverhalten f\u00fcr bestimmte Methoden zu definieren. In einer JPA-Anwendung kommt sie h\u00e4ufig zum Einsatz, um sicherzustellen, dass Operationen auf der Datenbank atomar, konsistent, isoliert und dauerhaft (ACID-Prinzipien) durchgef\u00fchrt werden.<\/p>\n\n\n\n

Grundlegende Verwendung<\/h3>\n\n\n\n

Um die @Transactional<\/code>-Annotation zu verwenden, platziert man sie einfach \u00fcber der Methode oder der Service-Klasse, die eine Transaktion ben\u00f6tigt. Hier ein einfaches Beispiel:<\/p>\n\n\n

@Service\npublic<\/span> class<\/span> MyService<\/span> <\/span>{\n\n    @Autowired\n    private<\/span> MyRepository myRepository;\n\n    @Transactional\n    public<\/span> void performTransaction() {\n        \/\/ Transaktionale Logik hier<\/span>\n        myRepository.save(entity);\n        \/\/ Weitere Logik...<\/span>\n    }\n}<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
In diesem Beispiel wird die performTransaction<\/code>-Methode als Transaktion behandelt, und alle darin enthaltenen Operationen werden als Teil derselben Transaktion ausgef\u00fchrt.<\/p>\n\n\n\n
Propagation-Varianten<\/h2>\n\n\n\n
Die Propagation-Variante legt fest, wie sich eine Transaktion verhalten soll, wenn sie auf eine bereits laufende Transaktion trifft oder wenn keine vorhanden ist. In Spring gibt es mehrere Propagation-Varianten, die durch das Attribut propagation<\/code> der @Transactional<\/code>-Annotation gesteuert werden.<\/p>\n\n\n\n
REQUIRED<\/h3>\n\n\n
@Transactional(propagation = Propagation.REQUIRED)\npublic void<\/span> requiredPropagation() {\n    \/\/ Transaktionale Logik hier<\/span>\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Die REQUIRED<\/code>-Propagation gibt an, dass die Methode in einer vorhandenen Transaktion ausgef\u00fchrt werden sollte, oder eine neue Transaktion startet, falls keine vorhanden ist. Dies ist die Standard-Propagation und wird h\u00e4ufig verwendet.<\/p>\n\n\n\n
REQUIRES_NEW<\/h3>\n\n\n
@Transactional(propagation = Propagation.REQUIRES_NEW)\npublic void<\/span> requiresNewPropagation() {\n    \/\/ Transaktionale Logik hier<\/span>\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Die REQUIRES_NEW<\/code>-Propagation gibt an, dass die Methode immer in einer neuen Transaktion ausgef\u00fchrt werden sollte. Wenn eine Transaktion bereits l\u00e4uft, wird sie pausiert und eine neue gestartet.<\/p>\n\n\n\n
NESTED<\/h3>\n\n\n
@Transactional(propagation = Propagation.NESTED)\npublic void<\/span> nestedPropagation() {\n    \/\/ Transaktionale Logik hier<\/span>\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Die NESTED<\/code>-Propagation ist \u00e4hnlich wie REQUIRED<\/code>, startet jedoch eine „verschachtelte“ Transaktion innerhalb der aktuellen Transaktion. Wenn die \u00e4u\u00dfere Transaktion abgeschlossen wird, wird die innere Transaktion entweder committet oder zur\u00fcckgerollt, abh\u00e4ngig von ihrem eigenen Status.<\/p>\n\n\n\n
SUPPORTS<\/h3>\n\n\n
@Transactional(propagation = Propagation.SUPPORTS)\npublic void<\/span> supportsPropagation() {\n    \/\/ Transaktionale Logik hier<\/span>\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Die SUPPORTS<\/code>-Propagation gibt an, dass die Methode in einer vorhandenen Transaktion ausgef\u00fchrt werden sollte, aber keine neue gestartet werden sollte, wenn keine vorhanden ist.<\/p>\n\n\n\n
NOT_SUPPORTED<\/h3>\n\n\n
@Transactional(propagation = Propagation.NOT_SUPPORTED)\npublic void<\/span> notSupportedPropagation() {\n    \/\/ Transaktionale Logik hier<\/span>\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Die NOT_SUPPORTED<\/code>-Propagation gibt an, dass die Methode au\u00dferhalb einer Transaktion ausgef\u00fchrt werden sollte. Falls eine Transaktion bereits vorhanden ist, wird sie vor\u00fcbergehend pausiert.<\/p>\n\n\n\n
NEVER<\/h3>\n\n\n
@Transactional(propagation = Propagation.NEVER)\npublic void<\/span> neverPropagation() {\n    \/\/ Transaktionale Logik hier<\/span>\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Die NEVER<\/code>-Propagation gibt an, dass die Methode au\u00dferhalb einer Transaktion ausgef\u00fchrt werden sollte. Wenn eine Transaktion bereits l\u00e4uft, wird eine Ausnahme ausgel\u00f6st.<\/p>\n\n\n\n
Isolation-Levels<\/h2>\n\n\n\n
Das Isolation-Level einer Transaktion gibt an, wie die Transaktionsergebnisse in Bezug auf andere gleichzeitige Transaktionen behandelt werden. Spring unterst\u00fctzt verschiedene Isolation-Levels, die mithilfe des Attributs isolation<\/code> der @Transactional<\/code>-Annotation festgelegt werden k\u00f6nnen.<\/p>\n\n\n\n
DEFAULT<\/h3>\n\n\n
@Transactional(isolation = Isolation.DEFAULT<\/span>)\npublic<\/span> void defaultIsolation() {\n    \/\/ Transaktionale Logik hier<\/span>\n}<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
Das DEFAULT<\/code>-Isolation-Level verwendet den Standard-Isolationsgrad der zugrunde liegenden Datenbank. Dies ist oft READ_COMMITTED<\/code>, was bedeutet, dass eine Transaktion nur auf bereits committete Daten anderer Transaktionen zugreifen kann.<\/p>\n\n\n\n
READ_UNCOMMITTED<\/h3>\n\n\n
@Transactional(isolation = Isolation.READ_UNCOMMITTED)\npublic void<\/span> readUncommittedIsolation() {\n    \/\/ Transaktionale Logik hier<\/span>\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Das READ_UNCOMMITTED<\/code>-Isolation-Level erlaubt einer Transaktion, auf noch nicht committete \u00c4nderungen anderer Transaktionen zuzugreifen. Dies birgt jedoch das Risiko von sogenannten „Dirty Reads“.<\/p>\n\n\n\n
READ_COMMITTED<\/h3>\n\n\n
@Transactional(isolation = Isolation.READ_COMMITTED)\npublic void<\/span> readCommittedIsolation() {\n    \/\/ Transaktionale Logik hier<\/span>\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Das READ_COMMITTED<\/code>-Isolation-Level erm\u00f6glicht einer Transaktion nur den Zugriff auf bereits committete Daten anderer Transaktionen. Dies minimiert das Risiko von „Dirty Reads“.<\/p>\n\n\n\n
REPEATABLE_READ<\/h3>\n\n\n
@Transactional(isolation = Isolation.REPEATABLE_READ)\npublic void<\/span> repeatableReadIsolation() {\n    \/\/ Transaktionale Logik hier<\/span>\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Das REPEATABLE_READ<\/code>-Isolation-Level stellt sicher, dass eine Transaktion auf dieselben Daten in derselben Reihenfolge zugreifen kann, unabh\u00e4ngig davon, ob andere Transaktionen in der Zwischenzeit \u00c4nderungen committen.<\/p>\n\n\n\n
SERIALIZABLE<\/h3>\n\n\n
@Transactional(isolation = Isolation.SERIALIZABLE)\npublic void<\/span> serializableIsolation() {\n    \/\/ Transaktionale Logik hier<\/span>\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Das SERIALIZABLE<\/code>-Isolation-Level ist das strengste Level, bei dem alle Transaktionen so abgewickelt werden, als ob sie nacheinander ausgef\u00fchrt w\u00fcrden. Dies minimiert das Risiko von „Dirty Reads“, „Non-Repeatable Reads“ und „Phantom Reads“.<\/p>\n\n\n\n
Schlussfolgerung<\/h2>\n\n\n\n
In diesem Artikel haben wir die @Transactional<\/code>-Annotation in einer Spring Boot JPA-Anwendung eingehend betrachtet. Wir haben die verschiedenen Propagation-Varianten und Isolation-Levels erkl\u00e4rt, die diese Annotation bietet, und wie sie dazu beitragen, die Integrit\u00e4t und Konsistenz von Datenbanktransaktionen zu gew\u00e4hrleisten.<\/p>\n\n\n\n
Es ist wichtig, die richtigen Propagation-Varianten und Isolation-Levels basierend auf den Anforderungen der Anwendung zu w\u00e4hlen. Die sorgf\u00e4ltige Verwendung dieser Annotation erm\u00f6glicht eine pr\u00e4zise Steuerung des Transaktionsverhaltens und tr\u00e4gt dazu bei, dass Datenbankoperationen in einer Spring Boot JPA-Anwendung effizient und zuverl\u00e4ssig abgewickelt werden.<\/p>\n","protected":false},"excerpt":{"rendered":"
Die @Transactional-Annotation in einer Spring Boot-Anwendung spielt eine zentrale Rolle bei der Verwaltung von Transaktionen im Zusammenhang mit der Java Persistence API (JPA). Dieser Artikel wird sich ausf\u00fchrlich mit der Verwendung dieser Annotation in einer Spring Boot JPA-Anwendung befassen, insbesondere mit den verschiedenen Propagation-Varianten und Isolation-Levels, die sie bietet. Einf\u00fchrung in @Transactional Die @Transactional-Annotation wird […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[5],"tags":[],"class_list":["post-183","post","type-post","status-publish","format-standard","hentry","category-spring"],"_links":{"self":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/183","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=183"}],"version-history":[{"count":1,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/183\/revisions"}],"predecessor-version":[{"id":184,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/183\/revisions\/184"}],"wp:attachment":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=183"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=183"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=183"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}