Configuration d'un pool de connexions Tomcat au démarrage du printemps
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 pratiques de démarrage, destinées à exécuter et à tester des applications Java avec une empreinte minimale.
One key component of these starter dependencies is spring-boot-starter-data-jpa. Cela nous permet d'utiliserJPA et de travailler avec des bases de données de production en utilisant certaines implémentations de pool de connexions JDBC courantes, telles queHikariCP etTomcat JDBC Connection Pool.
Dans ce didacticiel,we’ll learn how to configure a Tomcat connection pool in Spring Boot.
2. Les dépendances Maven
Spring Boot utilise HikariCP comme pool de connexion par défaut, en raison de ses performances remarquables et de ses fonctionnalités prêtes à l'emploi.
Voici comment Spring Boot configure automatiquement une source de données de pool de connexions:
-
Spring Boot recherchera HikariCP sur le chemin de classe et l'utilisera par défaut lorsqu'il est présent
-
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
-
Si aucune de ces options n'est disponible, Spring Boot choisiraApache Commons DBCP2, si cela est disponible
Pour configurer un pool de connexions Tomcat JDBC au lieu du HikariCP par défaut, nous allonsexclude HikariCP from the spring-boot-starter-data-jpa dependency and add the tomcat-jdbc Maven dependency vers nospom.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 en utilisant un pool de connexions Tomcat sans avoir à écrire une classe@Configuration et à définir par programme un beanDataSource.
It’s also worth noting that in this case, we’re using the H2 in-memory database. Spring Boot will autoconfigure H2 for us, without having to specify a database URL, user, and password.
Nous avons juste besoin d'inclure la dépendance correspondante dans le fichier“pom.xml” et Spring Boot fera le reste pour nous.
Alternativement,it’s possible to skip the connection pool scanning algorithm that Spring Boot uses and explicitly specify a connection pooling datasource dans le“application.properties” file, en utilisant la propriété“spring.datasource.type”:
spring.datasource.type=org.apache.tomcat.jdbc.pool.DataSource
// other spring datasource properties3. Modification du 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,it’s very likely that we’ll want to set up some additional properties, for optimizing its performance and suiting some specific requirements.
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=trueVeuillez 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 maximal et minimal 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=false4. 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. Un exemple d'application de ligne de commande
Avec toute la plomberie de regroupement de connexions déjà définie, créons 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 en utilisant la puissante coucheDAO queSpring Data JPA (et de manière transitoire, Spring Boot) fournit prête à l'emploi.
Pour un guide détaillé sur la façon de commencer à utiliser Spring Data JPA, veuillez vérifierthis article.
5.1. La classe d'entitéCustomer
Définissons d'abord une classe d'entité naïveCustomer:
@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'interfaceCustomerRepository
Dans ce cas, nous souhaitons simplement effectuer des opérations CRUD sur quelques entitésCustomer..
Donc,all that we have to do is to extend Spring Data JPA’s CrudRepository interface and define a tailored method:
public interface CustomerRepository extends CrudRepository {
List findByLastName(String lastName);
} Maintenant, nous pouvons facilement récupérer une entitéCustomer par son nom de famille.
5.3. L'implémentation deCommandLineRunner
Enfin, nous devons au moins conserver quelques entitésCustomer dans la base de données etverify that our Tomcat connection pool is actually working.
Créons une implémentation de l'interfaceCommandLineRunner 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 classeCommandLineCrudRunner enregistre d'abord quelques entitésCustomer dans la base de données. Ensuite, il récupère le premier en utilisant la méthodefindById(). Enfin, il récupère un client avec la méthodefindByLastName().
5.4. Exécution de l'application Spring Boot
Bien entendu, la dernière chose à faire est simplement d’exécuter l’application exemple. Ensuite, nous pouvons voir le tandem du 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 base de ligne de commande 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 tutoriel sont disponiblesover on GitHub.