Generieren Sie ein Datenbankschema mit Spring Data JPA

1. Übersicht

Beim Erstellen einer Persistenzschicht müssen wir unser SQL-Datenbankschema mit dem Objektmodell abgleichen, das wir in unserem Code erstellt haben. Dies kann eine Menge Arbeit sein, die manuell erledigt werden muss.

In diesem Tutorial erfahren Sie, wie Sie unser Datenbankschema basierend auf den Entitätsmodellen aus unserem Code generieren und exportieren .

Zunächst werden die JPA-Konfigurationseigenschaften für die Schemaerstellung behandelt. Anschließend erfahren Sie, wie Sie diese Eigenschaften in Spring Data JPA verwenden.

Schließlich werden wir eine Alternative für die DDL-Generierung mithilfe der nativen API von Hibernate untersuchen.

2. JPA-Schema-Generierung

Mit JPA 2.1 wurde ein Standard für die Generierung von Datenbankschemata eingeführt . Ab dieser Version können wir daher steuern, wie unser Datenbankschema über eine Reihe vordefinierter Konfigurationseigenschaften generiert und exportiert wird.

2.1. Das Script Aktion

Zuerst zu steuern , die DDL - Befehle werden wir erzeugen , führt JPA die Skript Aktion Konfigurationsoption:

javax.persistence.schema-generation.scripts.action

Wir können aus vier verschiedenen Optionen wählen:

  • none - generiert keine DDL-Befehle
  • create - generiert nur Datenbankerstellungsbefehle
  • drop - generiert nur Datenbank-Drop-Befehle
  • drop-and-create - generiert Datenbank-Drop-Befehle, gefolgt von create-Befehlen

2.2. Das Script Ziel

Zweitens für jede angegebene Skript Aktion , wir werden die entsprechenden definieren müssen Zielkonfiguration:

javax.persistence.schema-generation.scripts.create-target javax.persistence.schema-generation.scripts.drop-target

Im Wesentlichen das Skript Ziel definiert den Speicherort der Datei , die das Schema erstellen oder Drop - Befehle enthält . So zum Beispiel, wenn wir wählen Drop-and-erstellen als Skript Aktion wir beide angeben müssen Ziel s.

2.3. Das Schema Quelle

Schließlich die Schema - DDL - Befehle aus unserer Einheit Modell generieren wir die Schema enthalten sollten Source Konfigurationen mit der Metadaten - Option ausgewählt:

javax.persistence.schema-generation.create-source=metadata javax.persistence.schema-generation.drop-source=metadata

Im nächsten Abschnitt zeigen wir, wie wir Spring Data JPA verwenden können, um unser Datenbankschema automatisch mit den Standard-JPA-Eigenschaften zu generieren.

3. Schemagenerierung mit Spring Data JPA

3.1. Die Models

Stellen wir uns vor, wir implementieren ein Benutzerkontosystem mit einer Entität namens Konto :

@Entity @Table(name = "accounts") public class Account { @Id @GeneratedValue private Long id; @Column(nullable = false, length = 100) private String name; @Column(name = "email_address") private String emailAddress; @OneToMany(mappedBy = "account", cascade = CascadeType.ALL) private List accountSettings = new ArrayList(); // getters and setters }

Jedes Konto kann mehrere Kontoeinstellungen haben, daher haben wir hier eine Eins-zu-Viele-Zuordnung:

@Entity @Table(name = "account_settings") public class AccountSetting { @Id @GeneratedValue private Long id; @Column(name = "name", nullable = false) private String settingName; @Column(name = "value", nullable = false) private String settingValue; @ManyToOne @JoinColumn(name, nullable = false) private Account account; // getters and setters } 

3.2. Spring Data JPA-Konfiguration

Um das Datenbankschema zu generieren, müssen wir die Eigenschaften der Schemagenerierung an den verwendeten Persistenzanbieter übergeben. Dazu legen wir die nativen JPA-Eigenschaften in unserer Konfigurationsdatei unter dem Präfix spring.jpa.properties fest :

spring.jpa.properties.javax.persistence.schema-generation.scripts.action=create spring.jpa.properties.javax.persistence.schema-generation.scripts.create-target=create.sql spring.jpa.properties.javax.persistence.schema-generation.scripts.create-source=metadata

Folglich übergibt Spring Data JPA diese Eigenschaften an den Persistenzanbieter , wenn die EntityManagerFactory- Bean erstellt wird.

3.3. Die Datei create.sql

Infolgedessen generiert die obige Konfiguration beim Start der Anwendung die Datenbankerstellungsbefehle basierend auf den Metadaten der Entitätszuordnung. Darüber hinaus werden die DDL-Befehle in die Datei create.sql exportiert , die in unserem Hauptprojektordner erstellt wird:

create table account_settings ( id bigint not null, name varchar(255) not null, value varchar(255) not null, account_id bigint not null, primary key (id) ) create table accounts ( id bigint not null, email_address varchar(255), name varchar(100) not null, primary key (id) ) alter table account_settings add constraint FK54uo82jnot7ye32pyc8dcj2eh foreign key (account_id) references accounts (id)

4. Schemagenerierung mit der Hibernate-API

Wenn wir den Ruhezustand verwenden , können wir die native API SchemaExport direkt verwenden , um unsere Schema-DDL-Befehle zu generieren . Ebenso verwendet die Hibernate-API unsere Anwendungsentitätsmodelle, um das Datenbankschema zu generieren und zu exportieren.

Mit Hibernates SchemaExport können wir die Methoden drop , createOnly und create explizit verwenden:

MetadataSources metadataSources = new MetadataSources(serviceRegistry); metadataSources.addAnnotatedClass(Account.class); metadataSources.addAnnotatedClass(AccountSettings.class); Metadata metadata = metadataSources.buildMetadata(); SchemaExport schemaExport = new SchemaExport(); schemaExport.setFormat(true); schemaExport.setOutputFile("create.sql"); schemaExport.createOnly(EnumSet.of(TargetType.SCRIPT), metadata);

Wenn wir diesen Code ausführen, werden unsere Datenbankerstellungsbefehle in die Datei create.sql in unserem Hauptprojektordner exportiert .

Der SchemaExport ist Teil der Hibernate Bootstrapping-API.

5. Optionen zur Schemaerstellung

Obwohl die Generierung von Schemata uns während der Entwicklung Zeit sparen kann, sollten wir sie nur für grundlegende Szenarien verwenden.

Zum Beispiel könnten wir damit schnell Entwicklungs- oder Testdatenbanken hochfahren.

Im Gegensatz dazu sollten wir für komplexere Szenarien wie die Datenbankmigration verfeinerte Tools wie Liquibase oder Flyway verwenden .

6. Fazit

In diesem Tutorial haben wir gesehen, wie unser Datenbankschema mithilfe der Eigenschaften der JPA - Schemaerstellung generiert und exportiert wird . Anschließend haben wir gesehen, wie mit der nativen API von Hibernate, SchemaExport, dasselbe Ergebnis erzielt werden kann .

Wie immer finden wir den Beispielcode auf GitHub.