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 Tutorial de introducción.

Utilice una sesión de hibernación

Para iniciar una Hibernate Session, realiza los siguientes pasos:

1. Recupere un SessionFactory de su clase de utilidad HibernateUtil mediante el método getSessionFactory(). El SessionFactory almacena la configuración de su conexión de MongoDB y permite 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 puede utilizar la declaración try-with-resources de Java para simplificar la lógica de gestión de la sesión y cerrar la sesión automáticamente, 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 JPA

Para iniciar una API de persistencia de Jakarta (JPA) EntityManager, realice 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 EntityManagerFactory, lo 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, puede usar la declaración try-with-resources de Java para cerrar automáticamente EntityManager el, como se muestra en la sección Sesión de hibernación.

Utilice una transacción de Hibernate

Para iniciar una instancia de Hibernate Transaction, llame al método beginTransaction() en una instancia Session. Después de ejecutar las operaciones y usar el método persist() para registrar los cambios en la sesión, confirme 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 JPA EntityTransaction, llame al método getTransaction() en su EntityManager. Este método recupera un EntityTransaction, que encapsula el Hibernate subyacente Transaction. A continuación, llame al método begin() para iniciar la transacción. Después de ejecutar las operaciones y usar el método persist() para registrar los cambios en el administrador de entidades, confirme la transacción llamando al método commit().

El siguiente ejemplo usa un EntityTransaction para eliminar un documento de la colección sample_mflix.movies y, a continuación, inserta un nuevo documento cuyo valor de título es "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();