title: JPA Transaction not committed to DB
body: <p>I'm working on a small Spring-Hibernate-Mysql test project and for some reason I my transactions are not getting committed to the DB.</p>
  
  <p>In my application-context I got:</p>
  
  <pre><code>&lt;!-- JTA --&gt;
  
  &lt;bean id="txManager" class="org.springframework.orm.jpa.JpaTransactionManager"&gt;
      &lt;property name="entityManagerFactory" ref="entityManagerFactory" /&gt;
  
  &lt;/bean&gt;
  
  &lt;tx:annotation-driven transaction-manager="txManager" /&gt;
  
  &lt;!-- JPA --&gt;
  
  &lt;jee:jndi-lookup id="entityManagerFactory" jndi-name="persistence/myPU" /&gt;
  
  &lt;!-- In order to enable EntityManager injection --&gt;
  &lt;bean
      class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor"&gt;
      &lt;property name="persistenceUnits"&gt;
          &lt;map&gt;
              &lt;entry key="myPU" value="persistence/myPU" /&gt;
          &lt;/map&gt;
      &lt;/property&gt;
  &lt;/bean&gt;
  </code></pre>
  
  <p>My persistence.xml:</p>
  
  <pre><code>&lt;persistence-unit name="myPU" transaction-type="JTA"&gt;
      &lt;provider&gt;org.hibernate.ejb.HibernatePersistence&lt;/provider&gt;
      &lt;jta-data-source&gt;jdbc/mysqlResource&lt;/jta-data-source&gt;
      &lt;properties&gt;
          &lt;property name="hibernate.connection.shutdown" value="true" /&gt;
          &lt;property name="hibernate.dialect" value="org.hibernate.dialect.MySQLInnoDBDialect"&gt;&lt;/property&gt;
          &lt;property name="hibernate.show_sql" value="true" /&gt;
      &lt;/properties&gt;
  &lt;/persistence-unit&gt;
  </code></pre>
  
  <p>I created a simple table called 'persons' in my db:</p>
  
  <pre><code>CREATE TABLE persons(
  id VARCHAR(255) PRIMARY KEY,
  version int, 
  full_name VARCHAR(255),
  person_id VARCHAR(255),
  email VARCHAR(255));
  </code></pre>
  
  <p>Created entity a corresponding entity and Dao:</p>
  
  <pre><code>@Entity
  @Table(name = "persons")
  public class Person implements Serializable {
  
  private static final long serialVersionUID = 4349832844316517922L;
  
  /*--- Members ---*/
  
  /**
   * Hibernate genetared UUID
   */
  @Id
  @GeneratedValue(generator = "system-uuid")
  @GenericGenerator(name = "system-uuid", strategy = "uuid")
  private String id;
  
  @Version
  private int version;
  
  @Column(name = "full_name")
  private String fullName;
  
  @Column(name = "person_id")
  private String personId;
  
  @Column(name = "email")
  private String eMail;
  
  /*--- Constructor ---*/
  
  public Person() {
  }
  
  /*--- Overridden Methods ---*/
  
  @Override
  public boolean equals(Object obj) {
  
      if ((obj == null) || !(obj instanceof Person)) {
          return false;
      }
  
      // reference comparison
      if (obj == this) {
          return true;
      }
  
      final Person other = (Person) obj;
  
      return new EqualsBuilder().append(getPersonId(), other.getPersonId())
              .append(geteMail(), other.geteMail())
              .append(getFullName(), other.getFullName()).isEquals();
  }
  
  /**
   * The unique hash code based on the clients' id and citizenship
   * 
   * {@inheritDoc}
   */
  @Override
  public int hashCode() {
  
      return new HashCodeBuilder().append(geteMail()).append(this.geteMail())
              .append(this.getFullName()).toHashCode();
  }
  
  /*--- Getters &amp; Setters ---*/
  
  public String getId() {
      return id;
  }
  
  public void setId(String id) {
      this.id = id;
  }
  
  public int getVersion() {
      return version;
  }
  
  public void setVersion(int version) {
      this.version = version;
  }
  
  public String getFullName() {
      return fullName;
  }
  
  public void setFullName(String fullName) {
      this.fullName = fullName;
  }
  
  public String getPersonId() {
      return personId;
  }
  
  public void setPersonId(String personId) {
      this.personId = personId;
  }
  
  public String geteMail() {
      return eMail;
  }
  
  public void seteMail(String eMail) {
      this.eMail = eMail;
  }
  </code></pre>
  
  <p>}</p>
  
  <p>Dao:</p>
  
  <pre><code>@Repository
  public class PersonJpaDao extends BasicJpaDao&lt;Person&gt; implements IPersonDao {
  
  public PersonJpaDao() {
      super(Person.class);
  }
  </code></pre>
  
  <p>}</p>
  
  <p>here is BasicJpaDao:</p>
  
  <pre><code>public class BasicJpaDao&lt;T&gt; implements IBasicDao&lt;T&gt; {
  
  /* --- Members --- */
  
  /** The JPA utility to work with the persistence layer. */
  @PersistenceContext
  protected EntityManager entityManager;
  
  /** The type of the entity to which this DAO offers access. */
  protected Class&lt;T&gt; entityClass;
  
  /* --- Constructors --- */
  
  /**
   * Default constructor.
   * 
   * @param entityClass
   *            The type of the entity to which this DAO offers access.
   */
  public BasicJpaDao(Class&lt;T&gt; entityClass) {
      super();
      this.entityClass = entityClass;
  }
  
  /* --- Public methods --- */
  
  /**
   * {@inheritDoc}
   */
  @Override
  public void create(T entity) {
      getEntityManager().persist(entity);
  }
  
  /**
   * {@inheritDoc}
   */
  @Override
  public T read(Object primaryKey) {
      return getEntityManager().find(getEntityClass(), primaryKey);
  }
  
  /**
   * {@inheritDoc}
   */
  @Override
  public T update(T entity) {
      return getEntityManager().merge(entity);
  }
  
  /**
   * {@inheritDoc}
   */
  @Override
  public void delete(T entity) {
      getEntityManager().remove(entity);
  }
  
  /**
   * {@inheritDoc}
   */
  @Override
  public void flush() {
      getEntityManager().flush();
  }
  
  /* --- Getters/Setters --- */
  
  /**
   * @return The JPA utility to work with the persistence layer.
   */
  public EntityManager getEntityManager() {
      return this.entityManager;
  }
  
  /**
   * @param entityManager
   *            The JPA utility to work with the persistence layer.
   */
  public void setEntityManager(EntityManager entityManager) {
      this.entityManager = entityManager;
  }
  
  /**
   * @return The type of the entity to which this DAO offers access.
   */
  public Class&lt;T&gt; getEntityClass() {
      return entityClass;
  }
  
  /**
   * @param entityClass
   *            The type of the entity to which this DAO offers access.
   */
  public void setEntityClass(Class&lt;T&gt; entityClass) {
      this.entityClass = entityClass;
  }
  </code></pre>
  
  <p>Soo.. basically it works, but nothing gets committed, I mean, if I run </p>
  
  <pre><code>@Transactional(propagation = Propagation.REQUIRED)
  private void crearePerson() {
      Person p1 = myDao.read("12345");
      p1.setFullName("kiko too");
      myDao.update(p1);
  }
  </code></pre>
  
  <p>I can see (in debug) that p1 gets back from the DB but the update never takes place.
  The only close thing I could find was this:</p>
  
  <p><a href="https://stackoverflow.com/questions/3207208/jpa-transactions-not-being-commited">JPA - transactions not being committed</a></p>
  
  <p>And I tried adding </p>
  
  <pre><code>&lt;property name="hibernate.connection.shutdown" value="true" /&gt;
  </code></pre>
  
  <p>to my persistence.xml following this thread but it didn't help.
  I also added a property to my connection pool (in my application server gui) called connection.shutdown with the value of true but it didn't help either.</p>
  
  <p><strong>Update:</strong>
  Since I'm using JTA I figured my transaction manager is wrongly configured. While I was using org.springframework.orm.jpa.JpaTransactionManager I should have used org.springframework.transaction.jta.JtaTransactionManager.
  So I have changed my application context and now I have:</p>
  
  <pre><code>&lt;bean id="txManager"
      class="org.springframework.transaction.jta.JtaTransactionManager" /&gt;
  
  &lt;tx:annotation-driven transaction-manager="txManager" /&gt;
  </code></pre>
  
  <p>Unfortunately, I'm still experiencing the same issue :(
  In my console I can see the hibernate query as follows ()I've changed some of my original entity fields, but it doesn't really matters):</p>
  
  <p>INFO: Hibernate: select user0_.id as id0_0_, user0_.email as email0_0_, user0_.full_name as full3_0_0_, user0_.password as password0_0_, user0_.update_by_email as update5_0_0_, user0_.user_name as user6_0_0_, user0_.version as version0_0_ from users user0_ where user0_.id=?</p>
  
  <p>Any ideas?</p>
  
  <p>Thanks in advance,
  Yogi</p>