close

Java-transactie-API

Spring naar navigatie Spring naar zoeken

De Java Transaction API ( JTA ) is een van de API's die wordt aangeboden door de Java EE (Java Enterprise Edition) en is bedoeld om gedistribueerde transacties mogelijk te maken die worden uitgevoerd over meerdere X/Open XA- bronnen in een Java- omgeving . JTA is een specificatie die is ontwikkeld onder de richtlijnen van het Java Community Process als JSR 907 . De JTA voorziet in:

  • een afbakening van de transactiegrenzen.
  • van de X / Open XA API's waarmee resources kunnen deelnemen aan transacties.

X / Open XA-architectuur

In deze architectuur coördineert een Transaction Manager of een Transaction Processing-monitor (TP-monitor) transacties over meerdere bronnen, zoals databases of berichtenwachtrijen. Elke resource heeft zijn eigen Resource Manager. De Resource Manager gebruikt doorgaans zijn eigen API's om bronnen te manipuleren, zoals JDBC API's laten werken met relationele databases. De Resource Manager stelt een TP-monitor ook in staat om een ​​gedistribueerde transactie tussen zichzelf en andere Resource Managers te coördineren. Ten slotte start de applicatie die communiceert met de TP-monitor om typische transactiebewerkingen uit te voeren, zoals start (begin), commit en rollback . De applicatie communiceert ook met individuele bronnen om deze te wijzigen, met behulp van zijn eigen API.

Implementatie van de JTA in de X / Open XA-architectuur

De JTA API bestaat uit een reeks klassen die zijn onderverdeeld in de volgende twee Java-pakketten :

De JTA is gebouwd op het model van de X / Open XA-architectuur, maar definieert twee verschillende API's voor het afbakenen van transactiegrenzen. Er wordt onderscheid gemaakt tussen een applicatieserver zoals een EJB -server en een applicatiecomponent. Het biedt een javax.transaction.TransactionManager -interface , die door de eigenlijke applicatieserver wordt gebruikt voor het starten van transacties, commits en rollbacks. Het biedt ook een andere interface, javax.transaction.UserTransaction , die wordt gebruikt door generieke klantcode, zoals een servlet of EJB, om transacties te beheren.

De JTA-architectuur vereist dat elke resourcemanager de javax.transaction.xa.XAResource -interface implementeert om te worden beheerd door de TP-monitor. Zoals hierboven uitgelegd, heeft elke bron zijn eigen specifieke API, bijvoorbeeld:

  • Relationele databases gebruiken JDBC
  • Berichtenservices gebruiken JMS
  • Resources van het Generalized Enterprise Information System (EIS) maken gebruik van de Java EE Connector Architecture.

Java-transactie-API

De Java Transaction API bestaat uit drie elementen: een transactiedemarcatie-interface op hoog niveau in de applicatie, een altijd hoogwaardige Transaction Manager-interface en een standaard Java-toewijzing van het X/Open XA-protocol bedoeld voor een transactionele Resource Manager.

Gebruikerstransactie -interface

De javax.transaction.UserTransaction -interface biedt de toepassing de mogelijkheid om transactielimieten programmatisch te controleren. Deze interface kan worden gebruikt door Java-programma's aan de clientzijde of EJB-bonen.

De methode begin () start een globale transactie en koppelt deze aan de aanroepende thread. De transactie-naar-thread-associatie wordt transparant afgehandeld door de Transactiemanager.

Er is geen ondersteuning vereist voor geneste transacties. De methode begin () genereert de NotSupportedException wanneer de thread al aan een transactie is gekoppeld en de implementatie van Transaction Manager geen geneste transacties ondersteunt.

De context waarin de transactie zich tussen applicaties voortplant, wordt toegewezen door de achtergrondimplementaties van de Transactiemanagers op de client- en servermachines. Het contextformaat dat wordt gebruikt voor verspreiding is protocolafhankelijk en moet worden onderhandeld tussen de client- en serverhosts. Als de Transactiemanager bijvoorbeeld een implementatie is van de JTS- specificatie , zal deze degene gebruiken die is gespecificeerd in CORBA OTS 1.1. Transactievoortplanting is transparant voor de applicatie.

@Transactionele annotatie

De annotatie javax.transaction.Transactional biedt de toepassing de mogelijkheid om transactielimieten declaratief te controleren. Deze annotatie kan worden toegepast op elke klasse die door Java EE wordt gedefinieerd als een beheerde bean (inclusief door CDI beheerde bonen).

Het onderstaande codevoorbeeld illustreert het gebruik van @Transactional in een bereik waar door CDI beheerde bonen vereist zijn: 

@RequestScoped 
openbare  klasse  VoorbeeldBean  {

    @Transactional 
    public  void  foo ()  {  // De transactie is hier actief
        
        // Voer wat code uit

    }  // Na de terugkeer wordt de transactie vastgelegd of teruggedraaid 
}

Het transactiegedrag kan worden geconfigureerd met een attribuut in de annotatie.

@TransactionScoped annotatie

De annotatie javax.transaction.TransactionScoped biedt de applicatie de mogelijkheid om aan te geven dat de reikwijdte waarin een Bean leeft, gerelateerd is aan de tijd waarin een bepaalde transactie actief is.

Het onderstaande codevoorbeeld toont het gebruik van @TransactionScoped in een bereik waar door CDI beheerde bonen vereist zijn: 

@TransactionScoped 
public  class  TxScopedBean  { 
    public  int  number ;

    public  int  getNumber ()  { return  number ;} 
    public  void  setNumber ( int  number )  { this . getal  =  getal ;} 
}

@RequestScoped 
openbare  klasse  VoorbeeldBean  {

    @Inject 
    privé  TxScopedBean  txScopedBean ;

    @Transactional 
    public  void  foo ()  { 
        txScopedBean . setNummer ( 1 ); 
    }

    @Transactional 
    public  void  bar ()  { 
        Systeem . uit . print ( tXscopedBean . getNumber ()); 
    } 
}

Als de foo () -methode eerst wordt aangeroepen op een beheerd exemplaar van VoorbeeldBean en vervolgens de bar () -methode wordt aangeroepen , is het nummer dat op het scherm wordt afgedrukt 0 en niet 1. Dit komt omdat elke methode zijn eigen transactie heeft en daarom ook het eigen exemplaar van TxScopedBean. Het nummer 1 dat wordt toegekend tijdens de oproep naar foo () zal dus niet zichtbaar zijn tijdens de oproep naar bar () .

UserTransaction- ondersteuning op EJB-servers

EJB - servers moeten de UserTransaction -interface ondersteunen voor gebruik door EJB-beans met de BEAN-waarde in de annotatie javax.ejb.TransactionManagement (dit wordt bean-managed transactie of BMT genoemd). De UserTransaction -interface wordt blootgesteld aan EJB-componenten via zowel de EJBContext-interface met behulp van de getUserTransaction-methode als rechtstreeks met behulp van de generieke @Resource- annotatie . Daarom heeft een EJB-toepassing geen directe interface met de Transactiemanager voor het afbakenen van transacties; in plaats daarvan vertrouwen de EJB-beans op de EJB-server om ondersteuning te bieden voor al zijn transactiewerk, zoals gedefinieerd in de Enterprise JavaBeans-specificatie. (De onderliggende interactie tussen EJB Server en TM is transparant voor de applicatie; de ​​last van het implementeren van transactiebeheer ligt bij de EJB-container en serverprovider.)

De onderstaande voorbeeldcode demonstreert het gebruik van UserTransaction via door bean beheerde transacties in een EJB Bean-sessie: 

@Stateless 
@TransactionManagement ( BEAN ) 
openbare  klasse  VoorbeeldBean  {

    @Resource 
    privé  UserTransaction  utx ;

    public  void  foo ()  { 
        // start een transactie 
        utx . beginnen ();

        // Werken

        // Commit het 
        utx . plegen (); 
    } 
}

Als alternatief kan de UserTransaction worden verkregen via de SessionContext : 

@Stateless 
@TransactionManagement ( BEAN ) 
openbare  klasse  VoorbeeldBean  {

    @Resource 
    privé  SessionContext  ctx ;

    public  void  foo ()  { 
        UserTransaction  utx  =  ctx . getUserTransaction ();

        // start een transactie 
        utx . beginnen ();

        // Werken

        // Commit het 
        utx . plegen (); 
    } 
}

Merk op dat als in het voorbeeld de @TransactionManagement (BEAN)-annotatie was weggelaten, een JTA-transactie automatisch zou zijn gestart wanneer foo () wordt aangeroepen en, opnieuw automatisch, een commit en rollback zouden plaatsvinden bij het verlaten van foo ( ) . Het gebruik van een UserTransaction is daarom niet nodig bij EJB-programmering, maar kan vereist zijn in meer gespecialiseerde code.

UserTransaction- ondersteuning in JNDI

UserTransaction is beschikbaar onder java: comp / UserTransaction , als er een JTA-implementatie in uw omgeving is geïnstalleerd.

Open source implementaties voor de JTA

Enkele open source-implementaties voor de JTA staan ​​hieronder vermeld (vanaf september 2010):

  • Narayana
  • Atomikos TransactiesEssentiëlen
  • Bitronix JTA

Gerelateerde items

Externe links

Opgehaald van " https://it.wikipedia.org/w/index.php?title=Java_Transaction_API&oldid=121476405 "