Configuration d'un pool de connexions Tomcat dans Spring Boot

1. Vue d'ensemble

Spring Boot est une couche d'abstraction avisée - mais puissante - placée au-dessus d'une plate-forme Spring simple, ce qui rend le développement d'applications autonomes et Web une évidence. Spring Boot fournit quelques dépendances «de démarrage» pratiques, destinées à exécuter et à tester des applications Java avec un encombrement minimal.

Un composant clé de ces dépendances de démarrage est spring-boot-starter-data-jpa . Cela nous permet d'utiliser JPA et de travailler avec des bases de données de production en utilisant certaines implémentations de regroupement de connexions JDBC populaires, telles que HikariCP et Tomcat JDBC Connection Pool.

Dans ce didacticiel, nous allons apprendre à configurer un pool de connexions Tomcat dans Spring Boot .

2. Les dépendances de Maven

Spring Boot utilise HikariCP comme pool de connexions par défaut, en raison de ses performances remarquables et de ses fonctionnalités prêtes pour l'entreprise.

Voici comment Spring Boot configure automatiquement une source de données de pool de connexions:

  1. Spring Boot recherchera HikariCP sur le chemin de classe et l'utilisera par défaut lorsqu'il est présent
  2. Si HikariCP n'est pas trouvé sur le chemin de classe, Spring Boot récupérera le pool de connexions Tomcat JDBC, s'il est disponible
  3. Si aucune de ces options n'est disponible, Spring Boot choisira Apache Commons DBCP2, si cela est disponible

Pour configurer un pool de connexions Tomcat JDBC au lieu du HikariCP par défaut, nous allons exclure HikariCP de la dépendance spring-boot-starter-data-jpa et ajouter la dépendance tomcat-jdbc Maven à notre pom.xml :

 org.springframework.boot spring-boot-starter-data-jpa   com.zaxxer HikariCP     org.apache.tomcat tomcat-jdbc 9.0.10   com.h2database h2 1.4.197 runtime 

Cette approche simple nous permet d'obtenir Spring Boot à l'aide d'un pool de connexions Tomcat sans avoir à écrire une classe @Configuration et à définir par programme un bean DataSource .

Il est également intéressant de noter que dans ce cas, nous utilisons la base de données en mémoire H2 . Spring Boot configurera automatiquement H2 pour nous, sans avoir à spécifier une URL de base de données, un utilisateur et un mot de passe .

Nous avons juste besoin d'inclure la dépendance correspondante dans le fichier «pom.xml» et Spring Boot fera le reste pour nous.

Vous pouvez également ignorer l'algorithme d'analyse du pool de connexions utilisé par Spring Boot et spécifier explicitement une source de données de pool de connexions dans le fichier «application.properties» , à l'aide de la propriété «spring.datasource.type» :

spring.datasource.type=org.apache.tomcat.jdbc.pool.DataSource // other spring datasource properties

3. Ajuster le pool de connexions avec le fichier « application.properties »

Une fois que nous avons configuré avec succès un pool de connexions Tomcat dans Spring Boot, il est très probable que nous souhaitons configurer des propriétés supplémentaires, pour optimiser ses performances et répondre à certaines exigences spécifiques .

Nous pouvons le faire dans le fichier «application.properties» :

spring.datasource.tomcat.initial-size=15 spring.datasource.tomcat.max-wait=20000 spring.datasource.tomcat.max-active=50 spring.datasource.tomcat.max-idle=15 spring.datasource.tomcat.min-idle=8 spring.datasource.tomcat.default-auto-commit=true 

Veuillez noter que nous avons configuré quelques propriétés de regroupement de connexions supplémentaires, telles que la taille initiale du pool et le nombre maximum et minimum de connexions inactives.

Nous pouvons également spécifier certaines propriétés spécifiques à Hibernate:

# Hibernate specific properties spring.jpa.show-sql=false spring.jpa.hibernate.ddl-auto=update spring.jpa.hibernate.naming-strategy=org.hibernate.cfg.ImprovedNamingStrategy spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.H2Dialect spring.jpa.properties.hibernate.id.new_generator_mappings=false 

