streamalism.org

1. Overzicht

Spring Boot maakt het heel gemakkelijk om met verschillende databasesystemen te werken, zonder gedoe met handmatig afhankelijkheidsbeheer.

Meer specifiek biedt Spring Data JPA starter alle functionaliteit die nodig is voor naadloze integratie met meerdere Databron implementaties.

In deze tutorial we zullen leren hoe we Spring Boot kunnen integreren met HSQLDB.

2. De afhankelijkheden van Maven

Om te laten zien hoe eenvoudig het is om Spring Boot te integreren met HSQLDB, we zullen een eenvoudige JPA-repositorylaag maken die CRUD-bewerkingen uitvoert op entiteiten van klanten met behulp van een in-memory HSQLDB-database.

Hier is de Spring Boot-starter die we zullen gebruiken om onze voorbeeldrepository-laag in gebruik te nemen:

 org.springframework.boot spring-boot-starter-data-jpa 2.2.2.RELEASE org.hsqldb hsqldb 2.4.0 runtime 

Merk op dat we ook de HSQLDB-afhankelijkheid hebben opgenomen. Zonder dit zal Spring Boot proberen om automatisch een Databron bean en een JDBC-verbindingspool voor ons via HikariCP.

Als gevolg daarvan als we geen valid specificeren Databron afhankelijkheid in onze pom.xml bestand, krijgen we een build-fout.

Laten we er daarnaast voor zorgen dat we de nieuwste versie van spring-boot-starter-data-jpa op Maven Central.

3. Verbinding maken met een HSQLDB-database

Voor het oefenen van onze demo-repository-laag gebruiken we een in-memory database. Het is echter mogelijk om ook met op bestanden gebaseerde databases te werken. We zullen elk van deze methoden in de onderstaande secties onderzoeken.

3.1. Een externe HSQLDB-server draaien

Laten we eens kijken hoe u een externe HSQLDB-server kunt laten draaien en een op bestanden gebaseerde database kunt maken. Het installeren van HSQLDB en het draaien van de server is over het algemeen eenvoudig.

Hier zijn de stappen die we moeten volgen:

• Eerst downloaden we HSQLDB en pakken we het uit in een map
• Aangezien HSQLDB geen standaarddatabase biedt, maken we er een met de naam "Testdb" bijvoorbeeld doeleinden
• We starten een opdrachtprompt en navigeren naar de HSQLDB gegevens map
• Binnen de gegevens map, zullen we de volgende opdracht uitvoeren:

  java -cp ../lib/hsqldb.jar org.hsqldb.server.Server --database.0 file.testdb --dbname0.testdb

• De bovenstaande opdracht start de HSQLDB-server en maakt onze database aan waarvan de bronbestanden worden opgeslagen in het gegevens map
• We kunnen ervoor zorgen dat de database daadwerkelijk is gemaakt door naar het gegevens map, die een set bestanden met de naam "Testdb.lck", "Testdb.log", "Testdb.properties", en "Testdb.script" (het aantal bestanden varieert afhankelijk van het type database dat we maken)

Zodra de database is opgezet, moeten we er een verbinding mee maken.

Om dit op Windows te doen, laten we naar de database gaan bak map en voer het runManagerSwing.bat het dossier. Dit opent het beginscherm van HSQLDB Database Manager, waar we de verbindingsreferenties kunnen invoeren:

• Type: HSQL-database-engine
• URL:jdbc: hsqldb: hsql: // localhost / testdb
• Gebruiker: "SA" (systeembeheerder)
• Wachtwoord: laat het veld leeg

Op Linux / Unix / Mackunnen we NetBeans, Eclipse of IntelliJ IDEA gebruiken om de databaseverbinding tot stand te brengen via de visuele tools van de IDE, met dezelfde inloggegevens.

In elk van deze tools is het eenvoudig om een ​​databasetabel te maken door een SQL-script uit te voeren in Database Manager of binnen de IDE.

Eenmaal verbonden, kunnen we een klanten tafel:

