Schnellstart: Java und JDBC in Azure Database for PostgreSQL – Flexibler Server verwenden

In diesem Artikel wird gezeigt, wie Sie eine Beispielanwendung erstellen, die Java und JDBC verwendet, um Informationen in Azure Database for PostgreSQL zu speichern und abzurufen.

JDBC ist die Standard-Java-API zum Herstellen von Verbindungen mit herkömmlichen relationalen Datenbanken.

Dieser Artikel enthält zwei Authentifizierungsmethoden: Microsoft Entra Authentifizierung und PostgreSQL-Authentifizierung. Die Registerkarte Kennwortlos zeigt die Microsoft Entra-Authentifizierung und die Registerkarte Kennwort die PostgreSQL-Authentifizierung.

Die Microsoft Entra-Authentifizierung ist ein Mechanismus zum Herstellen einer Verbindung mit Azure Database for PostgreSQL unter Verwendung von Identitäten, die in Microsoft Entra ID definiert sind. Mithilfe Microsoft Entra Authentifizierung können Sie Datenbankbenutzeridentitäten und andere Microsoft-Dienste an einem zentralen Ort verwalten, wodurch die Berechtigungsverwaltung vereinfacht wird.

Die PostgreSQL-Authentifizierung verwendet Konten, die in PostgreSQL gespeichert sind. Wenn Sie Kennwörter als Anmeldeinformationen für die Konten verwenden möchten, speichern Sie diese Anmeldeinformationen in der user Tabelle. Da diese Kennwörter in PostgreSQL gespeichert sind, müssen Sie die Kennwörter selbst rotieren.

Voraussetzungen

Vorbereiten der Arbeitsumgebung

Richten Sie zunächst mithilfe des folgenden Befehls einige Umgebungsvariablen ein.

export AZ_RESOURCE_GROUP=database-workshop
export AZ_DATABASE_SERVER_NAME=<YOUR_DATABASE_SERVER_NAME>
export AZ_DATABASE_NAME=<YOUR_DATABASE_NAME>
export AZ_LOCATION=<YOUR_AZURE_REGION>
export AZ_POSTGRESQL_AD_NON_ADMIN_USERNAME=<YOUR_POSTGRESQL_AD_NON_ADMIN_USERNAME>
export AZ_LOCAL_IP_ADDRESS=<YOUR_LOCAL_IP_ADDRESS>
export CURRENT_USERNAME=$(az ad signed-in-user show --query userPrincipalName -o tsv)

Ersetzen Sie die Platzhalter durch die folgenden Werte, die in diesem Artikel verwendet werden:

  • <YOUR_DATABASE_SERVER_NAME>: Der Name Ihres Azure Database for PostgreSQL flexiblen Servers, der für Azure eindeutig sein sollte.
  • <YOUR_DATABASE_NAME>: Der Datenbankname des Azure Database for PostgreSQL flexiblen Servers, der innerhalb Azure eindeutig sein sollte.
  • <YOUR_AZURE_REGION>: Die zu verwendende Azure-Region. Sie können standardmäßig eastus verwenden, aber wählen Sie eine Region in Ihrer Nähe aus. Geben Sie az account list-locations ein, um eine Liste aller verfügbaren Regionen anzuzeigen.
  • <YOUR_POSTGRESQL_AD_NON_ADMIN_USERNAME>: Der Benutzername für Ihren Azure Database for PostgreSQL flexiblen Server. Stellen Sie sicher, dass der Benutzername ein gültiger Benutzer in Ihrem Microsoft Entra Mandanten ist.
  • <YOUR_LOCAL_IP_ADDRESS>: Die IP-Adresse Ihres lokalen Computers, von dem Aus Sie Die Spring Boot-Anwendung ausführen. Eine bequeme Möglichkeit, es zu finden, besteht darin, whatismyip.akamai.com zu öffnen.

Von Bedeutung

Bei der Einstellung <YOUR_POSTGRESQL_AD_NON_ADMIN_USERNAME>muss der Benutzer bereits in Ihrem Microsoft Entra Mandanten vorhanden sein, oder Sie können keinen Microsoft Entra Benutzer in Ihrer Datenbank erstellen.

