Share via

Použití Spring Data R2DBC se službou Azure Database for MySQL

  • Článek

Tento článek ukazuje vytvoření ukázkové aplikace, která používá Spring Data R2DBC k ukládání a načítání informací ve službě Azure Database for MySQL pomocí implementace R2DBC pro MySQL z úložiště GitHub r2dbc-mysql.

R2DBC přináší reaktivní rozhraní API do tradičních relačních databází. Pomocí aplikace Spring WebFlux můžete vytvářet plně reaktivní aplikace Spring Boot, které používají neblokující rozhraní API. Poskytuje lepší škálovatelnost než klasický přístup "jeden vlákno na připojení".

Požadavky

  • Klient příkazového řádku MySQL.

  • cURL nebo podobný nástroj HTTP pro testování funkčnosti.

Zobrazení ukázkové aplikace

V tomto článku naprogramujete ukázkovou aplikaci. Pokud chcete přejít rychleji, tato aplikace je již kódována a k dispozici na adrese https://github.com/Azure-Samples/quickstart-spring-data-r2dbc-mysql.

Příprava pracovního prostředí

Nejprve nastavte některé proměnné prostředí spuštěním následujících příkazů:

export AZ_RESOURCE_GROUP=database-workshop
export AZ_DATABASE_NAME=<YOUR_DATABASE_NAME>
export AZ_LOCATION=<YOUR_AZURE_REGION>
export AZ_MYSQL_ADMIN_USERNAME=spring
export AZ_MYSQL_ADMIN_PASSWORD=<YOUR_MYSQL_ADMIN_PASSWORD>
export AZ_MYSQL_NON_ADMIN_USERNAME=spring-non-admin
export AZ_MYSQL_NON_ADMIN_PASSWORD=<YOUR_MYSQL_NON_ADMIN_PASSWORD>

