Útmutató az Atomikoszhoz

1. Bemutatkozás

Atomikosz az tranzakciós könyvtár Java alkalmazásokhoz. Ebben az oktatóanyagban megértjük, miért és hogyan kell használni az Atomikos-t.

Ennek során áttekintjük a tranzakciók alapjait és azt is, hogy miért van szükségünk rájuk.

Ezután létrehozunk egy egyszerű alkalmazást az Atomikos különböző API-kat kihasználó tranzakciókkal.

2. Az alapok megértése

Mielőtt megvitatnánk az Atomikoszot, értsük meg, hogy mi is pontosan a tranzakció, és néhány hozzájuk kapcsolódó fogalmat. Leegyszerűsítve: a tranzakció a munka logikai egysége, amelynek hatása a tranzakción kívül vagy teljes egészében, vagy egyáltalán nem látható.

Vegyünk egy példát, hogy ezt jobban megértsük. Egy tipikus kiskereskedelmi alkalmazás lefoglalja a készletet, majd megrendelést ad:

Itt azt szeretnénk, ha ez a két művelet együttesen vagy egyáltalán nem történik meg. Ezt úgy érhetjük el, hogy ezeket a műveleteket egyetlen tranzakcióba csomagoljuk.

2.1. Helyi vagy elosztott tranzakció

Egy tranzakció több független műveletet is magában foglalhat. Ezek a műveletek végrehajthat ugyanazon az erőforráson vagy különböző erőforrásokon. Erőforrásként a tranzakcióban részt vevő komponensekre, például egy adatbázisra hivatkozunk.

Az egyetlen erőforráson belüli tranzakciók ismert helyi tranzakciók, míg a több erőforráson keresztül keletkező tranzakciók elosztott tranzakcióként:

Itt a leltár és a megrendelések két táblázat lehetnek ugyanabban az adatbázisban, vagy két különböző adatbázis - esetleg különböző gépeken futhatnak.

2.2. XA specifikáció és Java Transaction API

Az XA az eXtended Architecture-re utal, amely az elosztott tranzakciók feldolgozásának specifikációja. A Az XA célja atomenergia biztosítása a heterogén komponenseket magában foglaló globális tranzakciókban.

Az XA specifikáció integritást biztosít egy kétfázisú elkötelezettség néven ismert protokollon keresztül. A kétfázisú elkötelezettség egy széles körben használt elosztott algoritmus, amely megkönnyíti az elosztott tranzakció végzésére vagy visszavonására vonatkozó döntést.

A Java Transaction API (JTA) egy Java Enterprise Edition API, amelyet a Java Community Process keretében fejlesztettek ki. Azt lehetővé teszi a Java alkalmazások és alkalmazásszerverek számára, hogy elosztott tranzakciókat hajtsanak végre az XA erőforrások között.

A JTA az XA architektúra köré épül, kétfázisú elkötelezettséget kihasználva. A JTA szabványos Java interfészeket határoz meg egy tranzakciókezelő és egy elosztott tranzakció többi résztvevője között.

3. Bevezetés az Atomikoszba

Most, hogy átéltük a tranzakciók alapjait, készek vagyunk megtanulni az Atomikoszot. Ebben a részben megértjük, hogy mi is az Atomikos pontosan, és hogyan viszonyul az olyan fogalmakhoz, mint az XA és a JTA. Megértjük az Atomikos felépítését és áttekintjük termékkínálatát.

3.1. Mi az Atomikosz

Mint láttuk, a JTA interfészeket biztosít a Java-ban elosztott tranzakciókkal rendelkező alkalmazások felépítéséhez. Most a JTA csak specifikáció, és nem kínál semmilyen megvalósítást. Nekünk egy alkalmazás futtatásához, ahol a JTA-t kihasználjuk, szükségünk van a JTA megvalósítására. Az ilyen megvalósítást tranzakciókezelőnek nevezzük.

