JPA-Entitäts-Listener und Rückrufmethoden

Vor JPA 2.1 Das Konzept der Entity Listener (Injectable EntityListeners) wurde erst mit der Veröffentlichung von JPA 2.1 definiert. Das Entity-Listener-Konzept ermöglicht es dem Programmierer, Methoden als Lebenszyklus-Callback-Methoden festzulegen, um Benachrichtigungen über Entitätslebenszyklusereignisse zu erhalten. Rückrufmethoden für den Lebenszyklus können für eine Entitätsklasse, eine zugeordnete Superklasse oder eine Entitäts-Listener-Klasse definiert werden, die einer Entität oder zugeordneten Superklasse zugeordnet ist.

Standard-Entitäts-Listener sind Entitäts-Listener, deren Rückrufmethoden von allen Entitäten aufgerufen wurden, die in einem bestimmten Persistenzkontext (Einheit) definiert sind. Die Lifecycle-Callback-Methoden und Entity-Listener-Klassen können mithilfe von Metadatenanmerkungen oder durch einen XML-Deskriptor definiert werden.

Entity-Listener (Standard-Listener) unter Verwendung der Entity-Listener-Klasse

Wenn Sie bereits nach den Einführungsbeispielen für EclipseLink gesucht haben (siehe EclipseLink-Tutorial), ist es an der Zeit, sich die Ereignisse anzuhören, die durch den Lebenszyklus der Entitäten ausgelöst werden. Schauen wir uns den ersten Entitäts-Listener an, der auf jede definierte Entität in der persistence.xml wartet.

PersistenceContextListener.java

package net.javabeat.eclipselink.data;

import javax.persistence.PostPersist;
import javax.persistence.PostRemove;
import javax.persistence.PostUpdate;
import javax.persistence.PrePersist;
import javax.persistence.PreRemove;
import javax.persistence.PreUpdate;

public class PersistenceContextListener {
 @PrePersist
 public void prePersist(Object object) {
 System.out.println("PersistenceContextListener :: Method PrePersist Invoked Upon Entity :: " + object);
 }

 @PostPersist
 public void postPersist(Object object){
 System.out.println("PersistenceContextListener :: Method PostPersist Invoked Upon Entity :: " + object);
 }

 @PreRemove
 public void PreRemove(Object object){
 System.out.println("PersistenceContextListener :: Method PreRemove Invoked Upon Entity :: " + object);
 }

 @PostRemove
 public void PostRemove(Object object){
 System.out.println("PersistenceContextListener :: Method PostRemove Invoked Upon Entity :: " + object);
 }

 @PreUpdate
 public void PreUpdate(Object object){
 System.out.println("PersistenceContextListener :: Method PreUpdate Invoked Upon Entity :: " + object);
 }