Zástupné symboly nahraďte následujícími hodnotami, které se používají v tomto článku:

  • <YOUR_DATABASE_NAME>: Název vašeho serveru MySQL, který by měl být jedinečný v rámci Azure.
  • <YOUR_AZURE_REGION>: Oblast Azure, kterou použijete. Standardně můžete použít eastus, ale doporučujeme nakonfigurovat oblast blíže k místu, kde se nacházíte. Úplný seznam dostupných oblastí můžete zobrazit pomocí .az account list-locations
  • <YOUR_MYSQL_ADMIN_PASSWORD> a <YOUR_MYSQL_NON_ADMIN_PASSWORD>: Heslo vašeho databázového serveru MySQL, které by mělo mít minimálně osm znaků. Znaky by měly být ze tří z následujících kategorií: velká písmena anglické abecedy, malá písmena anglické abecedy, číslice (0–9) a jiné než alfanumerické znaky (!, $, #, %atd.).

Následně vytvořte skupinu prostředků:

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

Vytvoření instance Azure Database for MySQL a nastavení uživatele správce

První věc, kterou vytvoříte, je spravovaný server MySQL s uživatelem správce.

Poznámka:

Podrobnější informace o vytváření serverů MySQL najdete v článku Vytvoření serveru Azure Database for MySQL pomocí webu Azure Portal.

az mysql flexible-server create \
    --resource-group $AZ_RESOURCE_GROUP \
    --name $AZ_DATABASE_NAME \
    --location $AZ_LOCATION \
    --admin-user $AZ_MYSQL_ADMIN_USERNAME \
    --admin-password $AZ_MYSQL_ADMIN_PASSWORD \
    --yes \
    --output tsv

Konfigurace databáze MySQL

Vytvořte novou databázi volanou demo pomocí následujícího příkazu:

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

Konfigurace pravidla brány firewall pro server MySQL

Instance Azure Database for MySQL jsou ve výchozím nastavení zabezpečené. Obsahuje bránu firewall, která nepovoluje žádné příchozí připojení.

Tento krok můžete přeskočit, pokud používáte Bash, protože flexible-server create příkaz už detekoval vaši místní IP adresu a nastavil ji na serveru MySQL.

Pokud se připojujete k serveru MySQL z Subsystém Windows pro Linux (WSL) na počítači s Windows, musíte do brány firewall přidat ID hostitele WSL. Získejte IP adresu hostitelského počítače spuštěním následujícího příkazu ve WSL:

cat /etc/resolv.conf

Zkopírujte IP adresu za termínem nameservera pak pomocí následujícího příkazu nastavte proměnnou prostředí pro IP adresu WSL:

export AZ_WSL_IP_ADDRESS=<the-copied-IP-address>

Pak pomocí následujícího příkazu otevřete bránu firewall serveru pro vaši aplikaci založenou na WSL:

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

Vytvoření uživatele bez oprávnění správce MySQL a udělení oprávnění

Tento krok vytvoří uživatele, který není správcem, a udělí mu všechna oprávnění k demo databázi.

Poznámka:

Podrobnější informace o vytváření uživatelů MySQL najdete v tématu Vytváření uživatelů ve službě Azure Database for MySQL.

Nejprve vytvořte skript SQL s názvem create_user.sql pro vytvoření uživatele bez oprávnění správce. Přidejte následující obsah a uložte ho místně:

cat << EOF > create_user.sql
CREATE USER '$AZ_MYSQL_NON_ADMIN_USERNAME'@'%' IDENTIFIED BY '$AZ_MYSQL_NON_ADMIN_PASSWORD';
GRANT ALL PRIVILEGES ON demo.* TO '$AZ_MYSQL_NON_ADMIN_USERNAME'@'%';
FLUSH PRIVILEGES;
EOF

Potom pomocí následujícího příkazu spusťte skript SQL a vytvořte uživatele bez oprávnění správce:

mysql -h $AZ_DATABASE_NAME.mysql.database.azure.com --user $AZ_MYSQL_ADMIN_USERNAME --enable-cleartext-plugin --password=$AZ_MYSQL_ADMIN_PASSWORD < create_user.sql

Teď pomocí následujícího příkazu odeberte dočasný soubor skriptu SQL:

rm create_user.sql

Vytvoření reaktivní aplikace Spring Boot

K vytvoření reaktivní aplikace Spring Boot použijeme Spring Initializr. Aplikace, kterou vytvoříme, používá:

  • Spring Boot 2.7.11.
  • Následující závislosti: Spring Reactive Web (označovaný také jako Spring WebFlux) a Spring Data R2DBC.

Vygenerování aplikace pomocí Spring Initializr

Zadáním následujícího příkazu na příkazovém řádku vygenerujte aplikaci:

curl https://start.spring.io/starter.tgz -d dependencies=webflux,data-r2dbc -d baseDir=azure-database-workshop -d bootVersion=2.7.11 -d javaVersion=17 | tar -xzvf -

Přidání implementace reaktivního ovladače MySQL

Otevřete soubor pom.xml vygenerovaného projektu a přidejte reaktivní ovladač MySQL z úložiště r2dbc-mysql na GitHubu.

Za závislost spring-boot-starter-webflux přidejte následující fragment kódu:

<dependency>
  <groupId>io.asyncer</groupId>
  <artifactId>r2dbc-mysql</artifactId>
  <version>0.9.1</version>
</dependency>

Konfigurace Spring Boot pro použití služby Azure Database for MySQL

Otevřete soubor src/main/resources/application.properties a přidejte:

logging.level.org.springframework.data.r2dbc=DEBUG

spring.r2dbc.url=r2dbc:pool:mysql://$AZ_DATABASE_NAME.mysql.database.azure.com:3306/demo?tlsVersion=TLSv1.2
spring.r2dbc.username=spring-non-admin
spring.r2dbc.password=$AZ_MYSQL_NON_ADMIN_PASSWORD

$AZ_DATABASE_NAME Nahraďte proměnné $AZ_MYSQL_NON_ADMIN_PASSWORD hodnotami, které jste nakonfigurovali na začátku tohoto článku.

Poznámka:

Kvůli lepšímu výkonu spring.r2dbc.url je vlastnost nakonfigurovaná tak, aby používala fond připojení pomocí fondu r2dbc-pool.

Teď byste měli být schopni spustit aplikaci pomocí poskytnuté obálky Maven:

./mvnw spring-boot:run

Zde je obrázek poprvé spuštěné aplikace:

Screenshot of the running application.

Vytvoření schématu databáze

V hlavní DemoApplication třídě nakonfigurujte novou sadu Spring bean, která vytvoří schéma databáze pomocí následujícího kódu:

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.core.io.ClassPathResource;
import org.springframework.data.r2dbc.connectionfactory.init.ConnectionFactoryInitializer;
import org.springframework.data.r2dbc.connectionfactory.init.ResourceDatabasePopulator;

import io.r2dbc.spi.ConnectionFactory;

@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

    @Bean
    public ConnectionFactoryInitializer initializer(ConnectionFactory connectionFactory) {
        ConnectionFactoryInitializer initializer = new ConnectionFactoryInitializer();
        initializer.setConnectionFactory(connectionFactory);
        ResourceDatabasePopulator populator = new ResourceDatabasePopulator(new ClassPathResource("schema.sql"));
        initializer.setDatabasePopulator(populator);
        return initializer;
    }
}

