Verbinden Sie Java -Anwendungen an PostgreSQL mit JDBC und Hikaricp

Fügen Sie Postgresql JDBC und Hikaricp -Abhängigkeiten über Maven oder Gradle hinzu. 2. Konfigurieren Sie Hikaricp mit Datenbank -URL, Anmeldeinformationen, Poolgröße, Zeitüberschreitungen und PostgreSQL -Optimierungen wie vorbereitete Anweisung Caching. 3. Verwenden Sie die HikaridataSource in Ihrer Anwendung, um gepoolte Verbindungen zu erhalten, und führen Sie SQL mit Try-with-Ressourcen für das automatische Ressourcenmanagement aus. 4. Befolgen Sie die Best Practices: Vermeiden Sie hartcodierte Anmeldeinformationen, melken Sie die Poolgröße, überwachen Sie Metriken, behandeln Sie vorübergehende Ausfälle und verhindern Sie Verbindungslecks. 5. Schalten Sie den Pool anmutig durch, indem Sie die Hikaridatasource während der Anwendungsabschluss schließen, um Ressourcen ordnungsgemäß freizugeben. Dieses Setup gewährleistet eine robuste Strategie für Hochleistungsdatenbankverbindungsstrategie für Java-Anwendungen, die postGresql verwendet werden.

Das Verbinden von JAVA-Anwendungen an PostgreSQL mit JDBC und Hikaricp ist ein häufiger und effizienter Ansatz für die Bearbeitung von Datenbankinteraktionen in Produktionsanwendungen. Während JDBC die Grundlage für die Datenbankkonnektivität bildet, verbessert Hikaricp die Leistung und Zuverlässigkeit durch Verbindungsbadung. Hier erfahren Sie, wie Sie es richtig und effizient einrichten können.

1. Fügen Sie Abhängigkeiten hinzu (Maven oder Gradle)

Geben Sie zunächst die erforderlichen Abhängigkeiten in Ihr Projekt ein. Wenn Sie Maven verwenden, fügen Sie Folgendes zu Ihrem pom.xml hinzu:

 <Depecies>
    <!-postgresql JDBC-Treiber->
    <De vorangehen>
        <gruppe> org.postgresql </Groupid>
        <artifactid> postgreSQL </artifactId>
        <version> 42.7.3 </Version>
    </abhängig>

    <!-Hikaricp Connection Pool->
    <De vorangehen>
        <gruppe> com.zaxxer </Groupid>
        <artifactid> hikaricp </artifactid>
        <version> 5.1.0 </Version>
    </abhängig>
</Abhängigkeiten>

Für Gradle , verwenden Sie:

 Implementierung 'org.postgresql: postgresql: 42.7.3'
Implementierung 'com.zaxxer: hikaricp: 5.1.0' '

Diese Bibliotheken geben Ihnen den PostgreSQL-Treiber und einen Hochleistungsverbindungspool.

2. Konfigurieren Sie Hikaricp für PostgreSQL

Hikaricp vereinfacht die Verbindungsverwaltung, indem Datenbankverbindungen wiederverwendet werden, anstatt jedes Mal eine neue zu erstellen. Dies reduziert den Overhead und verbessert die Reaktionszeiten.

Hier erfahren Sie, wie Sie eine HikariDataSource einrichten:

 import com.zaxxer.hikari.hikariconfig;
import com.zaxxer.hikari.hikaridatasource;

importieren javax.sql.datasource;

Public Class DatabaseConfig {
    public static dataSource erstellteatasource () {
        Hikariconfig config = new Hikariconfig ();

        // Datenbankverbindungseinstellungen
        config.setjdbcurl ("jdbc: postgreSQL: // localhost: 5432/your_database");
        config.setusername ("your_username");
        config.setPassword ("your_password");

        // Pooleinstellungen
        config.setMaximumpoolSize (10);
        config.setMinimumidle (2);
        config.setConnectionTimeout (30000); // 30 Sekunden
        config.setIdletimeout (600000); // 10 Minuten
        config.setMaxLifetime (1800000); // 30 Minuten

        // optional: postgresql-spezifische Optimierungen
        config.adddataSourceProperty ("cachePrepstmts", "true");
        config.adddataSourceProperty ("prepStmtCachesize", "250");
        config.adddataSourceProperty ("prepStmtCachesqllimit", "2048");

        Rückgabe neu HikaridataSource (config);
    }
}

