持久化和合并是为了两个不同的目的(它们根本不是替代方案)。

(编辑以扩大差异信息)

坚持:

向数据库中插入一个新的寄存器 将对象附加到实体管理器。

走：

找到具有相同id的附加对象并更新它。 如果存在，则更新并返回已附加的对象。 如果不存在，则将新寄存器插入数据库。

persist()效率:

在向数据库插入新寄存器时，它可能比merge()更有效。 它不会复制原始对象。

persist()的语义:

它确保您是在插入而不是错误地更新。

例子:

{
    AnyEntity newEntity;
    AnyEntity nonAttachedEntity;
    AnyEntity attachedEntity;

    // Create a new entity and persist it        
    newEntity = new AnyEntity();
    em.persist(newEntity);

    // Save 1 to the database at next flush
    newEntity.setValue(1);

    // Create a new entity with the same Id than the persisted one.
    AnyEntity nonAttachedEntity = new AnyEntity();
    nonAttachedEntity.setId(newEntity.getId());

    // Save 2 to the database at next flush instead of 1!!!
    nonAttachedEntity.setValue(2);
    attachedEntity = em.merge(nonAttachedEntity);

    // This condition returns true
    // merge has found the already attached object (newEntity) and returns it.
    if(attachedEntity==newEntity) {
            System.out.print("They are the same object!");
    }

    // Set 3 to value
    attachedEntity.setValue(3);
    // Really, now both are the same object. Prints 3
    System.out.println(newEntity.getValue());

    // Modify the un attached object has no effect to the entity manager
    // nor to the other objects
    nonAttachedEntity.setValue(42);
}

这种方法对于实体管理器中的任何寄存器只存在一个附加对象。

对于带id的实体，Merge()是这样的:

AnyEntity myMerge(AnyEntity entityToSave) {
    AnyEntity attached = em.find(AnyEntity.class, entityToSave.getId());
    if(attached==null) {
            attached = new AnyEntity();
            em.persist(attached);
    }
    BeanUtils.copyProperties(attached, entityToSave);

    return attached;
}

虽然如果连接到MySQL merge()可以像persist()一样有效，使用一个调用INSERT和ON DUPLICATE KEY UPDATE选项，JPA是一个非常高级的编程，你不能假设这将是任何地方的情况。

JPA is indisputably a great simplification in the domain of enterprise applications built on the Java platform. As a developer who had to cope up with the intricacies of the old entity beans in J2EE I see the inclusion of JPA among the Java EE specifications as a big leap forward. However, while delving deeper into the JPA details I find things that are not so easy. In this article I deal with comparison of the EntityManager’s merge and persist methods whose overlapping behavior may cause confusion not only to a newbie. Furthermore I propose a generalization that sees both methods as special cases of a more general method combine.

持久化实体

与merge方法相比，persist方法非常简单直观。使用persist方法最常见的场景可以总结如下:

一个新创建的实体类实例被传递给持久化方法。该方法返回后，将管理实体并计划将其插入到数据库中。它可能发生在事务提交时或提交之前，也可能发生在调用flush方法时。如果实体通过标记为PERSIST级联策略的关系引用另一个实体，则此过程也应用于它。”

规范中有更多的细节，然而，记住它们并不重要，因为这些细节只涵盖了或多或少的奇异情况。

合并实体

In comparison to persist, the description of the merge's behavior is not so simple. There is no main scenario, as it is in the case of persist, and a programmer must remember all scenarios in order to write a correct code. It seems to me that the JPA designers wanted to have some method whose primary concern would be handling detached entities (as the opposite to the persist method that deals with newly created entities primarily.) The merge method's major task is to transfer the state from an unmanaged entity (passed as the argument) to its managed counterpart within the persistence context. This task, however, divides further into several scenarios which worsen the intelligibility of the overall method's behavior.

我没有从JPA规范中重复段落，而是准备了一个流程图，概要地描述了合并方法的行为:

什么时候使用持久化，什么时候使用归并?

坚持

您希望该方法总是创建一个新实体，而从不更新实体。否则，该方法将因违反主键惟一性而引发异常。 批处理流程，以有状态的方式处理实体(参见网关模式)。 性能优化

走

您希望该方法插入或更新数据库中的实体。 您希望以无状态的方式处理实体(服务中的数据传输对象) 您希望插入一个新实体，该实体可能对另一个实体有引用，但可能尚未创建(关系必须标记为MERGE)。例如，插入带有新相册或已有相册引用的新照片。

persist(entity)应该与全新的实体一起使用，将它们添加到DB(如果实体已经存在于DB中，则会抛出EntityExistsException)。

应该使用Merge(实体)，如果实体被分离并被更改，则将实体放回持久性上下文中。

可能持久是生成INSERT sql语句和合并UPDATE sql语句(但我不确定)。

通过回答，有一些关于“Cascade”和id生成的细节缺失。看到问题

此外，值得一提的是，您可以为合并和持久化使用单独的Cascade注释:Cascade。合并和级联。PERSIST将根据使用的方法进行处理。

规格是你的朋友;)

这两种方法都会将实体添加到PersistenceContext中，区别在于之后如何处理实体。

Persist获取一个实体实例，将其添加到上下文中，并使该实例被管理(即将跟踪实体的未来更新)。

Merge返回与状态合并的托管实例。它确实返回存在于PersistenceContext中的内容或创建实体的新实例。在任何情况下，它都会从提供的实体复制状态，并返回一个托管副本。传入的实例不会被管理(你所做的任何更改都不会成为事务的一部分——除非你再次调用merge)。不过您可以使用返回的实例(托管实例)。

也许一个代码示例会有所帮助。

MyEntity e = new MyEntity();

// scenario 1
// tran starts
em.persist(e); 
e.setSomeField(someValue); 
// tran ends, and the row for someField is updated in the database

// scenario 2
// tran starts
e = new MyEntity();
em.merge(e);
e.setSomeField(anotherValue); 
// tran ends but the row for someField is not updated in the database
// (you made the changes *after* merging)
      
// scenario 3
// tran starts
e = new MyEntity();
MyEntity e2 = em.merge(e);
e2.setSomeField(anotherValue); 
// tran ends and the row for someField is updated
// (the changes were made to e2, not e)

场景1和3大致相同，但在某些情况下，您可能希望使用场景2。

JPA规范说明了关于persist()的以下内容。

如果X是一个分离对象，则在持久化时可能会抛出EntityExistsException 操作被调用，或者EntityExistsException或另一个PersistenceException可能在刷新或提交时抛出。

因此，当对象不应该是分离对象时，使用persist()是合适的。您可能更喜欢让代码抛出PersistenceException，以便快速失败。

尽管规范不清楚，persist()可能会为对象设置@GeneratedValue @Id。但是merge()必须有一个已经生成的@Id对象。