JPA-Anmerkungen – @GeneratedValue, @SequenceGenerator und @TableGenerator

Wir haben bereits eine andere Art von Primärschlüsseln besprochen, entweder einfache oder zusammengesetzte Primärschlüssel, denen in den erstellten ausführbaren Anwendungen Inline-Werte zugewiesen wurden. Wenn Sie sich die Beispiele @Id, @IdClass oder @EmbeddedId ansehen, können Sie das sehen. Aber was wäre, wenn wir einen Generator hätten, um diese Primärwerte zu generieren? In diesem Tutorial wird das ID-Generator-Konzept ausführlich erläutert. Die Java Persistence API einschließlich der EclipseLink-Distribution bietet verschiedene Arten von Anmerkungen zur Primärschlüsselgenerierung.

@GeneratedValue

Der @GeneratedValue stellt den Einstiegspunkt für die Primärschlüsselgenerierung dar und bietet die Spezifikation von Generierungsstrategien für die Werte von Primärschlüsseln. Die GeneratedValue-Annotation kann in Verbindung mit der Id-Annotation auf eine Primärschlüsseleigenschaft eines Felds einer Entität oder einer zugeordneten Superklasse angewendet werden. Die Werte, die mit @GeneratedValue verwendet werden können, sind die Werte, die in der Aufzählung GenerationType definiert sind. GenerationType.java

public enum GenerationType {TABLE,SEQUENCE,IDENTITY,AUTO};
  • TISCH: Ist ein Wert vom Typ Generator, gibt er an, dass der Entität mithilfe einer Datenbanktabelle Primärschlüssel zugewiesen werden müssen, um die Eindeutigkeit sicherzustellen.
  • SEQUENZ & IDENTITÄT: Sind Generatortypen, die die Verwendung einer Datenbanksequenz bzw. Identitätsspalte angeben.
  • AUTO: Ist ein Generatortyp angegeben, dass der Persistenzanbieter eine geeignete Strategie für die jeweilige Datenbank auswählen sollte.

Anatomie von @GeneratedValue

  • Ziel: Feld und Methode
  • Verwendet:@GeneratedValue
  • Streit:
  • Strategie (Optional): Die Primärschlüsselgenerierungsstrategie, die der Persistenzanbieter verwenden muss, um den Primärschlüssel der annotierten Entität zu generieren.
  • Generator (Optional): Der Name des zu verwendenden Primärgenerators, wie im SequenceGenerator oder TableGenerator angegeben.

Sehen wir uns die Umsetzung verschiedener Strategien mit derselben Entität an. Wie Sie bereits im EclipseLink-Tutorial bemerkt haben, haben wir zuvor eine zugeordnete Superklasse erstellt, daher sollte dieses Tutorial alle Strategien anhand des Beispiels einer Lizenzklasse verdeutlichen.

Lizenzeinheit

Die folgende Klasse zeigt Ihnen die Lizenzentität ohne Verwendung des @GeneratedValue.


package net.javabeat.eclipselink.data;

import javax.persistence.CascadeType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.MappedSuperclass;

@MappedSuperclass
public abstract class License {

@Id
protected int licenseId; // This primary key field has no generator

@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;
}
}

  • Die der Lizenz zugeordnete Superklasse stellt eine Identität mit dem Namen „licenseId“ bereit.
  • Die Lizenz-ID verfügt über keinen Primärschlüsselgenerator
  • Falls wir keinen Generator verwendet und keinen Primärschlüsselwert bereitgestellt haben, berücksichtigt die JPA den Standardwert für int-Primitivtypen (der Standardwert ist Null) und die Beibehaltung wird zum ersten Mal erfolgreich sein. Aber wenn es in die zweite Persistenz kommt, löst die JPA eine Ausnahme aus, die darauf hinweist, dass (Doppelter Eintrag „0“ für den Schlüssel-Primärschlüssel) vorliegt.

Primärschlüsselgenerierung mit Sequenzgenerator

In diesem Beispiel sehen Sie eine Datenbanksequenz zum Generieren eines Primärschlüssels.

Anatomie von @SequenceGenerator