Általában az alkalmazáskiszolgáló biztosítja a tranzakciókezelő alapértelmezett megvalósítását. Például az Enterprise Java Beans (EJB) esetében az EJB tárolók az alkalmazásfejlesztők kifejezett beavatkozása nélkül kezelik a tranzakció viselkedését. Ez azonban sok esetben nem biztos, hogy ideális, és szükségünk lehet az alkalmazásszervertől független közvetlen ellenőrzésre a tranzakció felett.

Az Atomikos egy könnyű tranzakciókezelő a Java számára amely lehetővé teszi az elosztott tranzakciókat használó alkalmazások önállóságát. Alapvetően az alkalmazásunknak nem kell egy nehézsúlyú komponensre, például egy alkalmazásszerverre támaszkodnia a tranzakciók során. Ez az elosztott tranzakciók fogalmát közelebb hozza a felhő-natív architektúrához.

3.2. Atomikos építészet

Az Atomikos elsősorban JTA tranzakciókezelőként épül fel, és ezért kétfázisú végrehajtási protokollal valósítja meg az XA architektúrát. Nézzük meg az Atomikosz magas szintű architektúráját:

Itt az Atomikos megkönnyíti az adatbázisban és az üzenetsoron átívelő kétfázisú, elkötelezettség-alapú tranzakciót.

3.3. Atomikos termékkínálat

Az Atomikos egy elosztott tranzakciókezelő, amely több funkciót kínál, mint amit a JTA / XA felhatalmaz. Nyílt forráskódú termékkel és sokkal átfogóbb kereskedelmi kínálattal rendelkezik:

  • Alapvető tudnivalók: Atomikos ' nyílt forráskódú termék, amely JTA / XA tranzakciókezelőt biztosít Java alkalmazásokhoz adatbázisokkal és üzenetsorokkal dolgozni. Ez leginkább tesztelési és értékelési célokra hasznos.
  • ExtremeTransactions: az az Atomikos kereskedelmi ajánlata, amely elosztott tranzakciókat kínál összetett alkalmazások között, beleértve a REST szolgáltatásokat, az adatbázisoktól és az üzenetsoroktól eltekintve. Ez hasznos az extrém tranzakciófeldolgozást (XTP) végrehajtó alkalmazások felépítéséhez.

Ebben az oktatóanyagban a TransactionEssentials könyvtárat használjuk az Atomikos képességeinek felépítésére és bemutatására.

4. Az Atomikos felállítása

Amint azt korábban láthattuk, az Atomikos egyik legfontosabb eseménye beágyazott tranzakciós szolgáltatás. Ez azt jelenti, hogy az alkalmazásunkkal megegyező JVM-ben futtathatjuk. Így az Atomikos felállítása meglehetősen egyszerű.

4.1. Függőségek

Először fel kell állítanunk a függőségeket. Itt csak annyit kell tennünk, hogy deklaráljuk a függőségeket Mavenünkben pom.xml fájl:

 com.atomikos tranzakciók-jdbc 5.0.6 com.atomikos tranzakciók-jms 5.0.6 

Ebben az esetben Atomikos-függőségeket használunk a JDBC-hez és a JMS-hez, de hasonló függőségek állnak rendelkezésre a Maven Central-on más XA-panaszos erőforrásokhoz.

4.2. Konfigurációk

Az Atomikos számos konfigurációs paramétert kínál, ésszerű alapértékekkel. A paraméterek felülírása a legegyszerűbb a biztosítja a ügyletek.tulajdonságok fájlt az osztályútvonalon. Számos paramétert adhatunk hozzá a tranzakciós szolgáltatás inicializálásához és működéséhez. Lássunk egy egyszerű konfigurációt a naplófájlok létrehozásának könyvtárának felülírására:

com.atomikos.icatch.file = elérési út_fájljához

Hasonlóképpen vannak más paraméterek is, amelyekkel szabályozhatjuk a tranzakciók időkorlátját, egyedi neveket állíthatunk be alkalmazásunkhoz, vagy meghatározhatjuk a leállási viselkedést.

