JPA/Hibernate 删除实体不起作用

Question

我正在使用 Hibernate 的 JPA 接口，并且我编写了一些简单的代码来从数据库中加载实体，然后删除（删除）它。我对插入和更新实体的所有合并调用都运行良好，但是当我尝试删除一个实体时，Hibernate 不会从数据库中删除它，也不会引发异常。我在下面包含了相关代码：

主要方法：

/**
 * Accept an invite that was sent to you.
 * 
 * @param inviteId
 * @return XML model of the EventMember.
 */
@RequestMapping(value="/invites/accept.rest")
public ModelAndView acceptInvite(@RequestParam final long inviteId) {
    final EventInvite invite = eventInviteDAO.find(EventInvite.class, eventInviteId);

    EventMember eventMember = new EventMember();
    eventMember.setEvent(invite.getEvent());
    eventMember.setUser(invite.getUser());
    eventMember = eventMemberDAO.store(eventMember);

    eventInviteDAO.remove(invite);

    return getXMLModelAndView("eventMember", eventMember);
}

AbstractJpaDao 类（由所有 DAO 类继承）：

public abstract class AbstractJpaDao<T> implements JpaDao<T> {
    abstract public EntityManager getEntityManager();

    public <T> T find(Class<T> entityClass, Object primaryKey) {
        return getEntityManager().find(entityClass, primaryKey);
    }

    @Transactional(isolation = Isolation.DEFAULT, propagation = Propagation.REQUIRED)
    public T store(final T objectToPersist) {
        T result = getEntityManager().merge(objectToPersist);
        return result;
    }

    @Transactional(isolation = Isolation.DEFAULT, propagation = Propagation.REQUIRED)
    public void remove(final T objectToDelete) {
        getEntityManager().remove(objectToDelete);
    }
}

EventInvite 域类：

@Entity
@Table(name = "TEventInvite")
public class EventInvite implements Serializable {
    private static final long serialVersionUID = 1L;

    @Column(name = "EventInviteID", nullable = false)
    @Basic(fetch = FetchType.EAGER)
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private long eventInviteId;

    @ManyToOne(fetch = FetchType.EAGER)
    @JoinColumns( { @JoinColumn(name = "EventID", referencedColumnName = "EventID", nullable = false) })
    private Event event;

    @Column(name = "Email")
    @Basic(fetch = FetchType.EAGER)
    private String email;

    @Temporal(TemporalType.TIMESTAMP)
    @Column(name = "CreateDate", nullable = false)
    @Basic(fetch = FetchType.EAGER)
    private Calendar createDate;

    @ManyToOne(fetch = FetchType.EAGER)
    @JoinColumns( { @JoinColumn(name = "UserID", referencedColumnName = "UserID") })
    private User user;

    public void setEventInviteId(long eventInviteId) {
        this.eventInviteId = eventInviteId;
    }

    public long getEventInviteId() {
        return this.eventInviteId;
    }

    public Event getEvent() {
        return event;
    }

    public void setEvent(Event event) {
        this.event = event;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getEmail() {
        return this.email;
    }

    public void setCreateDate(Calendar createDate) {
        this.createDate = createDate;
    }

    public Calendar getCreateDate() {
        return this.createDate;
    }

    public void setUser(User user) {
        this.user = user;
    }

    public User getUser() {
        return user;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result
                + ((createDate == null) ? 0 : createDate.hashCode());
        result = prime * result + ((email == null) ? 0 : email.hashCode());
        result = prime * result + ((event == null) ? 0 : event.hashCode());
        result = prime * result + ((user == null) ? 0 : user.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        EventInvite other = (EventInvite) obj;
        if (createDate == null) {
            if (other.createDate != null)
                return false;
        } else if (!createDate.equals(other.createDate))
            return false;
        if (email == null) {
            if (other.email != null)
                return false;
        } else if (!email.equals(other.email))
            return false;
        if (event == null) {
            if (other.event != null)
                return false;
        } else if (!event.equals(other.event))
            return false;
        if (user == null) {
            if (other.user != null)
                return false;
        } else if (!user.equals(other.user))
            return false;
        return true;
    }

}

关于问题可能是什么或如何调试它的任何想法？

Answer 1

是否因为EventInvite 跨越事务边界而感到困惑？您在一个事务中加载实体并在另一个事务中将其删除。

相反，创建一个新的@Transactional 方法，其中包含用于接受邀请的完整业务逻辑，因为它是一个单一的逻辑操作。当您希望启用通过 SMS 或电子邮件接受邀请时，这样做还会将表示层与模型分开。

Answer 2

我有一个类似的问题，我有一个类，它描述了一个值，它是一个类别的一部分。因此，值类具有对其所属类别的引用。

@Entity
public class CategoryValue extends LouhinObject implements Serializable, Idable {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;

    @ManyToOne
    private Category category;
}

在我能够删除 CategoryValue 对象之前，我必须手动将类别字段设置为 null，我真的不知道为什么 Hibernate 会这样工作。

Answer 3

我遇到了同样的问题。 我的实体是 Card（见下文）。而且我无法将 null 设置为帐户和客户，因为我有 数据库中的非空检查。

public class Card implements Serializable {  
    @ManyToOne 
    @JoinColumn(name="idAcc")
    private Account account; 
    @ManyToOne 
    @JoinColumn(name="idCl")
    private Client client;

当我尝试删除它时，我什至没有看到关于删除的 sql-request。

    em = getEntityManager();
    em.getTransaction().begin();  
    mergedCard = em.merge(card); 
    em.remove(mergedCard); 
    em.getTransaction().commit();

所以我通过注释解决了这个问题

 @ManyToOne(cascade=CascadeType.MERGE)
@JoinColumn(name="idAcc")
private Account account; 
@ManyToOne(cascade=CascadeType.MERGE)
@JoinColumn(name="idCl")
private Client client;

Answer 4

嗨 对于休眠，您可以尝试通过设置查看已执行的 sql

<property name="hibernate.show.sql" value="true"></property>

我怀疑当你删除时，不知何故会话或事务没有关闭，所以休眠不会刷新，结果也不会在数据库中看到。