Configurarea unei surse de date programat în Spring Boot

1. Prezentare generală

Spring Boot folosește un algoritm avizat pentru a căuta și configura o sursă de date . Acest lucru ne permite să obținem cu ușurință în mod implicit o implementare DataSource complet configurată .

În plus, Spring Boot configurează automat un pool de conexiuni rapid - fie HikariCP, Apache Tomcat sau Commons DBCP, în această ordine, în funcție de care se află pe calea de clasă.

Deși configurația automată DataSource a Spring Boot funcționează foarte bine în majoritatea cazurilor, uneori vom avea nevoie de un nivel mai ridicat de control , așa că va trebui să configurăm propria noastră implementare DataSource , prin urmare omitând procesul de configurare automată.

În acest tutorial, vom învăța cum să configurați o sursă de date programat în Spring Boot .

2. Dependențele Maven

Crearea unei implementări DataSource la nivel de program este simplă, în general .

Pentru a afla cum să realizăm acest lucru, vom implementa un strat simplu de depozit, care va efectua operațiuni CRUD pe unele entități JPA.

Să aruncăm o privire asupra dependențelor proiectului nostru demo:

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

După cum se arată mai sus, vom folosi o instanță de bază de date H2 în memorie pentru a exercita stratul de depozit. Procedând astfel, vom putea testa sursa noastră de date configurată programatic , fără costul efectuării unor operațiuni costisitoare în baza de date.

În plus, să ne asigurăm că verificăm cea mai recentă versiune de spring-boot-starter-data-jpa pe Maven Central.

3. Configurarea unei surse de date programatic

Acum, dacă rămânem cu configurația automată DataSource Spring Boot și executăm proiectul în starea actuală, acesta va funcționa așa cum era de așteptat.

Spring Boot va face toate instalațiile grele de instalare pentru noi. Aceasta include crearea unei implementări H2 DataSource , care va fi gestionată automat de HikariCP, Apache Tomcat sau Commons DBCP și configurarea unei instanțe a bazei de date în memorie.

În plus, nici măcar nu va trebui să creăm un fișier application.properties , deoarece Spring Boot va oferi și unele setări implicite ale bazei de date.

După cum am menționat anterior, uneori vom avea nevoie de un nivel mai ridicat de personalizare, prin urmare va trebui să configurăm programatic propria noastră implementare DataSource .

Cel mai simplu mod de a realiza acest lucru este prin definirea unei metode de fabrică DataSource și plasarea acesteia într-o clasă adnotată cu adnotarea @Configuration :

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

În acest caz, am folosit clasa de comoditate DataSourceBuilder - o versiune non-fluentă a modelului de constructor al lui Joshua Bloch - pentru a crea programatic obiectul nostru DataSource personalizat .

Această abordare este foarte frumoasă, deoarece constructorul face mai ușoară configurarea unei surse de date folosind unele proprietăți comune. În plus, folosește și pool-ul de conexiuni subiacent.

4. Externalizarea configurației sursei de date cu fișierul application.properties

Desigur, este posibilă și externalizarea parțială a configurației noastre DataSource . De exemplu, am putea defini câteva proprietăți de bază DataSource în metoda noastră din fabrică:

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

Și specificați câteva suplimentare în fișierul application.properties :

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

Proprietățile definite într-o sursă externă, cum ar fi fișierul application.properties de mai sus sau printr-o clasă adnotată cu @ConfigurationProperties , le vor suprascrie pe cele definite în API-ul Java.

Devine evident că, cu această abordare, nu vom mai păstra setările noastre de configurare DataSource stocate într-un singur loc .

Pe de altă parte, ne permite să păstrăm setările de configurare în timp de compilare și în timp de execuție bine separate unele de altele.

Acest lucru este foarte bun, deoarece ne permite să setăm cu ușurință un punct de legare a configurației. În acest fel putem include diferite setări DataSource din alte surse, fără a fi nevoie să refactorizăm metodele noastre de fabricație de fasole.

5. Testarea configurației sursei de date

Testarea configurației noastre personalizate DataSource este foarte simplă. Întregul proces se reduce doar la crearea unei entități JPA, definirea unei interfețe de bază a depozitului și testarea stratului depozitului.

5.1. Crearea unei entități JPA

Să începem să definim eșantionul clasei de entități JPA, care va modela utilizatorii:

@Entity @Table(name = "users") public class User { @Id @GeneratedValue(strategy = GenerationType.AUTO) private long id; private String name; private String email; // standard constructors / setters / getters / toString }

5.2. Un strat simplu de depozit

În continuare, trebuie să implementăm un strat de depozit de bază, care ne permite să efectuăm operații CRUD pe instanțe din clasa de entitate User definită mai sus.

Deoarece folosim Spring Data JPA, nu trebuie să creăm propria noastră implementare DAO de la zero. Trebuie pur și simplu să extindem interfața CrudRepository pentru a obține o implementare funcțională a depozitului:

@Repository public interface UserRepository extends CrudRepository {} 

5.3. Testarea stratului de depozit

În cele din urmă, trebuie să verificăm dacă sursa noastră de date configurată programatic funcționează efectiv. Putem realiza cu ușurință acest lucru printr-un test de integrare:

@RunWith(SpringRunner.class) @DataJpaTest public class UserRepositoryIntegrationTest { @Autowired private UserRepository userRepository; @Test public void whenCalledSave_thenCorrectNumberOfUsers() { userRepository.save(new User("Bob", "[email protected]")); List users = (List) userRepository.findAll(); assertThat(users.size()).isEqualTo(1); } }

UserRepositoryIntegrationTest Clasa este destul de auto-explicativ. Pur și simplu exercită două dintre metodele CRUD ale interfeței de depozitare pentru a persista și a găsi entități.

Observați că, indiferent dacă decidem să configurăm implementarea noastră DataSource sau să o împărțim într-o metodă de configurare Java și în fișierul application.properties , ar trebui să obținem întotdeauna o conexiune de bază de date funcțională .

5.4. Rularea aplicației eșantion

În cele din urmă, putem rula aplicația noastră demonstrativă folosind o metodă standard main () :

@SpringBootApplication public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } @Bean public CommandLineRunner run(UserRepository userRepository) throws Exception { return (String[] args) -> { User user1 = new User("John", "[email protected]"); User user2 = new User("Julie", "[email protected]"); userRepository.save(user1); userRepository.save(user2); userRepository.findAll().forEach(user -> System.out.println(user); }; } } 

Am testat deja stratul de depozit, așa că suntem siguri că DataSource a fost configurată cu succes. Astfel, dacă rulăm aplicația eșantion, ar trebui să vedem în ieșirea din consolă lista entităților de utilizator stocate în baza de date.

6. Concluzie

În acest tutorial, am învățat cum să configurăm o implementare DataSource programat în Spring Boot .

Ca de obicei, toate exemplele de cod afișate în acest tutorial sunt disponibile pe GitHub.