Delen via

Java en JDBC gebruiken met Azure Database for MySQL - Flexible Server

  • Artikel

VAN TOEPASSING OP: Azure Database for MySQL - Flexibele server

In dit onderwerp wordt gedemonstreerd hoe u een voorbeeldtoepassing maakt die gebruikmaakt van Java en JDBC om informatie op te slaan en op te halen in een flexibele Azure Database for MySQL-server.

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

In dit artikel bevatten we twee verificatiemethoden: Microsoft Entra-verificatie en MySQL-verificatie. Op het tabblad Wachtwoordloos ziet u de Microsoft Entra-verificatie en op het tabblad Wachtwoord wordt de MySQL-verificatie weergegeven.

Microsoft Entra-verificatie is een mechanisme voor het maken van verbinding met een flexibele Azure Database for MySQL-server met behulp van identiteiten die zijn gedefinieerd in Microsoft Entra-id. Met Microsoft Entra-verificatie kunt u databasegebruikersidentiteiten en andere Microsoft-services op een centrale locatie beheren, waardoor het beheer van machtigingen wordt vereenvoudigd.

MySQL-verificatie maakt gebruik van accounts die zijn opgeslagen in MySQL. Als u ervoor kiest om wachtwoorden als referenties voor de accounts te gebruiken, worden deze referenties opgeslagen in de user tabel. Omdat deze wachtwoorden zijn opgeslagen in MySQL, moet u de rotatie van de wachtwoorden zelf beheren.

Vereisten

De werkomgeving voorbereiden

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

export AZ_RESOURCE_GROUP=database-workshop
export AZ_DATABASE_NAME=<YOUR_DATABASE_NAME>
export AZ_LOCATION=<YOUR_AZURE_REGION>
export AZ_MYSQL_AD_NON_ADMIN_USERNAME=demo-non-admin
export AZ_USER_IDENTITY_NAME=<YOUR_USER_ASSIGNED_MANAGED_IDENTITY_NAME>
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)

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

  • <YOUR_DATABASE_NAME>: De naam van uw flexibele Azure Database for MySQL-serverexemplaren, die uniek moeten zijn in Azure.
  • <YOUR_AZURE_REGION>: de Azure-regio die u gaat gebruiken. U kunt standaard eastus gebruiken, maar we raden u aan om een regio dichtbij uw locatie te configureren. U kunt de volledige lijst met beschikbare regio's bekijken door deze in te voeren az account list-locations.
  • <YOUR_USER_ASSIGNED_MANAGED_IDENTITY_NAME>: De naam van de door de gebruiker toegewezen beheerde identiteitsserver, die uniek moet zijn in Azure.

Maak vervolgens een resourcegroep:

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

Een Azure Database for MySQL-instantie maken

Azure Database for MySQL Flexible Server-exemplaar maken en een gebruiker met beheerdersrechten instellen

Het eerste wat u maakt, is een beheerd exemplaar van een flexibele Azure Database for MySQL-server.

Notitie

U kunt meer gedetailleerde informatie lezen over het maken van MySQL-servers in Een exemplaar van een flexibele Azure Database for MySQL-server maken met behulp van Azure Portal.

Als u Azure CLI gebruikt, voert u de volgende opdracht uit om te controleren of deze voldoende machtigingen heeft:

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

Voer de volgende opdracht uit om de server te maken:

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

Voer de volgende opdracht uit om een door de gebruiker toegewezen identiteit te maken voor het toewijzen:

az identity create \
    --resource-group $AZ_RESOURCE_GROUP \
    --name $AZ_USER_IDENTITY_NAME

Belangrijk

Nadat u de door de gebruiker toegewezen identiteit hebt gemaakt, vraagt u uw globale Beheer istrator of bevoorrechte rol Beheer istrator om de volgende machtigingen voor deze identiteit te verlenen: User.Read.All, GroupMember.Read.Allen Application.Read.ALL. Zie de sectie Machtigingen van Active Directory-verificatie voor meer informatie.

Voer de volgende opdracht uit om de identiteit toe te wijzen aan azure Database for MySQL flexibele server voor het maken van Microsoft Entra-beheerder:

az mysql flexible-server identity assign \
    --resource-group $AZ_RESOURCE_GROUP \
    --server-name $AZ_DATABASE_NAME \
    --identity $AZ_USER_IDENTITY_NAME

Voer de volgende opdracht uit om de Microsoft Entra-beheerder in te stellen:

az mysql flexible-server ad-admin create \
    --resource-group $AZ_RESOURCE_GROUP \
    --server-name $AZ_DATABASE_NAME \
    --display-name $CURRENT_USERNAME \
    --object-id $CURRENT_USER_OBJECTID \
    --identity $AZ_USER_IDENTITY_NAME

Belangrijk

Wanneer u de beheerder instelt, wordt er een nieuwe gebruiker toegevoegd aan het exemplaar van de flexibele Azure Database for MySQL-server met volledige beheerdersmachtigingen. Er kan slechts één Microsoft Entra-beheerder worden gemaakt per exemplaar van flexibele Azure Database for MySQL-server en de selectie van een ander exemplaar overschrijft de bestaande Microsoft Entra-beheerder die is geconfigureerd voor de server.

Met deze opdracht maakt u een klein exemplaar van een flexibele Azure Database for MySQL-server en stelt u de Active Directory-beheerder in op de aangemelde gebruiker.

Het exemplaar van de flexibele Azure Database for MySQL-server dat u hebt gemaakt, heeft een lege database met de naam flexibleserverdb.

