TOC

Anleitung zum Hibernate EntityManager

Anleitung zum Hibernate EntityManager

1. Einführung

EntityManager ist Teil der Java Persistence API. Hauptsächlich werden die Programmierschnittstellen und Lebenszyklusregeln implementiert, die in der JPA 2.0-Spezifikation definiert sind.

Darüber hinaus können wir auf den Persistenzkontext zugreifen, indem wir die APIs inEntityManager verwenden.

In diesem Tutorial werden wir uns die Konfiguration, Typen und verschiedenen APIs derEntityManageransehen.

2. Maven-Abhängigkeiten

Zunächst müssen wir die Abhängigkeiten von Hibernate berücksichtigen: 


    org.hibernate
    hibernate-core
    5.4.0.Final

Abhängig von der verwendeten Datenbank müssen wir auch die Treiberabhängigkeiten einbeziehen: 


    mysql
    mysql-connector-java
    8.0.13

Die Abhängigkeitenhibernate-core undmysql-connector-java sind in Maven Central verfügbar.

3. Aufbau

Lassen Sie uns nun dieEntityManager demonstrieren, indem wir eineMovie-Entität verwenden, die einer MOVIE-Tabelle in der Datenbank entspricht.

Im Verlauf dieses Artikels verwenden wir die API vonEntityManager, um mit den Objekten vonMoviein der Datenbank zu arbeiten.

3.1. Die Entität definieren

Beginnen wir mit der Erstellung der Entität, die der MOVIE-Tabelle entspricht, unter Verwendung der Annotation@Entity: 

@Entity
@Table(name = "MOVIE")
public class Movie {

    @Id
    private Long id;

    private String movieName;

    private Integer releaseYear;

    private String language;

    // standard constructor, getters, setters
}

3.2. Diepersistence.xml-Datei

WennEntityManagerFactory erstellt wird,the persistence implementation searches for the META-INF/persistence.xml file in the classpath.

Diese Datei enthält die Konfiguration fürEntityManager: 


    Hibernate EntityManager Demo
    com.example.hibernate.pojo.Movie
    true

Zur Erklärung definieren wir die Persistenz-Einheit, die den zugrunde liegenden Datenspeicher angibt, der vonEntityManager verwaltet wird.

Darüber hinaus definieren wir den Dialekt und die anderen JDBC-Eigenschaften des zugrunde liegenden Datenspeichers. Der Ruhezustand ist datenbankunabhängig. Based on these properties, Hibernate connects with the underlying database.

4. Container und Anwendung verwaltetEntityManager

Grundsätzlichthere are two types of EntityManager – Container Managed and Application Managed.

Schauen wir uns jeden Typ genauer an.

4.1. Container verwaltetEntityManager

Hier injiziert der Container dieEntityManager in unsere Unternehmenskomponenten.

Mit anderen Worten, der Container erstellt für uns dieEntityManager aus denEntityManagerFactory: 

@PersistenceContext
EntityManager entityManager;

Dies bedeutet auchthe container is in charge of beginning, committing, or rolling back the transaction.

4.2. AnwendungsverwalteteEntityManager

Umgekehrt wird der Lebenszyklus vonEntityManager von der Anwendung hier verwaltet.

Tatsächlich erstellen wir dieEntityManager. manuell. Darüber hinaus verwalten wir auch den Lebenszyklus der von uns erstelltenEntityManager.

Zuerst erstellen wir dieEntityManagerFactory: 

EntityManagerFactory emf = Persistence.createEntityManagerFactory("com.example.movie_catalog");

Um einEntityManager zu erstellen, müssen wircreateEntityManager() inEntityManagerFactory explizit aufrufen: 

public static EntityManager getEntityManager() {
    return emf.createEntityManager();
}

5. Entitätsvorgänge im Ruhezustand

DieEntityManager-API bietet eine Sammlung von Methoden. Mit diesen Methoden können wir mit der Datenbank interagieren.

