在最初的帖子中，有两种方法，更新(obj)和合并(obj)，被提到是有效的，但在相反的情况下。如果这是真的，那么为什么不先测试一下对象是否已经在会话中，然后调用update(obj)如果它是，否则调用merge(obj)。

会话是否存在的测试是session.contains(obj)。因此，我认为下面的伪代码可以工作:

if (session.contains(obj))
{
    session.update(obj);
}
else 
{
    session.merge(obj);
}

会话。contains(Object obj)检查引用，不会检测到表示同一行且已经附加到该引用的不同实例。

这里是带有标识符属性的实体的通用解决方案。

public static void update(final Session session, final Object entity)
{
    // if the given instance is in session, nothing to do
    if (session.contains(entity))
        return;

    // check if there is already a different attached instance representing the same row
    final ClassMetadata classMetadata = session.getSessionFactory().getClassMetadata(entity.getClass());
    final Serializable identifier = classMetadata.getIdentifier(entity, (SessionImplementor) session);

    final Object sessionEntity = session.load(entity.getClass(), identifier);
    // override changes, last call to update wins
    if (sessionEntity != null)
        session.evict(sessionEntity);
    session.update(entity);
}

这是. net EntityFramework中我喜欢的几个方面之一，关于更改实体及其属性的不同附加选项。

因此，似乎没有办法在JPA中重新附加一个过时的分离实体。

merge()会将过期状态推送到DB， 并覆盖任何中间更新。

不能在分离实体上调用Refresh()。

不能在分离实体上调用Lock ()， 即使它可以，而且它确实重新连接了实体， 使用参数LockMode调用lock。没有' 这意味着你在锁定，但不是锁定， 是我见过的最违反直觉的API设计。

所以你陷入了困境。 有一个detach()方法，但没有attach()或reattach()。 对象生命周期中的一个明显步骤对您来说是不可用的。

根据关于JPA的类似问题的数量判断， 似乎即使JPA声称有一个一致的模型， 它肯定不符合大多数程序员的思维模式， 谁被诅咒浪费了很多时间试图理解 如何让JPA做最简单的事情，并以缓存结束 管理代码遍布他们的应用程序。

要做到这一点，似乎唯一的方法就是抛弃你陈旧的超然实体 并使用相同的id执行find查询，这将命中L2或DB。

Mik

我想出了一个解决方案，从持久存储中“刷新”一个对象，这将解释其他可能已经附加到会话的对象:

public void refreshDetached(T entity, Long id)
{
    // Check for any OTHER instances already attached to the session since
    // refresh will not work if there are any.
    T attached = (T) session.load(getPersistentClass(), id);
    if (attached != entity)
    {
        session.evict(attached);
        session.lock(entity, LockMode.NONE);
    }
    session.refresh(entity);
}

对不起，似乎不能添加评论(还?)。

使用Hibernate 3.5.0-Final

尽管已经弃用了session# lock方法，但javadoc建议使用session# buildLockRequest(LockOptions)#lock(entity)，如果您确保您的关联具有cascade=lock，惰性加载也不是问题。

我的attach方法看起来有点像

MyEntity attach(MyEntity entity) {
    if(getSession().contains(entity)) return entity;
    getSession().buildLockRequest(LockOptions.NONE).lock(entity);
    return entity;

初步测试表明它很有效。

我这样做在c#与NHibernate，但它应该在Java中以同样的方式工作:

public virtual void Attach()
{
    if (!HibernateSessionManager.Instance.GetSession().Contains(this))
    {
        ISession session = HibernateSessionManager.Instance.GetSession();
        using (ITransaction t = session.BeginTransaction())
        {
            session.Lock(this, NHibernate.LockMode.None);
            t.Commit();
        }
    }
}

对每个对象都调用First Lock，因为Contains总是false。问题是NHibernate通过数据库id和类型来比较对象。Contains使用equals方法，如果没有被覆盖，则通过引用进行比较。使用equals方法，它可以在没有任何异常的情况下工作:

public override bool Equals(object obj)
{
    if (this == obj) { 
        return true;
    } 
    if (GetType() != obj.GetType()) {
        return false;
    }
    if (Id != ((BaseObject)obj).Id)
    {
        return false;
    }
    return true;
}