Share via

Schnellstart: Verwenden von Java und JDBC mit Azure Database for MySQL

  • Artikel

GILT FÜR:Azure Database for MySQL – Single Server

Wichtig

Azure Database for MySQL single server is on the retirement path. Es wird dringend empfohlen, ein Upgrade auf azure Database for MySQL flexiblen Server durchzuführen. Weitere Informationen zum Migrieren zu Azure Database for MySQL flexible Server finden Sie unter Was geschieht mit Azure Database for MySQL Single Server?

In diesem Artikel wird die Erstellung einer Beispielanwendung veranschaulicht, die Java und JDBC verwendet, um Informationen in Azure Database for MySQL zu speichern bzw. daraus abzurufen.

JDBC ist die Standard-Java-API, um eine Verbindung mit herkömmlichen relationalen Datenbanken herzustellen.

In diesem Artikel werden zwei Authentifizierungsmethoden verwendet: Microsoft Entra-Authentifizierung und PostgreSQL-Authentifizierung. Die Registerkarte Kennwortlos zeigt die Microsoft Entra-Authentifizierung und die Registerkarte Kennwort die MySQL-Authentifizierung.

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

MySQL-Authentifizierung verwendet Konten, die in MySQL gespeichert sind. Wenn Sie Kennwörter als Anmeldeinformationen für die Konten verwenden möchten, werden diese Anmeldeinformationen in der user-Tabelle gespeichert. Da diese Kennwörter in MySQL gespeichert sind, müssen Sie die Rotation der Kennwörter selbst verwalten.

Voraussetzungen

  • Ein Azure-Konto. Falls Sie noch kein Konto haben, können Sie eine kostenlose Testversion verwenden.
  • Azure Cloud Shell oder Azure CLI. Wir empfehlen Azure Cloud Shell, damit Sie automatisch angemeldet werden und Zugriff auf alle erforderlichen Tools erhalten.
  • Ein unterstütztes Java Development Kit, Version 8 (in Azure Cloud Shell enthalten).
  • Das Apache Maven-Buildtool
  • MySQL-Befehlszeilenclient. Sie können mit dem Befehlszeilentool mysql.exe über Azure Cloud Shell eine Verbindung mit Ihrem Server herstellen. Alternativ können Sie die mysqlBefehlszeile in Ihrer lokalen Umgebung nutzen.

Vorbereiten der Arbeitsumgebung

Richten Sie zunächst einige Umgebungsvariablen ein. Führen Sie in Azure Cloud Shell die folgenden Befehle aus:

export AZ_RESOURCE_GROUP=database-workshop
export AZ_DATABASE_SERVER_NAME=<YOUR_DATABASE_SERVER_NAME>
export AZ_DATABASE_NAME=demo
export AZ_LOCATION=<YOUR_AZURE_REGION>
export AZ_MYSQL_AD_NON_ADMIN_USERNAME=demo-non-admin
export AZ_LOCAL_IP_ADDRESS=<YOUR_LOCAL_IP_ADDRESS>
export CURRENT_USERNAME=$(az ad signed-in-user show --query userPrincipalName -o tsv)
export CURRENT_USER_OBJECTID=$(az ad signed-in-user show --query id -o tsv)

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

  • <YOUR_DATABASE_SERVER_NAME>: Der Name Ihres MySQL-Servers, der in Azure eindeutig sein sollte.
  • <YOUR_AZURE_REGION>: Die von Ihnen verwendete Azure-Region. Sie können standardmäßig eastus verwenden, wir empfehlen aber, eine Region zu konfigurieren, die näher an Ihrem Standort liegt. Die vollständige Liste der verfügbaren Regionen wird angezeigt, wenn Sie az account list-locations eingeben.
  • <YOUR_LOCAL_IP_ADDRESS>: Die IP-Adresse Ihres lokalen Computers, auf dem Sie die Anwendung ausführen. Sie können sie ganz einfach ermitteln, indem Sie whatismyip.akamai.com öffnen.

