Snabbstart: Använda Java och JDBC för Azure HorizonDB (förhandsversion)

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 HorizonDB (förhandsversion).

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

Stegen i den här artikeln omfattar PostgreSQL-autentisering.

PostgreSQL-autentisering använder konton som lagras i PostgreSQL och du måste hantera rotationen av lösenorden själv.

Förutsättningar

Ett Azure-konto. Om du inte har en får du en kostnadsfri utvärderingsversion.
Azure Cloud Shell eller Azure CLI. Använd Azure Cloud Shell så att du autentiseras automatiskt och har åtkomst till alla verktyg du behöver.
En Java Development Kit version 8 som stöds (ingår i Cloud Shell).
Apache Maven-byggverktyget.

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_CLUSTER_NAME=<YOUR_DATABASE_CLUSTER_NAME>
export AZ_DATABASE_NAME=<YOUR_DATABASE_NAME>
export AZ_LOCATION=<YOUR_AZURE_REGION>
export AZ_POSTGRESQL_ADMIN_USERNAME=demo
export AZ_POSTGRESQL_ADMIN_PASSWORD=<YOUR_POSTGRESQL_ADMIN_PASSWORD>
export AZ_POSTGRESQL_NON_ADMIN_USERNAME=demo-non-admin
export AZ_POSTGRESQL_NON_ADMIN_PASSWORD=<YOUR_POSTGRESQL_NON_ADMIN_PASSWORD>
export AZ_LOCAL_IP_ADDRESS=<YOUR_LOCAL_IP_ADDRESS>

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

<YOUR_DATABASE_CLUSTER_NAME>: Namnet på ditt Azure HorizonDB-kluster, som bör vara unikt för din Azure-prenumeration och resursgrupp.
<YOUR_DATABASE_NAME>: Databasnamnet som du använder i ditt Azure HorizonDB-kluster.
<YOUR_AZURE_REGION>: Den Azure-region som ska användas. Du kan använda australiaeast som standard, men konfigurera en region närmare där du bor. Du kan se den fullständiga listan över tillgängliga regioner genom att ange az account list-locations.
<YOUR_POSTGRESQL_ADMIN_PASSWORD> och <YOUR_POSTGRESQL_NON_ADMIN_PASSWORD>: Lösenordet för ditt Azure HorizonDB-kluster. Lösenordet måste innehålla minst åtta tecken. Tecknen ska vara från tre av följande kategorier: engelska versaler, engelska gemener, siffror (0–9) och icke-numeriska tecken (!, $, #, %och så vidare).
<YOUR_LOCAL_IP_ADDRESS>: IP-adressen för den lokala datorn som du kör Spring Boot-programmet från. Ett praktiskt sätt att hitta det är att öppna whatismyip.akamai.com.

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

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

Skapa ett Azure HorizonDB-kluster

Note

Inkludera inte någon personlig, känslig eller konfidentiell information i resursnamn (till exempel tabellnamn, databasnamn) och resurstaggar. Data du matar in i dessa fält räknas inte som kunddata.

I följande avsnitt beskrivs hur du skapar och konfigurerar ditt databaskluster.

Skapa ett Azure HorizonDB-kluster

Konfigurera administratörsanvändare

Skapa först en hanterad Azure HorizonDB-instans.

Note

Mer detaljerad information om hur du skapar Azure HorizonDB finns i Skapa ett Azure HorizonDB-kluster.

az horizondb create \
  --resource-group $AZ_RESOURCE_GROUP \
  --name $AZ_DATABASE_CLUSTER_NAME \
  --location $AZ_LOCATION \
  --version 17 \
  --administrator-login $AZ_POSTGRESQL_ADMIN_USERNAME \
  --administrator-login-password $AZ_POSTGRESQL_ADMIN_PASSWORD \
  --v-cores 2 \
  --yes \
  --output tsv

Det här kommandot skapar ett litet Azure HorizonDB-kluster.

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

Konfigurera en brandväggsregel för din Azure HorizonDB-instans

Azure HorizonDB-instanser ä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 horizondb firewall-rule create \
  --resource-group $AZ_RESOURCE_GROUP \
  --cluster-name $AZ_DATABASE_CLUSTER_NAME \
  --firewall-rule-name $AZ_DATABASE_CLUSTER_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 ditt Azure HorizonDB-kluster från Podsystém Windowsu pre Linux (WSL) på en Windows-dator, måste du lägga till WSL-värd-ID:t i din brandvägg.

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 horizondb firewall-rule create \
  --resource-group $AZ_RESOURCE_GROUP \
  --cluster-name $AZ_DATABASE_CLUSTER_NAME \
  --firewall-rule-name $AZ_DATABASE_CLUSTER_NAME-database-allow-local-ip \
  --start-ip-address $AZ_WSL_IP_ADDRESS \
  --end-ip-address $AZ_WSL_IP_ADDRESS \
  --output tsv

Skapa en Azure HorizonDB-databas

Skapa ett SQL-skript med namnet create_database.sql för att skapa en ny databas i klustret. Lägg till följande innehåll och spara filen lokalt:

cat << EOF > create_database.sql
CREATE DATABASE "$AZ_DATABASE_NAME";
EOF

Kör det här kommandot för att hämta ditt fullständigt kvalificerade domännamn för Azure HorizonDB och kopiera värdet clusterName:

az horizondb show \
  --resource-group $AZ_RESOURCE_GROUP \
  --name $AZ_DATABASE_CLUSTER_NAME \
  --query "{clusterName:properties.fullyQualifiedDomainName, adminUser:properties.administratorLogin}" \
  --output table

Kopiera värdet clusterName och använd det i följande kommando:

AZ_HORIZONDB_FQDN=<the-copied-clusterName-value>

Kör sedan följande kommando för att köra SQL-skriptet och skapa databasen:

psql "host=$AZ_HORIZONDB_FQDN user=$AZ_POSTGRESQL_ADMIN_USERNAME dbname=$AZ_DATABASE_NAME port=5432 password=$AZ_POSTGRESQL_ADMIN_PASSWORD sslmode=require" < create_database.sql

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

rm create_database.sql

Skapa en Azure HorizonDB-användare utan administratörsbehörighet och bevilja behörighet

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

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

cat << EOF > create_user.sql
CREATE ROLE "$AZ_POSTGRESQL_NON_ADMIN_USERNAME" WITH LOGIN PASSWORD '$AZ_POSTGRESQL_NON_ADMIN_PASSWORD';
GRANT ALL PRIVILEGES ON DATABASE $AZ_DATABASE_NAME TO "$AZ_POSTGRESQL_NON_ADMIN_USERNAME";
EOF

Kör sedan följande kommando för att köra SQL-skriptet och skapa Microsoft Entra nonadmin-användare:

psql "host=$AZ_HORIZONDB_FQDN user=$AZ_POSTGRESQL_ADMIN_USERNAME dbname=$AZ_DATABASE_NAME port=5432 password=$AZ_POSTGRESQL_ADMIN_PASSWORD sslmode=require" < create_user.sql

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

rm create_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.3.6</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 HorizonDB

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_HORIZONDB_FQDN}:5432/${AZ_DATABASE_NAME}?sslmode=require
user=${AZ_POSTGRESQL_NON_ADMIN_USERNAME}
password=${AZ_POSTGRESQL_NON_ADMIN_PASSWORD}
EOF

