TransactionRequiredException Ausführen einer Aktualisierungs-/Löschabfrage

Hallo, ich verwende Hibernate JPA mit Spring und Mongodb und führe meine Anwendung auf Glassfish-4.0 aus.

Meine Serviceklasse ist:

@Component
public class Test {
    @PersistenceContext
    EntityManager em;
    EntityManagerFactory emf;

    @Transactional
    public String persist(Details details) {
        details.getUsername();
        details.getPassword();

        Query query = em.createNativeQuery("db.details.find(username="+details.getUsername()+"&password="+details.getPassword());

        em.getTransaction().begin();
        em.persist(details);
        em.getTransaction().commit();
        em.flush();
        em.clear();
        em.close();
        query.executeUpdate();
        System.out.println("Sucessful!");
        return "persist";        
    }
}

Und meine spring-context.xml ist:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/tx
    http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.0.xsd
    http://www.springframework.org/schema/mvc
    http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">

    <context:component-scan base-package="com.javapapers.spring.mvc" />
    <context:annotation-config />
    <mvc:annotation-driven />
    <tx:annotation-driven transaction-manager="txManager" />
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/view/" />
        <property name="suffix" value=".jsp" />
    </bean>
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalEntityManagerFactoryBean">
        <property name="persistenceUnitName" value="ogmTest"/>
    </bean>
    <bean id="txManager" class="org.springframework.transaction.jta.JtaTransactionManager">
    </bean>
</beans>

Ich habe einige Änderungen im Code vorgenommen, aber sie haben keine Auswirkungen. Kann mir bitte jemand helfen, das zu klären. Danke im Voraus.

Ich bin mir nicht sicher, ob dies Ihrer Situation helfen wird (das heißt, wenn es noch existiert), nachdem ich das Internet nach einem ähnlichen Problem durchsucht habe.

Ich habe eine native Abfrage aus einem Persistenz-EntityManager erstellt, um ein Update durchzuführen.

Query query = entityManager.createNativeQuery(queryString);

Ich habe die folgende Fehlermeldung erhalten:

verursacht durch: javax.persistence.TransactionRequiredException: Ausführen einer Aktualisierungs-/Löschabfrage

Viele Lösungen schlagen vor, @Transactional zu Ihrer Methode hinzuzufügen. Allein dies hat den Fehler nicht geändert.

Einige Lösungen schlagen vor, den EntityManager nach a zu fragen EntityTransaction damit Sie beginnen und sich verpflichten können. Dies wirft einen weiteren Fehler:

verursacht durch: java.lang.IllegalStateException: Es ist nicht erlaubt, eine Transaktion auf einem gemeinsam genutzten EntityManager zu erstellen – verwenden Sie stattdessen Spring-Transaktionen oder EJB CMT

Ich habe dann eine Methode ausprobiert, von der die meisten Websites sagen, dass sie zur Verwendung von anwendungsverwalteten Entitätsmanagern und nicht von Containern verwaltet wird (was meiner Meinung nach Spring ist), und das war joinTransaction().

Haben @Transactional die Methode dekorieren und dann aufrufen joinTransaction() auf dem EntityManager-Objekt kurz vor dem Aufruf query.executeUpdate() und meine native Abfrageaktualisierung funktionierte.

Ich hoffe, dies hilft jemand anderem, der dieses Problem hat.

In meinem Fall hatte ich das falsche @Transactional importiert.

Das Richtige ist:

import org.springframework.transaction.annotation.Transactional;

und nicht

import javax.transaction.Transactional;

Ich habe auch das gleiche Problem, wenn ich mit Hibernate und Spring Jpa Data Repository arbeite. Ich habe vergessen zu platzieren @Transactional auf Spring Data Repository-Methode.

Es funktioniert für mich nach dem Kommentieren mit @Transactional.

Aus der Konfigurations-XML ist klar, dass Sie eine frühlingsbasierte Transaktion verwenden werden. Bitte stellen Sie sicher, dass der Import, den Sie verwenden, für @Transactional ist “org.springframework.transaction.annotation.Transactional”

in deinem Fall könnte es sein “javax.transaction.Transaktional”

Ich habe diese Ausnahme erhalten, als ich versuchte, eine Massen-UPDATE-Abfrage in einem Entitätsmanager ohne JTA (d. h. ressourcenlokal) in Java SE auszuführen. Ich hatte einfach vergessen, meinen JPQL-Code einzufügen

em.getTransaction().begin();

und

em.getTransaction().commit();

Ich habe den gleichen Fehler.

Ich habe gerade die hinzugefügt @Transaktion Anmerkung von javax.transaction.Transaktional auf die Methode.

Aktualisieren:

Ich würde die Verwendung von Spring empfehlen @Transactional Anmerkung von org.springframework.transaction.annotation.Transactional;

Die Verwendung von @Modifying und @Transaction hat mich behoben

1. @Modifying @Query(value=”DELETE FROM lock WHERE user_id = ?1″ ,nativeQuery=true) void deleteByUserId(Long userId);

2. @Service @Transaktional