Im ersten Teil dieses Artikels haben wir gelernt, wie wir die Leistung unserer Anwendungen verbessern können, indem wir Tomcat durch Undertow ersetzt haben Ein Hochleistungs-Webserver, zusätzlich zur Aktivierung und Konfiguration der Datenkomprimierung, um die Größe von HTTP-Antworten zu reduzieren, die über das Netzwerk übertragen werden.

Jetzt werden wir darüber sprechen, wie wir die Leistung von Spring Boot-Anwendungen im Persistenzteil verbessern können, aber zuerst müssen wir verstehen, was JPA, Hibernate und Hikari.

JPA

JPA oder Java Persistence API, das später in Jakarta Persistence umbenannt wurde, ist ein Java-Sprachstandard, der eine gemeinsame Sprache beschreibt Schnittstelle für Datenpersistenz-Frameworks

Die

JPA-Spezifikation definiert die objektrelationale Zuordnung intern, anstatt sich auf herstellerspezifische Zuordnungsimplementierungen zu verlassen.

Überwintern

Hibernate ist eines der ORM-Frameworks, das die konkrete Umsetzung der JPA-Spezifikation ermöglicht. Das heißt, wenn diese Spezifikation die Notwendigkeit von Methoden zum Persistieren, Entfernen beschreibt, update und fetch data, die Person, die diese Verhaltensweisen tatsächlich aufbaut, ist Hibernate sowie EclipseLink , was ein weiterer ORM ist.

Hikari

Hikari ist ein Verbindungspooling-Framework, das für die Verwaltung von Verbindungen zur Datenbank verantwortlich ist und sie offen hält, damit sie wiederverwendet werden können, d. h. Es handelt sich um einen Cache von Verbindungen für zukünftige Anfragen, der den Zugriff auf die Datenbank beschleunigt und die Anzahl der neu zu erstellenden Verbindungen reduziert.

Konfigurieren von Hikari, JPA und Hibernate

Eine Konfiguration, die wir durchführen können, um die Leistung zu verbessern, ist die folgende:

Anwendung.yml verwenden:

Frühling: Hikari: Auto-Commit: falsch Verbindungs-Timeout: 250 Maximale Lebensdauer: 600.000 Maximale Poolgröße: 20 Mindestleerlauf: 10 Poolname: Master jpa: Open-in-View: falsch show-sql: wahr überwintern: ddl-auto: keine Eigenschaften: hibernate.connection.provider_disables_autocommit: true hibernate.generate_statistics: wahr

spring:
  hikari:
    auto-commit: false
    connection-timeout: 250
    max-lifetime: 600000
    maximum-pool-size: 20
    minimum-idle: 10
    pool-name: master

  jpa:
    open-in-view: false
    show-sql: true
    hibernate:
      ddl-auto: none
    properties:
      hibernate.connection.provider_disables_autocommit: true
      hibernate.generate_statistics: true

Application.properties verwenden:

spring.datasource.hikari.auto-commit=false spring.datasource.hikari.connection-timeout=50 spring.datasource.hikari.max-lifetime=600000 spring.datasource.hikari.maximum-pool-size=20 spring.datasource.hikari.minimum-idle=10 spring.datasource.hikari.pool-name=master spring.datasource.jpa.open-in-view=false spring.datasource.jpa.show-sql=true spring.datasource.jpa.hibernate.ddl-auto=none spring.jpa.properties.hibernate.generate_statistics=true spring.jpa.properties.hibernate.connection.provider_disables_autocommit=true

spring:
  hikari:
    auto-commit: false
    connection-timeout: 250
    max-lifetime: 600000
    maximum-pool-size: 20
    minimum-idle: 10
    pool-name: master

  jpa:
    open-in-view: false
    show-sql: true
    hibernate:
      ddl-auto: none
    properties:
      hibernate.connection.provider_disables_autocommit: true
      hibernate.generate_statistics: true

Lassen Sie uns nun eine kurze Zusammenfassung der Optionen geben:

Hikari

• spring.datasource.hikari.auto-commit: Bei „false“ wird bei jeder vom

  Verbindungspool zurückgegebenen Verbindung Auto-Commit deaktiviert.

• spring.datasource.hikari.connection-timeout: Zeit in Millisekunden, die der Client auf eine Verbindung vom

  Pool wartet. Es ist vorzuziehen, ein kurzes Timeout festzulegen, um schnell fehlzuschlagen und eine Fehlermeldung zurückzugeben, anstatt den Client auf unbestimmte Zeit warten zu lassen.

• spring.datasource.hikari.max-lifetime: Maximale Zeit, die eine Verbindung aktiv bleiben kann. Die Konfiguration dieses Parameters ist entscheidend, um Ausfälle aufgrund problematischer Verbindungen zu vermeiden und die Sicherheit zu erhöhen, da Verbindungen, die schon lange aktiv sind, anfälliger für Angriffe sind.