4. Test du pool de connexions

Écrivons un test d'intégration simple pour vérifier que Spring Boot a correctement configuré le pool de connexions:

@RunWith(SpringRunner.class) @SpringBootTest public class SpringBootTomcatConnectionPoolIntegrationTest { @Autowired private DataSource dataSource; @Test public void givenTomcatConnectionPoolInstance_whenCheckedPoolClassName_thenCorrect() { assertThat(dataSource.getClass().getName()) .isEqualTo("org.apache.tomcat.jdbc.pool.DataSource"); } }

5. Exemple d'application de ligne de commande

Avec toute la plomberie de mise en commun de connexions déjà définie, construisons une application de ligne de commande simple.

Ce faisant, nous pouvons voir comment effectuer certaines opérations CRUD sur une base de données H2 à l'aide de la puissante couche DAO fournie par Spring Data JPA (et de manière transitoire, Spring Boot).

Pour un guide détaillé sur la façon de commencer à utiliser Spring Data JPA, veuillez consulter cet article.

5.1. La classe d'entité client

Définissons d'abord une classe d'entité Customer naïve :

@Entity @Table(name = "customers") public class Customer { @Id @GeneratedValue(strategy = GenerationType.AUTO) private long id; @Column(name = "first_name") private String firstName; // standard constructors / getters / setters / toString }

5.2. L' interface CustomerRepository

Dans ce cas, nous souhaitons simplement effectuer des opérations CRUD sur quelques entités client . De plus, nous devons récupérer tous les clients qui correspondent à un nom de famille donné.

Il suffit donc d'étendre l' interface CrudRepository de Spring Data JPA et de définir une méthode sur mesure :

public interface CustomerRepository extends CrudRepository { List findByLastName(String lastName); }

Maintenant, nous pouvons facilement récupérer une entité client par son nom de famille.

5.3. L' implémentation CommandLineRunner

Enfin, nous devons au moins conserver quelques entités client dans la base de données et vérifier que notre pool de connexions Tomcat fonctionne réellement .

Créons une implémentation de l' interface CommandLineRunner de Spring Boot . Spring Boot démarrera l'implémentation avant de lancer l'application:

public class CommandLineCrudRunner implements CommandLineRunner { private static final Logger logger = LoggerFactory.getLogger(CommandLineCrudRunner.class); @Autowired private final CustomerRepository repository; public void run(String... args) throws Exception { repository.save(new Customer("John", "Doe")); repository.save(new Customer("Jennifer", "Wilson")); logger.info("Customers found with findAll():"); repository.findAll().forEach(c -> logger.info(c.toString())); logger.info("Customer found with findById(1L):"); Customer customer = repository.findById(1L) .orElseGet(() -> new Customer("Non-existing customer", "")); logger.info(customer.toString()); logger.info("Customer found with findByLastName('Wilson'):"); repository.findByLastName("Wilson").forEach(c -> { logger.info(c.toString()); }); } }

En un mot, la classe CommandLineCrudRunner enregistre d'abord quelques entités Customer dans la base de données. Ensuite, il récupère le premier en utilisant la méthode findById () . Enfin, il récupère un client avec la méthode findByLastName () .

5.4. Exécution de l'application Spring Boot

Bien sûr, la dernière chose que nous devons faire est d'exécuter simplement l'exemple d'application. Ensuite, nous pouvons voir le tandem de pool de connexions Spring Boot / Tomcat en action:

@SpringBootApplication public class SpringBootConsoleApplication { public static void main(String[] args) { SpringApplication.run(SpringBootConsoleApplication.class); } }

6. Conclusion

Dans ce didacticiel, nous avons appris à configurer et à utiliser un pool de connexions Tomcat dans Spring Boot. En outre, nous avons développé une application de ligne de commande de base pour montrer à quel point il est facile de travailler avec Spring Boot, un pool de connexions Tomcat et la base de données H2.

Comme d'habitude, tous les exemples de code présentés dans ce didacticiel sont disponibles à l'adresse over sur GitHub.