4.3. Adatbázisok

Oktatóanyagunkban felépítünk egy egyszerű kiskereskedelmi alkalmazást, mint amilyet korábban leírtunk, amely készletet foglal le, majd megrendelést ad le. Az egyszerűség kedvéért relációs adatbázist fogunk használni. Ezenkívül több adatbázist fogunk használni az elosztott tranzakciók bemutatására. Azonban, ez nagyon jól kiterjeszthető más XA-panaszforrásokra, például az üzenetsorokra és a témákra.

Készlet-adatbázisunk egy egyszerű táblázatot tartalmaz a termékleltárak tárolására:

Táblázatkészlet létrehozása (productId VARCHAR PRIMARY KEY, egyenleg INT);

Rendelési adatbázisunkban egy egyszerű táblázat található a leadott megrendelések fogadására:

TÁBLÁZATI RENDELÉSEK LÉTREHOZÁSA (orderId VARCHAR PRIMARY KEY, productId VARCHAR, összeg INT NULL CHECK (összeg <= 5));

Ez egy nagyon egyszerű adatbázis-séma, és csak a bemutatáshoz hasznos. Fontos azonban megjegyezni, hogy a sémakötelezettségünk nem teszi lehetővé az ötnél nagyobb termékmennyiséggel történő rendelést.

5. Munka az Atomikosszal

Most készen állunk az Atomikos könyvtárak használatára, hogy elosztott tranzakciókkal felépítsük alkalmazásunkat. A következő alfejezetekben a beépített Atomikos erőforrás-adaptereket használjuk a háttér-adatbázis-rendszereinkkel való kapcsolódáshoz. Ez a leggyorsabb és legegyszerűbb módszer az Atomikosz használatának megkezdéséhez.

5.1. Instantáló UserTransaction

Kihasználjuk a JTA-t UserTransaction a tranzakciós határok lehatárolásához. Minden a tranzakciószolgáltatással kapcsolatos egyéb lépésekről automatikusan gondoskodunk. Ez magában foglalja az erőforrások felsorolását és törlését a tranzakciós szolgáltatással.

Először példát kell tennünk a UserTransaction az Atomikoszból:

UserTransactionImp utx = new UserTransactionImp ();

5.2. Instantáló Adatforrás

Ezután be kell mutatnunk a Adatforrás az Atomikoszból. Vannak két változata Adatforrás hogy az Atomikos elérhetővé teszi.

Az első, AtomikosDataSourceBean, tisztában van egy mögöttes tényezővel XADataSource:

AtomikosDataSourceBean dataSource = új AtomikosDataSourceBean ();

Míg AtomikosNonXADataSourceBean bármely szokásos JDBC illesztőprogram-osztályt használ:

AtomikosNonXADataSourceBean dataSource = új AtomikosNonXADataSourceBean ();

Ahogy a neve is sugallja, AtomikosNonXADataSource nem XA kompatibilis. Ezért nem garantálható, hogy az ilyen adatforrással végrehajtott tranzakciók atomi jellegűek legyenek. Akkor miért használnánk ezt valaha? Lehet, hogy van olyan adatbázisunk, amely nem támogatja az XA specifikációkat. Az Atomikos nem tiltja, hogy ilyen adatforrást használjunk, és továbbra is megpróbáljuk biztosítani az atomosságot, ha egyetlen ilyen adatforrás van a tranzakcióban. Ez a technika hasonlít a Last Resource Gambit-hoz, amely a kétfázisú végrehajtási folyamat variációja.

Továbbá megfelelően konfigurálnunk kell a Adatforrás az adatbázistól és az illesztőprogramtól függően.

5.3. Adatbázis-műveletek végrehajtása

A konfigurálás után meglehetősen egyszerű használni Adatforrás alkalmazásunk tranzakciójának összefüggésében:

public void placeOrder (String productId, int összeg) dobja a Kivételt {String orderId = UUID.randomUUID (). toString (); logikai visszagörgetés = hamis; próbáld ki az {utx.begin (); Connection inventConnection = készletDataSource.getConnection (); Kapcsolat orderConnection = orderDataSource.getConnection (); S1 utasítás = inventConnection.createStatement (); Karakterlánc q1 = "Készletkészlet frissítése egyenleg = egyenleg -" + összeg + "ahol productId = '" + productId + "'"; s1.executeUpdate (q1); s1.close (); S2 utasítás = orderConnection.createStatement (); Karakterlánc q2 = "beszúrás az Orders értékekbe ('" + orderId + "', '" + productId + "'," + összeg + ")"; s2.executeUpdate (q2); s2.close (); inventConnection.close (); orderConnection.close (); } catch (e kivétel) {rollback = true; } végül {if (! rollback) utx.commit (); else utx.rollback (); }}

Itt frissítjük a készlet és rendelés adatbázis tábláit a tranzakció határán belül. Ez automatikusan előnyt nyújt ezeknek a műveleteknek az atomi úton.

5.4. A tranzakciós viselkedés tesztelése

Végül képesnek kell lennünk tesztelni alkalmazásunkat egyszerű egységtesztekkel annak igazolására, hogy a tranzakciós viselkedés a vártnak felel meg:

@Test public void testPlaceOrderSuccess () dobja a (z) {int összeg = 1 kivételt; long initialBalance = getBalance (készletDataSource, productId); Alkalmazásalkalmazás = új alkalmazás (inventDataSource, orderDataSource); application.placeOrder (productId, mennyiség); hosszú finalBalance = getBalance (készletDataSource, productId); assertEquals (kezdeti mérleg - összeg, végleges egyensúly); } @Test public void testPlaceOrderFailure () dobja a Kivételt {int összeg = 10; long initialBalance = getBalance (készletDataSource, productId); Alkalmazásalkalmazás = új alkalmazás (inventDataSource, orderDataSource); application.placeOrder (productId, mennyiség); hosszú finalBalance = getBalance (készletDataSource, productId); assertEquals (kezdeti mérleg, végleges egyensúly); }

Itt, érvényes megrendelésre számítunk a készlet csökkentésére, míg egy érvénytelen megrendelésre számítunk, ha a készlet változatlan marad. Felhívjuk figyelmét, hogy az adatbázisunkban foglalt korlátozásoknak megfelelően minden olyan megrendelés érvénytelen megrendelésnek minősül, amelynek mennyisége meghaladja az öt terméket.

5.5. Haladó Atomikos használat

A fenti példa az Atomikos használatának legegyszerűbb módja, és talán a legtöbb követelményhez elegendő. Vannak azonban más módok is, amelyek segítségével az Atomikosz felhasználható az alkalmazásunk felépítéséhez. Míg ezek közül néhány opció megkönnyíti az Atomikos használatát, mások nagyobb rugalmasságot kínálnak. A választás az igényeinktől függ.

Természetesen az nem szükséges mindig Atomikos adaptereket használni a JDBC / JMS-hez. Választhatjuk, hogy közvetlenül az Atomikos tranzakciókezelőt használjuk-e XAResource. Ebben az esetben azonban kifejezetten gondoskodnunk kell a felvételről és a törlésről XAResource példányok a tranzakciós szolgáltatással.

Az Atomikos lehetővé teszi a használatát is fejlettebb funkciók egy saját felületen keresztül, UserTransactionService. Ezen felület használatával kifejezetten regisztrálhatjuk az erőforrásokat a helyreállításhoz. Ez alapos ellenőrzést biztosít számunkra, hogy milyen erőforrásokat kell visszaszerezni, hogyan kell visszaszerezni és mikor kell a helyreállításra sor kerülni.

6. Atomikosz integrálása

