Configurazione di un pool di connessioni Tomcat in Spring Boot

1. Panoramica

Spring Boot è un supponente - ma potente - strato di astrazione posizionato sopra una semplice piattaforma Spring, che rende lo sviluppo di applicazioni web e autonome un gioco da ragazzi. Spring Boot fornisce alcune pratiche dipendenze "starter", volte a eseguire e testare applicazioni Java con un impatto minimo.

Un componente chiave di queste dipendenze di avvio è spring-boot-starter-data-jpa . Questo ci consente di utilizzare JPA e lavorare con i database di produzione utilizzando alcune popolari implementazioni di pool di connessioni JDBC, come HikariCP e Tomcat JDBC Connection Pool.

In questo tutorial impareremo come configurare un pool di connessioni Tomcat in Spring Boot .

2. Le dipendenze di Maven

Spring Boot utilizza HikariCP come pool di connessioni predefinito, grazie alle sue notevoli prestazioni e alle funzionalità pronte per l'azienda.

Ecco come Spring Boot configura automaticamente un'origine dati del pool di connessioni:

  1. Spring Boot cercherà HikariCP nel classpath e lo utilizzerà di default quando presente
  2. Se HikariCP non viene trovato sul classpath, Spring Boot raccoglierà il pool di connessioni JDBC Tomcat, se disponibile
  3. Se nessuna di queste opzioni è disponibile, Spring Boot sceglierà Apache Commons DBCP2, se disponibile

Per configurare un pool di connessioni JDBC Tomcat invece dell'HikariCP predefinito, escluderemo HikariCP dalla dipendenza spring-boot-starter-data-jpa e aggiungeremo la dipendenza tomcat-jdbc Maven al nostro 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 

Questo semplice approccio ci consente di ottenere Spring Boot utilizzando un pool di connessioni Tomcat senza dover scrivere una classe @Configuration e definire a livello di codice un bean DataSource .

Vale anche la pena notare che in questo caso stiamo usando il database in memoria H2 . Spring Boot configurerà automaticamente H2 per noi, senza dover specificare un URL del database, un utente e una password .

Dobbiamo solo includere la dipendenza corrispondente nel file "pom.xml" e Spring Boot farà il resto per noi.

In alternativa, è possibile saltare l'algoritmo di scansione del pool di connessioni utilizzato da Spring Boot e specificare esplicitamente un'origine dati del pool di connessioni nel file "application.properties" , utilizzando la proprietà "spring.datasource.type" :

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

3. Modifica del pool di connessioni con il file " application.properties "

Dopo aver configurato correttamente un pool di connessioni Tomcat in Spring Boot, è molto probabile che desidereremo impostare alcune proprietà aggiuntive, per ottimizzarne le prestazioni e soddisfare alcuni requisiti specifici .

Possiamo farlo nel file "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 

Tieni presente che abbiamo configurato alcune proprietà aggiuntive per il pool di connessioni, come la dimensione iniziale del pool e il numero massimo e minimo di connessioni inattive.

Possiamo anche specificare alcune proprietà specifiche di 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. Verifica del pool di connessioni

Scriviamo un semplice test di integrazione per verificare che Spring Boot abbia configurato correttamente il pool di connessioni:

@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'applicazione della riga di comando di esempio

Con tutto l'impianto idraulico del pool di connessioni già impostato, creiamo una semplice applicazione a riga di comando.

In tal modo, possiamo vedere come eseguire alcune operazioni CRUD su un database H2 utilizzando il potente livello DAO che Spring Data JPA (e in modo transitorio, Spring Boot) fornisce immediatamente.

Per una guida dettagliata su come iniziare a utilizzare Spring Data JPA, consulta questo articolo.

5.1. La classe di entità cliente

Definiamo prima una classe entità cliente ingenua :

@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' interfaccia CustomerRepository

In questo caso, vogliamo solo eseguire operazioni CRUD su poche entità Cliente . Inoltre, dobbiamo recuperare tutti i clienti che corrispondono a un determinato cognome.

Quindi, tutto ciò che dobbiamo fare è estendere l' interfaccia CrudRepository di Spring Data JPA e definire un metodo su misura :

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

Ora possiamo facilmente recuperare un'entità Customer in base al suo cognome.

5.3. L' implementazione di CommandLineRunner

Infine, dobbiamo almeno rendere persistenti alcune entità cliente nel database e verificare che il nostro pool di connessioni Tomcat funzioni effettivamente .

Creiamo un'implementazione dell'interfaccia CommandLineRunner di Spring Boot . Spring Boot eseguirà il bootstrap dell'implementazione prima di avviare l'applicazione:

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

In poche parole, la classe CommandLineCrudRunner salva prima un paio di entità Customer nel database. Successivamente, recupera il primo utilizzando il metodo findById () . Infine, recupera un cliente con il metodo findByLastName () .

5.4. Esecuzione dell'applicazione Spring Boot

Ovviamente, l'ultima cosa che dobbiamo fare è semplicemente eseguire l'applicazione di esempio. Quindi possiamo vedere il tandem del pool di connessioni Spring Boot / Tomcat in azione:

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

6. Conclusione

In questo tutorial, abbiamo imparato a configurare e utilizzare un pool di connessioni Tomcat in Spring Boot. Inoltre, abbiamo sviluppato un'applicazione a riga di comando di base per mostrare quanto sia facile lavorare con Spring Boot, un pool di connessioni Tomcat e il database H2.

Come al solito, tutti gli esempi di codice mostrati in questo tutorial sono disponibili su GitHub.