Quickstart: Java en JDBC gebruiken voor Azure HorizonDB (preview)

In dit artikel wordt gedemonstreerd hoe u een voorbeeldtoepassing maakt die gebruikmaakt van Java en JDBC voor het opslaan en ophalen van gegevens in Azure HorizonDB (preview).

JDBC is de standaard-Java-API voor het maken van verbinding met traditionele relationele databases.

De stappen in dit artikel omvatten PostgreSQL-verificatie.

PostgreSQL-verificatie maakt gebruik van accounts die zijn opgeslagen in PostgreSQL en u moet de rotatie van de wachtwoorden zelf beheren.

Prerequisites

• Een Azure-account. Als u er nog geen hebt, kunt u een gratis proefversie krijgen.
• Azure Cloud Shell of Azure CLI. Gebruik Azure Cloud Shell zodat u automatisch wordt geverifieerd en toegang hebt tot alle hulpprogramma's die u nodig hebt.
• Een ondersteunde Java Development Kit, versie 8 (opgenomen in Cloud Shell).
• De Apache Maven bouwtool.

De werkomgeving voorbereiden

Gebruik eerst de volgende opdracht om enkele omgevingsvariabelen in te stellen.

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>

Vervang de tijdelijke aanduidingen door de volgende waarden, die overal in dit artikel worden gebruikt:

• <YOUR_DATABASE_CLUSTER_NAME>: de naam van uw Azure HorizonDB-cluster, die uniek moet zijn in uw Azure-abonnement en resourcegroep.
• <YOUR_DATABASE_NAME>: de databasenaam die u gebruikt in uw Azure HorizonDB-cluster.
• <YOUR_AZURE_REGION>: de Azure-regio die moet worden gebruikt. U kunt standaard australiaeast gebruiken, maar configureer een regio dichter bij waar u woont. U kunt de volledige lijst met beschikbare regio's bekijken door deze in te voeren az account list-locations.
• <YOUR_POSTGRESQL_ADMIN_PASSWORD> en <YOUR_POSTGRESQL_NON_ADMIN_PASSWORD>: het wachtwoord van uw Azure HorizonDB-cluster. Het wachtwoord moet uit minimaal acht tekens bestaan. De tekens moeten uit drie van de volgende categorieën bestaan: Nederlandse hoofdletters, Nederlandse kleine letters, cijfers (0-9) en niet-phanumerische tekens (!, $, #, %, enzovoort).
• <YOUR_LOCAL_IP_ADDRESS>: Het IP-adres van uw lokale computer, van waaruit u uw Spring Boot-toepassing uitvoert. Een handige manier om het te vinden is om whatismyip.akamai.com te openen.

Maak vervolgens een resourcegroep met de volgende opdracht:

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

Een Azure HorizonDB-cluster maken

In de volgende secties wordt beschreven hoe u uw databasecluster maakt en configureert.

Een Azure HorizonDB-cluster maken

Gebruiker met beheerdersrechten instellen

Maak eerst een beheerd Azure HorizonDB-exemplaar.

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

Met deze opdracht maakt u een klein Azure HorizonDB-cluster.

Ondervindt u problemen? Laat het ons weten.

Een firewallregel configureren voor uw Azure HorizonDB-exemplaar

Azure HorizonDB-exemplaren zijn standaard beveiligd. Ze hebben een firewall die alle binnenkomende verbindingen blokkeert. Als u uw database wilt gebruiken, voegt u een firewallregel toe die toegang verleent tot uw lokale IP-adres tot de databaseserver.

Omdat u uw lokale IP-adres aan het begin van dit artikel hebt geconfigureerd, kunt u de firewall van de server openen door de volgende opdracht uit te voeren:

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

Als u verbinding maakt met uw Azure HorizonDB-cluster vanaf Windows-subsysteem voor Linux (WSL) op een Windows computer, moet u de WSL-host-id toevoegen aan uw firewall.

Haal het IP-adres van uw hostcomputer op door de volgende opdracht uit te voeren in WSL:

cat /etc/resolv.conf

Kopieer het IP-adres dat volgt op de term nameserveren gebruik vervolgens de volgende opdracht om een omgevingsvariabele in te stellen voor het WSL IP-adres:

AZ_WSL_IP_ADDRESS=<the-copied-IP-address>

Gebruik vervolgens de volgende opdracht om de firewall van de server te openen naar uw WSL-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

Een Azure HorizonDB-database maken

Maak een SQL-script met de naam create_database.sql om een nieuwe database in uw cluster te maken. Voeg de volgende inhoud toe en sla het bestand lokaal op:

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

Voer deze opdracht uit om uw Azure Fully Qualified Domain Name van HorizonDB op te halen en de waarde clusterName te kopiëren:

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

Kopieer de clusterName waarde en gebruik deze in het volgende commando:

AZ_HORIZONDB_FQDN=<the-copied-clusterName-value>

Voer vervolgens de volgende opdracht uit om het SQL-script uit te voeren en uw database te maken:

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

Voer nu de volgende opdracht uit om het tijdelijke SQL-scriptbestand te verwijderen:

rm create_database.sql

Een Azure HorizonDB-gebruiker zonder beheerdersrechten maken en machtigingen verlenen

Vervolgens maakt u een niet-beheerder en verleent u alle machtigingen aan de database.

Maak een SQL-script met de naam create_user.sql om een niet-beheerdersgebruiker te maken. Voeg de volgende inhoud toe en sla het bestand lokaal op:

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

Voer vervolgens de volgende opdracht uit om het SQL-script uit te voeren en de Microsoft Entra niet-beheerdersgebruiker te maken:

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

Voer nu de volgende opdracht uit om het tijdelijke SQL-scriptbestand te verwijderen:

rm create_user.sql

Een nieuw Java-project maken

Maak met uw favoriete IDE een nieuw Java project met behulp van Java 8 of hoger. Voeg een pom.xml-bestand toe aan de hoofdmap met de volgende inhoud:

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

Dit bestand is een Apache Maven-bestand dat uw project configureert voor gebruik:

• Java 8
• Een recent PostgreSQL-stuurprogramma voor Java

Een configuratiebestand voorbereiden om verbinding te maken met Azure HorizonDB

Maak een src/main/resources/application.properties-bestand en voeg de volgende inhoud toe:

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

Een SQL-bestand maken om het databaseschema te genereren

Gebruik een src/main/resources/schema.sql-bestand om een databaseschema te maken. Maak dat bestand met de volgende inhoud:

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

Codeer de toepassing

Verbinding maken met de database

Voeg vervolgens de Java code toe die gebruikmaakt van JDBC om gegevens op te slaan en op te halen uit uw Azure HorizonDB-exemplaar.

Maak een src/main/java/DemoApplication.java-bestand en voeg de volgende inhoud toe:

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

Ondervindt u problemen? Laat het ons weten.

Deze Java code maakt gebruik van de bestanden application.properties en de bestanden schema.sql die we eerder hebben gemaakt, om verbinding te maken met het Azure HorizonDB-exemplaar en een schema te maken waarin onze gegevens worden opgeslagen.

In dit bestand ziet u dat we methoden als commentaar hebben toegevoegd om gegevens in te voegen, te lezen, bij te werken en te verwijderen: deze methoden worden in de rest van dit artikel gecodeerd en u kunt de opmerkingen erna verwijderen.

U kunt nu deze main-klasse uitvoeren met uw favoriete tool:

• Klik in uw IDE met de rechtermuisknop op de klasse DemoApplication en voer deze uit.
• Als u Maven gebruikt, kunt u de toepassing uitvoeren met de volgende opdracht: mvn exec:java -Dexec.mainClass="com.example.demo.DemoApplication".

De toepassing moet verbinding maken met het Azure HorizonDB-exemplaar, een databaseschema maken en vervolgens de verbinding sluiten, zoals u zou moeten zien in de consolelogboeken:

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

Een domeinklasse maken

Maak een nieuwe Java-klasse Todo, naast de klasse DemoApplication, en voeg de volgende code toe:

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

Deze klasse is een domeinmodel dat is toegewezen aan de tabel todo die u eerder hebt gemaakt tijdens het uitvoeren van het script schema.sql.

Gegevens invoegen in Azure HorizonDB

Voeg na de methode main in het bestand src/main/java/DemoApplication.java de volgende methode toe om gegevens in te voegen in de database:

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

U kunt nu de twee volgende regels in de methode main uncommentariëren.

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

Als u nu de main-klasse uitvoert, zou dit de volgende uitvoer moeten opleveren:

[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

Gegevens lezen uit Azure HorizonDB

Laten we de gegevens lezen die u eerder hebt ingevoegd om te controleren of onze code goed werkt.

Voeg in het bestand src/main/java/DemoApplication.java, na de methode insertData, de volgende methode toe om gegevens te lezen uit de database:

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

U kunt nu de volgende regel decommentariëren in de methode main:

todo = readData(connection);

Als u nu de main-klasse uitvoert, zou dit de volgende uitvoer moeten opleveren:

[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

Gegevens bijwerken in Azure HorizonDB

Laten we de gegevens bijwerken die we eerder hebben ingevoegd.

Voeg in het bestand src/main/java/DemoApplication.java, na de methode readData, de volgende methode toe om gegevens bij te werken in de database:

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

U kunt nu de twee volgende regels in de methode main uncommentariëren.

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

Als u nu de main-klasse uitvoert, zou dit de volgende uitvoer moeten opleveren:

[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

Gegevens verwijderen in Azure HorizonDB

Laten we ten slotte de gegevens verwijderen die we eerder hebben ingevoegd.

Voeg in het bestand src/main/java/DemoApplication.java, na de methode updateData, de volgende methode toe om gegevens te verwijderen uit de database:

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

U kunt nu de volgende regel decommentariëren in de methode main:

deleteData(todo, connection);

Als u nu de main-klasse uitvoert, zou dit de volgende uitvoer moeten opleveren:

[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

De hulpbronnen opschonen

Gefeliciteerd! U hebt een Java-toepassing gemaakt die gebruikmaakt van JDBC om gegevens op te slaan en op te halen uit een Azure HorizonDB-exemplaar.

Als u alle resources wilt opschonen die tijdens deze quickstart zijn gebruikt, verwijdert u de resourcegroep. Dit kan met de volgende opdracht:

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

Verwante inhoud

• Quickstart: Gebruik Python om verbinding te maken en query's uit te voeren op gegevens in Azure HorizonDB (preview)
• Verbinding maken met en query’s uitvoeren op Azure HorizonDB (Preview)