CREATE TABLE-klanten (id INT NOT NULL, naam VARCHAR (45), e-mail VARCHAR (45), PRIMAIRE SLEUTEL (ID)); 

In slechts een paar eenvoudige stappen hebben we een op bestanden gebaseerde HSQLDB-database gemaakt met een klanten tafel.

3.2. De application.properties het dossier

Als we vanuit Spring Boot verbinding willen maken met de vorige bestandsgebaseerde database, zijn hier de instellingen die we in het application.properties het dossier:

spring.datasource.driver-class-name = org.hsqldb.jdbc.JDBCDriver spring.datasource.url = jdbc: hsqldb: hsql: // localhost / testdb spring.datasource.username = sa spring.datasource.password = spring.jpa .hibernate.ddl-auto = update 

Als alternatief, als we een in-memory database gebruiken, zouden we deze moeten gebruiken:

spring.datasource.driver-class-name = org.hsqldb.jdbc.JDBCDriver spring.datasource.url = jdbc: hsqldb: mem: testdb; DB_CLOSE_DELAY = -1 spring.datasource.username = sa spring.datasource.password = spring. jpa.hibernate.ddl-auto = maken 

Let op de DB_CLOSE_DELAY = -1 parameter toegevoegd aan het einde van de database-URL. Bij het werken met een in-memory database, moeten we dit specificeren, dus de JPA-implementatie, die Hibernate is, zal de database niet sluiten terwijl de applicatie wordt uitgevoerd.

4. Het Klant Entiteit

Nu de databaseverbindingsinstellingen al zijn ingesteld, moeten we vervolgens onze Klant entiteit:

@Entity @Table (naam = "klanten") openbare klasse Klant {@Id @GeneratedValue (strategie = GenerationType.AUTO) lange privé-id; private String naam; privé String-e-mail; // standard constructors / setters / getters / toString} 

5. Het Klant Opslagplaats

Bovendien moeten we een dunne persistentielaag implementeren, waardoor we basis CRUD-functionaliteit op onze Klant PPV-entiteiten.

We kunnen deze laag eenvoudig implementeren door het CrudRepository koppel:

@Repository openbare interface CustomerRepository breidt CrudRepository uit {}

6. Testen van het Klant Opslagplaats

Ten slotte moeten we ervoor zorgen dat Spring Boot daadwerkelijk verbinding kan maken met HSQLDB. We kunnen dit eenvoudig bereiken door alleen de repository-laag te testen.

Laten we beginnen met het testen van de repository's findById () en vind alle() methoden:

@RunWith (SpringRunner.class) @SpringBootTest openbare klasse CustomerRepositoryTest {@Autowired privé CustomerRepository customerRepository; @Test public void whenFindingCustomerById_thenCorrect () {customerRepository.save (nieuwe klant ("John", "[email protected]")); assertThat (customerRepository.findById (1L)). isInstanceOf (optional.class); } @Test public void whenFindingAllCustomers_thenCorrect () {customerRepository.save (nieuwe klant ("John", "[email protected]")); customerRepository.save (nieuwe klant ("Julie", "[e-mail beschermd]")); assertThat (customerRepository.findAll ()). isInstanceOf (List.class); }} 

Laten we tot slot het sparen() methode:

@Test public void whenSavingCustomer_thenCorrect () {customerRepository.save (nieuwe klant ("Bob", "[email protected]")); Klant klant = customerRepository.findById (1L) .orElseGet (() -> nieuwe klant ("john", "[email protected]")); assertThat (customer.getName ()). isEqualTo ("Bob"); }

7. Conclusie

In dit artikel, we hebben geleerd hoe we Spring Boot kunnen integreren met HSQLDB, en hoe u een op bestanden gebaseerde of in-memory database kunt gebruiken bij de ontwikkeling van een basis JPA-repositorylaag.

Zoals gewoonlijk zijn alle codevoorbeelden die in dit artikel worden getoond, beschikbaar op GitHub.