Een Tomcat-verbindingspool configureren in Spring Boot

1. Overzicht

Spring Boot is een eigenzinnige maar krachtige abstractielaag die bovenop een eenvoudig Spring-platform is geplaatst, waardoor het ontwikkelen van stand-alone en webapplicaties een goed idee is. Spring Boot biedt een aantal handige "starter" afhankelijkheden, gericht op het draaien en testen van Java-applicaties met een minimale footprint.

Een belangrijk onderdeel van deze starter-afhankelijkheden is spring-boot-starter-data-jpa. Dit stelt ons in staat om JPA te gebruiken en met productiedatabases te werken door gebruik te maken van enkele populaire implementaties van JDBC-verbindingspooling, zoals HikariCP en Tomcat JDBC-verbindingspool.

In deze tutorial we zullen leren hoe u een Tomcat-verbindingspool configureert in Spring Boot.

2. De afhankelijkheden van Maven

Spring Boot gebruikt HikariCP als de standaard verbindingspool, vanwege zijn opmerkelijke prestaties en bedrijfsklare functies.

Hier is hoe Spring Boot automatisch een gegevensbron van een verbindingspool configureert:

  1. Spring Boot zoekt naar HikariCP op het klassenpad en gebruikt het standaard indien aanwezig
  2. Als HikariCP niet wordt gevonden op het klassenpad, haalt Spring Boot de Tomcat JDBC-verbindingspool op, als deze beschikbaar is
  3. Als geen van deze opties beschikbaar is, kiest Spring Boot Apache Commons DBCP2, als dat beschikbaar is

Om een ​​Tomcat JDBC-verbindingspool te configureren in plaats van de standaard HikariCP, zullen we uitsluiten HikariCP van de spring-boot-starter-data-jpa afhankelijkheid en voeg het tomcat-jdbc Maven-afhankelijkheid naar onze 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 

Deze eenvoudige benadering stelt ons in staat om Spring Boot te krijgen met behulp van een Tomcat-verbindingspool zonder een @Configuratie class en programmatisch definiëren een Databron Boon.

Het is ook vermeldenswaard dat we in dit geval de H2 in-memory-database gebruiken. Spring Boot configureert H2 automatisch voor ons, zonder een database-URL, gebruiker en wachtwoord op te geven.

We hoeven alleen de bijbehorende afhankelijkheid op te nemen in het "Pom.xml" file en Spring Boot doet de rest voor ons.

Alternatief, het is mogelijk om het scanalgoritme voor verbindingspools dat Spring Boot gebruikt, over te slaan en expliciet een gegevensbron voor verbindingspooling op te geven in de "Application.properties" -bestand, de ... gebruiken "Spring.datasource.type" eigendom:

spring.datasource.type = org.apache.tomcat.jdbc.pool.DataSource // andere eigenschappen van de lentegegevensbron

3. De verbindingspool aanpassen met de “application.properties" Het dossier

Zodra we met succes een Tomcat-verbindingspool hebben geconfigureerd in Spring Boot, het is zeer waarschijnlijk dat we wat extra eigenschappen willen opzetten om de prestaties te optimaliseren en aan enkele specifieke vereisten te voldoen.

We kunnen dit doen in de "Application.properties" het dossier:

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 

Houd er rekening mee dat we een aantal extra eigenschappen voor pooling van verbindingen hebben geconfigureerd, zoals de initiële grootte van de pool en het maximum en minimum aantal inactieve verbindingen.

We kunnen ook enkele Hibernate-specifieke eigenschappen specificeren:

# Slaapspecifieke eigenschappen 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. Testen van de verbindingspool

Laten we een eenvoudige integratietest schrijven om te controleren of Spring Boot de verbindingspool correct heeft geconfigureerd:

@RunWith (SpringRunner.class) @SpringBootTest openbare klasse SpringBootTomcatConnectionPoolIntegrationTest {@Autowired privé DataSource dataSource; @Test openbare leegte gegevenTomcatConnectionPoolInstance_whenCheckedPoolClassName_thenCorrect () {assertThat (dataSource.getClass (). GetName ()) .isEqualTo ("org.apache.tomcat.jdbc.pool.DataSource"); }}