Die Annotation @SequenceGenerator definiert einen Primärschlüsselgenerator, auf den namentlich verwiesen werden kann, wenn ein Generatorelement für die Annotation GeneratedValue angegeben wird. Ein Sequenzgenerator kann in der Entitätsklasse oder im Primärschlüsselfeld oder in der Eigenschaft angegeben werden.

  • Ziel: Typ, Methode und Feld
  • Verwendet:@SequenceGenerator
  • Streit:
  • Name (erforderlich): Ein eindeutiger Generatorname, auf den eine oder mehrere Klassen als Generator für Primärschlüsselwerte verweisen können.
  • sequenceName (Optional): Der Name des Datenbanksequenzobjekts, von dem Primärschlüsselwerte abgerufen werden sollen.
  • initialValue (Optional): Der Wert, ab dem das Sequenzobjekt mit der Generierung beginnen soll.
  • allokationsgröße (Optional): Der Betrag, um den beim Zuweisen von Sequenznummern aus der Sequenz erhöht werden soll.

Erstellung von Datenbanksequenzen

Dieses Beispiel für die Sequenzerstellung sollte die Oracle-Datenbank verwenden, da MySQL die automatische Inkrementierung unterstützt, die nicht als Sequenz betrachtet wird. Die Abbildungen 1.0 und 1.1 zeigen die DriverLicense-Tabelle und die Sequenz, die in der Oracle-Datenbank erstellt wurden. Beachten Sie, dass die DriverLicense-Tabelle keine weiteren Beziehungen berücksichtigt, wie Sie in den vorherigen Beispielen gesehen haben. Führerscheintabelle

Abbildung 1.0

Reihenfolge des Führerscheins

Abbildung 1.1

Die Lizenzentität verwendet einen Sequenzgenerator

Die folgende Lizenzentität verwendet den Sequenzgenerator zum Generieren der Primärschlüssel für die Entitäten, die aus der Lizenz erstellt wurden (falls die Lizenz keiner Oberklasse zugeordnet ist) und von jeder Entität, die zur Lizenzvererbung gehört. Lizenz.java


package net.javabeat.eclipselink.data;

import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.MappedSuperclass;
import javax.persistence.SequenceGenerator;

@MappedSuperclass
public abstract class License {

@Id
@GeneratedValue(strategy=GenerationType.SEQUENCE,generator="LICENSE_SEQ")
@SequenceGenerator(name="LICENSE_SEQ",sequenceName="LICENSE_SEQ",allocationSize=1)
protected int licenseId;

public int getLicenseId() {
return licenseId;
}

public void setLicenseId(int licenseId) {
this.licenseId = licenseId;
}
}

DriverLicense.java


package net.javabeat.eclipselink.data;

import java.util.Date;

import javax.persistence.Entity;
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;
}
}

  • Die Lizenzentität verwendet @GeneratedValue, um sowohl den Generatortyp als auch den Namen bereitzustellen.
  • Der Generatortyp ist SEQUENCE und der Name ist LICENSE_SEQ.
  • Die Lizenzentität verwendet den @SequenceGenerator, um den Namen der Sequenz bereitzustellen, die vom @GeneratedValue verwendet wird, den Namen der Datenbanksequenz und die Zuordnungsgröße.

Erforderliche Persistenzkonfiguration

persistence.xml

<persistence-unit name="EclipseLink-JPA-OracleDS" transaction-type="RESOURCE_LOCAL">
<!-- Entities Created Before -->
<class>net.javabeat.eclipselink.data.License</class>
<class>net.javabeat.eclipselink.data.DriverLicense</class>
<properties>
<property name="javax.persistence.jdbc.url" value="jdbc:oracle:thin:@localhost:1521:xe"/>
<property name="javax.persistence.jdbc.user" value="ucm"/>
<property name="javax.persistence.jdbc.driver" value="oracle.jdbc.OracleDriver"/>
<property name="javax.persistence.jdbc.password" value="ucm"/>
</properties>
</persistence-unit>

Erforderliche Bibliotheken

Wie Sie oben in der Datei persistence.xml festgestellt haben, handelt es sich bei der Datenbank, die zum Erstellen eines Sequenzgenerators verwendet wird, um eine Oracle-Datenbank. Sie haben also eine neue Bibliothek in Ihrem Projektklassenpfad installiert, deren JAR-Datei ojdbc14.jar heißt. Um eine neue Bibliothek zu installieren, müssen Sie die folgenden Schritte ausführen:

  • Klicken Sie mit der rechten Maustaste auf das Projekt, dessen JAR Sie in seinem Klassenpfad hinzufügen möchten.
  • Wählen Sie im linken Bereich Java Build Path aus.
  • Klicken Sie im Bereich „Java Build Path“ auf „Externe JARs hinzufügen“.
  • Fügen Sie die JAR hinzu, indem Sie zu ihrem JAR-Speicherort navigieren.

Ausführbare Anwendung zum Generieren eines Primärschlüssels mithilfe des Sequenzgenerators

JPAImpl.java


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.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-OracleDS");
em = factory.createEntityManager();
}

public static void main(String [] args){
// Begin a Transaction
em.getTransaction().begin();
// Create a Driver License
createDriverLicense();
// Commit
em.getTransaction().commit();
}

public static void createDriverLicense(){
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
em.persist(license);
}

}

  • Die DriverLicense-Entität stellt keinen Primärschlüssel bereit, wie Sie in den bereitgestellten Beispielen im EclipseTutorial festgestellt haben.
  • Die Primärschlüssel werden automatisch mithilfe eines SequenceGenetator generiert, der in der der Lizenz zugeordneten Oberklasse definiert ist.

Die persistenten Datensätze mithilfe des Sequenzgenerators

Abbildung 1.2 zeigt die Datensätze, die mithilfe eines Sequenzgenerators in der Oracle-Datenbank gespeichert wurden. Lizenzdatensätze mit einem Sequenzgenerator

Abbildung 1.2

Primärschlüsselgenerierung mit Tabellengenerator

In diesem Beispiel sehen Sie eine Datenbanktabelle zum Generieren eines Primärschlüssels.

Anatomie von @TableGenerator

Die Annotation @TableGenerator definiert einen Primärschlüsselgenerator, auf den über seinen Namen verwiesen werden kann, wenn ein Generatorelement für @GeneratedValue angegeben wird. Ein Tabellengenerator kann für die Entitätsklasse oder für das Primärschlüsselfeld oder die Primärschlüsseleigenschaft angegeben werden.

  • Ziel: Typ, Methode und Feld
  • Verwendet:@TableGenerator
  • Streit:
  • Name (erforderlich): Ein eindeutiger Generatorname, auf den eine oder mehrere Klassen als Generator für ID-Werte verweisen können.
  • Tabelle (Optional): Name der Tabelle, die die generierten ID-Werte speichert.
  • Katalog (Optional): Der Katalog der Tabelle.
  • Schema (optional): Das Schema der Tabelle.
  • pKColumnName (Optional): Name der Primärschlüsselspalte in der Tabelle.
  • valueColumnName (Optional): Name der Spalte, die den zuletzt generierten Wert speichert.
  • pKColumnValue (Optional): Der Primärschlüsselwert in der Generatortabelle, der diesen Satz generierter Werte von anderen unterscheidet, die möglicherweise in der Tabelle gespeichert sind.
  • initialValue (Optional): Der Wert, der zum Initialisieren der Spalte verwendet wird, in der der zuletzt generierte Wert gespeichert wird.
  • allokationsgröße (Optional): Der Betrag, um den bei der Zuweisung von ID-Nummern vom Generator erhöht werden soll.
  • uniqueConstraints (Optional): Eindeutige Einschränkungen, die in der Tabelle platziert werden sollen.

Erstellung einer Datenbanktabellensequenz

Die MySQL-Datenbank ist in der Lage, Tabellensequenzen zu erstellen, daher kehren wir in diesem Abschnitt der Primärschlüsselgenerierung zu den vorherigen Beispielen zurück, die bereits mit der MySQL-Datenbank erstellt wurden. Abbildung 1.0 und 1.1 zeigen die Tabellensequenz und die DriverLicense-Tabelle, die jeweils in der MySQL-Datenbank erstellt wurden.

Tabellenfolge

Abbildung 1.0

Zuvor erstellter Führerschein

Abbildung 1.1

  • Die erstellte Tabellensequenz enthält zwei Spalten, eine für den Sequenznamen und eine für die Sequenznummer.
  • An der Tabelle der Laufwerkslizenzen hat sich nichts geändert.

Die Lizenzentität verwendet einen Tabellensequenzgenerator

Die folgende Lizenzentität verwendet den Tabellensequenzgenerator zum Generieren der Primärschlüssel für die Entitäten, die aus der Lizenz erstellt wurden (falls die Lizenz keiner Oberklasse zugeordnet ist) und aus einer beliebigen Entität, die zur Lizenzvererbung gehört. 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.TableGenerator;

@MappedSuperclass
public abstract class License {

@Id
@GeneratedValue(generator="LICENSE_TABLE_SEQ",strategy=GenerationType.TABLE)
@TableGenerator(name="LICENSE_TABLE_SEQ",
table="sequences",
pkColumnName="SEQ_NAME", // Specify the name of the column of the primary key
valueColumnName="SEQ_NUMBER", // Specify the name of the column that stores the last value generated
pkColumnValue="LICENSE_ID", // Specify the primary key column value that would be considered as a primary key generator
allocationSize=1)
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;
}
}

DriverLicense.java


package net.javabeat.eclipselink.data;

import java.util.Date;

import javax.persistence.Entity;
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;
}
}

Erforderliche Persistenzkonfiguration

<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">

<!-- Some Entities have omit intentionally -->

<class>net.javabeat.eclipselink.data.License</class>
<class>net.javabeat.eclipselink.data.DriverLicense</class>
<class>net.javabeat.eclipselink.data.Employee</class>
<class>net.javabeat.eclipselink.data.ICDLComputerLicense</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="FINEST"/>
<property name="" value=""/>
</properties>
</persistence-unit>
  • Wenn Sie die vorherigen Entitäten noch nie zuvor gesehen haben und mehr darüber erfahren möchten, lesen Sie das EclipseLink-Tutorial.
  • Die DriverLicense wird in der persistence.xml erwähnt
  • Die der Lizenz zugeordnete Superklasse wird in der Datei persistence.xml erwähnt
  • Der Generator der Primärschlüssel muss nicht erwähnt werden.

Ausführbare Anwendung zum Generieren eines Primärschlüssels mithilfe des Tabellensequenzgenerators

JPAImpl.java


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.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
em.getTransaction().begin();
// Find the Employee
Employee employee = em.find(Employee.class, 1);
// Create a Driver License
createDriverLicense(employee);
// Commit
em.getTransaction().commit();
}

public static void 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);
}

}

Die persistenten Datensätze mithilfe des Tabellensequenzgenerators

Abbildung 1.2 zeigt die Datensätze, die mithilfe eines Tabellensequenzgenerators in der Oracle-Datenbank gespeichert wurden. Datensätze bleiben unter Verwendung der Tabellensequenz erhalten

Abbildung 1.2

Die Auswirkung des Hinzufügens von drei Datensätzen des Führerscheins zur Tabellensequenz ist in Abbildung 1.3 dargestellt

Auswirkung des Hinzufügens von DriverLicenses auf die Tabellensequenz

Abbildung 1.3

  • Wenn Sie sich die SEQ_NUMBER notiert haben, ist ihr Wert 3, da dies die letzte Nummer ist, die generiert wurde.

IDENTITY- und AUTO-Generatoren

Der IDENTITY-Wert gibt die Verwendung einer Identifizierungsspalte an. Wenn Sie also die zugeordnete Oberklasse „License“ notiert haben, sollten Sie die „licenceId“ als identifizierte Eigenschaft sehen können. Die IDENTITY-Strategie ist eine der einfachsten Strategien, die angewendet werden können. Schauen wir uns die Lizenzentität an, wenn wir uns für die IDENTITY-Strategie entschieden haben. 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;

@MappedSuperclass
public abstract class License {

@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
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;
}
}

  • Der Primärschlüssel der Lizenzentität sollte mit @GeneratedValue annotiert werden, dieses Mal jedoch mit einer IDENTITY als Generator.

