Jakarta Transaksjoner - Jakarta Transactions
De Jakarta Transaksjoner ( JTA , tidligere Java Transaction API), en av Jakarta EE APIer , muliggjør distribuert transaksjoner som skal gjøres på tvers av flere X / Open XA ressurser i et Java -miljø. JTA var en spesifikasjon utviklet under Java Community Process som JSR 907. JTA gir:
- avgrensning av transaksjonsgrenser
- X/Open XA API som lar ressurser delta i transaksjoner.
X/Åpen XA -arkitektur
I X/Open XA -arkitekturen koordinerer en transaksjonsbehandler eller transaksjonsbehandlingsmonitor (TP -skjerm) transaksjonene på tvers av flere ressurser, for eksempel databaser og meldingskøer. Hver ressurs har sin egen ressursbehandling. Ressursbehandleren har vanligvis sitt eget API for å manipulere ressursen, for eksempel JDBC API for å arbeide med relasjonsdatabaser. I tillegg lar ressurssjefen en TP -skjerm koordinere en distribuert transaksjon mellom sin egen og andre ressursforvaltere. Til slutt er det applikasjonen som kommuniserer med TP -skjermen for å starte, forplikte eller tilbakeføre transaksjonene. Programmet kommuniserer også med de enkelte ressursene ved å bruke sitt eget API for å endre ressursen.
JTA -implementering av X/Open XA -arkitekturen
JTA API består av klasser i to Java -pakker :
JTA er modellert på X/Open XA -arkitekturen, men den definerer to forskjellige APIer for å avgrense transaksjonsgrenser. Den skiller mellom en applikasjonsserver som en EJB -server og en applikasjonskomponent. Det gir et grensesnitt, javax.transaction.TransactionManagersom brukes av applikasjonsserveren selv for å starte, forplikte og tilbakeføre transaksjonene. Det gir et annet grensesnitt, det javax.transaction.UserTransaction, som brukes av generell klientkode, for eksempel en servlet eller en EJB for å administrere transaksjonene.
JTA -arkitekturen krever at hver ressursbehandling må implementere javax.transaction.xa.XAResourcegrensesnittet for å bli administrert av TP -skjermen. Som nevnt tidligere, vil hver ressurs ha sitt eget spesifikke API, for eksempel:
- relasjonsdatabaser bruker JDBC
- meldingstjenester bruker JMS
- generaliserte EIS ( Enterprise Information System ) ressurser bruker Java EE Connector API .
Applikasjonsprogrammeringsgrensesnitt
Jakarta Transactions API består av tre elementer: et grensesnitt for applikasjonstransaksjoner på et høyt nivå, et transaksjonsbehandlingsgrensesnitt på høyt nivå beregnet for en applikasjonsserver og en standard Java-kartlegging av X/Open XA-protokollen beregnet på en transaksjonell ressursbehandling.
UserTransaction -grensesnitt
Den javax.transaction.UserTransactiongrensesnitt gir programmet muligheten til å kontrollere transaksjons grenser programmatisk. Dette grensesnittet kan brukes av Java -klientprogrammer eller EJB -bønner.
Den UserTransaction.begin()metoden starter en global transaksjon og knytter transaksjonen med kallet tråden. Transaksjon-til-tråd-tilknytningen administreres transparent av Transaction Manager.
Støtte for nestede transaksjoner er ikke nødvendig. Metoden UserTransaction.begin kaster NotSupportedException når anropstråden allerede er knyttet til en transaksjon og implementeringen av transaksjonsbehandling ikke støtter nestede transaksjoner.
Transaksjonskontekstformidling mellom applikasjonsprogrammer er levert av de underliggende transaksjonsbehandlerimplementeringene på klient- og servermaskinene. Transaksjonskontekstformatet som brukes til forplantning er protokollavhengig og må forhandles mellom klienten og serververter. For eksempel, hvis transaksjonslederen er en implementering av JTS -spesifikasjonen, vil den bruke transaksjonsforholdets formasjonsformat som spesifisert i CORBA OTS 1.1 -spesifikasjonen. Transaksjonsformidling er gjennomsiktig for applikasjonsprogrammer.
@Transaksjonell kommentar
Den javax.transaction.Transactionalmerknaden gir programmet muligheten til å kontrollere transaksjons grenser declaratively. Denne merknaden kan brukes på alle klasser som Jakarta EE -spesifikasjonen definerer som en administrert bønne (som inkluderer CDI -administrerte bønner).
Kodeksemplet nedenfor illustrerer bruken av @Transactional i en CDI -administrert bønne med forespørsel.
@RequestScoped
public class ExampleBean {
@Transactional
public void foo() { // A transaction is active here
// Do work
} // After the method returns transaction is committed or rolled back
}
Transaksjonell atferd kan konfigureres via et attributt på merknaden. De tilgjengelige alternativene gjenspeiler de som er i EJB -spesifikasjonen.
@TransactionScoped merknad
Den javax.transaction.TransactionScopedannotering gir anvendelsen evnen til å erklære at omfanget i løpet av hvilken en bønne liv er knyttet til den tid en gitt transaksjon er aktiv.
Kodeksemplet nedenfor illustrerer bruken av @TransactionScoped i en CDI -administrert bønne med forespørsel:
@TransactionScoped
public class TxScopedBean {
public int number;
public int getNumber() {return number;}
public void setNumber(int number) {this.number = number;}
}
@RequestScoped
public class ExampleBean {
@Inject
private TxScopedBean txScopedBean;
@Transactional
public void foo() {
txScopedBean.setNumber(1);
}
@Transactional
public void bar() {
System.out.print(tXscopedBean.getNumber());
}
}
Hvis metode foo () først kalles på en administrert forekomst av ExampleBean og deretter kalles metodelinje () , vil tallet som skrives ut være 0 og ikke 1. Dette er fordi hver metode hadde sin egen transaksjon og derfor sin egen forekomst av TxScopedBean . Tallet 1 som ble angitt under samtalen til foo () vil derfor ikke bli sett under samtalen til linjen () .
UserTransaction -støtte i EJB -server
EJB- servere kreves for å støtte UserTransaction-grensesnittet for bruk av EJB-bønner med BEAN-verdien i javax.ejb.TransactionManagement kommentaren (dette kalles bønnestyrte transaksjoner eller BMT). UserTransaction -grensesnittet blir eksponert for EJB -komponenter enten via EJBContext -grensesnittet ved hjelp av getUserTransaction -metoden, eller direkte via injeksjon ved hjelp av den generelle @Resourcekommentaren. En EJB -applikasjon har derfor ikke et grensesnitt med Transaction Manager direkte for transaksjonsavgrensning; I stedet er EJB -bønnen avhengig av EJB -serveren for å gi støtte for alt sitt transaksjonsarbeid som definert i Jakarta Enterprise Beans Specification. (Det underliggende samspillet mellom EJB -serveren og TM er gjennomsiktig for applikasjonen; byrden ved å implementere transaksjonsstyring er på EJB -beholderen og serverleverandøren.)
Kodeksemplet nedenfor illustrerer bruken av UserTransaction via bønnestyrte transaksjoner i en EJB-sesjonsbønne:
@Stateless
@TransactionManagement(BEAN)
public class ExampleBean {
@Resource
private UserTransaction utx;
public void foo() {
// start a transaction
utx.begin();
// Do work
// Commit it
utx.commit();
}
}
Alternativt kan UserTransaction hentes fra SessionContext:
@Stateless
@TransactionManagement(BEAN)
public class ExampleBean {
@Resource
private SessionContext ctx;
public void foo() {
UserTransaction utx = ctx.getUserTransaction();
// start a transaction
utx.begin();
// Do work
// Commit it
utx.commit();
}
}
Vær imidlertid oppmerksom på at i eksemplet ovenfor, hvis @TransactionManagement(BEAN)merknaden utelates, starter en JTA -transaksjon automatisk når den foo()blir ringt opp, og blir automatisk forpliktet eller rullet tilbake når den foo()avsluttes. Å bruke en UserTransaction er derfor ikke nødvendig i EJB -programmering, men kan være nødvendig for veldig spesialisert kode.
UserTransaction -støtte i JNDI
UserTransaction skal være tilgjengelig under java:comp/UserTransaction(hvis en JTA -implementering er installert i miljøet).
