JPA Session.delete einer Entity wird nicht ausgeführt

[ElBobby]

Hallo Leute,

ich habe ein Problem, kann mein DAO das Löschen einer Entity nicht durchführt.

Es gibt die Klasse City:

import static javax.persistence.GenerationType.IDENTITY;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.NamedQueries;
import javax.persistence.Table;
import javax.persistence.NamedQuery;

/**
 * The city.
 * 
 * @author User
 * 
 */
@NamedQueries({ @NamedQuery(name = City.FINDCITYBYNAME, query = "from City c where c.name = :name") })
@Entity
@Table(name = "city", catalog = "fbo")
public class City implements Serializable {
	/**
	 * 
	 */
	private static final long serialVersionUID = 877051983444997018L;

	/**
	 * Query : findCityByName.
	 */
	public static final String FINDCITYBYNAME = "findCityByName";

	/**
	 * PK.
	 */
	private Long id;

	/**
	 * Name of te city.
	 */
	private String name;

	@Id
	@GeneratedValue(strategy = IDENTITY)
	@Column(name = "id", unique = true, nullable = false)
	public Long getId() {
		return id;
	}

	public void setId(final Long id) {
		this.id = id;
	}

	@Column(name = "name", length = 255)
	public String getName() {
		return name;
	}

	public void setName(final String name) {
		this.name = name;
	}
}

Dazu kommt ein generischer Ansatz für die DAOs und eine abstrakte Klasse, in der direkt auch das Löschen implementiert ist.

import java.io.Serializable;
import java.util.List;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;

import com.google.common.base.Preconditions;

import de.bobby.dpitest.dao.common.IOperations;

@SuppressWarnings("unchecked")
public abstract class AbstractHibernateDao<T extends Serializable> implements
		IOperations<T> {
	private Class<T> clazz;

	@Autowired
	private SessionFactory sessionFactory;

	protected final void setClazz(final Class<T> clazzToSet) {
		clazz = Preconditions.checkNotNull(clazzToSet);
	}

	@Override
	public final T findOne(final long id) {
		return (T) getCurrentSession().get(clazz, id);
	}

	@Override
	public final List<T> findAll() {
		return getCurrentSession().createQuery("from " + clazz.getName())
				.list();
	}

	@Override
	public final void create(final T entity) {
		Preconditions.checkNotNull(entity);
		// getCurrentSession().persist(entity);
		getCurrentSession().saveOrUpdate(entity);
	}

	@Override
	public final T update(final T entity) {
		Preconditions.checkNotNull(entity);
		return (T) getCurrentSession().merge(entity);
	}

	@Override
	public final void delete(final T entity) {
		Preconditions.checkNotNull(entity);
		getCurrentSession().delete(entity);
	}

	@Override
	public final void deleteById(final long entityId) {
		final T entity = findOne(entityId);
		Preconditions.checkState(entity != null);
		delete(entity);
	}

	protected final Session getCurrentSession() {
		// return sessionFactory.getCurrentSession();
		return sessionFactory.openSession();
	}

}

Die SessionFactory wird via Spring 3 injected und da sieht die Application Context so aus:
[XML]<?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:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="
Index of /schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
Index of /schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">

<contextroperty-placeholder location="classpathersistence-mysql.properties" />

<bean id="sessionFactory"
class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="packagesToScan" value="de.bobby.dpitest.entity" />
<property name="hibernateProperties">
<props>
<prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>
<prop key="hibernate.dialect">${hibernate.dialect}</prop>
</props>
</property>
</bean>

<bean id="dataSource" class="org.apache.tomcat.dbcp.dbcp2.BasicDataSource">
<property name="driverClassName" value="${jdbc.driverClassName}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.user}" />
<property name="password" value="${jdbc.pass}" />
</bean>

<bean id="txManager"
class="org.springframework.orm.hibernate4.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
</bean>

<bean id="persistenceExceptionTranslationPostProcessor"
class="org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor" />

</beans>[/XML]

Alle Find-Operationen funktionieren soweit gut. Auch das Anlegen einer Entity funktioniert. Das Löschen jedoch nicht.

Der "stumpfe" Test für das Dao sieht wie folgt aus:

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.testng.AbstractTestNGSpringContextTests;
import org.testng.Assert;
import org.testng.annotations.Test;

import de.bobby.dpitest.dao.ICityDao;
import de.bobby.dpitest.entity.City;

/**
 * Test class for
 * 
 * @author User
 * 
 */
@Test
@ContextConfiguration(locations = { "classpath:dao-test-beans.xml" })
public class CityDaoTest extends AbstractTestNGSpringContextTests {

	/**
	 * Bremen.
	 */
	private static final String BREMEN = "Bremen";

	/**
	 * NUMBEROFCITIES.
	 */
	private static final int NUMBEROFCITIES = 4;

	@Autowired
	private ICityDao cityDao;

	@Test
	public void testFindAll() {

		final List<City> cities = this.cityDao.findAll();
		Assert.assertNotNull(cities);
	}

	public void testFindByName() {
		final City city = this.cityDao.findByName(BREMEN);
		Assert.assertNotNull(city);
		this.cityDao.deleteById(city.getId());
	}

}

Der Aufruf this.cityDao.deleteById(city.getId()); wird scheinbar durchgeführt, aber das Objekt verbleibt in der Datenbank.

Ich habe mir das Logging von MySQL angestellt und lasse alle Queries loggen. Dort fällt auf, dass erst gar keine Delete-Query ankommt.

Habt ihr da ein paar schlaue Ideen?

Viele Grüße,
Bob

 

[JavaMeister]

Führe ein flush auf der Session aus.

 

[ElBobby]

Hallo JavaMeister,

das war es tatsächlich. Ich habe die Methode delete wie folgt modifiziert:

	@Override
	public final void delete(final T entity) {
		Preconditions.checkNotNull(entity);
		Session session = this.getCurrentSession();
		session.delete(entity);
		session.flush();
	}

Danke.