? Tipp : Ersetzen Sie your_database , your_username und your_password durch die tatsächlichen Werte. Erwägen Sie, diese aus Umgebungsvariablen oder Konfigurationsdateien in der Produktion zu laden.

3. Verwenden Sie die Verbindung in Ihrer Anwendung

Sobald die Datenquelle konfiguriert ist, verwenden Sie sie, um Verbindungen zu erhalten und SQL auszuführen:

 Import Java.sql.Connection;
importieren java.sql.preeParedStatement;
importieren java.sql.resultset;
importieren java.sql.sqlexception;

öffentliche Klasse Userdao {
    private endgültige DataSource -DataSource;

    public userDao (DataSource -DataSource) {
        this.dataSource = DataSource;
    }

    public String findUserNamebyId (int id) {
        String SQL = "Wählen Sie den Namen von Benutzern aus, wo id =?";

        try (Verbindung conn = dataSource.getConnection ();
             PreparedStatement STMT = CONN.PREPARESTATEMENT (SQL)) {

            stmt.setint (1, id);
            try (resultset rs = stmt.executeQuery ()) {
                if (rs.Next ()) {
                    return Rs.getString ("Name");
                }
            }
        } catch (sqlexception e) {
            E. printstacktrace (); // Verwenden Sie in der Produktion die richtige Protokollierung
        }
        null zurückkehren;
    }
}

Schlüsselpunkte:

• Der Anruf dataSource.getConnection() gibt eine gepoolte Verbindung zurück.
• Verwenden Sie Try-with-Ressourcen, um sicherzustellen, dass Verbindungen, Aussagen und Ergebnissätze automatisch geschlossen werden.
• Hikaricp verwaltet den Lebenszyklus physikalischer Verbindungen hinter den Kulissen.

4. Best Practices und gemeinsame Fallstricke

So halten Sie Ihre Datenbankschicht stabil und effizient:

• Niemals Hardcode -Anmeldeinformationen : Verwenden Sie Umgebungsvariablen ( System.getenv() ) oder Konfigurationsdateien.
• Tune Poolgröße : Beginnen Sie mit maximumPoolSize=10 . Passen Sie basierend auf der Last und der DB -Kapazität Ihrer App ein.
• Vermeiden Sie Verbindungslecks : Schließen Sie immer Ressourcen über Try-with-Ressourcen oder explizite Reinigung.
• Überwachen Sie Poolmetriken : Hikaricp bietet JMX -Metriken für die Verfolgung von aktiven/im Leerlauf, Wartezeiten usw.
• Verwandten Sie vorübergehende Fehler : Für die Produktion sollten Sie die Logik wiederholen oder Frameworks wie Resilience4J verwenden.

PostgreSQL ist außerdem besser mit vorbereiteten Anweisung Caching - in der obigen Konfiguration.

5. den Pool anmutig herunterfahren

Wenn Ihre Anwendung abgeschaltet wird, schließen Sie die Datenquelle, um Ressourcenlecks zu vermeiden:

 if (DataSource -Instanz von HikaridataSource) {
    ((HikaridataSource) dataSource) .CLOSE ();
}

Dies stellt sicher, dass alle Poolfäden und Verbindungen ordnungsgemäß beendet werden.

Das Verbinden von Java mit PostgreSQL mit JDBC und Hikaricp ist einfach, sobald Sie das Setup -Muster verstanden haben. Mit der richtigen Konfiguration und Ressourcenverwaltung erhalten Sie eine schnelle, zuverlässige und skalierbare Datenbankschicht.

Grundsätzlich: Richten Sie die Abhängigkeiten ein, konfigurieren Sie Hikaricp mit vernünftigen Standardeinstellungen, verwenden Sie den Pool in Ihren Daos und räumen Sie beim Ausgang auf. Es ist nicht auffällig - aber es ist solide.

Das obige ist der detaillierte Inhalt vonVerbinden Sie Java -Anwendungen an PostgreSQL mit JDBC und Hikaricp. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!