JPA Session.delete einer Entity wird nicht ausgeführt

Dieses Thema JPA - Session.delete einer Entity wird nicht ausgeführt im Forum "Data Tier" wurde erstellt von ElBobby, 16. März 2014.

Thema: Session.delete einer Entity wird nicht ausgeführt Hallo Leute, ich habe ein Problem, kann mein DAO das Löschen einer Entity nicht durchführt. Es gibt die Klasse...

  1. ElBobby
    ElBobby Neues Mitglied
    Hallo Leute,

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

    Es gibt die Klasse City:
    Code (Java):

    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.
    Code (Java):
    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">

    <context:property-placeholder location="classpath:persistence-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:
    Code (Java):
    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
     
  2. Vielleicht hilft dir das kostenlose Training weiter --> (hier klicken)
  3. JavaMeister
    JavaMeister Gesperrter Benutzer
    Führe ein flush auf der Session aus.
     
  4. ElBobby
    ElBobby Neues Mitglied
    Hallo JavaMeister,

    das war es tatsächlich. Ich habe die Methode delete wie folgt modifiziert:
    Code (Java):
        @Override
        public final void delete(final T entity) {
            Preconditions.checkNotNull(entity);
            Session session = this.getCurrentSession();
            session.delete(entity);
            session.flush();
        }
    Danke.
     
  5. Schau dir jetzt hier den Kurs an und lerne Java zu programmieren: --> Hier klicken, um mehr zu erfahren (Klick)