Erstellen Sie nun mithilfe des folgenden Befehls eine Ressourcengruppe:

az group create \
    --name $AZ_RESOURCE_GROUP \
    --location $AZ_LOCATION \
    --output tsv

Erstellen eines flexiblen Servers

In den folgenden Abschnitten wird beschrieben, wie Sie Ihre Datenbankinstanz erstellen und konfigurieren.

Erstellen eines flexiblen Servers und Einrichten eines Administratorbenutzers

Hinweis

Ausführlichere Informationen zum Erstellen von Azure Database for PostgreSQL flexiblen Servern finden Sie in der Schnellstartanleitung: Erstellen eines Azure Database for PostgreSQL flexiblen Servers.

Wenn Sie die Azure CLI verwenden, führen Sie den folgenden Befehl aus, um sicherzustellen, dass sie über ausreichende Berechtigungen verfügt:

az login --scope https://graph.microsoft.com/.default

Führen Sie den folgenden Befehl aus, um den Server zu erstellen:

az postgres flexible-server create \
    --resource-group $AZ_RESOURCE_GROUP \
    --name $AZ_DATABASE_SERVER_NAME \
    --location $AZ_LOCATION \
    --yes \
    --output tsv

Wenn Sie nach dem Erstellen des Servers einen Microsoft Entra-Administrator einrichten möchten, führen Sie die Schritte unter Verwalten von Microsoft Entra-Rollen in Azure Database for PostgreSQL aus.

Von Bedeutung

Wenn Sie einen Administrator einrichten, legen Sie in der Azure-Datenbank des Azure Database for PostgreSQL – Flexibler Server einen neuen Benutzer mit vollständigen Administratorrechten an. Sie können mehrere Microsoft Entra Administratoren pro Azure Database for PostgreSQL flexiblen Server erstellen.

Treten Probleme auf? Informieren Sie uns darüber.

Konfigurieren Sie eine Firewallregel für Ihre Azure-Datenbank für Ihre PostgreSQL-Instanz

Azure Database for PostgreSQL flexible Server sind standardmäßig sicher. Sie verfügen über eine Firewall, die alle eingehenden Verbindungen blockiert. Um Ihre Datenbank zu verwenden, fügen Sie eine Firewallregel hinzu, die Ihrer lokalen IP-Adresse Zugriff auf den Datenbankserver gewährt.

Da Sie die lokale IP-Adresse zu Beginn dieses Artikels konfiguriert haben, können Sie die Firewall des Servers öffnen, indem Sie den folgenden Befehl ausführen:

az postgres flexible-server firewall-rule create \
    --resource-group $AZ_RESOURCE_GROUP \
    --name $AZ_DATABASE_SERVER_NAME \
    --rule-name $AZ_DATABASE_SERVER_NAME-database-allow-local-ip \
    --start-ip-address $AZ_LOCAL_IP_ADDRESS \
    --end-ip-address $AZ_LOCAL_IP_ADDRESS \
    --output tsv

Wenn Sie eine Verbindung mit Ihrem Azure Database for PostgreSQL flexiblen Server von Windows-Subsystem für Linux (WSL) auf einem Windows Computer herstellen, müssen Sie der Firewall die WSL-Host-ID hinzufügen.

Rufen Sie die IP-Adresse Ihres Hostcomputers ab, indem Sie den folgenden Befehl in WSL ausführen:

cat /etc/resolv.conf

Kopieren Sie die IP-Adresse, die dem Ausdruck nameserverfolgt, und verwenden Sie dann den folgenden Befehl, um eine Umgebungsvariable für die WSL-IP-Adresse festzulegen:

AZ_WSL_IP_ADDRESS=<the-copied-IP-address>

Verwenden Sie dann den folgenden Befehl, um die Firewall des Servers für Ihre WSL-basierte App zu öffnen:

az postgres flexible-server firewall-rule create \
    --resource-group $AZ_RESOURCE_GROUP \
    --name $AZ_DATABASE_SERVER_NAME \
    --rule-name $AZ_DATABASE_SERVER_NAME-database-allow-local-ip \
    --start-ip-address $AZ_WSL_IP_ADDRESS \
    --end-ip-address $AZ_WSL_IP_ADDRESS \
    --output tsv

Konfigurieren einer Azure-Datenbank für PostgreSQL

Erstellen Sie eine neue Datenbank mithilfe des folgenden Befehls:

az postgres flexible-server db create \
    --resource-group $AZ_RESOURCE_GROUP \
    --database-name $AZ_DATABASE_NAME \
    --server-name $AZ_DATABASE_SERVER_NAME \
    --output tsv

Erstellen einer Azure-Datenbank für Nicht-Administratorbenutzer von PostgreSQL und Erteilen von Berechtigungen

Erstellen Sie nun einen Nicht-Administratorbenutzer, und gewähren Sie ihm alle Berechtigungen für die Datenbank.

Hinweis

Ausführlichere Informationen zum Verwalten von Azure Database for PostgreSQL Benutzern finden Sie unter Verwalten von Microsoft Entra Rollen in Azure Database for PostgreSQL.

Erstellen Sie ein SQL-Skript mit dem Namen create_ad_user.sql zum Erstellen eines Nicht-Administratorbenutzers. Fügen Sie den folgenden Inhalt hinzu, und speichern Sie das Skript lokal:

cat << EOF > create_ad_user.sql
select * from pgaadauth_create_principal('$AZ_POSTGRESQL_AD_NON_ADMIN_USERNAME', false, false);
EOF

Verwenden Sie dann den folgenden Befehl, um das SQL-Skript auszuführen und den Microsoft Entra Nicht-Administratorbenutzer zu erstellen:

psql "host=$AZ_DATABASE_SERVER_NAME.postgres.database.azure.com user=$CURRENT_USERNAME dbname=postgres port=5432 password=$(az account get-access-token --resource-type oss-rdbms --output tsv --query accessToken) sslmode=require" < create_ad_user.sql

Verwenden Sie den folgenden Befehl, um die temporäre SQL-Skriptdatei zu entfernen:

rm create_ad_user.sql

Erstellen eines neuen Java-Projekts

Erstellen Sie mit Ihrer bevorzugten IDE ein neues Java Projekt mithilfe von Java 8 oder höher. Fügen Sie eine pom.xml Datei im Stammverzeichnis mit dem folgenden Inhalt hinzu:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>

    <properties>
        <java.version>1.8</java.version>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

    <dependencies>
      <dependency>
        <groupId>org.postgresql</groupId>
        <artifactId>postgresql</artifactId>
        <version>42.7.5</version>
      </dependency>
      <dependency>
        <groupId>com.azure</groupId>
        <artifactId>azure-identity-extensions</artifactId>
        <version>1.2.0</version>
      </dependency>
    </dependencies>
</project>

Dabei handelt es sich um eine Apache Maven-Datei, die Ihr Projekt für die Verwendung konfiguriert:

  • Java 8
  • Aktueller PostgreSQL-Treiber für Java

Vorbereiten einer Konfigurationsdatei zum Herstellen einer Verbindung mit Azure-Datenbank für PostgreSQL

Erstellen Sie eine Datei "src/main/resources/application.properties ", und fügen Sie den folgenden Inhalt hinzu:

cat << EOF > src/main/resources/application.properties
url=jdbc:postgresql://${AZ_DATABASE_SERVER_NAME}.postgres.database.azure.com:5432/${AZ_DATABASE_NAME}?sslmode=require&authenticationPluginClassName=com.azure.identity.extensions.jdbc.postgresql.AzurePostgresqlAuthenticationPlugin
user=${AZ_POSTGRESQL_AD_NON_ADMIN_USERNAME}
EOF

Hinweis