Bár az Atomikos kiváló támogatást nyújt az elosztott tranzakciókhoz, nem mindig kényelmes ilyen alacsony szintű API-kkal dolgozni. Ahhoz, hogy az üzleti területre összpontosítsunk és elkerüljük a kazánlap kódjának zűrzavarát, gyakran szükségünk van különböző keretek és könyvtárak támogatására. Az Atomikos támogatja a legnépszerűbb Java keretrendszerek nagy részét háttér-integrációkkal kapcsolatos. Párat felfedezünk itt.

6.1. Atomikos tavasszal és Adatforrás

A Spring a Java egyik legnépszerűbb keretrendszere, amely az inverziós vezérlés (IoC) tárolót biztosítja. Különösen fantasztikusan támogatja a tranzakciókat is. Deklaratív tranzakciókezelést kínál Aspect-Oriented Programming (AOP) technikákkal.

A Spring számos tranzakciós API-t támogat, köztük a JTA-t az elosztott tranzakciókhoz. Tudjuk használni Az Atomikos, mint JTA tranzakciókezelőnk a Spring-en belül, sok erőfeszítés nélkül. Ami a legfontosabb, hogy alkalmazásunk jóformán agnosztikus marad az Atomikos számára, tavasznak köszönhetően.

Lássuk, hogyan oldhatjuk meg korábbi problémánkat, ezúttal a Spring hatását. Kezdjük azzal, hogy átírjuk a Alkalmazás osztály:

public class Alkalmazás {private DataSource készletDataSource; privát DataSource orderDataSource; nyilvános alkalmazás (DataSource készletDataSource, DataSource orderDataSource) {this.inventoryDataSource = készletDataSource; this.orderDataSource = orderDataSource; } @Transactional (rollbackFor = Exception.class) public void placeOrder (String productId, int összeg) dobja a Kivételt {String orderId = UUID.randomUUID (). ToString (); Connection inventConnection = készletDataSource.getConnection (); Kapcsolat orderConnection = orderDataSource.getConnection (); S1 utasítás = inventConnection.createStatement (); Karakterlánc q1 = "Készletkészlet frissítése egyenleg = egyenleg -" + összeg + "ahol productId = '" + productId + "'"; s1.executeUpdate (q1); s1.close (); S2 utasítás = orderConnection.createStatement (); Karakterlánc q2 = "beszúrás az Orders értékekbe ('" + orderId + "', '" + productId + "'," + összeg + ")"; s2.executeUpdate (q2); s2.close (); inventConnection.close (); orderConnection.close (); }}

Amint itt láthatjuk, A tranzakcióval kapcsolatos kazán kód kódok nagy részét egyetlen feljegyzés váltotta fel módszer szintjén. Sőt, Spring gondoskodik a példányosításról és az injekció beadásáról Adatforrás, amelytől függ az alkalmazásunk.

Természetesen megfelelő konfigurációkat kell biztosítanunk Spring számára. Egy egyszerű Java osztály segítségével konfigurálhatjuk ezeket az elemeket:

@Configuration @EnableTransactionManagement nyilvános osztály Config {@Bean (initMethod = "init", destrMethod = "bezárás") public AtomikosDataSourceBean inventDataSource () {AtomikosDataSourceBean dataSource = new AtomikosDataSourceBean (); // Adatbázis beállítása a rendelési adatok visszaküldéséhez dataSource; } @Bean (initMethod = "init", destrMethod = "bezárás") public AtomikosDataSourceBean orderDataSource () {AtomikosDataSourceBean dataSource = new AtomikosDataSourceBean (); // Adatbázis beállítása a rendelési adatok visszaküldéséhez dataSource; } @Bean (initMethod = "init", destrMethod = "bezárás") public UserTransactionManager userTransactionManager () dobja a SystemException {UserTransactionManager userTransactionManager = új UserTransactionManager (); userTransactionManager.setTransactionTimeout (300); userTransactionManager.setForceShutdown (true); return userTransactionManager; } @Bean public JtaTransactionManager jtaTransactionManager () dobja a SystemException {JtaTransactionManager jtaTransactionManager = új JtaTransactionManager (); jtaTransactionManager.setTransactionManager (userTransactionManager ()); jtaTransactionManager.setUserTransaction (userTransactionManager ()); return jtaTransactionManager; } @Bean public Application application () {return new Application (inventDataSource (), orderDataSource ()); }}

Itt konfigurálunk AtomikosDataSourceBean a készlet és rendelési adatainkat tároló két különböző adatbázis számára. Ezenkívül a JTA tranzakciókezelő számára is megadjuk a szükséges konfigurációt.

Most már tesztelhetjük az alkalmazásunkat a tranzakciós viselkedés szempontjából, mint korábban. Ismét igazolnunk kell, hogy egy érvényes megrendelés csökkenti a készletegyenlegünket, míg egy érvénytelen megrendelés változatlanul hagyja.

6.2. Atomikos Tavasszal, a JPA-val és a Hibernate-tel

Noha a Tavasz segített nekünk bizonyos mértékig csökkenteni a kazánlap kódját, ez még mindig bőbeszédű. Egyes eszközök még könnyebbé tehetik a munkát a relációs adatbázisokkal a Java-ban. A Java Persistence API (JPA) olyan specifikáció, amely leírja a relációs adatok kezelését a Java alkalmazásokban. Ez nagymértékben leegyszerűsíti az adatokhoz való hozzáférést és a manipulációs kódot.

A hibernálás a JPA specifikáció egyik legnépszerűbb megvalósítása. Az Atomikos nagy támogatást nyújt a JPA több megvalósításához, beleértve a hibernált állapotot is. A tavasznak és a JPA-nak köszönhetően alkalmazásunk az előzőekhez hasonlóan továbbra is agnosztikus az Atomikosz, valamint a Hibernate számára is!

Lássuk, hogyan A Spring, a JPA és a Hibernate még tömörebbé teheti alkalmazásunkat, miközben az elosztott tranzakciók előnyeit biztosítja az Atomikoson. A korábbiakhoz hasonlóan a. Átírásával kezdjük Alkalmazás osztály:

public class Alkalmazás {@Autowired private InventoryRepository inventorRepository; @Autowired private OrderRepository orderRepository; @Transactional (rollbackFor = Exception.class) public void placeOrder (String productId, int összeg) dobja az SQLException {String orderId = UUID.randomUUID (). ToString (); Készletleltár = készletRepository.findOne (productId); invent.setBalance (készlet.getBalance () - összeg); inventRepository.save (készlet); Megrendelés = új Megrendelés (); order.setOrderId (orderId); order.setProductId (productId); order.setAmount (új Long (összeg)); orderRepository.save (rendelés); }}

Mint láthatjuk, most nem foglalkozunk alacsony szintű adatbázis-API-kkal. Ahhoz azonban, hogy ez a varázslat működjön, be kell állítanunk a Spring Data JPA osztályokat és konfigurációkat. Először meghatározzuk domain entitásainkat:

@Entity @Table (name = "INVENTORY") public class Inventory {@Id private String productId; privát Hosszú egyenleg; // Getters and Setters}
@Entity @Table (name = "ORDERS") public class Order {@Id private String orderId; privát String productId; @Max (5) privát Hosszú összeg; // Getters and Setters}

Ezután meg kell adnunk ezeknek az entitásoknak a tárhelyeit:

@Repository nyilvános felület Az InventoryRepository kiterjeszti a JpaRepository {} @Repository nyilvános felületét a OrderRepository kiterjeszti a JpaRepository-t {}

Ezek meglehetősen egyszerű interfészek, és a Spring Data gondoskodik ezek tényleges kóddal történő kidolgozásáról az adatbázis-entitásokkal való együttműködés érdekében.

Végül meg kell adnunk a megfelelő konfigurációkat egy adatforráshoz mind a készlet-, mind a rendelési adatbázisokhoz és a tranzakciókezelőhöz:

@Configuration @EnableJpaRepositories (basePackages = "com.baeldung.atomikos.spring.jpa.inventory", entityManagerFactoryRef = "inventEntityManager", tranzakcióManagerRef = "tranzakcióManager") nyilvános osztály InventoryConfig {@Bean (init = closeMethod = ") public AtomikosDataSourceBean inventDataSource () {AtomikosDataSourceBean dataSource = új AtomikosDataSourceBean (); // Az adatforrás visszaállítása dataSource; } @Bean public EntityManagerFactory inventEntityManager () {HibernateJpaVendorAdapter vendorAdapter = új HibernateJpaVendorAdapter (); LocalContainerEntityManagerFactoryBean factory = new LocalContainerEntityManagerFactoryBean (); gyár.setJpaVendorAdapter (vendorAdapter); // Konfigurálja az entitáskezelő gyári visszatérését factory.getObject (); }}
@Configuration @EnableJpaRepositories (basePackages = "com.baeldung.atomikos.spring.jpa.order", entityManagerFactoryRef = "orderEntityManager", tranzakcióManagerRef = "tranzakcióManager") nyilvános osztály OrderConfig {@Bean (initMethod = "init", megsemmisítés ") public AtomikosDataSourceBean orderDataSource () {AtomikosDataSourceBean dataSource = új AtomikosDataSourceBean (); // Az adatforrás visszaállítása dataSource; } @Bean public EntityManagerFactory orderEntityManager () {HibernateJpaVendorAdapter vendorAdapter = új HibernateJpaVendorAdapter (); LocalContainerEntityManagerFactoryBean factory = new LocalContainerEntityManagerFactoryBean (); gyár.setJpaVendorAdapter (vendorAdapter); // Konfigurálja az entitáskezelő gyári visszatérését factory.getObject (); }}
@Configuration @EnableTransactionManagement nyilvános osztály Config {@Bean (initMethod = "init", destrMethod = "bezárás") public UserTransactionManager userTransactionManager () dobja a SystemException {UserTransactionManager userTransactionManager = új UserTransactionManager (); userTransactionManager.setTransactionTimeout (300); userTransactionManager.setForceShutdown (true); return userTransactionManager; } @Bean public JtaTransactionManageractionManager () dobja a SystemException {JtaTransactionManager jtaTransactionManager = új JtaTransactionManager (); jtaTransactionManager.setTransactionManager (userTransactionManager ()); jtaTransactionManager.setUserTransaction (userTransactionManager ()); return jtaTransactionManager; } @Bean nyilvános alkalmazásalkalmazás () {return new Application (); }}

Ez még mindig elég sok konfiguráció, amit meg kell tennünk. Ez részben annak köszönhető, hogy a Spring JPA-t két külön adatbázis számára konfiguráljuk. Ezenkívül tovább csökkenthetjük ezeket a konfigurációkat a Spring Boot segítségével, de ez meghaladja az oktatóanyag kereteit.

Az eddigiekhez hasonlóan tesztelhetjük alkalmazásunkat ugyanazon tranzakciós viselkedés szempontjából. Ezúttal nincs újdonság, leszámítva azt a tényt, hogy a Spring Data JPA-t most a hibernált állapotban használjuk.

7. Atomikos Beyond JTA

Míg a JTA kiváló tranzakciós támogatást nyújt az elosztott rendszerek számára, ezeknek a rendszereknek XA-panasznak kell lenniük, mint a legtöbb relációs adatbázis vagy üzenetsor. Azonban, A JTA nem hasznos, ha ezen rendszerek egyike nem támogatja az XA specifikációt kétfázisú elkötelező protokollhoz. Számos erőforrás tartozik ebbe a kategóriába, főleg a mikroszolgáltatások architektúráján belül.

Számos alternatív protokoll támogatja az elosztott tranzakciókat. Ezek egyike kétfázisú végrehajtási protokoll variációja, amely kompenzációkat használ. Az ilyen ügyletek nyugodt elszigetelési garanciával rendelkeznek, és kompenzáció alapú tranzakcióknak nevezik őket. A résztvevők a tranzakció egyes részeit magában az első szakaszban kötik le, és a második szakaszban egy esetleges visszavonásért kompenzációs kezelőt ajánlanak fel.

Számos tervezési minta és algoritmus létezik a kompenzáció alapú tranzakció megvalósításához. Például a Sagas egy ilyen népszerű tervezési minta. Ezek végrehajtása azonban általában bonyolult és hajlamos a hibákra.

Az Atomikos a kompenzáció alapú tranzakciók variációját kínálja Try-Confirm / Cancel (TCC) néven.. A TCC jobb üzleti szemantikát kínál a tranzakció alatt álló entitások számára. Ez azonban csak a résztvevők fejlett architektúra támogatásával lehetséges, és a TCC csak az Atomikos kereskedelmi kínálatában, az ExtremeTransactions alatt érhető el.

8. Az Atomikos alternatívái

Eleget éltünk át az Atomikoszon, hogy értékeljük a kínálatát. Sőt, van egy kereskedelmi ajánlat az Atomikos-tól, még erősebb funkciókkal. Azonban az Atomikos nem az egyetlen lehetőség a JTA tranzakciókezelő kiválasztásában. Néhány másik hiteles lehetőség közül lehet választani. Lássuk, hogy áll az Atomikosz ellen.

8.1. Narayana

Narayana az talán az egyik legrégebbi nyílt forráskódú elosztott tranzakciókezelő és jelenleg a Red Hat irányítja. Széles körben használják az iparban, és a közösségi támogatás révén fejlődött, és számos specifikációt és szabványt befolyásolt.

A Narayana számos tranzakciós protokollt támogat, például JTA, JTS, Web-Services és REST, hogy csak néhányat említsünk. Ezenkívül a Narayana számos konténerbe ágyazható.

Az Atomikoszhoz képest a Narayana nagyjából az elosztott tranzakciókezelő összes tulajdonságát biztosítja. Sok esetben a Narayana rugalmasabban integrálható és használható az alkalmazásokban. Például a Narayana rendelkezik nyelvi kötéssel mind a C / C ++, mind a Java számára. Ez azonban a bonyolultság növelésével jár, és az Atomikos viszonylag könnyebben konfigurálható és használható.

8.2. Bitronix

A Bitronix az egy teljesen működő XA tranzakciókezelő, amely biztosítja a JTA API által előírt összes szolgáltatást. Fontos, hogy a Bitronix egy beágyazható tranzakciós könyvtár, amely kiterjedt és hasznos hibajelentést és naplózást biztosít. Elosztott tranzakció esetén ez megkönnyíti a hibák kivizsgálását. Ezenkívül kiválóan támogatja a Spring tranzakciós képességeit, és minimális konfigurációval működik.

Az Atomikoszhoz képest a Bitronix nyílt forráskódú projekt, és terméktámogatással nem rendelkezik kereskedelmi ajánlattal. Az Atomikos kereskedelmi kínálatában szereplő, de a Bitronix-ban hiányzó legfontosabb jellemzők közé tartozik a mikroszolgáltatások támogatása és a deklaratív rugalmas méretezési képesség.

9. Következtetés

Összefoglalva, ebben az oktatóanyagban áttekintettük a tranzakciók alapvető részleteit. Megértettük, hogy mi az elosztott tranzakció, és hogyan segíthet az olyan könyvtár, mint az Atomikos, azok végrehajtásában. Ennek során az Atomikos API-kat kiaknáztuk, hogy egyszerű alkalmazást hozzunk létre elosztott tranzakciókkal.

Megértettük azt is, hogy az Atomikos hogyan működik más népszerű Java keretrendszerekkel és könyvtárakkal. Végül átnéztük az Atomikos néhány rendelkezésünkre álló alternatíváját.

Szokás szerint a cikk forráskódja megtalálható a GitHubon.