Genera schema di database con Spring Data JPA

1. Panoramica

Quando creiamo un livello di persistenza, dobbiamo abbinare lo schema del nostro database SQL al modello a oggetti che abbiamo creato nel nostro codice. Questo può essere molto lavoro da fare manualmente.

In questo tutorial, vedremo come generare ed esportare il nostro schema di database in base ai modelli di entità dal nostro codice .

Innanzitutto, tratteremo le proprietà di configurazione JPA per la generazione dello schema. Quindi, esploreremo come utilizzare queste proprietà in Spring Data JPA.

Infine, esploreremo un'alternativa per la generazione di DDL utilizzando l'API nativa di Hibernate.

2. Generazione di schemi JPA

JPA 2.1 ha introdotto uno standard per la generazione di schemi di database . Pertanto, a partire da questa versione, possiamo controllare come generare ed esportare lo schema del nostro database attraverso un set di proprietà di configurazione predefinite.

2.1. L' azione Script

Innanzitutto, per controllare quali comandi DDL genereremo , JPA introduce l' opzione di configurazione dell'azione di script :

javax.persistence.schema-generation.scripts.action

Possiamo scegliere tra quattro diverse opzioni:

  • nessuno - non genera alcun comando DDL
  • create - genera solo i comandi di creazione del database
  • drop : genera solo comandi di rilascio del database
  • drop-and-create : genera i comandi di rilascio del database seguiti dai comandi di creazione

2.2. Il target dello script

In secondo luogo, per ogni azione di script specificata , dovremo definire la configurazione di destinazione corrispondente :

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

In sostanza, la destinazione dello script definisce la posizione del file che contiene i comandi di creazione o eliminazione dello schema . Quindi, ad esempio, se scegliamo drop-and-create come azione di script , dovremo specificare entrambi i target .

2.3. The Schema Source

Infine, per generare i comandi DDL dello schema dai nostri modelli di entità, dovremmo includere le configurazioni dell'origine dello schema con l' opzione dei metadati selezionata:

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

Nella sezione successiva, mostreremo come possiamo utilizzare Spring Data JPA per generare automaticamente il nostro schema di database con le proprietà JPA standard.

3. Generazione di schemi con Spring Data JPA

3.1. I modelli

Immaginiamo di implementare un sistema di account utente con un'entità chiamata Account :

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

Ogni account può avere più impostazioni account, quindi qui avremo una mappatura uno-a-molti:

@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. Configurazione JPA Spring Data

Ora, per generare lo schema del database, dovremo passare le proprietà di generazione dello schema al provider di persistenza in uso. Per fare ciò, imposteremo le proprietà JPA native nel nostro file di configurazione con il prefisso spring.jpa.properties :

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

Di conseguenza, Spring Data JPA passa queste proprietà al provider di persistenza , quando crea il bean EntityManagerFactory .

3.3. Il file create.sql

Di conseguenza, all'avvio dell'applicazione, la configurazione precedente genererà i comandi di creazione del database in base ai metadati di mappatura delle entità. Inoltre, i comandi DDL vengono esportati nel file create.sql , che viene creato nella nostra cartella principale del progetto:

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. Generazione di schemi con l'API Hibernate

Se stiamo usando Hibernate, possiamo usare direttamente la sua API nativa, SchemaExport , per generare i nostri comandi DDL dello schema . Allo stesso modo, l'API Hibernate utilizza i nostri modelli di entità dell'applicazione per generare ed esportare lo schema del database.

Con SchemaExport di Hibernate possiamo usare i metodi drop , createOnly e creare esplicitamente:

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);

Quando eseguiamo questo codice, i nostri comandi di creazione del database vengono esportati nel file create.sql nella nostra cartella del progetto principale.

La SchemaExport è parte della API Sospensione bootstrap.

5. Opzioni di generazione dello schema

Anche se la generazione dello schema può farci risparmiare tempo durante lo sviluppo, dovremmo usarlo solo per scenari di base.

Ad esempio, potremmo usarlo per avviare rapidamente database di sviluppo o test.

Al contrario, per scenari più complessi, come la migrazione del database, dovremmo utilizzare strumenti più raffinati come Liquibase o Flyway .

6. Conclusione

In questo tutorial, abbiamo visto come generare ed esportare il nostro schema di database con l'aiuto delle proprietà di generazione dello schema JPA . Successivamente, abbiamo visto come ottenere lo stesso risultato utilizzando l'API nativa di Hibernate, SchemaExport .

Come sempre, possiamo trovare il codice di esempio su GitHub.