Kurzanleitung zum Laden von Anfangsdaten mit Spring Boot

1. Übersicht

Spring Boot macht es wirklich einfach, unsere Datenbankänderungen auf einfache Weise zu verwalten. Wenn wir die Standardkonfiguration beibehalten, wird nach Entitäten in unseren Paketen gesucht und die entsprechenden Tabellen automatisch erstellt.

Aber manchmal brauchen wir eine genauere Kontrolle über die Datenbankänderungen. Dann können wir die Dateien data.sql und schema.sql in Spring verwenden.

2. Die Datei data.sql

Lassen Sie uns auch davon ausgehen, dass wir hier mit JPA arbeiten - eine einfache und definieren Land Einheit in unserem Projekt:

@Entity public class Country { @Id @GeneratedValue(strategy = IDENTITY) private Integer id; @Column(nullable = false) private String name; //... }

Wenn wir unsere Anwendung ausführen, erstellt Spring Boot eine leere Tabelle für uns, füllt sie jedoch nicht mit irgendetwas.

Eine einfache Möglichkeit, dies zu tun, besteht darin, eine Datei mit dem Namen data.sql zu erstellen :

INSERT INTO country (name) VALUES ('India'); INSERT INTO country (name) VALUES ('Brazil'); INSERT INTO country (name) VALUES ('USA'); INSERT INTO country (name) VALUES ('Italy');

Wenn wir das Projekt mit dieser Datei im Klassenpfad ausführen, nimmt Spring es auf und verwendet es zum Auffüllen der Datenbank.

3. Die Datei schema.sql

Manchmal möchten wir uns nicht auf den Standardmechanismus zur Schemaerstellung verlassen. In solchen Fällen können wir eine benutzerdefinierte schema.sql- Datei erstellen :

CREATE TABLE country ( id INTEGER NOT NULL AUTO_INCREMENT, name VARCHAR(128) NOT NULL, PRIMARY KEY (id) );

Spring nimmt diese Datei auf und verwendet sie zum Erstellen eines Schemas.

Denken Sie auch daran, die automatische Schemaerstellung zu deaktivieren, um Konflikte zu vermeiden:

spring.jpa.hibernate.ddl-auto=none

4. Steuern der Datenbankerstellung im Ruhezustand

Spring bietet eine JPA-spezifische Eigenschaft, die Hibernate für die DDL-Generierung verwendet: spring.jpa.hibernate.ddl-auto .

Die Standardwerte für den Ruhezustand sind: Erstellen , Aktualisieren , Erstellen, Löschen , Validieren und keine :

  • create - Hibernate löscht zuerst vorhandene Tabellen und erstellt dann neue Tabellen
  • update - Das auf den Zuordnungen (Annotationen oder XML) erstellte Objektmodell wird mit dem vorhandenen Schema verglichen. Anschließend aktualisiert Hibernate das Schema entsprechend dem Diff. Die vorhandenen Tabellen oder Spalten werden niemals gelöscht, auch wenn sie von der Anwendung nicht mehr benötigt werden
  • create-drop - ähnlich wie create , mit dem Zusatz, dass Hibernate die Datenbank löscht, nachdem alle Vorgänge abgeschlossen sind. Wird normalerweise für Unit-Tests verwendet
  • validieren - Der Ruhezustand überprüft nur, ob die Tabellen und Spalten vorhanden sind, andernfalls wird eine Ausnahme ausgelöst
  • none - Dieser Wert schaltet die DDL-Generierung effektiv aus

Spring Boot setzt diesen Parameterwert intern standardmäßig auf create-drop, wenn kein Schema-Manager erkannt wurde, andernfalls in allen anderen Fällen keinen .

Wir müssen den Wert sorgfältig festlegen oder einen der anderen Mechanismen verwenden, um die Datenbank zu initialisieren.

5. @Sql

Spring bietet auch die Annotation @Sql - eine deklarative Methode zum Initialisieren und Auffüllen unseres Testschemas .

Lassen Sie uns sehen, wie Sie mit der @ SQL- Annotation eine neue Tabelle erstellen und die Tabelle mit den Anfangsdaten für unseren Integrationstest laden:

@Sql({"/employees_schema.sql", "/import_employees.sql"}) public class SpringBootInitialLoadIntegrationTest { @Autowired private EmployeeRepository employeeRepository; @Test public void testLoadDataForTestClass() { assertEquals(3, employeeRepository.findAll().size()); } }

Die Attribute der @ SQL- Annotation sind:

  • config - lokale Konfiguration für die SQL-Skripte. Wir beschreiben dies im nächsten Abschnitt ausführlich
  • executionPhase - Wir können auch angeben, wann die Skripte ausgeführt werden sollen, entweder BEFORE_TEST_METHOD oder AFTER_TEST_METHOD
  • Anweisungen - Wir können Inline-SQL-Anweisungen für die Ausführung deklarieren
  • Skripte - Wir können die Pfade zu SQL-Skriptdateien deklarieren, die ausgeführt werden sollen. Dies ist ein Alias für den Wert Attribut

Die Annotation @Sql kann auf Klassen- oder Methodenebene verwendet werden . Wir können zusätzliche Daten laden, die für einen bestimmten Testfall erforderlich sind, indem wir diese Methode mit Anmerkungen versehen:

@Test @Sql({"/import_senior_employees.sql"}) public void testLoadDataForTestCase() { assertEquals(5, employeeRepository.findAll().size()); }
6. @SqlConfig

Wir können die Art und Weise konfigurieren, wie wir die SQL-Skripte analysieren und ausführen, indem wir die Annotation @SqlConfig verwenden .

@SqlConfig kann auf Klassenebene deklariert werden und dient dort als globale Konfiguration. Oder es kann verwendet werden, um eine bestimmte @ SQL- Annotation zu konfigurieren .

Sehen wir uns ein Beispiel an, in dem wir die Codierung unserer SQL-Skripte sowie den Transaktionsmodus für die Ausführung der Skripte angeben:

@Test @Sql(scripts = {"/import_senior_employees.sql"}, config = @SqlConfig(encoding = "utf-8", transactionMode = TransactionMode.ISOLATED)) public void testLoadDataForTestCase() { assertEquals(5, employeeRepository.findAll().size()); }

Schauen wir uns die verschiedenen Attribute von @SqlConfig an :

  • blockCommentStartDelimiter - Trennzeichen zum Identifizieren des Beginns von Blockkommentaren in SQL-Skriptdateien
  • blockCommentEndDelimiter - Trennzeichen für das Ende von Blockkommentaren in SQL-Skriptdateien
  • commentPrefix - Präfix zum Identifizieren einzeiliger Kommentare in SQL-Skriptdateien
  • dataSource - Name der Bean javax.sql.DataSource , für die die Skripte und Anweisungen ausgeführt werden
  • Codierung - Codierung für die SQL-Skriptdateien, Standard ist die Plattformcodierung
  • errorMode - Modus, der verwendet wird, wenn beim Ausführen der Skripte ein Fehler auftritt
  • Trennzeichen - Zeichenfolge zum Trennen einzelner Anweisungen. Die Standardeinstellung ist "-".
  • transactionManager - Bean-Name des PlatformTransactionManager , der für Transaktionen verwendet wird
  • transactionMode - Der Modus, der beim Ausführen von Skripten in einer Transaktion verwendet wird

7. @SqlGroup

Java 8 and above allow the use of repeated annotations. This feature can be utilized for @Sql annotations as well. For Java 7 and below, there is a container annotation — @SqlGroup. Using the @SqlGroup annotation, we can declare multiple @Sql annotations:

@SqlGroup({ @Sql(scripts = "/employees_schema.sql", config = @SqlConfig(transactionMode = TransactionMode.ISOLATED)), @Sql("/import_employees.sql")}) public class SpringBootSqlGroupAnnotationIntegrationTest { @Autowired private EmployeeRepository employeeRepository; @Test public void testLoadDataForTestCase() { assertEquals(3, employeeRepository.findAll().size()); } }

8. Conclusion

In this quick article, we saw how we can leverage schema.sql and data.sql files for setting up an initial schema and populating it with data. We also saw how we can use @Sql, @SqlConfig, and @SqlGroup annotations to load test data for tests.

Beachten Sie, dass dieser Ansatz besser für einfache und einfache Szenarien geeignet ist. Für jede erweiterte Datenbankverarbeitung wären erweiterte und verfeinerte Tools wie Liquibase oder Flyway erforderlich.

Code-Schnipsel finden Sie wie immer auf GitHub.