Die Konfigurationseigenschaft url umfasst ?sslmode=require, um sicherzustellen, dass der JDBC-Treiber TLS (Transport Layer Security) beim Herstellen einer Verbindung mit der Datenbank verwendet. Die Verwendung von TLS ist mit Azure Database for PostgreSQL flexiblen Servern obligatorisch und ist eine empfohlene Sicherheitspraxis.

Erstellen einer SQL-Datei zum Generieren des Datenbankschemas

Verwenden Sie eine Datei "src/main/resources/schema.sql ", um ein Datenbankschema zu erstellen. Erstellen Sie diese Datei, und fügen Sie den folgenden Inhalt hinzu:

DROP TABLE IF EXISTS todo;
CREATE TABLE todo (id SERIAL PRIMARY KEY, description VARCHAR(255), details VARCHAR(4096), done BOOLEAN);

Codieren der Anwendung

In den folgenden Abschnitten wird erläutert, wie man den Java-Code schreibt, der eine Verbindung zur Datenbank herstellt, ein Datenmodell definiert und grundlegende CRUD-Vorgänge ausführt.

Herstellen der Verbindung mit der Datenbank

Fügen Sie als Nächstes den Java-Code hinzu, der mithilfe von JDBC Daten in Ihrer Azure Database for PostgreSQL – Flexible Server speichert und daraus abruft.

Erstellen Sie eine Datei src/main/java/DemoApplication.java, und fügen Sie den folgenden Inhalt hinzu:

package com.example.demo;

import java.sql.*;
import java.util.*;
import java.util.logging.Logger;

public class DemoApplication {

    private static final Logger log;

    static {
        System.setProperty("java.util.logging.SimpleFormatter.format", "[%4$-7s] %5$s %n");
        log =Logger.getLogger(DemoApplication.class.getName());
    }

    public static void main(String[] args) throws Exception {
        log.info("Loading application properties");
        Properties properties = new Properties();
        properties.load(DemoApplication.class.getClassLoader().getResourceAsStream("application.properties"));

        log.info("Connecting to the database");
        Connection connection = DriverManager.getConnection(properties.getProperty("url"), properties);
        log.info("Database connection test: " + connection.getCatalog());

        log.info("Create database schema");
        Scanner scanner = new Scanner(DemoApplication.class.getClassLoader().getResourceAsStream("schema.sql"));
        Statement statement = connection.createStatement();
        while (scanner.hasNextLine()) {
            statement.execute(scanner.nextLine());
        }

        /*
        Todo todo = new Todo(1L, "configuration", "congratulations, you have set up JDBC correctly!", true);
        insertData(todo, connection);
        todo = readData(connection);
        todo.setDetails("congratulations, you have updated data!");
        updateData(todo, connection);
        deleteData(todo, connection);
        */

        log.info("Closing database connection");
        connection.close();
    }
}

Treten Probleme auf? Informieren Sie uns darüber.

Dieser Java Code verwendet die application.properties und die schema.sql Dateien, die Sie zuvor erstellt haben, um eine Verbindung mit dem Azure Database for PostgreSQL flexiblen Server herzustellen und ein Schema zu erstellen, das die Daten speichert.

In dieser Datei werden die Methoden zum Einfügen, Lesen, Aktualisieren und Löschen von Daten auskommentiert. Der Rest dieses Artikels durchläuft das Codieren dieser Methoden, und Sie können die Kommentare nacheinander aufheben.

Hinweis

Die Datenbankanmeldeinformationen werden in den Eigenschaften user und password der Datei application.properties gespeichert. Der Code verwendet diese Anmeldeinformationen beim Ausführen DriverManager.getConnection(properties.getProperty("url"), properties);, da die Eigenschaftendatei als Argument übergeben wird.

Sie können diese Hauptklasse nun mit Ihrem bevorzugten Tool ausführen:

  • Mit Ihrer IDE können Sie mit der rechten Maustaste auf die DemoApplication-Klasse klicken und diese ausführen.
  • Bei Verwendung von Maven können Sie die Anwendung mithilfe von mvn exec:java -Dexec.mainClass="com.example.demo.DemoApplication" ausführen.