5.1. Persistierende Entitäten

Um dem EntityManager ein Objekt zuzuordnen, können wir die Methodepersist()verwenden: 

public void saveMovie() {
    EntityManager em = getEntityManager();

    em.getTransaction().begin();

    Movie movie = new Movie();
    movie.setId(1L);
    movie.setMovieName("The Godfather");
    movie.setReleaseYear(1972);
    movie.setLanguage("English");

    em.persist(movie);
    em.getTransaction().commit();
}

Sobald das Objekt in der Datenbank gespeichert ist, befindet es sich im Statuspersistent.

5.2. Laden von Entitäten

Zum Abrufen eines Objekts aus der Datenbank können wir die Methodefind()verwenden.

Hier sucht die Methode nach Primärschlüssel. Tatsächlich erwartet die Methode den Entitätsklassentyp und den Primärschlüssel: 

public Movie getMovie(Long movieId) {
    EntityManager em = getEntityManager();
    Movie movie = em.find(Movie.class, new Long(movieId));
    em.detach(movie);
    return movie;
}

However, if we just need the reference to the entity, we can use the getReference() Methode stattdessen. Tatsächlich gibt es einen Proxy an die Entität zurück: 

Movie movieRef = em.getReference(Movie.class, new Long(movieId));

5.3. Entitäten trennen

Für den Fall, dass wir eine Entität vom Persistenzkontext trennen müssen,we can use the detach() method. Wir übergeben das zu trennende Objekt als Parameter an die Methode: 

em.detach(movie);

Sobald die Entität vom Persistenzkontext getrennt ist, befindet sie sich im getrennten Zustand.

5.4. Zusammenführen von Entitäten

In der Praxis erfordern viele Anwendungen eine Entitätsänderung über mehrere Transaktionen hinweg. Beispielsweise möchten wir möglicherweise eine Entität in einer Transaktion zum Rendern auf der Benutzeroberfläche abrufen. Anschließend werden die in der Benutzeroberfläche vorgenommenen Änderungen durch eine andere Transaktion übernommen.

In solchen Situationen können wir die Methodemerge()verwenden. The merge method helps to bring in the modifications made to the detached entity, in the managed entity, if any: 

public void mergeMovie() {
    EntityManager em = getEntityManager();
    Movie movie = getMovie(1L);
    em.detach(movie);
    movie.setLanguage("Italian");
    em.getTransaction().begin();
    em.merge(movie);
    em.getTransaction().commit();
}

5.5. Abfrage nach Entitäten

Darüber hinaus können wir JPQL verwenden, um nach Entitäten abzufragen. Wir werdengetResultList() aufrufen, um sie auszuführen.

Natürlich können wirgetSingleResult(), verwenden, wenn die Abfrage nur ein einziges Objekt zurückgibt: 

public List queryForMovies() {
    EntityManager em = getEntityManager();
    List movies = em.createQuery("SELECT movie from Movie movie where movie.language = ?1")
      .setParameter(1, "English")
      .getResultList();
    return movies;
}

5.6. Entitäten entfernen

Zusätzlichwe can remove an entity from the database using the remove() method. Es ist wichtig zu beachten, dass das Objekt nicht getrennt, sondern entfernt wird.

Hier ändert sich der Status der Entität von persistent zu neu: 

public void removeMovie() {
    EntityManager em = HibernateOperations.getEntityManager();
    em.getTransaction().begin();
    Movie movie = em.find(Movie.class, new Long(1L));
    em.remove(movie);
    em.getTransaction().commit();
}

6. Fazit

In diesem Artikel haben wir dieEntityManager inHibernate untersucht. Wir haben uns die Typen und die Konfiguration angesehen und uns mit den verschiedenen Methoden vertraut gemacht, die in der API für die Arbeit mitpersistence context.verfügbar sind

Wie immer ist der im Artikel verwendete Codeover at Github verfügbar.

Related