• spring.datasource.hikari.maximum-pool-size: Maximale Größe des

  Pools, einschließlich inaktiver und verwendeter Verbindungen, wodurch die maximale Anzahl aktiver Verbindungen zur Datenbank bestimmt wird. Wenn der Pool dieses Limit erreicht und keine inaktiven Verbindungen vorhanden sind, werden Aufrufe von getConnection() bis zu connectionTimeout Millisekunden lang blockiert, bevor sie fehlschlagen.

  Es ist wichtig, einen geeigneten Wert zu finden, da viele Leute glauben, dass sie eine großartige Leistung erzielen, wenn sie ihn auf 50, 70 oder sogar 100 setzen. Ideal ist ein Maximum von 20, was der Anzahl der
  • Threads[ entspricht. &&&] parallel über Verbindungen. Je höher der Wert, desto schwieriger wird es für die Datenbank, diese Verbindungen zu verwalten, und höchstwahrscheinlich können wir nicht über genügend
  Durchsatz
  • verfügen, um alle diese Verbindungen zu nutzen. Es ist wichtig zu verstehen, dass es aus Sicht von
  RDBMS
  • (Relationales Datenbankverwaltungssystem) schwierig ist, eine offene Verbindung mit sich selbst aufrechtzuerhalten, stellen Sie sich n Verbindungen vor .
spring.datasource.hikari.minimum-idle: Mindestanzahl an Verbindungen, die der Pool bei geringer Nachfrage aufrechterhält. Der Pool kann Verbindungen auf bis zu 10 reduzieren und diese bei Bedarf neu erstellen. Für maximale Leistung und eine bessere Reaktion auf Nachfragespitzen wird jedoch empfohlen, diesen Wert nicht festzulegen, damit Hikari als Pool mit fester Größe fungieren kann. Standard: wie spring.datasource.hikari.maximum-pool-size.
spring.datasource.hikari.pool-name: Benutzerdefinierter Name für die Verbindung
• pool

  und erscheint hauptsächlich in Registrierungsverwaltungskonsolen und JMX zur Identifizierung von Pools und ihre Konfigurationen.

JPA

spring.datasource.jpa.open-in-view: Wenn
• OSIV

  (Open Session In View) aktiviert ist, wird eine Sitzung sogar während der gesamten Anfrage aufrechterhalten ohne die @Transactional-Annotation. Dies kann zu Leistungsproblemen wie fehlenden Anwendungsantworten führen, da die Sitzung die Verbindung zur Datenbank bis zum Ende der Anfrage aufrechterhält.

spring.datasource.jpa.show-sql: Zeigt das SQL-Protokoll an, das in unserer Anwendung ausgeführt wird. Wir lassen es in der Entwicklung im Allgemeinen aktiviert, in der Produktion jedoch deaktiviert.
spring.datasource.jpa.hibernate.ddl-auto: Konfiguriert das Verhalten von

• Hibernate in Bezug auf das Schema der Datenbank. Es kann die folgenden Werte haben:

  none: Tut nichts. Wir verwalten das Schema der Bank manuell.
  • validieren: Validiert das
  Schema
  • der Datenbank, nimmt jedoch keine Änderungen vor. Dies ist nützlich, um sicherzustellen, dass das aktuelle Schema mit den von uns zugeordneten Entitäten übereinstimmt. update: Aktualisiert das
  Schema
  • der Datenbank, um Änderungen an den Entitäten widerzuspiegeln. create: Erstellt das
  Schema
  • der Datenbank. Wenn das Schema bereits vorhanden ist, wird es entfernt und erneut erstellt. create-drop: Erstellt das
  Schema
  • aus der Datenbank und entfernt das Schema, wenn die Anwendung beendet wird. Nützlich für Tests, bei denen wir für jeden Test eine saubere Datenbank benötigen.
spring.jpa.properties.hibernate.generate_statistics: Dient zum Sammeln detaillierter Informationen über Hibernate, z. B. Abfrageausführungszeiten, Anzahl der ausgeführten Abfragen und andere Metriken.
spring.jpa.properties.hibernate.connection.provider_disables_autocommit: Informiert

• Hibernate darüber, dass wir die automatische Festschreibung von Anbietern deaktiviert haben (PostgreSQL, MySQL usw.). Dies wirkt sich auf die Leistung aus, da Hibernate eine Verbindung vom Pool herstellen muss, um zu wissen, ob Auto-Commit aktiviert ist oder nicht , für jede Transaktion, die er durchführt.

Damit schließen wir den zweiten Teil des Artikels. Nicht alle vorhandenen Einstellungen betrafen die Leistung, aber diejenigen, die sich wirklich auswirken, sind die

Hikari-Einstellungen wie Auto-Commit und Pool-Größe , die von JPA und Hibernate mögen OSIV (Sitzung in Ansicht öffnen) und informieren Sie, dass wir Auto-Commit von Anbietern deaktiviert haben. Im nächsten Teil werden wir über Ausnahmen und deren Konfiguration sprechen, um Ressourcen aus der

JVM

(Java Virtual Machine) zu sparen. Referenzen:

https://en.wikipedia.org/wiki/Jakarta_Persistence

• https://www.ibm.com/docs/pt-br/was/8.5.5?topic=SSEQTP_8.5.5/com.ibm.websphere.nd.multiplatform.doc/ae/cejb_persistence.htm
• https://github.com/brettwooldridge/HikariCP
• https://github.com/corona-warn-app/cwa-server/issues/556
• https://medium.com/@rafaelralf90/open-session-in-view-is-evil-fd9a21645f8e