5. Een voorbeeld van een opdrachtregeltoepassing

Nu al het sanitair voor het poolen van verbindingen al is ingesteld, gaan we een eenvoudige opdrachtregelapplicatie bouwen.

Door dit te doen, kunnen we zien hoe we sommige CRUD-bewerkingen op een H2-database kunnen uitvoeren met behulp van de krachtige DAO-laag die Spring Data JPA (en tijdelijk Spring Boot) uit de doos biedt.

Raadpleeg dit artikel voor een gedetailleerde handleiding om aan de slag te gaan met Spring Data JPA.

5.1. De Klant Entiteitsklasse

Laten we eerst een naïef definiëren Klant entiteitsklasse:

@Entity @Table (naam = "klanten") openbare klasse Klant {@Id @GeneratedValue (strategie = GenerationType.AUTO) lange privé-id; @Column (name = "first_name") private String firstName; // standard constructors / getters / setters / toString}

5.2. De CustomerRepository Koppel

In dit geval willen we alleen CRUD-bewerkingen uitvoeren op een paar Klant entiteiten. Bovendien moeten we alle klanten ophalen die overeenkomen met een bepaalde achternaam.

Zo, het enige wat we hoeven te doen is de Spring Data JPA's uit te breiden CrudRepository interface en definieer een op maat gemaakte methode:

openbare interface CustomerRepository breidt CrudRepository {List findByLastName (String lastName) uit; }

Nu kunnen we gemakkelijk een Klant entiteit op achternaam.

5.3. De CommandLineRunner Implementatie

Ten slotte moeten we er in ieder geval een paar volhouden Klant entiteiten in de database en controleer of onze Tomcat-verbindingspool echt werkt.

Laten we een implementatie maken van Spring Boot's CommandLineRunner koppel. Spring Boot zal de implementatie bootstrap voordat de applicatie wordt gestart:

openbare klasse CommandLineCrudRunner implementeert CommandLineRunner {privé statische laatste Logger-logger = LoggerFactory.getLogger (CommandLineCrudRunner.class); @Autowired privé definitieve CustomerRepository-repository; public void run (String ... args) gooit Uitzondering {repository.save (nieuwe klant ("John", "Doe")); repository.save (nieuwe klant ("Jennifer", "Wilson")); logger.info ("Klanten gevonden met findAll ():"); repository.findAll (). forEach (c -> logger.info (c.toString ())); logger.info ("Klant gevonden met findById (1L):"); Klant klant = repository.findById (1L) .orElseGet (() -> nieuwe klant ("Niet-bestaande klant", "")); logger.info (customer.toString ()); logger.info ("Klant gevonden met findByLastName ('Wilson'):"); repository.findByLastName ("Wilson"). forEach (c -> {logger.info (c.toString ());}); }}

In een notendop, de CommandLineCrudRunner class first bespaart een paar Klant entiteiten in de database. Vervolgens haalt het de eerste op met behulp van de findById () methode. Ten slotte haalt het een klant op met de findByLastName () methode.

5.4. De Spring Boot-applicatie uitvoeren

Het laatste dat we moeten doen, is natuurlijk gewoon de voorbeeldtoepassing uitvoeren. Dan kunnen we de Spring Boot / Tomcat-verbindingspooltandem in actie zien:

@SpringBootApplication openbare klasse SpringBootConsoleApplication {openbare statische leegte hoofd (String [] args) {SpringApplication.run (SpringBootConsoleApplication.class); }}

6. Conclusie

In deze zelfstudie hebben we geleerd hoe we een Tomcat-verbindingspool in Spring Boot kunnen configureren en gebruiken. Daarnaast hebben we een eenvoudige opdrachtregelapplicatie ontwikkeld om te laten zien hoe gemakkelijk het is om met Spring Boot, een Tomcat-verbindingspool en de H2-database te werken.

Zoals gewoonlijk zijn alle codevoorbeelden die in deze tutorial worden getoond, beschikbaar op GitHub.