Erstellen Sie nun mithilfe des folgenden Befehls eine Ressourcengruppe:

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

Erstellen einer Instanz von Azure-Datenbank für MySQL

Erstellen eines MySQL-Servers und Einrichten eines Administratorbenutzers

Zunächst erstellen Sie einen verwalteten MySQL-Server.

Hinweis

Ausführlichere Informationen zum Erstellen von MySQL-Servern finden Sie unter Schnellstart: Erstellen eines Azure Database for MySQL-Servers im Azure-Portal.

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

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

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

az mysql server create \
    --resource-group $AZ_RESOURCE_GROUP \
    --name $AZ_DATABASE_SERVER_NAME \
    --location $AZ_LOCATION \
    --sku-name B_Gen5_1 \
    --storage-size 5120 \
    --output tsv

Führen Sie nun den folgenden Befehl aus, um den/die Microsoft Entra-Administratorbenutzer*in festzulegen:

az mysql server ad-admin create \
    --resource-group $AZ_RESOURCE_GROUP \
    --server-name $AZ_DATABASE_SERVER_NAME \
    --display-name $CURRENT_USERNAME \
    --object-id $CURRENT_USER_OBJECTID

Wichtig

Beim Festlegen des Administrators wird dem Azure Database for MySQL-Server ein neuer Benutzer mit vollständigen Administratorberechtigungen hinzugefügt. Sie können nur einen Microsoft Entra-Administrator pro MySQL-Server erstellen. Die Auswahl eines anderen Benutzers überschreibt den vorhandenen Microsoft Entra-Administrator, der für den Server konfiguriert ist.

Dieser Befehl erstellt einen kleinen MySQL-Server und legt den Active Directory-Administrator auf den angemeldeten Benutzer fest.

Konfigurieren einer Firewallregel für den MySQL-Server

Azure Database for MySQL-Instanzen werden standardmäßig gesichert. Diese Instanzen verfügen über eine Firewall, die keine eingehenden Verbindungen zulässt. Damit Sie die Datenbank verwenden können, müssen Sie eine Firewallregel hinzufügen, die den Zugriff der lokalen IP-Adresse auf den Datenbankserver zulässt.

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 mysql server firewall-rule create \
    --resource-group $AZ_RESOURCE_GROUP \
    --name $AZ_DATABASE_SERVER_NAME-database-allow-local-ip \
    --server $AZ_DATABASE_SERVER_NAME \
    --start-ip-address $AZ_LOCAL_IP_ADDRESS \
    --end-ip-address $AZ_LOCAL_IP_ADDRESS \
    --output tsv

Wenn Sie eine Verbindung mit Ihrem MySQL-Server aus 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 nach dem Ausdruck nameserver, 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 mysql server firewall-rule create \
    --resource-group $AZ_RESOURCE_GROUP \
    --name $AZ_DATABASE_SERVER_NAME-database-allow-local-ip-wsl \
    --server $AZ_DATABASE_SERVER_NAME \
    --start-ip-address $AZ_WSL_IP_ADDRESS \
    --end-ip-address $AZ_WSL_IP_ADDRESS \
    --output tsv

Konfigurieren einer MySQL-Datenbank

Der MySQL-Server, den Sie zuvor erstellt haben, ist leer. Erstellen Sie mit dem folgenden Befehl eine neue Datenbank.

az mysql db create \
    --resource-group $AZ_RESOURCE_GROUP \
    --name $AZ_DATABASE_NAME \
    --server-name $AZ_DATABASE_SERVER_NAME \
    --output tsv

Erstellen eines MySQL-Nicht-Administratorbenutzers 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 Erstellen von MySQL-Benutzern finden Sie unter Erstellen von Benutzern in Azure Database for MySQL.

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

export AZ_MYSQL_AD_NON_ADMIN_USERID=$CURRENT_USER_OBJECTID