Tato aplikace Spring bean používá soubor s názvem schema.sql, takže ho vytvořte ve složce src/main/resources a přidejte následující text:

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

Zastavte spuštěnou aplikaci a spusťte ji znovu. Aplikace teď bude používat databázi demo, kterou jste vytvořili dřív, a vytvoří v ní tabulku todo.

./mvnw spring-boot:run

Tady je snímek obrazovky s tabulkou databáze při vytváření:

Screenshot of the creation of the database table.

Vytvoření kódu aplikace

Dále přidejte kód Java, který bude používat R2DBC k ukládání a načítání dat z vašeho serveru MySQL.

Vytvořte novou Todo třídu Java vedle DemoApplication třídy pomocí následujícího kódu:

package com.example.demo;

import org.springframework.data.annotation.Id;

public class Todo {

    public Todo() {
    }

    public Todo(String description, String details, boolean done) {
        this.description = description;
        this.details = details;
        this.done = done;
    }

    @Id
    private Long id;

    private String description;

    private String details;

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

Tato třída je doménový model mapovaný na tabulku todo, kterou jste vytvořili dřív.

Ke správě této třídy budete potřebovat úložiště. Pomocí následujícího kódu definujte nové TodoRepository rozhraní ve stejném balíčku:

package com.example.demo;

import org.springframework.data.repository.reactive.ReactiveCrudRepository;

public interface TodoRepository extends ReactiveCrudRepository<Todo, Long> {
}

Toto úložiště je reaktivní úložiště, které spravuje Spring Data R2DBC.

Dokončete aplikaci vytvořením kontroleru, který může ukládat a načítat data. Ve stejném balíčku implementujte třídu TodoController a přidejte následující kód:

package com.example.demo;

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.*;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

@RestController
@RequestMapping("/")
public class TodoController {

    private final TodoRepository todoRepository;

    public TodoController(TodoRepository todoRepository) {
        this.todoRepository = todoRepository;
    }

    @PostMapping("/")
    @ResponseStatus(HttpStatus.CREATED)
    public Mono<Todo> createTodo(@RequestBody Todo todo) {
        return todoRepository.save(todo);
    }

    @GetMapping("/")
    public Flux<Todo> getTodos() {
        return todoRepository.findAll();
    }
}

Nakonec aplikaci zastavte a znovu ji spusťte pomocí následujícího příkazu:

./mvnw spring-boot:run

Testování aplikace

K otestování aplikace můžete použít cURL.

Nejprve pomocí následujícího příkazu vytvořte v databázi novou položku „úkolu“:

curl --header "Content-Type: application/json" \
    --request POST \
    --data '{"description":"configuration","details":"congratulations, you have set up R2DBC correctly!","done": "true"}' \
    http://127.0.0.1:8080

Tento příkaz by měl vrátit vytvořenou položku, jak je znázorněno tady:

{"id":1,"description":"configuration","details":"congratulations, you have set up R2DBC correctly!","done":true}

Potom načtěte data pomocí nového požadavku cURL pomocí následujícího příkazu:

curl http://127.0.0.1:8080

Tento příkaz vrátí seznam položek "todo", včetně položky, kterou jste vytvořili, jak je znázorněno tady:

[{"id":1,"description":"configuration","details":"congratulations, you have set up R2DBC correctly!","done":true}]

Tady je snímek obrazovky s těmito požadavky cURL:

Screenshot of the cURL test.

Blahopřejeme! Vytvořili jste plně reaktivní aplikaci Spring Boot, která k ukládání a načítání dat ze služby Azure Database for MySQL používá R2DBC.

Vyčištění prostředků

Pokud chcete vyčistit všechny prostředky použité během tohoto rychlého startu, odstraňte skupinu prostředků pomocí následujícího příkazu:

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

Další kroky

Další informace o nasazení aplikace Spring Data do Azure Spring Apps a použití spravované identity najdete v tématu Kurz: Nasazení aplikace Spring do Azure Spring Apps s bez heslem připojení k databázi Azure.

Pokud se chcete dozvědět více o architektuře Spring a Azure, přejděte do centra dokumentace Spring v Azure.

Spring v Azure

Viz také

Další informace o Spring Data R2DBC najdete v referenční dokumentaci spring.

Další informace o používání Azure s jazykem Java najdete v článku Azure pro vývojáře v jazyce Java a Práce s Azure DevOps a jazykem Java.