Ondervindt u problemen? Laat het ons weten.

Een firewallregel configureren voor uw flexibele Azure Database for MySQL-serverexemplaren

Azure Database for MySQL Flexibele serverexemplaren worden standaard beveiligd. Ze hebben een firewall die geen enkele binnenkomende verbinding toestaat.

U kunt deze stap overslaan als u Bash gebruikt, omdat met de flexible-server create opdracht al uw lokale IP-adres is gedetecteerd en dit is ingesteld op de MySQL-server.

Als u vanuit Windows-subsysteem voor Linux (WSL) verbinding maakt met uw Exemplaar van flexibele Azure Database for MySQL-server 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:

sudo cat /etc/resolv.conf

Kopieer het IP-adres na 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 mysql flexible-server firewall-rule create \
    --resource-group $AZ_RESOURCE_GROUP \
    --name $AZ_DATABASE_NAME \
    --start-ip-address $AZ_WSL_IP_ADDRESS \
    --end-ip-address $AZ_WSL_IP_ADDRESS \
    --rule-name allowiprange \
    --output tsv

Een MySQL-database configureren

Maak daarom een nieuwe database met de naam demo door de volgende opdracht te gebruiken:

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

Een MySQL-gebruiker maken die niet-beheerder is en machtigingen verlenen

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

Notitie

Meer gedetailleerde informatie over het maken van MySQL-gebruikers vindt u in Create users in Azure Database for MySQL.

Maak een SQL-script met de naam create_ad_user.sql voor het maken van een niet-beheerdersgebruiker. Voeg de volgende inhoud toe en sla deze lokaal op:

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 demo.* TO '$AZ_MYSQL_AD_NON_ADMIN_USERNAME'@'%';

FLUSH privileges;

EOF

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

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

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

rm create_ad_user.sql

Een nieuw Java-project maken

Maak met uw favoriete IDE een nieuw Java-project en voeg een pom.xml bestand toe in de hoofdmap:

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

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

  • Java 8
  • Een recent MySQL-stuurprogramma voor Java

Een configuratiebestand voorbereiden om verbinding te maken met Azure Database for MySQL

Voer het volgende script uit in de hoofdmap van het project om een src/main/resources/database.properties-bestand te maken en configuratiegegevens toe te voegen:

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

cat << EOF > src/main/resources/database.properties
url=jdbc:mysql://${AZ_DATABASE_NAME}.mysql.database.azure.com:3306/demo?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}
EOF

Notitie

Als u Mysql Verbinding maken ionPoolDataSource-klasse gebruikt als de gegevensbron in uw toepassing, verwijdert u 'defaultAuthenticationPlugin=com.azure.identity.extensions.jdbc.mysql.AzureMysqlAuthenticationPlugin' in de URL.

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

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

Notitie

De configuratie-eigenschap url heeft ?serverTimezone=UTC toegevoegd om het JDBC-stuurprogramma te laten weten dat de UTC-datumnotatie (of Coordinated Universal Time) moet worden gebruikt bij het maken van verbinding met de database. Anders zou uw Java-server niet dezelfde datumnotatie gebruiken als de database, wat tot een fout zou leiden.

Een SQL-bestand maken om het databaseschema te genereren

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

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

De toepassing coderen

Verbinding maken met de database

Voeg vervolgens de Java-code toe die gebruik gaat maken van JDBC om gegevens op te slaan en op te halen van uw MySQL-server.

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

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

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

Ondervindt u problemen? Laat het ons weten.

Deze Java-code gebruikt de database.properties en de schema.sql bestanden die u eerder hebt gemaakt, om verbinding te maken met het flexibele serverexemplaren van Azure Database for MySQL en een schema te maken waarmee uw gegevens worden opgeslagen.

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

Notitie

De databasereferenties worden opgeslagen in de eigenschappen van de gebruiker en het wachtwoord van het bestand database.properties. Deze referenties worden gebruikt bij het uitvoeren van DriverManager.getConnection(properties.getProperty("url"), properties);, omdat het eigenschappenbestand als argument wordt doorgegeven.

Notitie

De regel AbandonedConnectionCleanupThread.uncheckedShutdown(); aan het einde is een opdracht voor MySQL-stuurprogramma's voor het vernietigen van een interne thread bij het afsluiten van de app. Dit kan gerust worden genegeerd.

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 exemplaar van de flexibele Azure Database for MySQL-server, 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 Database for MySQL

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 commentaartekens verwijderen van de twee volgende regels in de methode main:

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 Database for MySQL

Lees vervolgens de gegevens die eerder zijn ingevoegd om te controleren of uw code correct 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 commentaartekens verwijderen van de volgende regel 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

Ondervindt u problemen? Laat het ons weten.

Gegevens bijwerken in Azure Database for MySQL Flexibele server

Werk vervolgens de gegevens bij die u eerder hebt 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 commentaartekens verwijderen van de twee volgende regels in de methode main:

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 Een flexibele Azure Database for MySQL-server

Verwijder ten slotte de gegevens die u eerder hebt 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 commentaartekens verwijderen van de volgende regel 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

Resources opschonen

Gefeliciteerd U hebt een Java-toepassing gemaakt die gebruikmaakt van JDBC om gegevens op te slaan en op te halen uit azure Database for MySQL flexibele server.

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

Volgende stappen

Uw MySQL-database migreren naar Azure Database voor MySQL met behulp van dumpen en terugzetten