cat << EOF > create_ad_user.sql
SET aad_auth_validate_oids_in_tenant = OFF;

CREATE AADUSER '$AZ_MYSQL_AD_NON_ADMIN_USERNAME' IDENTIFIED BY '$AZ_MYSQL_AD_NON_ADMIN_USERID';

GRANT ALL PRIVILEGES ON $AZ_DATABASE_NAME.* TO '$AZ_MYSQL_AD_NON_ADMIN_USERNAME'@'%';

FLUSH privileges;

EOF

Verwenden Sie dann den folgenden Befehl, um das SQL-Skript zum Erstellen des/der Microsoft Entra-Benutzers/-Benutzerin ohne Administratorrechte auszuführen:

mysql -h $AZ_DATABASE_SERVER_NAME.mysql.database.azure.com --user $CURRENT_USERNAME@$AZ_DATABASE_SERVER_NAME --enable-cleartext-plugin --password=$(az account get-access-token --resource-type oss-rdbms --output tsv --query accessToken) < create_ad_user.sql

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

rm create_ad_user.sql

Erstellen eines neuen Java-Projekts

Erstellen Sie mithilfe Ihrer bevorzugten IDE ein neues Java-Projekt mit Java 8 oder höher. Erstellen Sie eine Datei pom.xml in ihrem Stammverzeichnis, und fügen Sie den 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>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.30</version>
        </dependency>
        <dependency>
            <groupId>com.azure</groupId>
            <artifactId>azure-identity-extensions</artifactId>
            <version>1.0.0</version>
        </dependency>
    </dependencies>
</project>

Diese Datei ist eine Apache Maven-Datei, die Ihr Projekt so konfiguriert, dass Java 8 und ein aktueller MySQL-Treiber für Java verwendet werden.

Vorbereiten einer Konfigurationsdatei für das Herstellen einer Verbindung mit Azure Database for MySQL

Führen Sie das folgende Skript im Projektstammverzeichnis aus, um eine Datei vom Typ src/main/resources/database.properties zu erstellen und Konfigurationsdetails hinzuzufügen:

mkdir -p src/main/resources && touch src/main/resources/database.properties

cat << EOF > src/main/resources/database.properties
url=jdbc:mysql://${AZ_DATABASE_SERVER_NAME}.mysql.database.azure.com:3306/${AZ_DATABASE_NAME}?sslMode=REQUIRED&serverTimezone=UTC&defaultAuthenticationPlugin=com.azure.identity.extensions.jdbc.mysql.AzureMysqlAuthenticationPlugin&authenticationPlugins=com.azure.identity.extensions.jdbc.mysql.AzureMysqlAuthenticationPlugin
user=${AZ_MYSQL_AD_NON_ADMIN_USERNAME}@${AZ_DATABASE_SERVER_NAME}
EOF

Hinweis

Wenn Sie die MysqlConnectionPoolDataSource-Klasse als Datenquelle in Ihrer Anwendung verwenden, entfernen Sie „defaultAuthenticationPlugin=com.azure.identity.extensions.jdbc.mysql.AzureMysqlAuthenticationPlugin“ in der URL.

mkdir -p src/main/resources && touch src/main/resources/database.properties

cat << EOF > src/main/resources/database.properties
url=jdbc:mysql://${AZ_DATABASE_SERVER_NAME}.mysql.database.azure.com:3306/${AZ_DATABASE_NAME}?sslMode=REQUIRED&serverTimezone=UTC&authenticationPlugins=com.azure.identity.extensions.jdbc.mysql.AzureMysqlAuthenticationPlugin
user=${AZ_MYSQL_AD_NON_ADMIN_USERNAME}@${AZ_DATABASE_SERVER_NAME}
EOF

Hinweis

An die url-Konfigurationseigenschaft wird ?serverTimezone=UTC angefügt, um den JDBC-Treiber anzuweisen, beim Herstellen einer Verbindung mit der Datenbank das UTC-Datumsformat (Coordinated Universal Time, koordinierte Weltzeit) zu verwenden. Andernfalls verwendet Ihr Java-Server nicht das gleiche Datumsformat wie die Datenbank, was zu einem Fehler führen würde.

Erstellen einer SQL-Datei zum Generieren des Datenbankschemas

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

touch src/main/resources/schema.sql

cat << EOF > src/main/resources/schema.sql
DROP TABLE IF EXISTS todo;
CREATE TABLE todo (id SERIAL PRIMARY KEY, description VARCHAR(255), details VARCHAR(4096), done BOOLEAN);
EOF

Codieren der Anwendung

Herstellen der Verbindung mit der Datenbank

Fügen Sie als Nächstes den Java-Code hinzu, der JDBC zum Speichern und Abrufen von Daten auf Ihrem MySQL-Server verwendet.

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

package com.example.demo;

import com.mysql.cj.jdbc.AbandonedConnectionCleanupThread;

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

        /* Prepare to store and retrieve data from the MySQL server.
        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();
        AbandonedConnectionCleanupThread.uncheckedShutdown();
    }
}

Dieser Java-Code verwendet die zuvor erstellten Dateien database.properties und schema.sql. Nachdem Sie eine Verbindung mit dem MySQL-Server hergestellt haben, können Sie ein Schema erstellen, um Ihre Daten zu speichern.

In dieser Datei können Sie sehen, dass wir Methoden zum Einfügen, Lesen, Aktualisieren und Löschen von Daten kommentiert haben. Sie implementieren diese Methoden im Rest dieses Artikels und können ihre Kommentierung nacheinander aufheben.

Hinweis

Die Datenbankanmeldeinformationen werden in den Eigenschaften user und password der Datei database.properties gespeichert. Diese Anmeldeinformationen werden bei der Ausführung von DriverManager.getConnection(properties.getProperty("url"), properties); verwendet, da die Eigenschaftendatei als Argument übergeben wird.

Hinweis

Bei der Zeile AbandonedConnectionCleanupThread.uncheckedShutdown(); am Ende handelt es sich um einen MySQL-Treiberbefehl, um beim Herunterfahren der Anwendung einen internen Thread zu löschen. Sie können diese Zeile unbesorgt ignorieren.

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

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

Die Anwendung sollte eine Verbindung mit Azure Database for MySQL herstellen, ein Datenbankschema erstellen und die Verbindung dann trennen. Die Ausgabe sollte etwa folgendem Beispiel in den Konsolenprotokollen entsprechen:

[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 neben der Klasse DemoApplication eine neue Todo-Java-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 +
                '}';
    }
}

Bei dieser Klasse handelt es sich um 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 Database for MySQL

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

Das Ausführen der Hauptklasse sollte nun die folgende Ausgabe ergeben:

[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 MySQL

Lesen Sie nun die zuvor eingefügten Daten, um zu überprüfen, ob der Code ordnungsgemäß funktioniert.

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

Das Ausführen der Hauptklasse sollte nun die folgende Ausgabe ergeben:

[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 MySQL

Aktualisieren Sie nun die Daten, die Sie zuvor eingefügt haben.

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

Das Ausführen der Hauptklasse sollte nun die folgende Ausgabe ergeben:

[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 MySQL

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

Das Ausführen der Hauptklasse sollte nun die folgende Ausgabe ergeben:

[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

Glückwunsch! Sie haben eine Java-Anwendung erstellt, die JDBC zum Speichern und Abrufen von Daten in bzw. aus Azure Database for MySQL verwendet.

Löschen Sie die Ressourcengruppe mit dem folgenden Befehl, um alle in dieser Schnellstartanleitung verwendeten Ressourcen zu bereinigen:

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

Nächste Schritte

Migrieren der MySQL-Datenbank auf Azure-Datenbank für MySQL durch Sicherungen und Wiederherstellungen