 @PostUpdate
 public void PostUpdate(Object object){
 System.out.println("PersistenceContextListener :: Method PostUpdate Invoked Upon Entity :: " + object);
 }

}
  • Rückrufmethoden für den Entitätslebenszyklus können für eine Entitäts-Listener-Klasse definiert werden.
  • Lebenszyklus-Callback-Methoden werden mit einer Annotation versehen, die die Callback-Ereignisse angibt, für die sie aufgerufen werden.
  • Rückrufmethoden, die für eine Entitäts-Listener-Klasse definiert sind, sollten die folgenden Signaturen haben: void (Objekt), das Objektargument ist die Entitätsklasse, für die die Rückrufmethode aufgerufen wird.
  • Die Rückrufmethoden können öffentlichen, privaten, geschützten oder Paketebenenzugriff haben, dürfen jedoch nicht statisch oder endgültig sein.
  • Die folgenden Anmerkungen bezeichnen Rückrufmethoden für Lebenszyklusereignisse der entsprechenden Typen (Entitäten).
  • PrePersist: Diese Rückrufmethode wird für eine bestimmte Entität aufgerufen, bevor der entsprechende Entitätsmanager einen Persistenzvorgang für diese Entität ausführt.
  • PostPersist: Diese Rückrufmethode wird für eine bestimmte Entität aufgerufen, nachdem der entsprechende Entitätsmanager einen Persistenzvorgang für diese Entität ausgeführt hat.
  • Vorab entfernen: Diese Rückrufmethode wird für eine bestimmte Entität aufgerufen, bevor der entsprechende Entitätsmanager den Entfernungsvorgang für diese Entität ausführt.
  • PostRemove: Diese Rückrufmethode wird für eine bestimmte Entität aufgerufen, nachdem der entsprechende Entitätsmanager den Entfernungsvorgang für diese Entität ausgeführt hat.
  • Vorabaktualisierung: Diese Rückrufmethode wird für eine bestimmte Entität aufgerufen, bevor der entsprechende Entitätsmanager den Zusammenführungsvorgang für diese Entität ausführt.
  • PostUpdate: Diese Rückrufmethode wird für eine bestimmte Entität aufgerufen, nachdem der entsprechende Entitätsmanager den Zusammenführungsvorgang für diese Entität ausgeführt hat.
  • PostLoad: Die PostLoad-Methode für eine Entität wird aufgerufen, nachdem die Entität aus der Datenbank in den aktuellen Persistenzkontext geladen wurde oder nachdem der Aktualisierungsvorgang auf sie angewendet wurde.
  • Die Entität und die zugeordnete Superklasse mit Listener

    Nachdem wir einen separaten Entitäts-Listener gesehen haben, wollen wir uns einen Listener ansehen, der bei der Entität selbst definiert werden könnte.

    Adresse.java

    package net.javabeat.eclipselink.data;
    
    import javax.persistence.CascadeType;
    import javax.persistence.EmbeddedId;
    import javax.persistence.Entity;
    import javax.persistence.OneToOne;
    import javax.persistence.PrePersist;
    
    @Entity(name="address")
    public class Address {
     @EmbeddedId
     private AddressPK addressId;
     private String addressCountry;
     private String addressCity;
    
     @OneToOne(cascade=CascadeType.ALL,mappedBy="address")
     private Employee employee;
    
     public Employee getEmployee() {
     return employee;
     }
    
     public void setEmployee(Employee employee) {
     this.employee = employee;
     }
    
    public String getAddressCountry() {
     return addressCountry;
     }
     public void setAddressCountry(String addressCountry) {
     this.addressCountry = addressCountry;
     }
     public String getAddressCity() {
     return addressCity;
     }
     public void setAddressCity(String addressCity) {
     this.addressCity = addressCity;
     }
    
    public AddressPK getAddressId() {
     return addressId;
     }
    
    public void setAddressId(AddressPK addressId) {
     this.addressId = addressId;
     }
    
     @PrePersist
     public void prePersist(){
     System.out.println("Address Entity :: Method PrePersist Invoked Upon Entity "+this);
     }
    
    }
    
    

    Lizenz.java

    
    package net.javabeat.eclipselink.data;
    
    import javax.persistence.CascadeType;
    import javax.persistence.GeneratedValue;
    import javax.persistence.GenerationType;
    import javax.persistence.Id;
    import javax.persistence.JoinColumn;
    import javax.persistence.ManyToOne;
    import javax.persistence.MappedSuperclass;
    import javax.persistence.PostRemove;
    import javax.persistence.PrePersist;
    import javax.persistence.PreRemove;
    import javax.persistence.TableGenerator;
    
    @MappedSuperclass
    public abstract class License {
    
    @Id
     @GeneratedValue(generator="LICENSE_SEQ",strategy=GenerationType.SEQUENCE)
     @TableGenerator(name="LICENSE_SEQ",pkColumnName="SEQ_NAME",valueColumnName="SEQ_NUMBER",pkColumnValue="LICENSE_ID",allocationSize=1,table="sequences")
     protected int licenseId;
    
    @ManyToOne(cascade = CascadeType.ALL)
     @JoinColumn(name = "employeeId")
     private Employee employee;
    
    public Employee getEmployee() {
     return employee;
     }
    
    public void setEmployee(Employee employee) {
     this.employee = employee;
     }
    
    public int getLicenseId() {
     return licenseId;
     }
    
    public void setLicenseId(int licenseId) {
     this.licenseId = licenseId;
     }
    
     @PrePersist
     public void prePersist(){
     System.out.println("License Entity :: Method PrePersist Invoked Upon Entity "+this);
     }
    
     @PreRemove
     public void peRemove(){
     System.out.println("License Entity :: Method PreRemove Invoked Upon Entity "+this);
     }
    
     @PostRemove
     public void postRemove(){
     System.out.println("License Entity :: Method PostRemove Invoked Upon Entity "+this);
     }
    }
    
    
    • Rückrufmethoden für den Entitätslebenszyklus können für eine Entitätsklasse definiert werden.
    • Lebenszyklus-Callback-Methoden werden mit Annotationen versehen, die die Callback-Ereignisse angeben, für die sie innerhalb der definierten Entität aufgerufen werden.
    • Rückrufmethoden, die für eine Entitäts-Listener-Klasse definiert sind, sollten die folgenden Signaturen haben: void ().
    • Die Rückrufmethoden können öffentlichen, privaten, geschützten oder Paketebenenzugriff haben, dürfen jedoch nicht statisch oder endgültig sein.
    • Die Anmerkungen, die das Abhören der Entitätslebenszyklusereignisse ermöglichen, sind dieselben wie diejenigen, die in der oben definierten Entitäts-Listener-Klasse definiert sind.
    • Die Definition der Rückrufmethoden für Lebenszyklusereignisse ist dieselbe wie in der abgebildeten zugeordneten Oberklasse definiert.

    Persistenzkonfiguration

    <?xml version="1.0" encoding="UTF-8"?>
    <persistence version="2.1" xmlns="http://xmlns.jcp.org/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd">
     <persistence-unit name="EclipseLink-JPA-Installation" transaction-type="RESOURCE_LOCAL">
     <class>net.javabeat.eclipselink.data.Employee</class>
     <class>net.javabeat.eclipselink.data.Address</class>
     <class>net.javabeat.eclipselink.data.AddressPK</class>
     <class>net.javabeat.eclipselink.data.License</class>
     <class>net.javabeat.eclipselink.data.DriverLicense</class>
     <properties>
     <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/JavaBeat"/>
     <property name="javax.persistence.jdbc.user" value="root"/>
     <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
     <property name="javax.persistence.jdbc.password" value="root"/>
     <property name="eclipselink.logging.level" value="OFF"/>
     </properties>
     </persistence-unit>
    </persistence>
    

    Ausführbare Anwendung

    
    package net.javabeat.eclipselink;
    
    import java.math.BigDecimal;
    import java.util.ArrayList;
    import java.util.Date;
    import java.util.List;
    
    import javax.persistence.EntityManager;
    import javax.persistence.EntityManagerFactory;
    import javax.persistence.Persistence;
    
    import net.javabeat.eclipselink.data.Address;
    import net.javabeat.eclipselink.data.AddressPK;
    import net.javabeat.eclipselink.data.ContractDeveloper;
    import net.javabeat.eclipselink.data.Developer;
    import net.javabeat.eclipselink.data.DriverLicense;
    import net.javabeat.eclipselink.data.Employee;
    import net.javabeat.eclipselink.data.EmployeePeriod;
    import net.javabeat.eclipselink.data.FreelanceDeveloper;
    import net.javabeat.eclipselink.data.GlobalProject;
    import net.javabeat.eclipselink.data.ICDLComputerLicense;
    import net.javabeat.eclipselink.data.License;
    import net.javabeat.eclipselink.data.LocalProject;
    import net.javabeat.eclipselink.data.Phone;
    import net.javabeat.eclipselink.data.PhonePK;
    import net.javabeat.eclipselink.data.Project;
    
    public class JPAImpl {
     static EntityManagerFactory factory = null;
     static EntityManager em = null;
     static {
     factory = Persistence.createEntityManagerFactory("EclipseLink-JPA-Installation");
     em = factory.createEntityManager();
     }
    
     public static void main(String () args){
     // Begin a Transaction for creation
     em.getTransaction().begin();
     // Find the Employee
     Employee employee = createEmployee();
     // Find the Employee
     License license = createDriverLicense(employee);
     // Commit
     em.getTransaction().commit();
    
     // Begin a Transaction for Update an Employee
     em.getTransaction().begin();
     // Find the Employee
     employee.setEmployeeName("Edward Halshmit");
     em.merge(employee);
     // Commit
     em.getTransaction().commit();
    
     // Begin a Transaction for removing an employee and driver license
     em.getTransaction().begin();
     // Remove License
     em.remove(license);
     // Find the Employee
     em.remove(employee);
     // Commit
     em.getTransaction().commit();
    
     }
    
     public static Employee createEmployee(){
     // Create an address entity
     Address address = new Address();
     AddressPK addressPk = new AddressPK();
     addressPk.setAddressCountryId(1);
     addressPk.setAddressId(1);
     address.setAddressId(addressPk);
     // Address Embeddable class (Type) instantiation
     address.setAddressCountry("United Kingdom");
     address.setAddressCity("London");
     // Create an employee entity
     Employee employee = new Employee();
     employee.setEmployeeId(1);
     employee.setEmployeeName("John Smith");
    
     // Create an Employee Period Instance
     EmployeePeriod period = new EmployeePeriod();
     period.setStartDate(new Date());
     period.setEndDate(new Date());
    
     employee.setEmployeePeriod(period);
    
     // Associate the address with the employee
     employee.setAddress(address);
     // Create a Phone entity
     Phone firstPhone = new Phone();
     // PhoneId and PhoneCountryKeyId is now the primary key for the phone entity
     firstPhone.setPhoneId(1);
     firstPhone.setPhoneCountryKeyId("+441");
     firstPhone.setPhoneNumber("4050 615");
     firstPhone.setEmployee(employee);
     // Create a list of phone
     List phones = new ArrayList();
     phones.add(firstPhone);
    
     // Create a list of projects
     List projects = new ArrayList();
    
     // Set the project into employee
     employee.setProjects(projects);
     // Set the phones into your employee
     employee.setPhones(phones);
    
     // Persist the employee
    
     em.persist(employee);
    
     // return the persisted employee
     return employee;
     }
    
    public static License createDriverLicense(Employee employee){
     DriverLicense license = new DriverLicense(); // Create a driver license
     license.setDriverLicenseName("All Vehicles License"); // Set License Name
     license.setDriverLicenseIssueDate(new Date()); // Anonymous date
     license.setDriverLicenseExpiryDate(new Date()); // Anonymous date
     license.setEmployee(employee);
     em.persist(license);
     return license;
     }
    
    }
    
    

    Die auf die Lifecycle-Callback-Methoden angewendeten Regeln

    Für Lebenszyklus-Callback-Methoden gelten die folgenden Regeln:

    • Lebenszyklus-Callback-Methoden können ungeprüfte/Laufzeit-Ausnahmen auslösen. Eine Laufzeitausnahme, die von einer Rückrufmethode ausgelöst wird, die innerhalb einer Transaktion ausgeführt wird, führt dazu, dass diese Transaktion für ein Rollback markiert wird, wenn der Persistenzkontext mit der Transaktion verbunden ist.
    • Lebenszyklusrückrufe können JNDI, JDBC, JMS und Enterprise Beans aufrufen.
    • Im Allgemeinen sollte die Lebenszyklusmethode einer portablen Anwendung nicht EntityManager aufrufen oder Optionen abfragen, auf andere Instanzen zugreifen oder Beziehungen innerhalb desselben Persistenzkontexts ändern. Eine Lebenszyklus-Rückrufmethode kann den Nicht-Beziehungsstatus der Entität ändern, für die sie aufgerufen wird.

    Vorrang der Listener-Ausführung

    Die Rangfolge der Listener-Ausführung ist wie folgt geregelt:

    • Der Standard-Listener wird zuerst ausgeführt. Der Standard-Listener gilt für alle Entitäten in der Persistenzeinheit. Wenn Sie also mehrere Listener in @EntityListener definiert haben, wie Sie es in der Entität „Employee“ gesehen haben, werden die Rückrufmethoden in der Reihenfolge als Listener aufgerufen angegeben, sofern nicht ausdrücklich durch die ExecludedDefaultListeners-Annotation ausgeschlossen.
    • Die Rückrufmethoden, die innerhalb der Entität oder der zugeordneten Superklassen selbst definiert sind, sollten nach dem Standard-Listener und in derselben Reihenfolge ausgeführt werden.
    • Wenn mehrere Klassen in einer Vererbungshierarchie (Entitätsklassen oder zugeordnete Superklassen) Entitäts-Listener definieren, werden die in den Superklassen definierten Listener vor den für ihre Unterklassen definierten Listener aufgerufen.

    Das Ergebnis einer ausführbaren Anwendung

    
    PersistenceContextListener :: Method PrePersist Invoked Upon Entity :: net.javabeat.eclipselink.data.Employee@d5d4de6
    Address Entity :: Method PrePersist Invoked Upon Entity net.javabeat.eclipselink.data.Address@6e92b1a1
    License Entity :: Method PrePersist Invoked Upon Entity net.javabeat.eclipselink.data.DriverLicense@47f08ed8
    PersistenceContextListener :: Method PostPersist Invoked Upon Entity :: net.javabeat.eclipselink.data.Employee@d5d4de6
    PersistenceContextListener :: Method PreUpdate Invoked Upon Entity :: net.javabeat.eclipselink.data.Employee@d5d4de6
    PersistenceContextListener :: Method PostUpdate Invoked Upon Entity :: net.javabeat.eclipselink.data.Employee@d5d4de6
    License Entity :: Method PreRemove Invoked Upon Entity net.javabeat.eclipselink.data.DriverLicense@47f08ed8
    PersistenceContextListener :: Method PreRemove Invoked Upon Entity :: net.javabeat.eclipselink.data.Employee@d5d4de6
    License Entity :: Method PostRemove Invoked Upon Entity net.javabeat.eclipselink.data.DriverLicense@47f08ed8
    PersistenceContextListener :: Method PostRemove Invoked Upon Entity :: net.javabeat.eclipselink.data.Employee@d5d4de6
    
    

    Was wäre, wenn wir die Entitäten „Lizenz“ und „Adresse“ geändert hätten, indem wir ihnen erlaubt hätten, bei ihrer Deklaration einen @EntityListener zu definieren, um auf den PersistenceContextListener zu verweisen, wie Sie bei der Entität „Employee“ gesehen haben?

    Das Ergebnis der ausführbaren Anwendung nach der letzten Änderung

    
    PersistenceContextListener :: Method PrePersist Invoked Upon Entity :: net.javabeat.eclipselink.data.Employee@343aff84
    PersistenceContextListener :: Method PrePersist Invoked Upon Entity :: net.javabeat.eclipselink.data.Address@301db5ec
    Address Entity :: Method PrePersist Invoked Upon Entity net.javabeat.eclipselink.data.Address@301db5ec
    PersistenceContextListener :: Method PrePersist Invoked Upon Entity :: net.javabeat.eclipselink.data.DriverLicense@77546dbc
    License Entity :: Method PrePersist Invoked Upon Entity net.javabeat.eclipselink.data.DriverLicense@77546dbc
    PersistenceContextListener :: Method PostPersist Invoked Upon Entity :: net.javabeat.eclipselink.data.Address@301db5ec
    PersistenceContextListener :: Method PostPersist Invoked Upon Entity :: net.javabeat.eclipselink.data.Employee@343aff84
    PersistenceContextListener :: Method PostPersist Invoked Upon Entity :: net.javabeat.eclipselink.data.DriverLicense@77546dbc
    PersistenceContextListener :: Method PreUpdate Invoked Upon Entity :: net.javabeat.eclipselink.data.Employee@343aff84
    PersistenceContextListener :: Method PostUpdate Invoked Upon Entity :: net.javabeat.eclipselink.data.Employee@343aff84
    PersistenceContextListener :: Method PreRemove Invoked Upon Entity :: net.javabeat.eclipselink.data.DriverLicense@77546dbc
    License Entity :: Method PreRemove Invoked Upon Entity net.javabeat.eclipselink.data.DriverLicense@77546dbc
    PersistenceContextListener :: Method PreRemove Invoked Upon Entity :: net.javabeat.eclipselink.data.Employee@343aff84
    PersistenceContextListener :: Method PreRemove Invoked Upon Entity :: net.javabeat.eclipselink.data.Address@301db5ec
    PersistenceContextListener :: Method PostRemove Invoked Upon Entity :: net.javabeat.eclipselink.data.DriverLicense@77546dbc
    License Entity :: Method PostRemove Invoked Upon Entity net.javabeat.eclipselink.data.DriverLicense@77546dbc
    PersistenceContextListener :: Method PostRemove Invoked Upon Entity :: net.javabeat.eclipselink.data.Employee@343aff84
    PersistenceContextListener :: Method PostRemove Invoked Upon Entity :: net.javabeat.eclipselink.data.Address@301db5ec
    
    

    Vererbung von Callback-Lebenszyklusmethoden

    Die Vererbung von Rückruf-Lebenszyklusmethoden ist anwendbar, sodass eine Lebenszyklus-Rückrufmethode für dasselbe Lebenszyklusereignis auch für die Entitätsklasse oder eine oder mehrere ihrer Entitäten oder zugeordneten Oberklassen angegeben wird. Die Rückrufmethoden für die Entitätsklasse oder Oberklassen werden zuerst aufgerufen.

    Den Unterklassen ist es gestattet, eine geerbte Rückrufmethode desselben Rückruftyps zu überschreiben (dh dieselbe Methode der Oberklasse in der Unterklasse mit demselben Annotationstyp zu überschreiben). In diesem Fall wird die überschriebene Methode nicht aufgerufen. Sehen wir uns die DriverLicense an, die die prePersist-Methode überschreibt, die mit demselben Rückruftyp versehen ist (@PrePersist)

    DriverLicense.java

    
    package net.javabeat.eclipselink.data;
    
    import java.util.Date;
    
    import javax.persistence.Entity;
    import javax.persistence.PrePersist;
    import javax.persistence.Table;
    import javax.persistence.Temporal;
    import javax.persistence.TemporalType;
    
    @Entity
    @Table(name="driverlicenses")
    public class DriverLicense extends License{
    
     private String driverLicenseName;
     @Temporal(TemporalType.DATE)
     private Date driverLicenseExpiryDate;
     @Temporal(TemporalType.DATE)
     private Date driverLicenseIssueDate;
    
     public String getDriverLicenseName() {
     return driverLicenseName;
     }
     public void setDriverLicenseName(String driverLicenseName) {
     this.driverLicenseName = driverLicenseName;
     }
     public Date getDriverLicenseExpiryDate() {
     return driverLicenseExpiryDate;
     }
     public void setDriverLicenseExpiryDate(Date driverLicenseExpiryDate) {
     this.driverLicenseExpiryDate = driverLicenseExpiryDate;
     }
     public Date getDriverLicenseIssueDate() {
     return driverLicenseIssueDate;
     }
     public void setDriverLicenseIssueDate(Date driverLicenseIssueDate) {
     this.driverLicenseIssueDate = driverLicenseIssueDate;
     }
    
     @PrePersist
     public void prePersist(){
     System.out.println("DriverLicense Entity :: Method PrePersist Invoked Upon Entity "+this);
     }
    
    }
    
    

    Das Ergebnis ist

    
    PersistenceContextListener :: Method PrePersist Invoked Upon Entity :: net.javabeat.eclipselink.data.Employee@74b957ea
    PersistenceContextListener :: Method PrePersist Invoked Upon Entity :: net.javabeat.eclipselink.data.Address@edc86eb
    Address Entity :: Method PrePersist Invoked Upon Entity net.javabeat.eclipselink.data.Address@edc86eb
    PersistenceContextListener :: Method PrePersist Invoked Upon Entity :: net.javabeat.eclipselink.data.DriverLicense@6f7918f0
    DriverLicense Entity :: Method PrePersist Invoked Upon Entity net.javabeat.eclipselink.data.DriverLicense@6f7918f0
    PersistenceContextListener :: Method PostPersist Invoked Upon Entity :: net.javabeat.eclipselink.data.Address@edc86eb
    PersistenceContextListener :: Method PostPersist Invoked Upon Entity :: net.javabeat.eclipselink.data.Employee@74b957ea
    PersistenceContextListener :: Method PostPersist Invoked Upon Entity :: net.javabeat.eclipselink.data.DriverLicense@6f7918f0
    PersistenceContextListener :: Method PreUpdate Invoked Upon Entity :: net.javabeat.eclipselink.data.Employee@74b957ea
    PersistenceContextListener :: Method PostUpdate Invoked Upon Entity :: net.javabeat.eclipselink.data.Employee@74b957ea
    PersistenceContextListener :: Method PreRemove Invoked Upon Entity :: net.javabeat.eclipselink.data.DriverLicense@6f7918f0
    License Entity :: Method PreRemove Invoked Upon Entity net.javabeat.eclipselink.data.DriverLicense@6f7918f0
    PersistenceContextListener :: Method PreRemove Invoked Upon Entity :: net.javabeat.eclipselink.data.Employee@74b957ea
    PersistenceContextListener :: Method PreRemove Invoked Upon Entity :: net.javabeat.eclipselink.data.Address@edc86eb
    PersistenceContextListener :: Method PostRemove Invoked Upon Entity :: net.javabeat.eclipselink.data.DriverLicense@6f7918f0
    License Entity :: Method PostRemove Invoked Upon Entity net.javabeat.eclipselink.data.DriverLicense@6f7918f0
    PersistenceContextListener :: Method PostRemove Invoked Upon Entity :: net.javabeat.eclipselink.data.Employee@74b957ea
    PersistenceContextListener :: Method PostRemove Invoked Upon Entity :: net.javabeat.eclipselink.data.Address@edc86eb
    
    
    • Wenn Sie versucht haben, eine Methode zu überschreiben, ohne denselben Methodennamen und denselben Rückruftyp anzugeben, handelt es sich wahrscheinlich um eine neue Methode, die nicht als Überschreibung einer Rückrufmethode gilt.

    Zusammenfassung

    Die Entity-Callback-Lebenszyklusmethoden sind eines der wichtigen Themen, wenn Sie versuchen, tief in die JPA einzusteigen. Dieses Tutorial bietet Ihnen die erforderliche Definition und Anzahl der Rückrufmethoden, die Ihnen beim Debuggen und Durchlaufen der verschiedenen Vorgänge von JPA helfen können.

    Kommentar verfassen

    Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

    Nach oben scrollen