Außerdem sollte Ihre Datenbank-Engine das AUTO_INCREMENT-Prinzip unterstützen. Abbildung 1.4 zeigt Ihnen die aktualisierte Spalte „licenseId“. Automatisches Inkrementieren ausgewählt

Abbildung 1.4

  • Der primäre Schlüssel „licenseId“ wird auf „Automatische Inkrementierung“ aktualisiert.

Das müssen Sie tun, wenn Sie Identity als Primärschlüsselgenerator ausgewählt haben. Jetzt führen wir die vorherige ausführbare Datei JPAImpl aus. Der JPAImpl wird ohne Änderungen reibungslos ausgeführt, da die IDENTITY nicht mehr als eine automatisch inkrementelle Primärschlüsselspalte benötigt. Siehe Abbildung 1.5, die Ihnen zusätzliche Datensätze zeigt, die mit IDENTITY bestehen blieben. Persistente Datensätze mithilfe der Identität

Abbildung 1.5

AUTO Der Wert gibt an, dass der Persistenzanbieter eine geeignete Strategie für die jeweilige Datenbank auswählen sollte. Wenn wir MySQL verwendet und die Lizenzentität mit Auto annotiert haben, erhalten wir höchstwahrscheinlich diese Ausnahme.


Caused by: com.mysql.jdbc.exceptions.jdbc4.MySQLSyntaxErrorException: Table 'javabeat.sequence' doesn't exist
at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
at sun.reflect.NativeConstructorAccessorImpl.newInstance(Unknown Source)
at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(Unknown Source)
at java.lang.reflect.Constructor.newInstance(Unknown Source)
at com.mysql.jdbc.Util.handleNewInstance(Util.java:411)
at com.mysql.jdbc.Util.getInstance(Util.java:386)
at com.mysql.jdbc.SQLError.createSQLException(SQLError.java:1054)
at com.mysql.jdbc.MysqlIO.checkErrorPacket(MysqlIO.java:4120)
at com.mysql.jdbc.MysqlIO.checkErrorPacket(MysqlIO.java:4052)
at com.mysql.jdbc.MysqlIO.sendCommand(MysqlIO.java:2503)
at com.mysql.jdbc.MysqlIO.sqlQueryDirect(MysqlIO.java:2664)
at com.mysql.jdbc.ConnectionImpl.execSQL(ConnectionImpl.java:2815)
at com.mysql.jdbc.PreparedStatement.executeInternal(PreparedStatement.java:2155)
at com.mysql.jdbc.PreparedStatement.executeUpdate(PreparedStatement.java:2458)
at com.mysql.jdbc.PreparedStatement.executeUpdate(PreparedStatement.java:2375)
at com.mysql.jdbc.PreparedStatement.executeUpdate(PreparedStatement.java:2359)
at org.eclipse.persistence.internal.databaseaccess.DatabaseAccessor.executeDirectNoSelect(DatabaseAccessor.java:890)
... 32 more

Es ist klar, dass die JPA-Auswahlsequenz eine Primärschlüsselstrategie zum Generieren eines Primärschlüssels ist. Im Allgemeinen geht die automatische Generierung davon aus, dass eine Datenbankressource vorhanden ist, oder sie versucht, eine solche zu erstellen. Ein Anbieter stellt möglicherweise Dokumentation zum Erstellen solcher Ressourcen bereit, falls er die Schemagenerierung nicht unterstützt oder keine Schemaressource zur Laufzeit erstellen kann.

Zusammenfassung

Dieses Tutorial soll die verschiedenen Möglichkeiten zur Generierung eines Primärschlüssels erklären. Wir haben bereits die Verwendung der Annotation @GeneratedValue und die verschiedenen möglichen Werte, die darin auftreten könnten, erläutert. Die JPA bietet viele Generatoren, die von einfach bis komplex reichen. Die einfachsten Generatoren, die verwendet werden könnten, sind IDENTITY und AUTO, während die komplexesten Generatoren, für deren Umsetzung etwas mehr Aufwand erforderlich ist, SEQUENCE und TABLE SEQUENCE sind.

Kommentar verfassen

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

Nach oben scrollen