A Spring és az adatbázis/tranzakció-kezelés

1. a tranzakciókhoz is kell egy connection. A már ismert módon létrehozunk egyet. Szerveres környezetben az alkalmazásunknak nyilván lesz egy előre konfigurált data soruce-a és a connection-t attól is el tudjuk kérni.
2. ez az egyetlen módja annak, hogy Java-ban adatbázis tranzakciót indítsunk! Még úgy is, hogy a neve kicsit félrevezető. A .setAutoCommit(true) (ami az alapértelmezett) esetben minden egyes SQL művelet automatikusan becsomagolódik egy saját tranzakcióba, a .setAutoCommit(false) pedig pont az ellenkezőjét csinálja: mi kezeljük a tranzakciókat és nekünk kell meghívnunk a commit-ot és társait. Az autoCommit flag a connection megnyitott ideje alatt végig érvényes, vagyis a beállítást csak egyszer kell meghívnunk.
3. kommitoljuk a tranzakciónkat
4. vagy rollback-eljük a változásokat ha kivételt kaptunk

És ez a 4 sor (leegyszerűsítve) az amit a Spring is csinál amikor a @Transactional annotációt használjuk. Persze mire odáig eljutunk még sok mindent meg kell ismerni, de nem számít, hogy végül majd a Spring @Transactional annotációját használjuk, vagy Hibernate-et, jOOQ-t vagy bármilyen más adatbáziskezelő keretrendszert. A végén lényegében mind ugyanezt a dolgot csinálja ahhoz, hogy megnyisson és lezárjon (mondjuk úgy: kezeljen) adatbázis tranzakciókat.

CREATE TABLE main.`customer` (

`id` bigint NOT NULL AUTO_INCREMENT,
`first_name` varchar(256) NOT NULL,
`last_name` varchar(256) NOT NULL,
`address` varchar(1024) NOT NULL,
PRIMARY KEY (`id`)

);

Ha a projektünkben sok különféle repository-ban van ugyanaz a metódus akkor csinálhatunk egy saját ős-repository interfészt mindegyikhez, amiben megadjuk a közös metódusokat. Csak annyit kell tennünk, hogy ezt az őst megannotáljuk a NoRepositoryBean annotációval, ebből a Spring tudni fogja, hogy ne csináljon hozzá automatikusan példányt:

package hu.egalizer.template.service;

import org.springframework.stereotype.Service;

import org.springframework.transaction.PlatformTransactionManager;

import org.springframework.transaction.TransactionDefinition;

import org.springframework.transaction.support.TransactionTemplate;

import hu.egalizer.template.domain.Orders;

@Service

public class OrderService {

private final TransactionTemplate template;

public OrderService(PlatformTransactionManager transactionManager) {

template = new TransactionTemplate(transactionManager);

// a tranzakció beállításait akár kézzel is megadhatjuk, ahogy az alábbi példák mutatják

template.setIsolationLevel(TransactionDefinition.ISOLATION_READ_UNCOMMITTED);

template.setTimeout(30); 

}

public Long placeOrder(Orders order) {

Long id = template.execute(status -> {

Long result = null;

// amit itt csinálunk az egy tranzakcióban fog lefutni

return result;

});

return id;

}

}

Itt van két adatbázisműveletünk és egy valószínűleg költséges API hívásunk. Első látásra van értelme az egész metódust transactional-nak jelölni, hiszen azt akarjuk, hogy az egész egy tranzakcióban fusson le. Viszont ha a külső API hívásunk a vártnál hosszabb ideig tart akkor nagyon hamar kifogyhatunk az adatbázis connection-ökből. Már láttuk, hogy mi történik a háttérben, tehát ez esetben:

1. kapunk egy connection-t a pool-ból
2. az első adatbázis hívás után meghívunk egy külső API-t, közben fogjuk a megkapott connection-t
3. miután az API hívás lefutott, elvégezzük a további adatbázisműveleteket

Ha a külső API hívás nagyon lelassul akkor a metódus beragad egy darabig, fogja a connection-t, míg vár a válaszra. Képzeljük el hogy ez a metódus élesben valami miatt egyszercsak tömegesen meghívódik. Nagyon hamar az összes connection várakozni fog egy API hívás miatt, így kifogyunk a szabad adatbázis connection-ökből. Mindezt egy lassú háttérrendszer miatt! Az adatbázisműveleteket más típusú I/O hívásokkal keverni nagyon nem jó ötlet egy tranzakción belül. Ilyen esetekben vagy szervezzük ki a nem oda való kódot a tranzakció belsejéből vagy pedig ha ez ésszerűen nem megoldható akkor használjuk a már megismert TransactionTemplate-et az adatbázisműveletek szeparálására az annotáció helyett.