Programmatisch een gegevensbron configureren in Spring Boot

1. Overzicht

Spring Boot gebruikt een eigenzinnig algoritme om een Databron. Hierdoor kunnen we eenvoudig een volledig geconfigureerd Databron implementatie standaard.

Bovendien configureert Spring Boot automatisch een razendsnelle verbindingspool - ofwel HikariCP, Apache Tomcat of Commons DBCP, in die volgorde, afhankelijk van welke op het klassenpad staan.

Terwijl Spring Boot automatisch is Databron configuratie werkt in de meeste gevallen erg goed, soms hebben we meer controle nodig, dus we zullen onze eigen moeten opzetten Databron implementatie, waardoor het automatische configuratieproces wordt overgeslagen.

In deze tutorial leren we hoe u een Databron programmatisch in Spring Boot.

2. De afhankelijkheden van Maven

Een Databron implementatie programmatisch is over het algemeen eenvoudig.

Om te leren hoe u dit kunt bereiken, zullen we een eenvoudige repository-laag implementeren, die CRUD-bewerkingen op sommige JPA-entiteiten zal uitvoeren.

Laten we eens kijken naar de afhankelijkheden van ons demoproject:

 org.springframework.boot spring-boot-starter-data-jpa com.h2database h2 2.4.1 runtime 

Zoals hierboven getoond, gebruiken we een H2-database-instantie in het geheugen om de repository-laag uit te oefenen. Door dit te doen, kunnen we onze programmatisch geconfigureerde Databron, zonder de kosten van het uitvoeren van dure databasebewerkingen.

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

3. Configureren van een Databron Programmatisch

Nu, als we vasthouden aan Spring Boot's automaat Databron configuratie en voer ons project uit in de huidige staat, het zal gewoon werken zoals verwacht.

Spring Boot zal al het zware infrastructuurwerk voor ons doen. Dit omvat het maken van een H2 Databron implementatie, die automatisch wordt afgehandeld door HikariCP, Apache Tomcat of Commons DBCP, en het opzetten van een in-memory database-instantie.

Bovendien hoeven we niet eens een application.properties bestand, aangezien Spring Boot ook enkele standaard database-instellingen zal bieden.

Zoals we eerder al zeiden, hebben we soms een hoger aanpassingsniveau nodig, daarom zullen we onze eigen programmatisch moeten configureren Databron implementatie.

De eenvoudigste manier om dit te bereiken is door een Databron factory-methode en deze in een klasse plaatsen die is geannoteerd met de @Configuratie annotatie:

@Configuration openbare klasse DataSourceConfig {@Bean openbare DataSource getDataSource () {DataSourceBuilder dataSourceBuilder = DataSourceBuilder.create (); dataSourceBuilder.driverClassName ("org.h2.Driver"); dataSourceBuilder.url ("jdbc: h2: mem: test"); dataSourceBuilder.username ("SA"); dataSourceBuilder.password (""); retourneer dataSourceBuilder.build (); }}

In dit geval, we gebruikten het gemak DataSourceBuilder klasse - een niet-vloeiende versie van het bouwpatroon van Joshua Bloch - om programmatisch onze custom Databron voorwerp.

Deze benadering is erg prettig omdat de builder het gemakkelijk maakt om een Databron met behulp van enkele algemene eigenschappen. Bovendien gebruikt het ook de onderliggende verbindingspool.

4. Externaliserend Databron Configuratie met de application.properties het dossier

Het is natuurlijk ook mogelijk om onze Databron configuratie. We zouden bijvoorbeeld een basis kunnen definiëren Databron eigenschappen in onze fabrieksmethode:

@Bean openbare DataSource getDataSource () {DataSourceBuilder dataSourceBuilder = DataSourceBuilder.create (); dataSourceBuilder.username ("SA"); dataSourceBuilder.password (""); retourneer dataSourceBuilder.build (); }

En specificeer een paar extra in het application.properties het dossier:

spring.datasource.url = jdbc: h2: mem: test spring.datasource.driver-class-name = org.h2.Driver 

