Transacciones y Sesiones

Datos de muestra

Los ejemplos de esta guía utilizan la Movie entidad, que representa la sample_mflix.movies colección de los conjuntos de datos de muestra del Atlas. La Movie entidad tiene la siguiente definición:

import com.mongodb.hibernate.annotations.ObjectIdGenerator;
import org.bson.types.ObjectId;
import java.util.List;
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
@Entity
@Table(name = "movies")
public class Movie {
   @Id
   @ObjectIdGenerator
   private ObjectId id;
   private String title;
   private String plot;
   private int year;
   private List<String> cast;
   public Movie(String title, String plot, int year, List<String> cast) {
      this.title = title;
      this.plot = plot;
      this.year = year;
      this.cast = cast;
   }
   public Movie() {
   }
   public ObjectId getId() {
      return id;
   }
   public String getTitle() {
      return title;
   }
   public void setTitle(String title) {
      this.title = title;
   }
   public String getPlot() {
      return plot;
   }
   public void setPlot(String plot) {
      this.plot = plot;
   }
   public int getYear() {
      return year;
   }
   public void setYear(int year) {
      this.year = year;
   }
   public List<String> getCast() {
      return cast;
   }
   public void setCast(List<String> cast) {
      this.cast = cast;
   }
}

Para aprender a crear una aplicación Java que use la extensión MongoDB para Hibernate ORM para interactuar con esta colección de muestra de MongoDB, consulte Comenzar tutorial.

Utilice una sesión de hibernación

Para iniciar una Hibernate Session, realiza los siguientes pasos:

1. Recupere un SessionFactory de su clase utilitaria HibernateUtil utilizando el método getSessionFactory(). El SessionFactory almacena tu configuración de conexión MongoDB y puede abrir nuevas sesiones de base de datos.

2. Cree un Session llamando al método openSession() en su instancia SessionFactory.

3. Después de ejecutar operaciones en la base de datos, cierra tu SessionFactory y Session utilizando el método close() en ambas instancias.

El siguiente ejemplo ejecuta una consulta de base de datos en una sesión y recupera un documento que tiene un valor title de "Erin Brockovich" de la colección sample_mflix.movies:

var sf = HibernateUtil.getSessionFactory();
Session session = sf.openSession();
var movie = session.createQuery("from Movie where title = :t", Movie.class)
                    .setParameter("t", "Erin Brockovich")
                    .getSingleResult();
System.out.println("Title: " + movie.getTitle() + ", Year: " + movie.getYear());
session.close();
sf.close();

Title: Erin Brockovich, Year: 2000

También puedes utilizar la instrucción try-with-resources de Java para simplificar la lógica de gestión de sesiones y cerrar automáticamente la sesión, como se muestra en el siguiente código:

var sf = HibernateUtil.getSessionFactory();
try (Session session = sf.openSession()) {
    var movie = session.createQuery("from Movie where title = :t", Movie.class)
            .setParameter("t", "Erin Brockovich")
            .getSingleResult();
    System.out.println("Title: " + movie.getTitle() + ", Year: " + movie.getYear());
}
sf.close();

Utilice un EntityManager de JPA

Para iniciar una EntityManager de la API de persistencia de Jakarta (JPA), realiza los siguientes pasos:

1. Cree un EntityManagerFactory a partir de su archivo persistence.xml llamando al método createEntityManagerFactory(), que crea un SessionFactory internamente.

2. Cree un EntityManager llamando al método createEntityManager() en su instancia de EntityManagerFactory, que crea un Session internamente.

3. Después de ejecutar las operaciones de base de datos, cierre EntityManagerFactory y EntityManager llamando al método close() en ambas instancias.

El siguiente ejemplo ejecuta una consulta de base de datos en un administrador de entidades y recupera documentos que tienen un valor year de 1929 de la colección sample_mflix.movies:

// Replace <persistence unit> with the name of your persistence unit in the persistence.xml file
EntityManagerFactory emf = Persistence.createEntityManagerFactory("<persistence unit>");
EntityManager entityManager = emf.createEntityManager();
var results = entityManager.createQuery("select m from Movie m where m.year = :y", Movie.class)
        .setParameter("y", 1929)
        .getResultList();
results.forEach(movie -> System.out.println(movie.getTitle()));
entityManager.close();
emf.close();

The Broadway Melody
Queen Kelly
Asphalt
Hallelujah
Disraeli
Applause
Lambchops

En Jakarta Persistence v3.1 o posterior, puedes usar la instrucción try-with-resources de Java para cerrar automáticamente el EntityManager, como se muestra en la sección Hibernate Session.

Utilice una transacción de Hibernate

Para iniciar un Hibernate Transaction, llama al método beginTransaction() en una instancia de Session. Después de ejecutar las operaciones y utilizar el método persist() para registrar tus cambios con la sesión, confirma la transacción llamando al método commit().

El siguiente ejemplo usa una transacción para realizar las siguientes operaciones en la colección sample_mflix.movies:

• Crea una nueva entidad Movie y la inserta como un documento en la colección

• Actualiza el campo cast de un documento que tiene un valor title de "Black Swan"

Las líneas resaltadas inician y confirman la transacción:

var sf = HibernateUtil.getSessionFactory();
Session session = sf.openSession();
Transaction tx = session.beginTransaction();
var newMovie = new Movie();
newMovie.setTitle("Lady Bird");
newMovie.setYear(2017);
session.persist(newMovie);
var movie = session.createQuery("from Movie where title = :t", Movie.class)
        .setParameter("t", "Black Swan")
        .getSingleResult();
var currentCast = new ArrayList<>(movie.getCast());
currentCast.add("Winona Ryder");
movie.setCast(currentCast);
tx.commit();
session.close();
sf.close();

Utilice una entidad JPA Transaction

Para crear un/una JPA EntityTransaction, llama al método getTransaction() en tu EntityManager. Este método recupera un EntityTransaction, que envuelve el subyacente Hibernate Transaction. A continuación, llama al método begin() para iniciar la transacción. Después de ejecutar operaciones y de utilizar el método persist() para registrar los cambios con el administrador de entidades, confirmar la transacción llamando al método commit().

El siguiente ejemplo utiliza un EntityTransaction para borrar un documento de la colección sample_mflix.movies y luego insertar un nuevo documento que tenga un valor de título de "The Favourite". Las líneas resaltadas inician y confirman la transacción:

// Replace <persistence unit> with the name of your persistence unit in the persistence.xml file
EntityManagerFactory emf = Persistence.createEntityManagerFactory("<persistence unit>");
EntityManager entityManager = emf.createEntityManager();
entityManager.getTransaction().begin();
// Your ObjectId value might differ
Movie movieToDelete = entityManager.find(Movie.class, new ObjectId("573a1399f29313caabcedc5d"));
entityManager.remove(movieToDelete);
var addMovie = new Movie();
addMovie.setTitle("The Favourite");
addMovie.setYear(2018);
entityManager.persist(addMovie);
entityManager.getTransaction().commit();
entityManager.close();
emf.close();