Configuración de una fuente de datos mediante programación en Spring Boot

1. Información general

Spring Boot utiliza un algoritmo obstinado para buscar y configurar una fuente de datos . Esto nos permite obtener fácilmente una implementación de DataSource completamente configurada de forma predeterminada.

Además, Spring Boot configura automáticamente un grupo de conexiones ultrarrápido, ya sea HikariCP, Apache Tomcat o Commons DBCP, en ese orden, dependiendo de cuáles estén en la ruta de clases.

Si bien la configuración automática de DataSource de Spring Boot funciona muy bien en la mayoría de los casos, a veces necesitaremos un mayor nivel de control , por lo que tendremos que configurar nuestra propia implementación de DataSource y , por lo tanto, omitir el proceso de configuración automática.

En este tutorial, aprenderemos cómo configurar un DataSource mediante programación en Spring Boot .

2. Las dependencias de Maven

La creación de una implementación de DataSource mediante programación es sencilla, en general .

Para aprender cómo lograr esto, implementaremos una capa de repositorio simple, que realizará operaciones CRUD en algunas entidades JPA.

Echemos un vistazo a las dependencias de nuestro proyecto de demostración:

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

Como se muestra arriba, usaremos una instancia de base de datos H2 en memoria para ejercitar la capa de repositorio. Al hacerlo, podremos probar nuestro DataSource configurado mediante programación , sin el costo de realizar costosas operaciones de base de datos.

Además, asegurémonos de verificar la última versión de spring-boot-starter-data-jpa en Maven Central.

3. Configuración de una fuente de datos mediante programación

Ahora, si nos atenemos a la configuración automática de DataSource de Spring Boot y ejecutamos nuestro proyecto en su estado actual, funcionará como se esperaba.

Spring Boot hará todo el trabajo de infraestructura pesada por nosotros. Esto incluye la creación de una implementación H2 DataSource , que será manejada automáticamente por HikariCP, Apache Tomcat o Commons DBCP, y la configuración de una instancia de base de datos en memoria.

Además, ni siquiera necesitaremos crear un archivo application.properties , ya que Spring Boot también proporcionará algunas configuraciones de base de datos predeterminadas.

Como mencionamos anteriormente, a veces necesitaremos un mayor nivel de personalización, por lo tanto, tendremos que configurar programáticamente nuestra propia implementación de DataSource .

La forma más sencilla de lograr esto es definiendo un método de fábrica DataSource y colocándolo dentro de una clase anotada con la anotación @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(); } }

En este caso, utilizamos la clase DataSourceBuilder de conveniencia , una versión no fluida del patrón de construcción de Joshua Bloch, para crear mediante programación nuestro objeto DataSource personalizado .

Este enfoque es realmente bueno porque el constructor facilita la configuración de una fuente de datos utilizando algunas propiedades comunes. Además, también utiliza el grupo de conexiones subyacente.

4. La externalización origen de datos de configuración con el application.properties Archivo

Por supuesto, también es posible externalizar parcialmente nuestra configuración de DataSource . Por ejemplo, podríamos definir algunas propiedades básicas de DataSource en nuestro método de fábrica:

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

Y especifique algunos adicionales en el archivo application.properties :

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

Las propiedades definidas en una fuente externa, como el archivo application.properties anterior o mediante una clase anotada con @ConfigurationProperties , anularán las definidas en la API de Java.

Se hace evidente que, con este enfoque, ya no mantendremos nuestra configuración de DataSource almacenada en un solo lugar .

Por otro lado, nos permite mantener las configuraciones de tiempo de compilación y de ejecución bien separadas entre sí.

Esto es realmente bueno, ya que nos permite establecer fácilmente un punto de enlace de configuración. De esa manera podemos incluir diferentes configuraciones de DataSource de otras fuentes, sin tener que refactorizar nuestros métodos de fábrica de frijoles.

5. Prueba de la configuración de la fuente de datos

Probar nuestra configuración de fuente de datos personalizada es muy simple. Todo el proceso se reduce a crear una entidad JPA, definir una interfaz de repositorio básica y probar la capa de repositorio.

5.1. Creación de una entidad JPA

Comencemos a definir nuestra clase de entidad JPA de muestra, que modelará a los usuarios:

@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. Una capa de repositorio simple

A continuación, necesitamos implementar una capa de repositorio básica, que nos permite realizar operaciones CRUD en instancias de la clase de entidad Usuario definida anteriormente.

Dado que estamos usando Spring Data JPA, no tenemos que crear nuestra propia implementación DAO desde cero. Simplemente tenemos que extender la interfaz CrudRepository para obtener una implementación de repositorio que funcione:

@Repository public interface UserRepository extends CrudRepository {} 

5.3. Prueba de la capa de repositorio

Por último, debemos verificar que nuestro DataSource configurado mediante programación esté funcionando. Podemos lograr esto fácilmente con una prueba de integración:

@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); } }

La clase UserRepositoryIntegrationTest es bastante autoexplicativa. Simplemente ejercita dos de los métodos CRUD de la interfaz del repositorio para persistir y encontrar entidades.

Notice that regardless of whether we decide to programmatically configure our DataSource implementation, or split it into a Java config method and the application.properties file, we should always get a working database connection.

5.4. Running the Sample Application

Finally, we can run our demo application using a standard main() method:

@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); }; } } 

We already tested the repository layer, so we're sure that our DataSource has been configured successfully. Thus, if we run the sample application, we should see in our console output the list of User entities stored in the database.

6. Conclusion

En este tutorial, aprendimos cómo configurar una implementación de DataSource mediante programación en Spring Boot .

Como de costumbre, todos los ejemplos de código que se muestran en este tutorial están disponibles en GitHub.