A Spring Data R2DBC használata az Azure SQL Database-lel
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
Azure-előfizetés – hozzon létre egyet ingyenesen.
Java Development Kit (JDK), 8-es vagy újabb verzió.
cURL vagy hasonló HTTP-segédprogram a funkciók teszteléséhez.
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értelmezetteastus
é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ávalaz account list-locations
tekintheti 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 nameserver
utá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:
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ó:
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:
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.
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.
Visszajelzés
https://aka.ms/ContentUserFeedback.
Hamarosan elérhető: 2024-ben fokozatosan kivezetjük a GitHub-problémákat a tartalom visszajelzési mechanizmusaként, és lecseréljük egy új visszajelzési rendszerre. További információ:Visszajelzés küldése és megtekintése a következőhöz: