Comment utiliser Atomikos Transaction Essentials avec Hibernate >= 4.3

Je suis passé de mise en veille prolongée 4.2 mise en veille prolongée 4.3 et mon projet n'est pas de travail, pas plus. Je suis un

HibernateException: Impossible de localiser actuel transaction JTA

quand je fais

Session s = sessionFactory.getCurrentSession();

J'ai réalisé que org.mise en veille prolongée.des transactions.TransactionManagerLookup n'existe plus. Il a été supprimé en veille prolongée 4.3. Comment dois-je changer ma configuration actuelle?

<hibernate-configuration>
<session-factory>
    <property name="connection.datasource">testDS</property>

    <property name="current_session_context_class">jta</property>
    <property name="transaction.manager_lookup_class">com.atomikos.icatch.jta.hibernate3.TransactionManagerLookup</property>
    <property name="transaction.factory_class">org.hibernate.transaction.CMTTransactionFactory</property>
    <property name="connection.release_mode">auto</property>
    <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>

    <property name="hibernate.hbm2ddl.auto">create-drop</property>
    <property name="hibernate.show_sql">true</property>
    <mapping class="test.entities.Person" />
    <mapping class="test.entities.CreditCard" />
    <mapping class="test.entities.ExampleRevEntity" />
</session-factory>

OriginalL'auteur sebplorenz | 2013-12-19

7

En veille prolongée 4.3 le long obsolète TransactionManagerLookup est supprimé. Maintenant, le JTA fournisseur doit mettre en œuvre org.mise en veille prolongée.moteur.des transactions.jta.la plate-forme.le spi.JtaPlatform. Un résumé de la mise en œuvre de la JTA Plate-forme est déjà disponible dans Hibernate à savoir org.mise en veille prolongée.moteur.des transactions.jta.la plate-forme.interne.AbstractJtaPlatform. L'utilisation de ce il est assez simple à écrire un JTA Plate-forme pour Atomikos:
```
package test;

import javax.transaction.TransactionManager;
import javax.transaction.UserTransaction;
import org.hibernate.engine.transaction.jta.platform.internal.AbstractJtaPlatform;
import com.atomikos.icatch.jta.UserTransactionManager;

public class AtomikosJtaPlatform extends AbstractJtaPlatform {

  private static final long serialVersionUID = 1L;
  private UserTransactionManager utm;

  public AtomikosJtaPlatform() {
    utm = new UserTransactionManager();
  }

  @Override
  protected TransactionManager locateTransactionManager() {
    return utm;
  }

  @Override
  protected UserTransaction locateUserTransaction() {
    return utm;
  }
}
```
En outre, le nom de la plate-forme de mise en œuvre de la classe doit être ajouté à la hibernate:
```
<property name="hibernate.transaction.jta.platform">test.AtomikosJtaPlatform</property>
```
Super réponse! Je me battais pour un jour et demi. Savez-vous si il existe un moyen de Printemps à utiliser mon défini précédemment transactionManager et un usertransaction haricots au lieu de créer un nouveau ici?
Salut Eric, le problème est que Hibernate va créer une nouvelle instance de la JTA plate-forme au démarrage. Il n'existe aucun moyen pour injecter un Ressort créé JTA plate-forme avec son Ressort créé gestionnaire de transactions en Hibernation (autant que je sache). Ce que vous pourriez faire est de faire des références à la transaction de l'utilisateur et le gestionnaire de transactions statique dans le JTA Plate-forme. Puis créez tout dans le Ressort du contexte avant Hibernate fait de la première utilisation de la JTA plate-forme.
Je l'ai eu vers le printemps problème de l'injection par la création d'une Classe qui implémente l'ApplicationContextAware interface pour permettre la appCtx et modifier le AtomikosJtaPlatform classe pour aller chercher de l'un usertransaction à partir du printemps contexte à chaque fois : @Override protected TransactionManager locateTransactionManager() { return SpringContext.getcontexteapplication().getBean("atomikosTransactionManager", UserTransactionManager.class); }
Je suis en train d'utiliser atomikos tm pour jbpm moteur d'exécution. J'ai mis en œuvre personnalisée plate-forme de mise en œuvre et la mise à jour hibernate plate-forme de l'entrée en persistance.xml mais je suis en dessous exception - Causé par: javax.la persistance.TransactionRequiredException: Explicitement de rejoindre une transaction JTA nécessite une transaction JTA être actuellement active au org.mise en veille prolongée.interne.SessionImpl.joinTransaction(SessionImpl.java:3766) at org.mise en veille prolongée.interne.SessionImpl.joinTransaction(SessionImpl.java:3751)

OriginalL'auteur sebplorenz

À utiliser Hibernate JTA Plate-forme avec le Printemps, d'écrire et de compiler ce code

package my.domain.spring.hibernate.jta;

import javax.transaction.TransactionManager;
import javax.transaction.UserTransaction;

import org.hibernate.engine.transaction.jta.platform.internal.AbstractJtaPlatform;
import org.springframework.transaction.jta.JtaTransactionManager;
import org.springframework.util.Assert;

@SuppressWarnings("serial")
public class SpringJtaPlatformAdapter extends AbstractJtaPlatform {

    private static TransactionManager sTransactionManager;
    private static UserTransaction sUserTransaction;


    @Override
    protected TransactionManager locateTransactionManager() {
        Assert.notNull(sTransactionManager, "TransactionManager has not been setted");
        return sTransactionManager;
    }


    @Override
    protected UserTransaction locateUserTransaction() {
        Assert.notNull(sUserTransaction, "UserTransaction has not been setted");
        return sUserTransaction;
    }


    public void setJtaTransactionManager(JtaTransactionManager jtaTransactionManager) {
        sTransactionManager = jtaTransactionManager.getTransactionManager();
        sUserTransaction = jtaTransactionManager.getUserTransaction();
    }


    public void setTransactionManager(TransactionManager transactionManager) {
        sTransactionManager = transactionManager;
    }


    public void setUserTransaction(UserTransaction userTransaction) {
        sUserTransaction = userTransaction;
    }

}

Ajouter dans votre printemps-configuration

  <bean id="txObjcoreManager" class="org.springframework.transaction.jta.JtaTransactionManager">
        <property name="transactionManager">
            <bean class="com.atomikos.icatch.jta.UserTransactionManager" init-method="init" destroy-method="close">
                <property name="forceShutdown" value="true" />
            </bean>
        </property>
        <property name="userTransaction">
            <bean class="com.atomikos.icatch.jta.UserTransactionImp">
                <property name="transactionTimeout" value="300" />
            </bean>
        </property>
    </bean>

    <bean id="springJtaPlatformAdapter" class="my.domain.spring.hibernate.jta.SpringJtaPlatformAdapter">
        <property name="jtaTransactionManager" ref="txObjcoreManager" />
    </bean>

N'oubliez pas d'ajouter une dépendance

<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean"
        depends-on="springJtaPlatformAdapter">

Et enfin la modification de hibernate configuration comme celle - hibernate.transaction.jta.platform=my.domain.spring.hibernate.jta.SpringJtaPlatformAdapter

OriginalL'auteur Anton Lem

Un indice pour le Printemps utilisateurs - il suffit d'utiliser cette application si vous l'installation des trucs avec de l'usine bean:

public class AtomikosPlatform extends AbstractJtaPlatform {

  private static final long serialVersionUID = -1L;

  @Override
  protected TransactionManager locateTransactionManager() {
    return new J2eeTransactionManager();
  }

  @Override
  protected UserTransaction locateUserTransaction() {
    return new J2eeUserTransaction();
  }

}

OriginalL'auteur Torsten Krah

Vous pouvez essayer le réglage de la jtaTransactionManager propriété de org.springframework.orm.hibernate4.LocalSessionFactoryBean pour le Printemps JtaTransactionManager? J'ai le même problème mais résolu par la présente. Par ailleurs, la HibernateTemplate est de retour sur le Printemps 4.0.1. Bien qu'il n'est pas recommandé, mais j'aime l'utiliser. Il a aidé à prendre soin de beaucoup de choses. (Je suis en utilisant le Printemps 4.0.5 + Hibernate 4.3.5 + Atomikos 3.9.3)

<bean id="atomikosTransactionManager" class="com.atomikos.icatch.jta.UserTransactionManager" init-method="init" destroy-method="close" depends-on="userTransactionService">
<property name="forceShutdown" value="true" />
</bean>
<bean id="atomikosUserTransaction" class="com.atomikos.icatch.jta.UserTransactionImp" depends-on="userTransactionService">
<property name="transactionTimeout" value="180" />
</bean>
<bean id="JtaTransactionManager" class="org.springframework.transaction.jta.JtaTransactionManager">
<property name="transactionManager" ref="atomikosTransactionManager" />
<property name="userTransaction" ref="atomikosUserTransaction" />
<property name="allowCustomIsolationLevels" value="true"></property>
</bean>
<bean id="rentSessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
<property name="dataSource"><ref bean="rentXADataSource" /></property>
<property name="mappingLocations" value="classpath:com/kj/model/web/*.hbm.xml"/>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.SQLServerDialect</prop>
<prop key="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</prop>
<prop key="hibernate.show_sql">false</prop>
<prop key="hibernate.transaction.factory_class">org.hibernate.transaction.CMTTransactionFactory</prop>          
<prop key="hibernate.cache.use_query_cache">true</prop> 
<prop key="hibernate.cache.use_second_level_cache">true</prop>
<prop key="hibernate.format_sql">false</prop>
<prop key="hibernate.bytecode.use_reflection_optimizer">true</prop>
</props>
</property>
<property name="jtaTransactionManager" ref="JtaTransactionManager"></property>
</bean>

OriginalL'auteur Po-Ting Huang

Ce qui suit est une approche alternative qui fonctionne avec la configuration Spring. C'est différent d'Anton dans une démarche qui ne repose pas sur une méthode d'instance de l'écriture d'un champ statique (ce qui est généralement considéré comme une mauvaise pratique).

@SuppressWarnings("serial")
public class AtomikosJtaPlatform extends AbstractJtaPlatform {
private static TransactionManager transactionManager;
private static UserTransaction userTransaction;
public static void factoryInit(TransactionManager transactionManager, UserTransaction userTransaction) {
AtomikosJtaPlatform.transactionManager = transactionManager;
AtomikosJtaPlatform.userTransaction = userTransaction;
}
@Override
protected TransactionManager locateTransactionManager() {
return transactionManager;
}
@Override
protected UserTransaction locateUserTransaction() {
return userTransaction;
}
}

Puis au Printemps de configuration:

    <bean id="AtomikosTransactionManager" class="com.atomikos.icatch.jta.UserTransactionManager" init-method="init"
destroy-method="close">
<property name="startupTransactionService" value="false" />
<property name="forceShutdown" value="false" />
</bean>
<bean id="AtomikosUserTransaction" class="com.atomikos.icatch.jta.UserTransactionImp">
<property name="transactionTimeout" value="300" />
</bean>
<!-- AtomikosJtaPlatform is created by Hibernate using reflection. This ensures it uses our Spring configured beans --> 
<bean id="JtaPlatformInitializer" class="org.springframework.beans.factory.config.MethodInvokingBean">
<property name="targetClass" value="com.mycompany.a.b.AtomikosJtaPlatform" />
<property name="targetMethod" value="factoryInit" />
<property name="arguments">
<list>
<ref bean="AtomikosTransactionManager" />
<ref bean="AtomikosUserTransaction" />
</list>
</property>
</bean>
<bean id="emf" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean" depends-on="JtaPlatformInitializer">
<property name="jpaProperties">
<props>
<prop key="hibernate.transaction.jta.platform">com.mycompnay.a.b.AtomikosJtaPlatform</prop>
...

OriginalL'auteur The Gilbert Arenas Dagger

Vous devez vous connecter pour publier un commentaire.