A Spring Data R2DBC használata az Azure SQL Database-lel

  • Cikk

Ez a cikk egy mintaalkalmazás létrehozását mutatja be, amely a Spring Data R2DBC használatával tárolja és kéri le az adatokat az Azure SQL Database-ben a Microsoft SQL Server R2DBC-implementációjának használatával az r2dbc-mssql GitHub-adattárból.

Az R2DBC reaktív API-kkal egészíti ki a hagyományos relációs adatbázisokat. A Spring WebFlux használatával teljesen reaktív Spring Boot-alkalmazásokat hozhat létre, amelyek nem blokkoló API-kat használnak. Jobb méretezhetőséget biztosít, mint a klasszikus "kapcsolatonként egy szál" megközelítés.

Előfeltételek

A mintaalkalmazás megtekintése

Ebben a cikkben egy mintaalkalmazást fog kódni. Ha gyorsabban szeretne haladni, ez az alkalmazás már kódolt és elérhető a következő címen https://github.com/Azure-Samples/quickstart-spring-data-r2dbc-sql-server: .

A munkakörnyezet előkészítése

Először állítsa be a környezeti változókat az alábbi parancsokkal:

export AZ_RESOURCE_GROUP=database-workshop
export AZ_DATABASE_NAME=<YOUR_DATABASE_NAME>
export AZ_LOCATION=<YOUR_AZURE_REGION>
export AZ_SQL_SERVER_ADMIN_USERNAME=spring
export AZ_SQL_SERVER_ADMIN_PASSWORD=<YOUR_AZURE_SQL_ADMIN_PASSWORD>
export AZ_SQL_SERVER_NON_ADMIN_USERNAME=nonspring
export AZ_SQL_SERVER_NON_ADMIN_PASSWORD=<YOUR_AZURE_SQL_NON_ADMIN_PASSWORD>
export AZ_LOCAL_IP_ADDRESS=<YOUR_LOCAL_IP_ADDRESS>

