Dela via

Använda Java och JDBC med Azure Database for MySQL – flexibel server

  • Artikel

GÄLLER FÖR: Azure Database for MySQL – flexibel server

Det här avsnittet visar hur du skapar ett exempelprogram som använder Java och JDBC för att lagra och hämta information i Azure Database for MySQL – flexibel server.

JDBC är java-standard-API:et för att ansluta till traditionella relationsdatabaser.

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

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

MySQL-autentisering använder konton som lagras i MySQL. Om du väljer att använda lösenord som autentiseringsuppgifter för kontona lagras dessa autentiseringsuppgifter i user tabellen. Eftersom dessa lösenord lagras i MySQL 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_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)

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

  • <YOUR_DATABASE_NAME>: Namnet på din Azure Database for MySQL – flexibel serverinstans, som ska vara unik i Hela Azure.
  • <YOUR_AZURE_REGION>: Den Azure-region som du ska använda. Du kan använda eastus som standard, men vi rekommenderar att du konfigurerar den region som är närmast dig. Du kan se den fullständiga listan över tillgängliga regioner genom att ange az account list-locations.
  • <YOUR_USER_ASSIGNED_MANAGED_IDENTITY_NAME>: Namnet på den användartilldelade hanterade identitetsservern, som ska vara unik i Hela Azure.

Skapa sedan en resursgrupp:

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

Skapa en Azure Database for MySQL-instans

Skapa Azure Database for MySQL – flexibel serverinstans och konfigurera en administratörsanvändare

Det första du skapar är en hanterad Azure Database for MySQL – flexibel serverinstans.

Kommentar

Du kan läsa mer detaljerad information om hur du skapar MySQL-servrar i Skapa en Azure Database for MySQL – flexibel serverinstans med hjälp av Azure Portal.

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 mysql flexible-server create \
    --resource-group $AZ_RESOURCE_GROUP \
    --name $AZ_DATABASE_NAME \
    --location $AZ_LOCATION \
    --yes \
    --output tsv

Kör följande kommando för att skapa en användartilldelad identitet för tilldelning:

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

Viktigt!

När du har skapat den användartilldelade identiteten ber du en användare med minst rollen Privilegierad rolladministratör att bevilja följande behörigheter för den här användartilldelade hanterade identiteten: User.Read.All, GroupMember.Read.Alloch Application.Read.ALL. Alternativt kan du ge den användartilldelade hanterade identiteten rollen Katalogläsare . Mer information finns i avsnittet Behörigheter i Active Directory-autentisering.

Kör följande kommando för att tilldela identiteten till Azure Database for MySQL – flexibel server för att skapa Microsoft Entra-administratör:

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

Kör följande kommando för att ange Microsoft Entra-administratörsanvändaren:

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

Viktigt!

När du ställer in administratören läggs en ny användare till i Azure Database for MySQL – flexibel serverinstans med fullständig administratörsbehörighet. Endast en Microsoft Entra-administratör kan skapas per Azure Database for MySQL – flexibel serverinstans och val av en annan skriver över den befintliga Microsoft Entra-administratören som konfigurerats för servern.

Det här kommandot skapar en liten Azure Database for MySQL – flexibel serverinstans och anger Active Directory-administratören till den inloggade användaren.

Azure Database for MySQL – flexibel server-instans som du skapade har en tom databas med namnet flexibleserverdb.

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

Konfigurera en brandväggsregel för din Azure Database for MySQL – flexibel serverinstans

Azure Database for MySQL – flexibel server-instanser skyddas som standard. Databaserna har en brandvägg som inte tillåter inkommande anslutningar.

Du kan hoppa över det här steget om du använder Bash eftersom flexible-server create kommandot redan har identifierat din lokala IP-adress och angett den på MySQL-servern.

Om du ansluter till din Azure Database for MySQL Flexible Server-instans från Windows-undersystem för 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:

sudo cat /etc/resolv.conf

Kopiera IP-adressen efter 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 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

Konfigurera en MySQL-databas

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

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

Skapa en MySQL-användare som inte är administratör och bevilja behörighet

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

Kommentar

Du kan läsa mer detaljerad information om hur du skapar MySQL-användare i Skapa användare i Azure Database for MySQL.

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:

export AZ_MYSQL_AD_NON_ADMIN_USERID=$(az ad signed-in-user show --query id --output tsv)

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

Använd sedan följande kommando för att köra SQL-skriptet för att skapa microsoft Entra-användaren som inte är administratör:

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

Använd nu 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, skapa ett nytt Java-projekt och lägg till en pom.xml fil i rotkatalogen:

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

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

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

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

Kör följande skript i projektrotkatalogen för att skapa en src/main/resources/database.properties-fil och lägg till konfigurationsinformation:

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

Kommentar

Om du använder klassen MysqlConnectionPoolDataSource som datakälla i ditt program tar du bort "defaultAuthenticationPlugin=com.azure.identity.extensions.jdbc.mysql.AzureMysqlAuthenticationPlugin" i url:en.

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

Kommentar

Konfigurationsegenskapen url har ?serverTimezone=UTC lagts till för att instruera JDBC-drivrutinen att använda UTC-datumformatet (eller Coordinated Universal Time) när du ansluter till databasen. Annars skulle Java-servern inte använda samma datumformat som databasen, vilket skulle resultera i ett fel.

Skapa en SQL-fil för att generera databasschemat

Du använder 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 VARCHAR(255), details VARCHAR(4096), done BOOLEAN);

Koda appen

Ansluta till databasen

Lägg sedan till Java-koden som använder JDBC för att lagra och hämta data från MySQL-servern.

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

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

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

Den här Java-koden använder database.properties och de schema.sql filer som du skapade tidigare, för att ansluta till Azure Database for MySQL – flexibel serverinstans och skapa ett schema som lagrar dina data.

I den här filen kan du se att vi har kommenterat metoder för att infoga, läsa, uppdatera och ta bort data: du kodar dessa metoder i resten av den här artikeln och du kommer att kunna avkommenteras en efter varandra.

Kommentar

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

Kommentar

Raden AbandonedConnectionCleanupThread.uncheckedShutdown(); i slutet är ett MySQL-drivrutinsspecifikt kommando för att förstöra en intern tråd när programmet stängs av. Det kan ignoreras på ett säkert sätt.

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 Database for MySQL – flexibel serverinstans, 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 Database for MySQL

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

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

Körning av huvudklassen bör 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äsa data från Azure Database for MySQL

Läs sedan de data som tidigare infogats för att verifiera att koden 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 bör 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

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

Uppdatera data i Azure Database for MySQL – flexibel server

Uppdatera sedan de data som du 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 avkommenta de två följande raderna main i metoden:

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

Körning av huvudklassen bör 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 Database for MySQL – flexibel server

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

Körning av huvudklassen bör 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 Azure Database for MySQL – flexibel server.

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

Nästa steg

Migrera MySQL-databasen till Azure Database för MySQL med säkerhetskopiering och återställning