¿Cuál es la diferencia entre persist () y merge () en JPA e Hibernate?

¿Cuál es la diferencia entre persist () y merge () en Hibernate?

persist() puede crear una consulta ACTUALIZAR E INSERTAR, por ejemplo:

SessionFactory sef = cfg.buildSessionFactory();
Session session = sef.openSession();
A a=new A();
session.persist(a);
a.setName("Mario");
session.flush();

en este caso, la consulta se generará así:

Hibernate: insert into A (NAME, ID) values (?, ?)
Hibernate: update A set NAME=? where ID=?

por lo que el persist()método puede generar una inserción y una actualización.

Ahora con merge():

SessionFactory sef = cfg.buildSessionFactory();
Session session = sef.openSession();
Singer singer = new Singer();
singer.setName("Luciano Pavarotti");
session.merge(singer);
session.flush();

Esto es lo que veo en la base de datos:

SINGER_ID   SINGER_NAME
1           Ricky Martin
2           Madonna
3           Elvis Presley
4           Luciano Pavarotti

Ahora actualice un registro usando merge()

SessionFactory sef = cfg.buildSessionFactory();
Session session = sef.openSession();
Singer singer = new Singer();
singer.setId(2);
singer.setName("Luciano Pavarotti");
session.merge(singer);
session.flush();

Esto es lo que veo en la base de datos:

SINGER_ID   SINGER_NAME
1           Ricky Martin
2           Luciano Pavarotti
3           Elvis Presley

La especificación JPA contiene una descripción muy precisa de la semántica de estas operaciones, mejor que en javadoc:

La semántica de la operación de persistencia , aplicada a una entidad X, es la siguiente:

• Si X es una entidad nueva, se gestiona. La entidad X se ingresará en la base de datos en o antes de la transacción confirmada o como resultado de la operación de descarga.

• Si X es una entidad gestionada preexistente, la operación de persistencia la ignora. Sin embargo, la operación de persistencia se conecta en cascada a las entidades a las que hace referencia X, si las relaciones de X a estas otras entidades se anotan con el valor del elemento de anotación cascade=PERSISTo cascade=ALLo se especifican con el elemento descriptor XML equivalente.

• Si X es una entidad eliminada, se gestiona.

• Si X es un objeto separado, EntityExistsExceptionse puede lanzar cuando se invoca la operación de persistencia, o se puede lanzar el EntityExistsExceptionu otro PersistenceExceptionen el tiempo de descarga o compromiso.

• Para todas las entidades Y a las que hace referencia una relación de X, si la relación con Y se ha anotado con el valor del elemento en cascada cascade=PERSISTo cascade=ALL, la operación de persistencia se aplica a Y.

La semántica de la operación de fusión aplicada a una entidad X es la siguiente:

• Si X es una entidad separada, el estado de X se copia en una instancia X 'de entidad gestionada preexistente de la misma identidad o se crea una nueva copia gestionada X' de X.

• Si X es una nueva instancia de entidad, se crea una nueva instancia de entidad gestionada X 'y el estado de X se copia en la nueva instancia de entidad gestionada X'.

• Si X es una instancia de entidad eliminada, IllegalArgumentExceptionla operación de fusión lanzará una (o la confirmación de la transacción fallará).

• Si X es una entidad gestionada, la operación de fusión la ignora; sin embargo, la operación de fusión se conecta en cascada a entidades referenciadas por relaciones de X si estas relaciones se han anotado con el valor cascade=MERGEo cascade=ALLanotación del elemento en cascada .

• Para todas las entidades Y referenciadas por relaciones de X que tienen el valor del elemento en cascada cascade=MERGEo cascade=ALL, Y se fusiona recursivamente como Y '. Para todos esos Y referenciados por X, X 'se establece para hacer referencia a Y'. (Tenga en cuenta que si se administra X, entonces X es el mismo objeto que X ').

• Si X es una entidad fusionada con X ', con una referencia a otra entidad Y, donde se especifica cascade=MERGEo cascade=ALLno, la navegación de la misma asociación desde X' produce una referencia a un objeto gestionado Y 'con la misma identidad persistente que Y.

Esto viene de JPA. De una forma muy sencilla:

• persist(entity) debe usarse con entidades totalmente nuevas, para agregarlas a DB (si la entidad ya existe en DB, habrá EntityExistsException throw).

• merge(entity) debe usarse para devolver la entidad al contexto de persistencia si la entidad se separó y se cambió.

Se debe llamar a Persist solo en entidades nuevas, mientras que la fusión está destinada a volver a adjuntar entidades separadas.

Si está usando el generador asignado, usar merge en lugar de persist puede causar una declaración SQL redundante , lo que afecta el rendimiento.

Además, llamar a la fusión para entidades administradas también es un error, ya que las entidades administradas son administradas automáticamente por Hibernate y su estado se sincroniza con el registro de la base de datos mediante el mecanismo de verificación sucia al vaciar el contexto de persistencia .

La diferencia más importante es esta:

• En el caso del persistmétodo, si la entidad que se va a gestionar en el contexto de persistencia ya existe en el contexto de persistencia, se ignora la nueva. (No pasó nada)

• Pero en el caso del mergemétodo, la entidad que ya está administrada en el contexto de persistencia será reemplazada por la nueva entidad (actualizada) y una copia de esta entidad actualizada regresará. (de ahora en adelante, se deben realizar cambios en esta entidad devuelta si desea reflejar sus cambios en el contexto de persistencia)