Note

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. Azure HorizonDB kräver TLS, och det ä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 med följande innehåll:

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

Koda programmet

Ansluta till databasen

Lägg sedan till Java kod som använder JDBC för att lagra och hämta data från din Azure HorizonDB-instans.

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 filerna application.properties och schema.sql som vi skapade tidigare, för att ansluta till Azure HorizonDB-instansen och skapa ett schema som lagrar våra data.

I den här filen kan du se att vi har kommenterat bort metoder för att infoga, läsa, uppdatera och ta bort data: i resten av den här artikeln kommer vi att skriva de här metoderna, och du kommer att kunna avkommentera dem en efter en.

Note

Databasautentiseringsuppgifterna lagras i användar- och lösenordsegenskaperna för filen application.properties. Dessa autentiseringsuppgifter används 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 bör du kunna 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 bör ansluta till Azure HorizonDB-instansen, skapa ett databasschema och sedan stänga anslutningen, som du bör se 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 i tabellen todo som du skapade när du körde schema.sql skriptet.

Infoga data i Azure HorizonDB

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 två följande raderna i main metoden.

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

Körning av huvudklassen ska nu 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äs data från Azure HorizonDB

Nu ska vi läsa de data som tidigare infogats för att verifiera att vår kod fungerar korrekt.

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

Körning av huvudklassen ska nu 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 HorizonDB

Nu ska vi uppdatera de data som vi infogade tidigare.

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 två följande raderna i main metoden.

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

Körning av huvudklassen ska nu 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 HorizonDB

Slutligen ska vi ta bort de data som vi 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);

Körning av huvudklassen ska nu 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

Grattis! Du har skapat ett Java program som använder JDBC för att lagra och hämta data från en Azure HorizonDB-instans.

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

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

Feedback

Var den här sidan till hjälp?

Last updated on 2026-06-03

Snabbstart: Använda Java och JDBC för Azure HorizonDB (förhandsversion)

Förutsättningar

Förbereda arbetsmiljön

Skapa ett Azure HorizonDB-kluster

Skapa ett Azure HorizonDB-kluster

Konfigurera en brandväggsregel för din Azure HorizonDB-instans

Skapa en Azure HorizonDB-databas

Skapa en Azure HorizonDB-användare utan administratörsbehörighet och bevilja behörighet

Skapa ett nytt Java-projekt

Förbereda en konfigurationsfil för att ansluta till Azure HorizonDB

Skapa en SQL-fil för att generera databasschemat

Koda programmet

Ansluta till databasen

Skapa en domänklass

Infoga data i Azure HorizonDB

Läs data från Azure HorizonDB

Uppdatera data i Azure HorizonDB

Ta bort data i Azure HorizonDB

Rensa resurser

Relaterat innehåll

Feedback

Ytterligare resurser