Snabbstart: Använd Java och JDBC med Azure Database for PostgreSQL – flexibel server

Den här artikeln visar hur du skapar ett exempelprogram som använder Java och JDBC för att lagra och hämta information i Azure Database for PostgreSQL.

JDBC är standard-Java-API:et för anslutning till traditionella relationsdatabaser.

Den här artikeln innehåller två autentiseringsmetoder: Microsoft Entra autentisering och PostgreSQL-autentisering. Fliken Lösenordslös visar Microsoft Entra-autentiseringen och fliken Lösenord visar PostgreSQL-autentisering.

Microsoft Entra-autentisering är en mekanism för att ansluta till Azure Database for PostgreSQL med hjälp av identiteter som definierats i Microsoft Entra-ID. Genom att använda Microsoft Entra autentisering kan du hantera databasanvändares identiteter och andra Microsoft-tjänster på en central plats, vilket förenklar behörighetshanteringen.

PostgreSQL-autentisering använder konton som lagras i PostgreSQL. Om du väljer att använda lösenord som autentiseringsuppgifter för kontona lagrar du dessa autentiseringsuppgifter i user tabellen. Eftersom dessa lösenord lagras i PostgreSQL måste du hantera rotationen av lösenorden själv.

Förutsättningar

Förbereda arbetsmiljön

Använd först följande kommando för att konfigurera vissa miljövariabler.

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)

Ersätt platshållarna med följande värden, som används i hela den här artikeln:

  • <YOUR_DATABASE_SERVER_NAME>: Namnet på din Azure Database for PostgreSQL flexibla server, som bör vara unik i Azure.
  • <YOUR_DATABASE_NAME>: Databasnamnet på den Azure Database for PostgreSQL flexibla servern, som bör vara unik inom Azure.
  • <YOUR_AZURE_REGION>: Den Azure-region som ska användas. Du kan använda eastus som standard, men välja en region närmare där du bor. Om du vill se den fullständiga listan över tillgängliga regioner anger du az account list-locations.
  • <YOUR_POSTGRESQL_AD_NON_ADMIN_USERNAME>: Användarnamnet för din Azure Database for PostgreSQL flexibla servern. Kontrollera att användarnamnet är en giltig användare i din Microsoft Entra klientorganisation.
  • <YOUR_LOCAL_IP_ADDRESS>: IP-adressen för den lokala datorn som du kör Spring Boot-programmet från. Ett bekvämt sätt att hitta det är att öppna whatismyip.akamai.com.

Viktigt!

När du anger <YOUR_POSTGRESQL_AD_NON_ADMIN_USERNAME>måste användaren redan finnas i din Microsoft Entra klientorganisation eller så kan du inte skapa en Microsoft Entra användare i databasen.

Skapa sedan en resursgrupp med hjälp av följande kommando:

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

Skapa en flexibel server

I följande avsnitt beskrivs hur du skapar och konfigurerar din databasinstans.

Skapa en flexibel server och konfigurera administratörsanvändare

Anmärkning

Mer detaljerad information om hur du skapar Azure Database for PostgreSQL flexibla servrar finns i Snabbstart: Skapa en Azure Database for PostgreSQL flexibel server.

Om du använder Azure CLI kör du följande kommando för att se till att det har tillräcklig behörighet:

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

Kör följande kommando för att skapa servern:

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

Om du vill konfigurera en Microsoft Entra-administratör när du har skapat servern följer du stegen i Hantera Microsoft Entra-roller i Azure Database for PostgreSQL.

Viktigt!

När du konfigurerar en administratör lägger du till en ny användare med fullständig administratörsbehörighet till Azure Database for PostgreSQL flexibla serverns Azure databas. Du kan skapa flera Microsoft Entra-administratörer för varje Azure Database for PostgreSQL Flexible Server.

Har du några problem? Berätta för oss.

Konfigurera en brandväggsregel för din Azure Database for PostgreSQL-instans

Azure Database for PostgreSQL flexibla servrar är säkra som standard. De har en brandvägg som blockerar alla inkommande anslutningar. Om du vill använda databasen lägger du till en brandväggsregel som ger din lokala IP-adress åtkomst till databasservern.

Eftersom du konfigurerade din lokala IP-adress i början av den här artikeln kan du öppna serverns brandvägg genom att köra följande kommando:

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

Om du ansluter till din Azure Database for PostgreSQL-flexibla server från Podsystém Windowsu pre Linux (WSL) på en Windows-dator, måste du lägga till WSL-värd-ID:t i brandväggen.

Hämta IP-adressen för värddatorn genom att köra följande kommando i WSL:

cat /etc/resolv.conf

Kopiera IP-adressen som följer termen nameserveroch använd sedan följande kommando för att ange en miljövariabel för WSL IP-adressen:

AZ_WSL_IP_ADDRESS=<the-copied-IP-address>

Använd sedan följande kommando för att öppna serverns brandvägg till din WSL-baserade app:

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

Konfigurera en Azure-databas för PostgreSQL-databas

Skapa en ny databas med hjälp av följande kommando:

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

Skapa en Azure Database for PostgreSQL-användare som inte är administratör och bevilja behörighet

Skapa sedan en icke-administratörsanvändare och bevilja alla behörigheter till databasen.

Anmärkning