Die Anwendung stellt eine Verbindung mit dem flexiblen Azure Database for PostgreSQL-Server her, erstellt ein Datenbankschema und schließt dann die Verbindung, wie in den Konsolenprotokollen zu sehen ist:

[INFO   ] Loading application properties
[INFO   ] Connecting to the database
[INFO   ] Database connection test: demo
[INFO   ] Create database schema
[INFO   ] Closing database connection

Erstellen einer Domänenklasse

Erstellen Sie eine neue Todo Java Klasse neben der DemoApplication Klasse, und fügen Sie den folgenden Code hinzu:

package com.example.demo;

public class Todo {

    private Long id;
    private String description;
    private String details;
    private boolean done;

    public Todo() {
    }

    public Todo(Long id, String description, String details, boolean done) {
        this.id = id;
        this.description = description;
        this.details = details;
        this.done = done;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public String getDetails() {
        return details;
    }

    public void setDetails(String details) {
        this.details = details;
    }

    public boolean isDone() {
        return done;
    }

    public void setDone(boolean done) {
        this.done = done;
    }

    @Override
    public String toString() {
        return "Todo{" +
                "id=" + id +
                ", description='" + description + '\'' +
                ", details='" + details + '\'' +
                ", done=" + done +
                '}';
    }
}

Diese Klasse ist ein Domänenmodell, das der todo Tabelle zugeordnet ist, die Sie beim Ausführen des skripts schema.sql erstellt haben.

Einfügen von Daten in azure-Datenbank für PostgreSQL

Fügen Sie in der Datei src/main/java/DemoApplication.java nach der main-Methode die folgende Methode ein, um Daten in die Datenbank einzufügen:

private static void insertData(Todo todo, Connection connection) throws SQLException {
    log.info("Insert data");
    PreparedStatement insertStatement = connection
            .prepareStatement("INSERT INTO todo (id, description, details, done) VALUES (?, ?, ?, ?);");

    insertStatement.setLong(1, todo.getId());
    insertStatement.setString(2, todo.getDescription());
    insertStatement.setString(3, todo.getDetails());
    insertStatement.setBoolean(4, todo.isDone());
    insertStatement.executeUpdate();
}

Sie können die Auskommentierung der beiden folgenden Zeilen in der Methode main aufheben:

Todo todo = new Todo(1L, "configuration", "congratulations, you have set up JDBC correctly!", true);
insertData(todo, connection);

Wenn Sie die Hauptklasse ausführen, sollte sie die folgende Ausgabe erzeugen:

[INFO   ] Loading application properties
[INFO   ] Connecting to the database
[INFO   ] Database connection test: demo
[INFO   ] Create database schema
[INFO   ] Insert data
[INFO   ] Closing database connection

Lesen von Daten aus Azure Database for PostgreSQL

Um zu überprüfen, ob Ihr Code ordnungsgemäß funktioniert, lesen Sie die Daten, die Sie zuvor eingefügt haben.

Fügen Sie in der Datei src/main/java/DemoApplication.java nach der insertData-Methode die folgende Methode ein, um Daten aus der Datenbank zu lesen:

private static Todo readData(Connection connection) throws SQLException {
    log.info("Read data");
    PreparedStatement readStatement = connection.prepareStatement("SELECT * FROM todo;");
    ResultSet resultSet = readStatement.executeQuery();
    if (!resultSet.next()) {
        log.info("There is no data in the database!");
        return null;
    }
    Todo todo = new Todo();
    todo.setId(resultSet.getLong("id"));
    todo.setDescription(resultSet.getString("description"));
    todo.setDetails(resultSet.getString("details"));
    todo.setDone(resultSet.getBoolean("done"));
    log.info("Data read from the database: " + todo.toString());
    return todo;
}

Sie können die Auskommentierung der folgenden Zeile nun in der Methode main aufheben:

todo = readData(connection);

Wenn Sie die Hauptklasse ausführen, sollte sie die folgende Ausgabe erzeugen:

[INFO   ] Loading application properties
[INFO   ] Connecting to the database
[INFO   ] Database connection test: demo
[INFO   ] Create database schema
[INFO   ] Insert data
[INFO   ] Read data
[INFO   ] Data read from the database: Todo{id=1, description='configuration', details='congratulations, you have set up JDBC correctly!', done=true}
[INFO   ] Closing database connection

Aktualisieren von Daten in Azure Database for PostgreSQL

Führen Sie die folgenden Schritte aus, um die Daten zu aktualisieren.

Fügen Sie in der Datei src/main/java/DemoApplication.java nach der readData-Methode die folgende Methode ein, um die Daten in der Datenbank zu aktualisieren:

private static void updateData(Todo todo, Connection connection) throws SQLException {
    log.info("Update data");
    PreparedStatement updateStatement = connection
            .prepareStatement("UPDATE todo SET description = ?, details = ?, done = ? WHERE id = ?;");

    updateStatement.setString(1, todo.getDescription());
    updateStatement.setString(2, todo.getDetails());
    updateStatement.setBoolean(3, todo.isDone());
    updateStatement.setLong(4, todo.getId());
    updateStatement.executeUpdate();
    readData(connection);
}

Sie können die Auskommentierung der beiden folgenden Zeilen in der Methode main aufheben:

todo.setDetails("congratulations, you have updated data!");
updateData(todo, connection);

Wenn Sie die Hauptklasse ausführen, sollte sie die folgende Ausgabe erzeugen:

[INFO   ] Loading application properties
[INFO   ] Connecting to the database
[INFO   ] Database connection test: demo
[INFO   ] Create database schema
[INFO   ] Insert data
[INFO   ] Read data
[INFO   ] Data read from the database: Todo{id=1, description='configuration', details='congratulations, you have set up JDBC correctly!', done=true}
[INFO   ] Update data
[INFO   ] Read data
[INFO   ] Data read from the database: Todo{id=1, description='configuration', details='congratulations, you have updated data!', done=true}
[INFO   ] Closing database connection

Löschen von Daten in Azure Database for PostgreSQL

Löschen Sie schließlich die Daten, die Sie zuvor eingefügt haben.

Fügen Sie in der Datei src/main/java/DemoApplication.java nach der updateData-Methode die folgende Methode ein, um die Daten in der Datenbank zu löschen:

private static void deleteData(Todo todo, Connection connection) throws SQLException {
    log.info("Delete data");
    PreparedStatement deleteStatement = connection.prepareStatement("DELETE FROM todo WHERE id = ?;");
    deleteStatement.setLong(1, todo.getId());
    deleteStatement.executeUpdate();
    readData(connection);
}

Sie können die Auskommentierung der folgenden Zeile nun in der Methode main aufheben:

deleteData(todo, connection);

Wenn Sie die Hauptklasse ausführen, sollte sie die folgende Ausgabe erzeugen:

[INFO   ] Loading application properties
[INFO   ] Connecting to the database
[INFO   ] Database connection test: demo
[INFO   ] Create database schema
[INFO   ] Insert data
[INFO   ] Read data
[INFO   ] Data read from the database: Todo{id=1, description='configuration', details='congratulations, you have set up JDBC correctly!', done=true}
[INFO   ] Update data
[INFO   ] Read data
[INFO   ] Data read from the database: Todo{id=1, description='configuration', details='congratulations, you have updated data!', done=true}
[INFO   ] Delete data
[INFO   ] Read data
[INFO   ] There is no data in the database!
[INFO   ] Closing database connection

Bereinigen von Ressourcen

Sie haben eine Java-Anwendung erstellt, die JDBC verwendet, um Daten in einem Azure Database for PostgreSQL – Flexible Server zu speichern und daraus abzurufen.

Um alle während dieser Schnellstartanleitung verwendeten Ressourcen zu bereinigen, löschen Sie die Ressourcengruppe mithilfe des folgenden Befehls:

az group delete \
    --name $AZ_RESOURCE_GROUP \
    --yes

Verwandte Inhalte

  • Last updated on