Générer un schéma de base de données avec Spring Data JPA

1. Vue d'ensemble

Lors de la création d'une couche de persistance, nous devons faire correspondre notre schéma de base de données SQL avec le modèle d'objet que nous avons créé dans notre code. Cela peut être beaucoup de travail à faire manuellement.

Dans ce tutoriel, nous allons voir comment générer et exporter notre schéma de base de données basé sur les modèles d'entité de notre code .

Tout d'abord, nous aborderons les propriétés de configuration JPA pour la génération de schéma. Ensuite, nous explorerons comment utiliser ces propriétés dans Spring Data JPA.

Enfin, nous explorerons une alternative pour la génération DDL à l'aide de l'API native d'Hibernate.

2. Génération de schéma JPA

JPA 2.1 a introduit une norme pour la génération de schéma de base de données . Par conséquent, à partir de cette version, nous pouvons contrôler comment générer et exporter notre schéma de base de données via un ensemble de propriétés de configuration prédéfinies.

2.1. L' action Script

Tout d'abord, pour contrôler les commandes DDL que nous allons générer , JPA introduit l' option de configuration d' action de script :

javax.persistence.schema-generation.scripts.action

Nous pouvons choisir parmi quatre options différentes:

  • aucun - ne génère aucune commande DDL
  • create - génère uniquement des commandes de création de base de données
  • drop - génère uniquement des commandes de suppression de base de données
  • drop-and-create - génère des commandes de suppression de base de données suivies de commandes de création

2.2. La cible Script

Deuxièmement, pour chaque action de script spécifiée , nous devrons définir la configuration cible correspondante :

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

Essentiellement, la cible du script définit l'emplacement du fichier contenant les commandes de création ou de suppression de schéma . Ainsi, par exemple, si nous choisissons drop-and-create comme action de script , nous devrons spécifier les deux cibles .

2.3. La source du schéma

Enfin, pour générer les commandes DDL de schéma à partir de nos modèles d'entité, nous devons inclure les configurations de source de schéma avec l' option de métadonnées sélectionnée:

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

Dans la section suivante, nous montrerons comment nous pouvons utiliser Spring Data JPA pour générer automatiquement notre schéma de base de données avec les propriétés JPA standard.

3. Génération de schéma avec Spring Data JPA

3.1. Les modèles

Imaginons que nous implémentions un système de compte utilisateur avec une entité appelée 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 }

Chaque compte peut avoir plusieurs paramètres de compte, nous aurons donc ici un mappage un-à-plusieurs:

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

Maintenant, pour générer le schéma de base de données, nous devons transmettre les propriétés de génération de schéma au fournisseur de persistance utilisé. Pour ce faire, nous allons définir les propriétés JPA natives dans notre fichier de configuration sous le préfixe 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

Par conséquent, Spring Data JPA transmet ces propriétés au fournisseur de persistance , lorsqu'il crée le bean EntityManagerFactory .

3.3. Le fichier create.sql

En conséquence, au démarrage de l'application, la configuration ci-dessus générera les commandes de création de base de données en fonction des métadonnées de mappage d'entité. De plus, les commandes DDL sont exportées dans le fichier create.sql , qui est créé dans notre dossier de projet principal:

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. Génération de schéma avec l'API Hibernate

Si nous utilisons Hibernate, nous pouvons utiliser directement son API native, SchemaExport , pour générer nos commandes DDL de schéma . De même, l'API Hibernate utilise nos modèles d'entité d'application pour générer et exporter le schéma de base de données.

Avec SchemaExport d'Hibernate, nous pouvons utiliser les méthodes drop , createOnly et créer explicitement:

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

Lorsque nous exécutons ce code, nos commandes de création de base de données sont exportées dans le fichier create.sql de notre dossier de projet principal.

Le SchemaExport fait partie de l'API Hibernate Bootstrapping.

5. Options de génération de schéma

Même si la génération de schéma peut nous faire gagner du temps lors du développement, nous ne devons l'utiliser que pour les scénarios de base.

Par exemple, nous pourrions l'utiliser pour lancer rapidement des bases de données de développement ou de test.

En revanche, pour des scénarios plus complexes, comme la migration de bases de données, nous devrions utiliser des outils plus raffinés comme Liquibase ou Flyway .

6. Conclusion

Dans ce didacticiel, nous avons vu comment générer et exporter notre schéma de base de données à l'aide des propriétés de génération de schéma JPA . Par la suite, nous avons vu comment obtenir le même résultat en utilisant l'API native d'Hibernate, SchemaExport .

Comme toujours, nous pouvons trouver l'exemple de code sur GitHub.