Genereer databaseschema met Spring Data JPA

1. Overzicht

Bij het maken van een persistentielaag moeten we ons SQL-databaseschema matchen met het objectmodel dat we in onze code hebben gemaakt. Dit kan veel werk zijn om handmatig te doen.

In deze tutorial we gaan zien hoe we ons databaseschema kunnen genereren en exporteren op basis van de entiteitsmodellen uit onze code.

Eerst behandelen we de JPA-configuratie-eigenschappen voor het genereren van schema's. Vervolgens onderzoeken we hoe u deze eigenschappen in Spring Data JPA kunt gebruiken.

Ten slotte zullen we een alternatief verkennen voor het genereren van DDL met behulp van de native API van Hibernate.

2. Genereren van JPA-schema's

JPA 2.1 introduceerde een standaard voor het genereren van databaseschema's. Daarom kunnen we vanaf deze release bepalen hoe we ons databaseschema moeten genereren en exporteren via een set vooraf gedefinieerde configuratie-eigenschappen.

2.1. Het script actie

Eerste, om te bepalen welke DDL-opdrachten we zullen genereren, JPA introduceert het script actie configuratie optie:

javax.persistence.schema-generation.scripts.action

We kunnen kiezen uit vier verschillende opties:

  • geen - genereert geen DDL-opdrachten
  • creëren - genereert alleen commando's voor het maken van databases
  • laten vallen - genereert alleen drop-commando's voor de database
  • drop-and-create - genereert commando's voor het neerzetten van databases, gevolgd door commando's voor het maken van bestanden

2.2. Het script doelwit

Ten tweede, voor elk gespecificeerd script actie, moeten we de corresponderende doelwit configuratie:

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

In wezen is het script doelwitdefinieert de locatie van het bestand dat de opdrachten voor het maken of neerzetten van het schema bevat. Dus bijvoorbeeld als we ervoor kiezen drop-and-create als script actie we moeten beide specificeren doelwits.

2.3. Het schema Bron

Ten slotte moeten we het schema opnemen om de DDL-opdrachten voor het schema uit onze entiteitsmodellen te genereren bron configuraties met de metadata optie geselecteerd:

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

In de volgende sectie laten we zien hoe we Spring Data JPA kunnen gebruiken om automatisch ons databaseschema te genereren met de standaard JPA-eigenschappen.

3. Schema-generatie met Spring Data JPA

3.1. De modellen

Laten we ons voorstellen dat we een gebruikersaccountsysteem implementeren met een entiteit genaamd Account:

@Entity @Table (name = "accounts") openbare klasse Account {@Id @GeneratedValue privé Lange id; @Column (nullable = false, length = 100) private String naam; @Column (name = "email_address") privé String emailAddress; @OneToMany (mappedBy = "account", cascade = CascadeType.ALL) privélijst accountSettings = nieuwe ArrayList (); // getters en setters}

Elk account kan meerdere accountinstellingen hebben, dus hier hebben we een een-op-veel-toewijzing:

@Entity @Table (name = "account_settings") openbare klasse AccountSetting {@Id @GeneratedValue privé Lange id; @Column (name = "name", nullable = false) private String settingName; @Column (name = "waarde", nullable = false) private String settingValue; @ManyToOne @JoinColumn (naam, nullable = false) privé account account; // getters en setters} 

3.2. Spring Data JPA-configuratie

Om het databaseschema te genereren, moeten we de eigenschappen voor het genereren van het schema doorgeven aan de gebruikte persistentieprovider. Om dit te doen, stellen we de native JPA-eigenschappen in ons configuratiebestand onder de spring.jpa.properties voorvoegsel:

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

Bijgevolg, Spring Data JPA geeft deze eigenschappen door aan de persistentieleverancier, wanneer het de EntityManagerFactory Boon.

3.3. De create.sql het dossier

Als gevolg hiervan genereert de bovenstaande configuratie bij het opstarten van de applicatie de commando's voor het maken van databases op basis van de metagegevens van de entiteitstoewijzing. Bovendien worden de DDL-opdrachten geëxporteerd naar het create.sql bestand, dat is aangemaakt in onze hoofdprojectmap:

maak tabel account_instellingen (id bigint niet null, naam varchar (255) niet null, waarde varchar (255) niet null, account_id bigint niet null, primaire sleutel (id)) maak tabelaccounts (id bigint niet null, email_adres varchar (255) , naam varchar (100) niet null, primaire sleutel (id)) tabel wijzigen account_instellingen beperking toevoegen FK54uo82jnot7ye32pyc8dcj2eh externe sleutel (account_id) verwijst naar accounts (id)

4. Schema-generatie met de Hibernate-API

Als we Hibernate gebruiken, we kunnen de native API rechtstreeks gebruiken, SchemaExport, om onze schema DDL-opdrachten te genereren. Evenzo gebruikt de Hibernate API onze applicatie-entiteitsmodellen om het databaseschema te genereren en te exporteren.

Met Hibernate's SchemaExport we kunnen de laten vallen, createOnly, en creëren methoden expliciet:

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

Wanneer we deze code uitvoeren, worden onze commando's voor het maken van databases geëxporteerd naar het create.sql bestand in onze hoofdprojectmap.

De SchemaExport maakt deel uit van de Hibernate Bootstrapping API.

5. Opties voor het genereren van schema's

Hoewel het genereren van schema's ons tijd kan besparen tijdens de ontwikkeling, moeten we het alleen voor basisscenario's gebruiken.

We zouden het bijvoorbeeld kunnen gebruiken om snel ontwikkelings- of testdatabases op gang te brengen.

Voor complexere scenario's, zoals databasemigratie, we zouden meer verfijnde gereedschappen zoals Liquibase of Flyway moeten gebruiken.

6. Conclusie

In deze tutorial hebben we gezien hoe we ons databaseschema kunnen genereren en exporteren met behulp van de JPA schema-generatie eigendommen. Vervolgens hebben we gezien hoe we hetzelfde resultaat konden bereiken met de native API van Hibernate, SchemaExport.

Zoals altijd kunnen we de voorbeeldcode vinden op GitHub.