Jakarta Transaktioner - Jakarta Transactions

De Jakarta Transaktioner ( JTA , tidligere Java Transaktion API), en af de Jakarta EE API'er , muliggør distribuerede transaktioner , der skal gøres på tværs af flere X / Open XA ressourcer i et Java- miljø. JTA var en specifikation udviklet under Java Community Process som JSR 907. JTA giver mulighed for:

  • afgrænsning af transaktionsgrænser
  • X/Open XA API giver ressourcer mulighed for at deltage i transaktioner.

X/Åben XA -arkitektur

I X/Open XA -arkitekturen koordinerer en transaktionsmanager eller transaktionsbehandlingsmonitor (TP -monitor) transaktionerne på tværs af flere ressourcer, f.eks. Databaser og meddelelseskøer. Hver ressource har sin egen ressourceforvalter. Ressourcehåndtereren har typisk sin egen API til manipulation af ressourcen, f.eks. JDBC API til at arbejde med relationsdatabaser. Desuden tillader ressourcestyreren en TP -monitor at koordinere en distribueret transaktion mellem sin egen og andre ressourceforvaltere. Endelig er der applikationen, der kommunikerer med TP -skærmen for at starte, begå eller tilbageføre transaktionerne. Applikationen kommunikerer også med de enkelte ressourcer ved hjælp af deres egen API til at ændre ressourcen.

JTA -implementering af X/Open XA -arkitekturen

JTA API består af klasser i to Java -pakker :

JTA er modelleret efter X/Open XA -arkitekturen, men den definerer to forskellige API'er til afgrænsning af transaktionsgrænser. Det skelner mellem en applikationsserver såsom en EJB -server og en applikationskomponent. Det giver en grænseflade, javax.transaction.TransactionManagerder bruges af applikationsserveren selv til at starte, begå og tilbageføre transaktionerne. Det giver en anden grænseflade, den javax.transaction.UserTransaction, der bruges af generel klientkode, f.eks. En servlet eller en EJB til at styre transaktionerne.

JTA -arkitekturen kræver, at hver ressourcehåndterer skal implementere javax.transaction.xa.XAResourcegrænsefladen for at kunne administreres af TP -skærmen. Som tidligere nævnt vil hver ressource have sin egen specifikke API, for eksempel:

Applikationsprogrammeringsgrænseflade

Jakarta Transactions API består af tre elementer: en grænseflade til afgrænsning af applikationstransaktioner på højt niveau, en transaktionsstyringsinterface på højt niveau beregnet til en applikationsserver og en standard Java-kortlægning af X/Open XA-protokollen beregnet til en transaktionsressourcehåndterer.

UserTransaction -grænseflade

Den javax.transaction.UserTransactioninterface giver ansøgningen mulighed for at styre transaktionsomkostninger grænser programmatisk. Denne grænseflade kan bruges af Java -klientprogrammer eller EJB -bønner.

Den UserTransaction.begin()metode starter en global transaktion og knytter transaktionen med den kaldende tråd. Transaktion-til-tråd-tilknytningen administreres gennemsigtigt af Transaction Manager.

Support til indlejrede transaktioner er ikke påkrævet. Metoden UserTransaction.begin kaster NotSupportedException, når den kaldende tråd allerede er knyttet til en transaktion, og implementeringen af ​​transaktionsstyring ikke understøtter indlejrede transaktioner.

Transaktionskontekstformidling mellem applikationsprogrammer leveres af de underliggende transaktionsstyringsimplementeringer på klient- og servermaskinerne. Transaktionskontekstformatet, der bruges til spredning, er protokolafhængigt og skal forhandles mellem klienten og serverværterne. For eksempel, hvis transaktionsadministratoren er en implementering af JTS -specifikationen, vil den bruge transaktionskontekstformationsformatet som specificeret i CORBA OTS 1.1 -specifikationen. Transaktionsformidling er gennemsigtig for applikationsprogrammer.

@Transaktionel kommentar

Den javax.transaction.Transactionalanmærkning giver ansøgningen mulighed for at styre transaktionsomkostninger grænser declaratively. Denne kommentar kan anvendes på enhver klasse, som Jakarta EE -specifikationen definerer som en administreret bønne (som inkluderer CDI -administrerede bønner).

Nedenstående kodeeksempel illustrerer brugen af ​​@Transactional i en CDI -administreret bønne, der er omfattet af en anmodning: 

@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
}

Transaktionsadfærd kan konfigureres via en attribut på annotationen. De tilgængelige muligheder afspejler nøje de i EJB -specifikationen.

@TransactionScoped annotation

Den javax.transaction.TransactionScopedanmærkning giver ansøgningen mulighed for at erklære, at omfanget i hvilket en bønne liv er bundet til den tid, en given transaktion er aktiv.

Nedenstående kodeeksempel illustrerer brugen af ​​@TransactionScoped i en CDI -administreret bønne, der er omfattet af en anmodning: 

@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 kaldes til en administreret forekomst af ExampleBean og derefter kaldes metodebjælke () , vil det udskrevne tal være 0 og ikke 1. Dette skyldes, at hver metode havde sin egen transaktion og derfor sin egen forekomst af TxScopedBean . Nummeret 1, der blev indstillet under opkaldet til foo (), vil derfor ikke blive set under opkaldet til linjen () .

Support af UserTransaction i EJB -server

EJB- servere skal understøtte UserTransaction-grænsefladen til brug af EJB-bønner med BEAN-værdien i javax.ejb.TransactionManagement annotationen (dette kaldes bønnestyrede transaktioner eller BMT). UserTransaction -grænsefladen udsættes for EJB -komponenter via enten EJBContext -grænsefladen ved hjælp af getUserTransaction -metoden eller direkte via injektion ved hjælp af den generelle @Resourcekommentar. En EJB -applikation har således ikke grænseflade med Transaction Manager direkte til transaktionsafgrænsning; i stedet er EJB -bønnen afhængig af, at EJB -serveren understøtter alt sit transaktionsarbejde som defineret i Jakarta Enterprise Beans Specification. (Den underliggende interaktion mellem EJB -serveren og TM er gennemsigtig for applikationen; byrden ved at implementere transaktionsstyring er på EJB -containeren og serverudbyderen.)

Nedenstående kodeeksempel illustrerer brugen af ​​UserTransaction via bønnestyrede transaktioner i en EJB-sessionbø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();
    }
}

Bemærk dog, at i eksemplet ovenfor, hvis @TransactionManagement(BEAN)annotationen udelades, startes en JTA -transaktion automatisk, når foo()der kaldes til den, og den bliver automatisk begået eller rullet tilbage, når den foo()forlades. Det er derfor ikke nødvendigt at bruge en UserTransaction i EJB -programmering, men kan være nødvendig for meget specialiseret kode.

Support af UserTransaction i JNDI

UserTransaction skal være tilgængelig under java:comp/UserTransaction(hvis en JTA -implementering er installeret i miljøet).

Se også

Referencer

eksterne links