Konfigurieren eines Tomcat-Verbindungspools in Spring Boot
1. Überblick
Spring Boot ist eine eigensinnige und dennoch leistungsstarke Abstraktionsebene, die auf einer einfachen Spring-Plattform platziert ist. Dadurch ist die Entwicklung von eigenständigen Anwendungen und Webanwendungen ein Kinderspiel. Spring Boot bietet einige praktische "Starter" -abhängigkeiten, mit denen Java-Anwendungen mit minimalem Platzbedarf ausgeführt und getestet werden können.
One key component of these starter dependencies is spring-boot-starter-data-jpa. Auf diese Weise können wirJPA verwenden und mit Produktionsdatenbanken arbeiten, indem wir einige gängige JDBC-Implementierungen für das Verbindungspooling verwenden, z. B.HikariCP undTomcat JDBC Connection Pool.
In diesem Tutorial werdenwe’ll learn how to configure a Tomcat connection pool in Spring Boot.
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:
-
Spring Boot sucht im Klassenpfad nach HikariCP und verwendet es standardmäßig, wenn es vorhanden ist
-
Wenn HikariCP nicht im Klassenpfad gefunden wird, nimmt Spring Boot den Tomcat JDBC-Verbindungspool auf, falls verfügbar
-
Wenn keine dieser Optionen verfügbar ist, wählt Spring BootApache Commons DBCP2, falls verfügbar
Um einen Tomcat JDBC-Verbindungspool anstelle des Standard-HikariCP zu konfigurieren, werdenexclude HikariCP from the spring-boot-starter-data-jpa dependency and add the tomcat-jdbc Maven dependency zupom.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
Dieser einfache Ansatz ermöglicht es uns, Spring Boot mithilfe eines Tomcat-Verbindungspools zu erhalten, ohne eine@Configuration-Klasse schreiben und programmgesteuert eineDataSource-Bean definieren zu müssen.
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.
Wir müssen nur die entsprechende Abhängigkeit in die“pom.xml”-Datei aufnehmen, und Spring Boot erledigt den Rest für uns.
Alternativ könnenit’s possible to skip the connection pool scanning algorithm that Spring Boot uses and explicitly specify a connection pooling datasource in“application.properties” file, unter Verwendung der Eigenschaft“spring.datasource.type” verwendet werden:
spring.datasource.type=org.apache.tomcat.jdbc.pool.DataSource
// other spring datasource properties3. Optimieren des Verbindungspools mit der Datei "application.properties"
Sobald wir einen Tomcat-Verbindungspool in Spring Boot erfolgreich konfiguriert haben,it’s very likely that we’ll want to set up some additional properties, for optimizing its performance and suiting some specific requirements.
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=trueBeachten 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 Ruhezustand-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=false4. 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
Erstellen wir eine einfache Befehlszeilenanwendung, da alle Verbindungspooling-Installationen bereits festgelegt sind.
Auf diese Weise können wir sehen, wie einige CRUD-Operationen in einer H2-Datenbank unter Verwendung der leistungsstarkenDAO-Schicht ausgeführt werden, dieSpring Data JPA (und transitiv Spring Boot) standardmäßig bereitstellt.
Eine ausführliche Anleitung zum Einstieg in Spring Data JPA finden Sie unterthis article.
5.1. Die EntitätsklasseCustomer
Definieren wir zunächst die Entitätsklasse eines naivenCustomer:
@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. DieCustomerRepository-Schnittstelle
In diesem Fall möchten wir nur CRUD-Operationen für einigeCustomer-Entitäten.ausführen. Außerdem müssen wir alle Kunden abrufen, die einem bestimmten Nachnamen entsprechen.
Also,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);
} Jetzt können wir die Entität vonCustomerleicht anhand ihres Nachnamens abrufen.
5.3. Die Implementierung vonCommandLineRunner
Schließlich müssen wir mindestens einigeCustomer Entitäten in der Datenbank undverify that our Tomcat connection pool is actually working beibehalten.
Erstellen wir eine Implementierung derCommandLineRunner-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 KlasseCommandLineCrudRunnerpeichert zuerst einigeCustomer-Entitäten in der Datenbank. Als nächstes wird der erste mit derfindById()-Methode abgerufen. Schließlich wird ein Kunde mit derfindByLastName()-Methode abgerufen.
5.4. Ausführen der Spring Boot-Anwendung
Als letztes müssen wir natürlich nur die Beispielanwendung ausfü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 Lernprogramm gezeigten Codebeispieleover on GitHub verfügbar.