Beknopte handleiding voor het laden van initiële gegevens met Spring Boot

1. Overzicht

Spring Boot maakt het heel gemakkelijk om onze databasewijzigingen op een gemakkelijke manier te beheren. Als we de standaardconfiguratie verlaten, zoekt het naar entiteiten in onze pakketten en maakt het automatisch de respectieve tabellen.

Maar soms hebben we wat fijnere controle nodig over de wijzigingen in de database. Dat is wanneer we de data.sql en schema.sql bestanden in het voorjaar.

2. Het data.sql het dossier

Laten we hier ook aannemen dat we met JPA werken - en een eenvoudig definiëren Land entiteit in ons project:

@Entity openbare klasse Land {@Id @GeneratedValue (strategy = IDENTITY) privé Geheel getal-id; @Column (nullable = false) private String naam; // ...}

Als we onze applicatie uitvoeren, Spring Boot zal een lege tabel voor ons maken, maar deze met niets vullen.

Een gemakkelijke manier om dit te doen, is door een bestand met de naam data.sql:

INVOEGEN IN land (naam) WAARDEN ('India'); INVOEGEN IN land (naam) WAARDEN ('Brazilië'); INVOEGEN IN land (naam) WAARDEN ('VS'); INVOEGEN IN land (naam) WAARDEN ('Italië');

Wanneer we het project met dit bestand op het klassenpad uitvoeren, pikt Spring het op en gebruikt het voor het vullen van de database.

3. Het schema.sql het dossier

Soms willen we niet vertrouwen op het standaardmechanisme voor het maken van schema's. In dergelijke gevallen kunnen we een custom schema.sql het dossier:

CREATE TABLE land (id INTEGER NOT NULL AUTO_INCREMENT, naam VARCHAR (128) NOT NULL, PRIMARY KEY (id));

Spring pikt dit bestand op en gebruikt het om een ​​schema te maken.

Het is ook belangrijk om te onthouden om het automatisch maken van schema's uit te schakelen om conflicten te voorkomen:

spring.jpa.hibernate.ddl-auto = geen

4. Beheer van het maken van databases met behulp van de slaapstand

Spring biedt een JPA-specifiek eigenschap die Hibernate gebruikt voor het genereren van DDL: spring.jpa.hibernate.ddl-auto.

De standaardwaarden van de Hibernate-eigenschap zijn: creëren, bijwerken, create-drop, valideren en geen:

  • creëren - Hibernate verwijdert eerst bestaande tabellen en maakt vervolgens nieuwe tabellen
  • bijwerken - het objectmodel dat is gemaakt op basis van de toewijzingen (annotaties of XML) wordt vergeleken met het bestaande schema, en vervolgens werkt Hibernate het schema bij volgens de diff. Het verwijdert nooit de bestaande tabellen of kolommen, zelfs als ze niet meer nodig zijn door de toepassing
  • create-drop - gelijkwaardig aan creëren, met de toevoeging dat Hibernate de database laat vallen nadat alle bewerkingen zijn voltooid. Meestal gebruikt voor het testen van eenheden
  • valideren - Hibernate valideert alleen of de tabellen en kolommen bestaan, anders genereert het een uitzondering
  • geen - deze waarde schakelt de DDL-generatie effectief uit

Spring Boot stelt deze parameterwaarde intern standaard in op create-drop als er geen schemamanager is gedetecteerd, anders geen voor alle andere gevallen.

We moeten de waarde zorgvuldig instellen of een van de andere mechanismen gebruiken om de database te initialiseren.

5. @Sql

De lente biedt ook de @Sql annotatie - een declaratieve manier om ons testschema te initialiseren en te vullen.

Laten we eens kijken hoe we de @Sql annotatie om een ​​nieuwe tabel te maken en ook de tabel te laden met initiële gegevens voor onze integratietest:

@Sql ({"/ workers_schema.sql", "/import_employees.sql"}) openbare klasse SpringBootInitialLoadIntegrationTest {@Autowired privé EmployeeRepository employeeRepository; @Test openbare ongeldige testLoadDataForTestClass () {assertEquals (3, employeeRepository.findAll (). Size ()); }}

De attributen van de @Sql annotaties zijn:

  • config - lokale configuratie voor de SQL-scripts. We beschrijven dit in detail in de volgende sectie
  • uitvoeringsfase - we kunnen ook specificeren wanneer de scripts moeten worden uitgevoerd BEFORE_TEST_METHOD of AFTER_TEST_METHOD
  • verklaringen - we kunnen inline SQL-instructies declareren om uit te voeren
  • scripts - we kunnen de paden naar uit te voeren SQL-scriptbestanden declareren. Dit is een alias voor de waarde attribuut

De @Sql annotatie kan worden gebruikt op klassenniveau of op methodeniveau. We kunnen aanvullende gegevens laden die nodig zijn voor een bepaald testgeval door die methode te annoteren:

@Test @Sql ({"/ import_senior_employees.sql"}) openbare ongeldige testLoadDataForTestCase () {assertEquals (5, employeeRepository.findAll (). Size ()); }
6. @SqlConfig

Wij kunnen configureer de manier waarop we de SQL-scripts parseren en uitvoeren door de @SqlConfig annotatie.

@SqlConfig kan worden gedeclareerd op klassenniveau, waar het dient als een globale configuratie. Of het kan worden gebruikt om een ​​bepaald @Sql annotatie.

Laten we een voorbeeld bekijken waarin we de codering van onze SQL-scripts specificeren, evenals de transactiemodus voor het uitvoeren van de scripts:

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

En laten we eens kijken naar de verschillende kenmerken van @SqlConfig:

  • blockCommentStartDelimiter - scheidingsteken om het begin van blokcommentaar in SQL-scriptbestanden te identificeren
  • blockCommentEndDelimiter - scheidingsteken om het einde van blokcommentaar in SQL-scriptbestanden aan te geven
  • commentPrefix - voorvoegsel om opmerkingen van één regel in SQL-scriptbestanden te identificeren
  • databron - naam van de javax.sql.DataSource bean waartegen de scripts en statements zullen worden uitgevoerd
  • codering - codering voor de SQL-scriptbestanden, standaard is platformcodering
  • errorMode - modus die wordt gebruikt wanneer er een fout optreedt bij het uitvoeren van de scripts
  • scheidingsteken - string gebruikt om individuele statements te scheiden, standaard is "-"
  • transactionManager - boon naam van de PlatformTransactionManager dat zal worden gebruikt voor transacties
  • transactionMode - de modus die zal worden gebruikt bij het uitvoeren van scripts in transactie

7. @SqlGroup

Met Java 8 en hoger kunnen herhaalde annotaties worden gebruikt. Deze functie kan worden gebruikt voor @Sql annotaties ook. Voor Java 7 en lager is er een containerannotatie - @SqlGroup. De ... gebruiken @SqlGroup annotatie kunnen we meerdere declareren @Sql annotaties:

@SqlGroup ({@Sql (scripts = "/employees_schema.sql", config = @SqlConfig (transactionMode = TransactionMode.ISOLATED)), @Sql ("/ import_employees.sql")}) openbare klasse SpringBootSqlGroupAnnotation EmployeeIntegrationTest privé werknemerRepository ; @Test openbare ongeldige testLoadDataForTestCase () {assertEquals (3, employeeRepository.findAll (). Size ()); }}

8. Conclusie

In dit korte artikel hebben we gezien hoe we kunnen profiteren schema.sql en data.sql bestanden voor het opzetten van een initieel schema en het vullen met gegevens. We hebben ook gezien hoe we het kunnen gebruiken @Sql, @SqlConfig, en @SqlGroup annotaties om testgegevens voor tests te laden.

Houd er rekening mee dat deze aanpak geschikter is voor eenvoudige en eenvoudige scenario's. Voor elke geavanceerde databaseafhandeling is meer geavanceerde en verfijnde tooling nodig, zoals Liquibase of Flyway.

Codefragmenten zijn, zoals altijd, te vinden op GitHub.