A helyőrzőket írja felül a következő értékekkel, amelyeket a cikk teljes további részében használni fogunk:

  • <YOUR_DATABASE_NAME>: Az Azure SQL Database-kiszolgáló neve, amelynek egyedinek kell lennie az Azure-ban.
  • <YOUR_AZURE_REGION>: A használni kívánt Azure-régió. Használhatja az alapértelmezett eastus értéket, de ajánlott az Ön lakóhelyéhez közelebbi régiót konfigurálni. A rendelkezésre álló régiók teljes listáját a használatával az account list-locationstekintheti meg.
  • <AZ_SQL_SERVER_ADMIN_PASSWORD> és <AZ_SQL_SERVER_NON_ADMIN_PASSWORD>: Az Azure SQL Database-kiszolgáló jelszava, amelynek legalább nyolc karakterből kell lennie. A karaktereknek a következő kategóriák közül háromból kell állniuk: angol nagybetűk, angol kisbetűk, számok (0-9) és nem alfanumerikus karakterek (!, $, #, %stb.).
  • <YOUR_LOCAL_IP_ADDRESS>: A helyi számítógép IP-címe, amelyről a Spring Boot-alkalmazást fogja futtatni. Az egyik kényelmes módja annak, hogy megtalálja, hogy nyissa meg whatismyip.akamai.com.

Ezután hozzon létre egy erőforráscsoportot a következő paranccsal:

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

Azure SQL Database-példány létrehozása

Ezután hozzon létre egy felügyelt Azure SQL Database-kiszolgálópéldányt az alábbi parancs futtatásával.

Megjegyzés:

Az MS SQL-jelszónak meg kell felelnie bizonyos feltételeknek, és a beállítás nem megfelelő jelszóval meghiúsul. További információ: Jelszóházirend.

az sql server create \
    --resource-group $AZ_RESOURCE_GROUP \
    --name $AZ_DATABASE_NAME \
    --location $AZ_LOCATION \
    --admin-user $AZ_SQL_SERVER_ADMIN_USERNAME \
    --admin-password $AZ_SQL_SERVER_ADMIN_PASSWORD \
    --output tsv

Tűzfalszabály konfigurálása az Azure SQL Database-kiszolgálóhoz

Az Azure SQL Database-példányok alapértelmezés szerint védettek. Tűzfallal rendelkezik, amely semmilyen bejövő kapcsolatot sem engedélyez. Az adatbázis használatához hozzá kell adnia egy tűzfalszabályt, amely lehetővé teszi, hogy a helyi IP-cím hozzáférjen az adatbázis-kiszolgálóhoz.

Mivel a cikk elején konfigurálta a helyi IP-címet, az alábbi parancs futtatásával megnyithatja a kiszolgáló tűzfalát:

az sql server firewall-rule create \
    --resource-group $AZ_RESOURCE_GROUP \
    --name $AZ_DATABASE_NAME-database-allow-local-ip \
    --server $AZ_DATABASE_NAME \
    --start-ip-address $AZ_LOCAL_IP_ADDRESS \
    --end-ip-address $AZ_LOCAL_IP_ADDRESS \
    --output tsv

Ha windowsos számítógépen Linuxos Windows-alrendszer (WSL) keresztül csatlakozik az Azure SQL Database-kiszolgálóhoz, hozzá kell adnia a WSL-gazdagép azonosítóját a tűzfalhoz.

Szerezze be a gazdagép IP-címét a következő parancs WSL-ben való futtatásával:

cat /etc/resolv.conf

Másolja ki az IP-címet a kifejezés nameserverután, majd az alábbi paranccsal állítson be környezeti változót a WSL IP-címéhez:

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

Ezután a következő paranccsal nyissa meg a kiszolgáló tűzfalát a WSL-alapú alkalmazás számára:


az sql server firewall-rule create \
    --resource-group $AZ_RESOURCE_GROUP \
    --name $AZ_DATABASE_NAME-database-allow-local-ip-wsl \
    --server $AZ_DATABASE_NAME \
    --start-ip-address $AZ_WSL_IP_ADDRESS \
    --end-ip-address $AZ_WSL_IP_ADDRESS \
    --output tsv

Azure SQL-adatbázis konfigurálása

A korábban létrehozott Azure SQL Database-kiszolgáló üres. Nem tartalmaz a Spring Boot-alkalmazással használható adatokat. Hozzon létre egy új, az alábbi parancs futtatásával hívott demo adatbázist:

az sql db create \
    --resource-group $AZ_RESOURCE_GROUP \
    --name demo \
    --server $AZ_DATABASE_NAME \
    --output tsv

SQL-adatbázis létrehozása nem rendszergazdai felhasználóként, és engedély megadása

Ez a lépés létrehoz egy nem rendszergazdai felhasználót, és minden engedélyt megad az demo adatbázishoz.

Hozzon létre egy create_user.sql nevű SQL-szkriptet nem rendszergazdai felhasználó létrehozásához. Adja hozzá a következő tartalmat, és mentse helyileg:

cat << EOF > create_user.sql
USE demo;
GO
CREATE USER $AZ_SQL_SERVER_NON_ADMIN_USERNAME WITH PASSWORD='$AZ_SQL_SERVER_NON_ADMIN_PASSWORD'
GO
GRANT CONTROL ON DATABASE::demo TO $AZ_SQL_SERVER_NON_ADMIN_USERNAME;
GO
EOF

Ezután a következő paranccsal futtassa az SQL-szkriptet a nem rendszergazdai felhasználó létrehozásához:

sqlcmd -S $AZ_DATABASE_NAME.database.windows.net,1433  -d demo -U $AZ_SQL_SERVER_ADMIN_USERNAME -P $AZ_SQL_SERVER_ADMIN_PASSWORD  -i create_user.sql

Megjegyzés:

További információ az SQL-adatbázis felhasználóinak létrehozásáról: CREATE U Standard kiadás R (Transact-SQL).

Reaktív Spring Boot-alkalmazás létrehozása

Reaktív Spring Boot-alkalmazás létrehozásához a Spring Initializrt fogjuk használni. A létrehozható alkalmazás a következőket használja:

  • Spring Boot 2.7.11.
  • A következő függőségek: Spring Reactive Web (más néven Spring WebFlux) és Spring Data R2DBC.

Az alkalmazás generálása a Spring Initializr használatával

Hozza létre az alkalmazást a parancssorban a következő parancs futtatásával:

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 -

A reaktív Azure SQL Database-illesztő implementációjának hozzáadása

Nyissa meg a létrehozott projekt pom.xml fájlját, hogy hozzáadja a reaktív Azure SQL Database-illesztőt az r2dbc-mssql GitHub-adattárból.

A spring-boot-starter-webflux függőség után adja hozzá a következő szöveget:

<dependency>
    <groupId>io.r2dbc</groupId>
    <artifactId>r2dbc-mssql</artifactId>
    <scope>runtime</scope>
</dependency>

A Spring Boot konfigurálása az Azure SQL Database használatára

Nyissa meg az src/main/resources/application.properties fájlt, és adja hozzá a következő szöveget:

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

spring.r2dbc.url=r2dbc:pool:mssql://$AZ_DATABASE_NAME.database.windows.net:1433/demo
spring.r2dbc.username=nonspring@$AZ_DATABASE_NAME
spring.r2dbc.password=$AZ_SQL_SERVER_NON_ADMIN_PASSWORD

Cserélje le a két $AZ_DATABASE_NAME változót és a $AZ_SQL_SERVER_NON_ADMIN_PASSWORD változót a cikk elején konfigurált értékekre.

Megjegyzés:

A jobb teljesítmény érdekében a spring.r2dbc.url tulajdonság úgy van konfigurálva, hogy r2dbc-készlet használatával használjon kapcsolatkészletet.

Most már a megadott Maven burkolóval kell elindítania az alkalmazást az alábbiak szerint:

./mvnw spring-boot:run

Az alábbi képernyőkép az alkalmazás első futtatását ábrázolja:

Screenshot of the running application.

Az adatbázisséma létrehozása

A főosztályon DemoApplication belül konfiguráljon egy új Spring bean-t, amely létrehoz egy adatbázissémát az alábbi kód használatával:

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

Ez a Spring bean egy schema.sql nevű fájlt használ, ezért hozza létre a fájlt az src/main/resources mappában, és adja hozzá a következő szöveget:

DROP TABLE IF EXISTS todo;
CREATE TABLE todo (id INT IDENTITY PRIMARY KEY, description VARCHAR(255), details VARCHAR(4096), done BIT);

Állítsa le a futó alkalmazást, és indítsa újra az alábbi paranccsal. Az alkalmazás mostantól a korábban létrehozott demo adatbázist fogja használni, és létrehoz benne egy todo táblát.

./mvnw spring-boot:run

Az alábbi képernyőképen az adatbázistábla létrehozása közben látható:

Screenshot of the creation of the database table.

Az alkalmazás kódolása

Ezután adja hozzá azt a Java-kódot, amely az R2DBC használatával tárolja és kéri le az adatokat az Azure SQL Database-kiszolgálóról.

Hozzon létre egy új Todo Java-osztályt az DemoApplication osztály mellett a következő kóddal:

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

Ez az osztály egy tartománymodell, amely az előzőleg létrehozott todo táblára van leképezve.

Az osztály kezeléséhez egy adattárra van szükség. Adjon meg egy új TodoRepository felületet ugyanabban a csomagban a következő kóddal:

package com.example.demo;

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

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

Ez az adattár egy reaktív adattár, amelyet a Spring Data R2DBC kezel.

Fejezze be az alkalmazást egy olyan vezérlő létrehozásával, amely képes tárolni és lekérni az adatokat. Implementáljon ugyanebben a csomagban egy TodoController osztályt, és szúrja be az alábbi kódot:

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

Végül állítsa le az alkalmazást, és indítsa el újra az alábbi paranccsal:

./mvnw spring-boot:run

Az alkalmazás tesztelése

Az alkalmazást tesztelheti a cURL használatával.

Először hozzon létre egy új „todo“ elemet az adatbázisban az alábbi paranccsal:

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

Ennek a parancsnak a létrehozott elemet kell visszaadnia, ahogy az itt látható:

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

Ezután kérje le az adatokat egy új cURL-kéréssel a következő paranccsal:

curl http://127.0.0.1:8080

Ez a parancs a "teendő" elemek listáját adja vissza, beleértve a létrehozott elemet is, az itt látható módon:

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

Az alábbi cURL-kérelmek képernyőképe:

Screenshot of the cURL test.

Gratulálunk! Létrehozott egy teljesen reaktív Spring Boot-alkalmazást, amely R2DBC használatával tárolja és kéri le az adatokat az Azure SQL Database-ből.

Clean up resources

Az ebben a rövid útmutatóban használt összes erőforrás törléséhez törölje az erőforráscsoportot az alábbi paranccsal:

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

További lépések

A Spring Data-alkalmazások Azure Spring Appsben való üzembe helyezéséről és a felügyelt identitás használatáról további információt a következő oktatóanyagban talál : Spring-alkalmazás üzembe helyezése az Azure Spring Appsben jelszó nélküli kapcsolattal egy Azure-adatbázishoz.

Ha szeretne többet megtudni a Spring és az Azure szolgáltatásról, lépjen tovább a Spring on Azure dokumentációs központra.

A Spring használata az Azure-ban

Kapcsolódó információk

A Spring Data R2DBC-vel kapcsolatos további információkért tekintse meg a Spring referenciadokumentációját.

Az Azure Javával történő használatáról az Azure Java-fejlesztőknek és Az Azure DevOps és a Java használata című cikkek kínálnak bővebb információt.