Konfigurieren eines Tomcat-Verbindungspools im Spring Boot

1. Übersicht

Spring Boot ist eine eigensinnige und dennoch leistungsstarke Abstraktionsebene, die auf einer einfachen Spring-Plattform platziert ist und die Entwicklung von eigenständigen und Webanwendungen zum Kinderspiel macht. Spring Boot bietet einige nützliche Starter-Abhängigkeiten, mit denen Java-Anwendungen mit minimalem Platzbedarf ausgeführt und getestet werden können.

Eine Schlüsselkomponente dieser Starterabhängigkeiten ist Spring-Boot-Starter-Data-JPA . Auf diese Weise können wir JPA verwenden und mit Produktionsdatenbanken arbeiten, indem wir einige gängige JDBC-Implementierungen für das Verbindungspooling verwenden, z. B. HikariCP und Tomcat JDBC Connection Pool.

In diesem Tutorial erfahren Sie, wie Sie einen Tomcat-Verbindungspool in Spring Boot konfigurieren .

2. Die Maven-Abhängigkeiten

Spring Boot verwendet HikariCP aufgrund seiner bemerkenswerten Leistung und unternehmensfähigen Funktionen als Standardverbindungspool.

So konfiguriert Spring Boot automatisch eine Verbindungspool-Datenquelle:

  1. Spring Boot sucht im Klassenpfad nach HikariCP und verwendet es standardmäßig, wenn es vorhanden ist
  2. Wenn HikariCP nicht im Klassenpfad gefunden wird, nimmt Spring Boot den Tomcat JDBC-Verbindungspool auf, falls verfügbar
  3. Wenn keine dieser Optionen verfügbar ist, wählt Spring Boot Apache Commons DBCP2, falls verfügbar

Einen Tomcat JDBC Connection Pool anstelle des Standard - HikariCP zu konfigurieren, werden wir ausschließen HikariCP aus der Feder-boot-Starter-data-JPA Abhängigkeit und fügen Sie die tomcat-jdbc Maven Abhängigkeit unserer 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 

Mit diesem einfachen Ansatz können wir Spring Boot mithilfe eines Tomcat-Verbindungspools abrufen, ohne eine @ Configuration- Klasse schreiben und programmgesteuert eine DataSource- Bean definieren zu müssen .

Es ist auch erwähnenswert, dass wir in diesem Fall die H2-In-Memory-Datenbank verwenden . Spring Boot konfiguriert H2 automatisch für uns, ohne eine Datenbank-URL, einen Benutzer und ein Kennwort angeben zu müssen .

Wir müssen nur die entsprechende Abhängigkeit in die Datei "pom.xml" aufnehmen , und Spring Boot erledigt den Rest für uns.

Alternativ ist es möglich , den Verbindungspool Scan - Algorithmus , dass Frühlings - Boot - Anwendungen und explizit eine Verbindung Pooling - Datenquelle angeben , überspringen in der „application.properties“ Datei , die mit „spring.datasource.type“ Eigenschaft:

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

3. Optimieren des Verbindungspools mit der Datei " application.properties "

Sobald wir einen Tomcat-Verbindungspool in Spring Boot erfolgreich konfiguriert haben , möchten wir höchstwahrscheinlich einige zusätzliche Eigenschaften einrichten, um die Leistung zu optimieren und bestimmte Anforderungen zu erfüllen .

Wir können dies in der Datei "application.properties" tun :

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 

Beachten Sie, dass wir einige zusätzliche Eigenschaften für das Verbindungspooling konfiguriert haben, z. B. die anfängliche Größe des Pools sowie die maximale und minimale Anzahl inaktiver Verbindungen.

Wir können auch einige Hibernate-spezifische Eigenschaften angeben:

# 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. Testen des Verbindungspools

Schreiben wir einen einfachen Integrationstest, um zu überprüfen, ob Spring Boot den Verbindungspool korrekt konfiguriert hat:

@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. Eine Beispielbefehlszeilenanwendung

Nachdem alle Verbindungsinstallationsinstallationen bereits festgelegt sind, erstellen wir eine einfache Befehlszeilenanwendung.

Auf diese Weise können wir sehen, wie einige CRUD-Operationen in einer H2-Datenbank mithilfe der leistungsstarken DAO-Schicht ausgeführt werden, die Spring Data JPA (und transitiv Spring Boot) standardmäßig bereitstellt.

Eine ausführliche Anleitung zum Einstieg in Spring Data JPA finden Sie in diesem Artikel.

5.1. Die Kunden Entitätsklasse

Definieren wir zunächst eine naive Kundenentitätsklasse :

@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. Die CustomerRepository- Schnittstelle

In diesem Fall wollen wir nur CRUD - Operationen auf ein paar auszuführen Kunden Einheiten . Außerdem müssen wir alle Kunden abrufen, die einem bestimmten Nachnamen entsprechen.

Also, alles , was wir tun müssen, ist Spring Data JPA ist zu erweitern CrudRepository Schnittstelle und eine maßgeschneiderte Methode definieren :

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

Jetzt können wir eine Kundenentität leicht anhand ihres Nachnamens abrufen.

5.3. Die CommandLineRunner- Implementierung

Schließlich müssen wir mindestens einige Kundenentitäten in der Datenbank beibehalten und überprüfen, ob unser Tomcat-Verbindungspool tatsächlich funktioniert .

Erstellen wir eine Implementierung der CommandLineRunner- Schnittstelle von Spring Boot . Spring Boot bootet die Implementierung, bevor die Anwendung gestartet wird:

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

Kurz gesagt, die CommandLineCrudRunner- Klasse speichert zunächst einige Kundenentitäten in der Datenbank. Als nächstes wird der erste mit der findById () -Methode abgerufen . Schließlich wird ein Kunde mit der Methode findByLastName () abgerufen .

5.4. Ausführen der Spring Boot-Anwendung

Das Letzte, was wir tun müssen, ist natürlich nur die Beispielanwendung auszuführen. Dann können wir das Spring Boot / Tomcat-Verbindungspool-Tandem in Aktion sehen:

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

6. Fazit

In diesem Tutorial haben wir gelernt, wie Sie einen Tomcat-Verbindungspool in Spring Boot konfigurieren und verwenden. Darüber hinaus haben wir eine grundlegende Befehlszeilenanwendung entwickelt, um zu zeigen, wie einfach die Arbeit mit Spring Boot, einem Tomcat-Verbindungspool und der H2-Datenbank ist.

Wie üblich sind alle in diesem Tutorial gezeigten Codebeispiele auf GitHub verfügbar.