Mer detaljerad information om hur du hanterar Azure Database for PostgreSQL användare finns i Hantera Microsoft Entra roller i Azure Database for PostgreSQL.

Skapa ett SQL-skript med namnet create_ad_user.sql för att skapa en icke-administratörsanvändare. Lägg till följande innehåll och spara det lokalt:

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

Använd sedan följande kommando för att köra SQL-skriptet och skapa Microsoft Entra icke-administratörsanvändare:

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

Använd följande kommando för att ta bort den tillfälliga SQL-skriptfilen:

rm create_ad_user.sql

Skapa ett nytt Java-projekt

Använd din favorit-IDE och skapa ett nytt Java projekt med hjälp av Java 8 eller senare. Lägg till en pom.xml fil i rotkatalogen med följande innehåll:

<?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>

Den här filen är en Apache Maven-fil som konfigurerar ditt projekt att använda:

  • Java 8
  • En ny PostgreSQL-drivrutin för Java

Förbereda en konfigurationsfil för att ansluta till Azure Database for PostgreSQL

Skapa en src/main/resources/application.properties-fil och lägg till följande innehåll:

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

Anmärkning

Konfigurationsegenskapen url innehåller ?sslmode=require för att säkerställa att JDBC-drivrutinen använder TLS (Transport Layer Security) vid anslutning till databasen. Att använda TLS är obligatoriskt med Azure Database for PostgreSQL flexibla servrar och är en rekommenderad säkerhetspraxis.

Skapa en SQL-fil för att generera databasschemat

Använd en src/main/resources/schema.sql-fil för att skapa ett databasschema. Skapa filen och lägg till följande innehåll:

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

Koda programmet

Följande avsnitt går igenom hur du skriver Java kod som ansluter till databasen, definierar en datamodell och utför grundläggande CRUD-åtgärder.

Ansluta till databasen

Lägg sedan till den Java kod som använder JDBC för att lagra och hämta data från din Azure Database for PostgreSQL flexibla servern.

Skapa en src/main/java/DemoApplication.java-fil och lägg till följande innehåll:

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

Har du några problem? Berätta för oss.

Den här Java koden använder application.properties och de schema.sql filer som du skapade tidigare för att ansluta till den Azure Database for PostgreSQL flexibla servern och skapa ett schema som lagrar data.

I den här filen kommenteras metoderna för att infoga, läsa, uppdatera och ta bort data ut. Resten av den här artikeln går igenom kodning av dessa metoder och du kan avkommentera dem en efter en.

Anmärkning

Databasautentiseringsuppgifterna lagras i användar- och lösenordsegenskaperna för filen application.properties. Koden använder dessa autentiseringsuppgifter när du kör DriverManager.getConnection(properties.getProperty("url"), properties);, eftersom egenskapsfilen skickas som ett argument.

Nu kan du köra den här huvudklassen med ditt favoritverktyg:

  • Med din IDE kan du högerklicka på klassen DemoApplication och köra den.
  • Med Maven kan du köra programmet genom att köra: mvn exec:java -Dexec.mainClass="com.example.demo.DemoApplication".

Programmet ansluter till Azure Database for PostgreSQL flexibel server, skapar ett databasschema och stänger sedan anslutningen, som du ser i konsolloggarna:

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

Skapa en domänklass

Skapa en ny Todo Java-klass bredvid DemoApplication klassen och lägg till följande kod:

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 +
                '}';
    }
}

Den här klassen är en domänmodell som mappas till tabellen todo som du skapade när du körde schema.sql skriptet.

Infoga data i Azure Database for PostgreSQL

I filen src/main/java/DemoApplication.java lägger du efter huvudmetoden till följande metod för att infoga data i databasen:

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

Du kan nu avkommentera de följande två raderna i mainmetoden:

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

När du kör huvudklassen bör den generera följande utdata:

[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

Läsa data från Azure Database for PostgreSQL

Om du vill verifiera att koden fungerar korrekt läser du de data som du tidigare infogade.

I filen src/main/java/DemoApplication.java lägger du efter insertData metoden till följande metod för att läsa data från databasen:

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

Du kan nu avkommentara följande rad i main metoden:

todo = readData(connection);

När du kör huvudklassen bör den generera följande utdata:

[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

Uppdatera data i Azure Database for PostgreSQL

Använd följande steg för att uppdatera data.

I filen src/main/java/DemoApplication.java lägger du efter readData metoden till följande metod för att uppdatera data i databasen:

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

Du kan nu avkommentera de följande två raderna i mainmetoden:

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

När du kör huvudklassen bör den generera följande utdata:

[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

Ta bort data i Azure Database for PostgreSQL

Ta slutligen bort de data som du infogade tidigare.

I filen src/main/java/DemoApplication.java lägger du efter updateData metoden till följande metod för att ta bort data i databasen:

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

Du kan nu avkommentara följande rad i main metoden:

deleteData(todo, connection);

När du kör huvudklassen bör den generera följande utdata:

[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

Rensa resurser

Du har skapat ett Java program som använder JDBC för att lagra och hämta data från en Azure Database for PostgreSQL flexibel server.

Om du vill rensa alla resurser som används under den här snabbstarten tar du bort resursgruppen med hjälp av följande kommando:

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

Relaterat innehåll

  • Last updated on