De eigenschappen die zijn gedefinieerd in een externe bron, zoals hierboven application.properties bestand of via een klasse die is geannoteerd met @ConfigurationProperties, zullen degene die zijn gedefinieerd in de Java API overschrijven.

Het wordt duidelijk dat we met deze aanpak de onze niet langer zullen behouden Databron configuratie-instellingen opgeslagen op één enkele plaats.

Aan de andere kant stelt het ons in staat om de compilatie- en runtime-configuratie-instellingen mooi van elkaar gescheiden te houden.

Dit is echt goed, omdat het ons in staat stelt om eenvoudig een configuratiebindingspunt in te stellen. Op die manier kunnen we verschillende opnemen Databron instellingen uit andere bronnen, zonder dat we onze bonenfabrieksmethoden hoeven te refactoren.

5. Testen van het Databron Configuratie

Onze gewoonte testen Databron configuratie is heel eenvoudig. Het hele proces komt neer op het creëren van een JPA-entiteit, het definiëren van een basisrepository-interface en het testen van de repositorylaag.

5.1. Een PPV-entiteit creëren

Laten we beginnen met het definiëren van onze voorbeeld JPA-entiteitsklasse, die gebruikers zal modelleren:

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

5.2. Een eenvoudige repositorylaag

Vervolgens moeten we een basisrepository-laag implementeren, waarmee we CRUD-bewerkingen kunnen uitvoeren op instanties van het Gebruiker entiteitsklasse hierboven gedefinieerd.

Omdat we Spring Data JPA gebruiken, hoeven we onze eigen DAO-implementatie niet helemaal opnieuw te maken. We moeten gewoon het CrudRepository interface om een ​​werkende repository-implementatie te krijgen:

@Repository openbare interface UserRepository breidt CrudRepository uit {} 

5.3. Testen van de repositorylaag

Ten slotte moeten we controleren of onze programmatisch geconfigureerd Databron werkt echt. Dit kunnen we eenvoudig doen met een integratietest:

@RunWith (SpringRunner.class) @DataJpaTest openbare klasse UserRepositoryIntegrationTest {@Autowired privé UserRepository userRepository; @Test public void whenCalledSave_thenCorrectNumberOfUsers () {userRepository.save (nieuwe gebruiker ("Bob", "[e-mail beschermd]")); Lijst gebruikers = (Lijst) userRepository.findAll (); assertThat (users.size ()). isEqualTo (1); }}

De UserRepositoryIntegrationTest klasse spreekt voor zich. Het oefent eenvoudig twee van de CRUD-methoden van de repository-interface uit om te blijven bestaan ​​en entiteiten te vinden.

Merk op dat ongeacht of we besluiten om onze Databron implementatie, of split het op in een Java-configuratiemethode en de application.properties bestand, moeten we altijd een werkende databaseverbinding krijgen.

5.4. De voorbeeldtoepassing uitvoeren

Ten slotte kunnen we onze demo-applicatie draaien met behulp van een standaard hoofd() methode:

@SpringBootApplication openbare klasse Toepassing {openbare statische leegte hoofd (String [] args) {SpringApplication.run (Application.class, args); } @Bean openbare CommandLineRunner run (UserRepository userRepository) genereert uitzondering {return (String [] args) -> {User user1 = nieuwe gebruiker ("John", "[email protected]"); Gebruiker user2 = nieuwe gebruiker ("Julie", "[email protected]"); userRepository.save (gebruiker1); userRepository.save (gebruiker2); userRepository.findAll (). forEach (gebruiker -> System.out.println (gebruiker);};}} 

We hebben de repository-laag al getest, dus we zijn er zeker van dat onze Databron is succesvol geconfigureerd. Dus als we de voorbeeldtoepassing uitvoeren, zouden we in onze console-uitvoer de lijst met Gebruiker entiteiten die zijn opgeslagen in de database.

6. Conclusie

In deze tutorial we hebben geleerd hoe we een Databron implementatie programmatisch in Spring Boot.

Zoals gewoonlijk zijn alle codevoorbeelden die in deze tutorial worden getoond, beschikbaar op GitHub.