Overview
En esta guía, puedes aprender a usar la extensión de MongoDB para Hibernate ORM para realizar un bloqueo optimista. El bloqueo optimista permite que sesiones concurrentes lean la misma entidad y, luego, detecta un conflicto cuando más de una sesión intenta guardar en esa entidad.
Cuando activas el bloqueo optimista, la extensión de Hibernate ORM genera una instrucción de MongoDB languaje del query (MQL) para cada operación de actualizar o borrar. La instrucción filtra por el valor de la versión que leyó la sesión, además de la llave primaria. Si otra sesión modificó el documento primero, el filtro no coincide con ningún documento y Hibernate ORM lanza un OptimisticLockException.
La extensión Hibernate ORM no admite el bloqueo pesimista. El bloqueo pesimista bloquea una entidad cuando una sesión la lee, lo que impide que otras sesiones modifiquen la entidad hasta que la sesión libere el bloqueo.
Agregar un campo de versión
Para activar el bloqueo optimista para una entidad, agregue un campo anotado con @Version a la clase de la entidad.
Defina un getter para el campo si su aplicación lee el valor de la versión, pero no defina un setter. Hibernate ORM asigna el valor por sí mismo, y establecer el campo en el código de su aplicación podría hacer que la extensión de Hibernate ORM genere un filtro que no coincida con el documento almacenado.
Los ejemplos de esta guía utilizan la siguiente entidad Product, que se asigna a la colección products. No inicialice el campo version, porque Hibernate ORM asigna su valor inicial cuando persiste la entidad por primera vez:
@Entity@Table(name = "products")public class Product { @Id @ObjectIdGenerator private ObjectId id; private String name; private int quantity;
@Version private Long version;
public Product() { }
public Product(String name, int quantity) { this.name = name; this.quantity = quantity; }
public ObjectId getId() { return id; }
public Long getVersion() { return version; }
public void setQuantity(int quantity) { this.quantity = quantity; }}La extensión Hibernate ORM admite los siguientes tipos para un campo @Version:
intyIntegerlongyLongInstant
Un campo de versión numérico comienza en 0 y se incrementa en 1 en cada guardar. Un campo de versión Instant almacena la hora de la guardar.
Actualizar una entidad versionada
Al persistir una nueva entidad, el ORM de Hibernate establece el campo de versión en 0. Al modificar la entidad y confirmar la transacción, la extensión del ORM de Hibernate genera una instrucción de actualización que filtra tanto la clave primaria como el valor de versión leído por la sesión. Esta instrucción también establece el nuevo valor de versión.
El siguiente ejemplo inserta una nueva entidad Product y luego actualiza su campo quantity para incrementar la versión:
var sf = HibernateUtil.getSessionFactory();try (Session session = sf.openSession()) { // Insert a new product, which sets the version to 0 session.beginTransaction(); var product = new Product("notebook", 100); session.persist(product); session.getTransaction().commit(); System.out.println("Version after insert: " + product.getVersion());
// Update the same product, which increments the version to 1 session.beginTransaction(); product.setQuantity(75); session.getTransaction().commit(); System.out.println("Version after update: " + product.getVersion());}sf.close();La actualización del ejemplo anterior genera una instrucción similar a la siguiente MQL:
{ "update": "products", "updates": [ { "q": { "$and": [ { "_id": { "$eq": "..." } }, { "version": { "$eq": 0 } } ] }, "u": { "$set": { "quantity": 75, "version": 1 } } } ]}Las operaciones de borrar utilizan el mismo filtro. Debido a que el valor de la versión es parte del filtro, una operación de guardar solo tiene éxito si el documento aún conserva la versión que leyó la sesión.
Gestionar un conflicto de versión
Si otra sesión modifica un documento después de que su sesión lo haya leído, el valor de versión en su filtro ya no coincide con el valor almacenado, y el ORM de Hibernate lanza una excepción OptimisticLockException. Para solucionarlo, capture la excepción y recargue la entidad e intente escribir de nuevo, o bien devuelva un error que notifique al usuario de su aplicación sobre el conflicto.
El siguiente ejemplo utiliza dos sesiones para leer el mismo documento. La segunda sesión confirma primero, por lo que la confirmación en la primera sesión lanza un OptimisticLockException:
var sf = HibernateUtil.getSessionFactory();ObjectId productId;
// Insert a new product for two sessions to modifytry (Session session = sf.openSession()) { session.beginTransaction(); var product = new Product("notebook", 100); session.persist(product); session.getTransaction().commit(); productId = product.getId();}
try (Session sessionA = sf.openSession(); Session sessionB = sf.openSession()) { // Both sessions load the product at version 0 var productA = sessionA.find(Product.class, productId); var productB = sessionB.find(Product.class, productId);
// Session B commits first and increments the version to 1 sessionB.beginTransaction(); productB.setQuantity(75); sessionB.getTransaction().commit();
// Session A commits second, but still holds version 0 try { sessionA.beginTransaction(); productA.setQuantity(50); sessionA.getTransaction().commit(); } catch (OptimisticLockException e) { System.out.println("Update failed: Another session modified this document"); // Reload the entity and retry, or report the conflict to the user }}sf.close();Nota
Dependiendo de cómo su aplicación cargue la entidad, el ORM de Hibernate podría lanzar una excepción StaleObjectStateException. Esta excepción es el equivalente nativo del ORM de Hibernate a OptimisticLockException.
Incrementar una versión sin cambiar los datos
Para incrementar la versión de una entidad que su sesión no modificó, pase la entidad y el modo de bloqueo LockMode.OPTIMISTIC_FORCE_INCREMENT al método lock() de su Session. Utilice este modo de bloqueo cuando un cambio en los datos relacionados deba invalidar las copias de la entidad de otras sesiones.
El siguiente ejemplo incrementa la versión de un documento Product:
var sf = HibernateUtil.getSessionFactory();try (Session session = sf.openSession()) { session.beginTransaction();
var product = session.createQuery("from Product where name = :n", Product.class) .setParameter("n", "notebook") .setMaxResults(1) .getSingleResult(); session.lock(product, LockMode.OPTIMISTIC_FORCE_INCREMENT);
session.getTransaction().commit();}sf.close();Si otra sesión incrementó la versión primero, la confirmación arroja un OptimisticLockException.
Bloqueo sin un campo de versión
También puedes detectar conflictos sin agregar un campo de versión. Para ello, anota tu entidad con @OptimisticLocking y especifica uno de los siguientes tipos:
OptimisticLockType.DIRTY: La extensión de Hibernate ORM filtra los valores anteriores solo de los campos que la sesión modificó.OptimisticLockType.ALL: La extensión Hibernate ORM filtra según los valores anteriores de todos los campos de la entidad.
Ambos tipos requieren la anotación @DynamicUpdate.
El siguiente ejemplo utiliza el tipo DIRTY:
@Entity@Table(name = "products")@OptimisticLocking(type = OptimisticLockType.DIRTY)@DynamicUpdatepublic class Product { @Id @ObjectIdGenerator private ObjectId id; private String name; private int quantity;
// Constructors, getters, and setters}Para excluir un campo del bloqueo optimista en una entidad versionada, anote el campo con @OptimisticLock(excluded = true). Los cambios en un campo excluido no incrementan la versión:
@Entity@Table(name = "products")public class Product { @Id @ObjectIdGenerator private ObjectId id;
@OptimisticLock(excluded = true) private String name;
private int quantity;
@Version private Long version;
// Constructors, getters, and setters}Limitaciones
El bloqueo optimista tiene las siguientes limitaciones:
La extensión Hibernate ORM no admite el bloqueo pesimista. Para obtener más información sobre la compatibilidad con el bloqueo, consulte la sección Transacciones y concurrencia de la página Compatibilidad de funciones.
No se puede pasar una entidad que tenga un campo
@Versional métodoStatelessSession.upsert(). La extensión Hibernate ORM lanza una excepciónUnsupportedFeatureExceptionpara esta operación.
Información Adicional
Para aprender más sobre el bloqueo optimista, consulta Bloqueo optimista en la documentación de Hibernate ORM.
Para aprender más sobre cómo ejecutar operaciones de guardar en una transacción, consulte la guía de Transacciones y sesiones.