Frühjahr transaktionalen Kontext nicht die Persistenz der Daten
Ich weiß, dass mein problem ist ein häufiges problem, aber ich habe eine Menge Fragen hier, überprüft Frühling Dokumentation, und ich weiß wirklich nicht, was ich falsch mache.
Mein problem: ich habe eine Spring WebFlow Projekt mit JPA (Umsetzung: OpenJPA + MySQL-Datenbank). Ich benutze Spring ORM zu inject EntityManager (von @PersistenceContext-annotation) zu meinem einfachen RegisterDAO. Ich habe konfiguriert GlassFishs (die ich benutze) Verbindungs-pools für die Verwendung von MySQL und alles funktioniert - ich kann die Arbeit mit meiner Datenbank, aber wenn ich persistierenden etwas - nichts passiert (die Daten sind nicht persistent auf der Datenbank). Ich weiß, dass problem ist mit dem transaktionalen Kontext, die ich benutze. Ich lese in der Dokumentation von Spring Transaction Management, und befolgen Sie die Konfigurationsschritte, die in dieser Dokumentation. Dies ist mein applicationContext.xml:
<?xml version="1.0" encoding="windows-1250"?>
<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:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:jee="http://www.springframework.org/schema/jee"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-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/jee http://www.springframework.org/schema/jee/spring-jee-3.0.xsd
http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-2.0.xsd">
<jee:jndi-lookup id="entityManagerFactory" jndi-name="myPersistenceUnit"/>
<bean class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor"/>
<bean id="registerDaoImpl" class="umk.dumont.db.dao.RegisterDAO" />
<bean id="registerModel" class="umk.dumont.models.RegisterFormModel">
<property name="registerDAO" ref="registerDaoImpl" />
</bean>
<tx:advice id="txAdvice">
<tx:attributes>
<tx:method name="*" />
</tx:attributes>
</tx:advice>
<aop:config>
<aop:pointcut id="registerModelOperation" expression="execution(* umk.dumont.models.RegisterFormModel.*(..))"/>
<aop:advisor advice-ref="txAdvice" pointcut-ref="registerModelOperation"/>
</aop:config>
<bean id="transactionManager" class="org.springframework.transaction.jta.JtaTransactionManager" />
</beans>
Wie Sie sehen können ich bin Injektion RegisterDAO in meine RegisterFormModel, die enthält meine business-Logik für die Validierung registrieren-Formular-Daten und schließlich das hinzufügen von Benutzer-Datenbank. Die Validierung funktioniert einwandfrei, das problem tritt auf, wenn ich versuche neue Benutzer hinzuzufügen. Hier ist der code:
package umk.dumont.models;
...
public class RegisterFormModel implements Serializable {
private String login;
private String password;
private String email;
@Autowired
private RegisterDAO registerDAO = null;
...
public boolean addUser()
{
MyUser user = new MyUser();
user.setLogin(login);
user.setPassword(password);
user.setEmail(email);
return registerDAO.insertUserIntoDB(user) == 0 ? true : false;
}
...
}
RegisterDAO:
public class RegisterDAO implements RegisterDAOInterface, Serializable {
private EntityManager em;
@PersistenceContext
public void setEm(EntityManager em)
{
this.em = em;
}
...
public int insertUserIntoDB(MyUser user)
{
int result = -4;
try {
em.persist(user);
result = 0;
}
catch(Exception ex)
{
ex.printStackTrace();
result = -4;
}
finally {
return result;
}
}
...
}
Habe ich auch schon versucht mit @Transactional-annotation. Ich konfigurierte Frühling applicationContext.xml wie diese:
<?xml version="1.0" encoding="windows-1250"?>
<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:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:jee="http://www.springframework.org/schema/jee"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-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/jee http://www.springframework.org/schema/jee/spring-jee-3.0.xsd
http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-2.0.xsd">
<jee:jndi-lookup id="entityManagerFactory" jndi-name="myPersistenceUnit"/>
<bean class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor"/>
<bean id="registerDaoImpl" class="umk.dumont.db.dao.RegisterDAO" />
<bean id="registerModel" class="umk.dumont.models.RegisterFormModel">
<property name="registerDAO" ref="registerDaoImpl" />
</bean>
<tx:annotation-driven />
<bean id="transactionManager" class="org.springframework.transaction.jta.JtaTransactionManager" />
</beans>
und kommentierte mein addUser () - Methode mit @Transactional-annotation, wie diese:
package umk.dumont.models;
...
public class RegisterFormModel implements Serializable {
private String login;
private String password;
private String email;
@Autowired
private RegisterDAO registerDAO = null;
...
@Transactional
public boolean addUser()
{
MyUser user = new MyUser();
user.setLogin(login);
user.setPassword(password);
user.setEmail(email);
return registerDAO.insertUserIntoDB(user) == 0 ? true : false;
}
...
}
oder sogar kommentierte ganze Klasse durch diese Anmerkung:
package umk.dumont.models;
...
@Transactional
public class RegisterFormModel implements Serializable {
private String login;
private String password;
private String email;
@Autowired
private RegisterDAO registerDAO = null;
...
public boolean addUser()
{
MyUser user = new MyUser();
user.setLogin(login);
user.setPassword(password);
user.setEmail(email);
return registerDAO.insertUserIntoDB(user) == 0 ? true : false;
}
...
}
in beiden Fällen aber problem ist das gleiche - Daten nicht in der Datenbank gespeichert. Gibt es irgendein problem mit meinem AOP proxing, weil ich bin Neuling in diesem (wie auch in den ganzen Frühling :))?
EDIT: In meinem persistence.xml ich bin mit transaction-type="JTA
" also ich denke, ich sollte verwenden <bean id="transactionManager" class="org.springframework.transaction.jta.JtaTransactionManager" />
in meinem applicationContext.xml - habe ich Recht?
InformationsquelleAutor Arek Woźniak | 2011-03-10
Du musst angemeldet sein, um einen Kommentar abzugeben.
In der version des Codes, die verwendet die JPA-entity-manager. Versuchen Sie, hinzufügen von ein em.flush() nach der em.persist() - alle em.persist() tut, ist, befestigen Sie die Einheit an den Persistenz-Kontext.
Das Unternehmen ist nicht 'permanenten' an diesem Punkt.
Sollten Sie nicht auf die em.flush() - aber probieren Sie es aus, um zu sehen, ob es hilft.
Wenn die Transaktion endet dann die Persistenz-Kontext sollte automatisch geleert werden (in die Datenbank geschrieben).
Ich muss sagen du hast Recht komplizierte setup-hier - müssen Sie möglicherweise einige trial & error, es einzugrenzen ist. Hinzufügen JTA in die Mischung könnte die Sache nicht besser - Sie könnten versuchen, mit 'Ressource local' im Frühjahr, bis Sie es zu arbeiten. Gibt es irgendwelche Fehler in den logs ?
INFO: Mit JTA-UserTransaction: com.sun.enterprise.transaction.UserTransactionImpl@13536a8 INFO: die Verwendung von JTA-TransactionManager: com.sun.enterprise.transaction.TransactionManagerHelper@102ff4 INFO: die Verwendung von JTA TransactionSynchronizationRegistry: com.sun.enterprise.transaction.TransactionSynchronizationRegistryImpl@1744bd3 vielen Dank für Ihre Antwort.
Woźniak ich verstehen, dass die endgültige Lösung sollte nicht direkt em.flush. Aber Sie scheinen zu versuchen, viele verschiedene Optionen, so der Vorschlag ist zu verfeinern, unten ein einfacher Testfall, der funktioniert. E. g. ein Junit-test - vielleicht mit Hilfe von in-memory-db - , nur speichert einen Datensatz. Junit-tests markiert @Transactional gerollt werden, wieder bis zum Frühjahr. Sobald Sie haben einfache Konfiguration arbeiten - fügen Sie die zusätzliche Komponenten ? Auch schalten einige debug-Protokollierung vielleicht ?
InformationsquelleAutor David Victor
mein problem gelöst mit
damit Ihre Bohnen werden sollte
hoffen, dass diese Arbeit!
InformationsquelleAutor Wilson Campusano
Vielleicht hilft:
Aus:
http://static.springsource.org/spring/docs/3.0.x/api/org/springframework/orm/jpa/support/PersistenceAnnotationBeanPostProcessor.html
Übrigens - ich habe diese zusätzliche Konfiguration - das gleiche problem 🙁
InformationsquelleAutor Tomasz Nurkiewicz