A Spring Data R2DBC használata az Azure Database for PostgreSQL-lel
Ez a cikk bemutatja, hogyan hozhat létre egy mintaalkalmazást, amely a Spring Data R2DBC használatával tárol és kér le adatokat egy Azure Database for PostgreSQL-adatbázisban. A minta a PostgreSQL R2DBC-implementációját fogja használni a GitHub r2dbc-postgresql adattárábó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-postgresql: .
A munkakörnyezet előkészítése
Először állítson be néhány környezeti változót a következő parancsok futtatásával:
export AZ_RESOURCE_GROUP=database-workshop
export AZ_DATABASE_SERVER_NAME=<YOUR_DATABASE_SERVER_NAME>
export AZ_DATABASE_NAME=<YOUR_DATABASE_NAME>
export AZ_LOCATION=<YOUR_AZURE_REGION>
export AZ_POSTGRESQL_ADMIN_USERNAME=spring
export AZ_POSTGRESQL_ADMIN_PASSWORD=<YOUR_POSTGRESQL_ADMIN_PASSWORD>
export AZ_POSTGRESQL_NON_ADMIN_USERNAME=nonspring
export AZ_POSTGRESQL_NON_ADMIN_PASSWORD=<YOUR_POSTGRESQL_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_SERVER_NAME>
: A PostgreSQL-kiszolgáló neve, amelynek egyedinek kell lennie az Azure-ban.<YOUR_DATABASE_NAME>
: A PostgreSQL-kiszolgáló adatbázisneve, 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.<YOUR_POSTGRESQL_ADMIN_PASSWORD>
és<YOUR_POSTGRESQL_NON_ADMIN_PASSWORD>
: A PostgreSQL-adatbáziskiszolgá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 Database for PostgreSQL-példány létrehozása és a rendszergazdai felhasználó beállítása
Elsőként egy felügyelt PostgreSQL-kiszolgálót fog létrehozni egy rendszergazdai felhasználóval.
Megjegyzés:
A PostgreSQL-kiszolgálók létrehozásáról az Azure Portalon olvashat részletesebben az Azure Database for PostgreSQL-kiszolgáló létrehozásával kapcsolatban.
az postgres flexible-server create \
--resource-group $AZ_RESOURCE_GROUP \
--name $AZ_DATABASE_SERVER_NAME \
--location $AZ_LOCATION \
--admin-user $AZ_POSTGRESQL_ADMIN_USERNAME \
--admin-password $AZ_POSTGRESQL_ADMIN_PASSWORD \
--yes \
--output tsv
PostgreSQL-adatbázis konfigurálása
A korábban létrehozott PostgreSQL-kiszolgáló üres. Az alábbi paranccsal hozzon létre egy új adatbázist.
az postgres flexible-server db create \
--resource-group $AZ_RESOURCE_GROUP \
--database-name $AZ_DATABASE_NAME \
--server-name $AZ_DATABASE_SERVER_NAME \
--output tsv
Tűzfalszabály konfigurálása a PostgreSQL-kiszolgálóhoz
Az Azure Database for PostgreSQL-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 postgres flexible-server firewall-rule create \
--resource-group $AZ_RESOURCE_GROUP \
--name $AZ_DATABASE_SERVER_NAME \
--rule-name $AZ_DATABASE_SERVER_NAME-database-allow-local-ip \
--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 a PostgreSQL-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 postgres flexible-server firewall-rule create \
--resource-group $AZ_RESOURCE_GROUP \
--name $AZ_DATABASE_SERVER_NAME \
--rule-name $AZ_DATABASE_SERVER_NAME-database-allow-local-ip \
--start-ip-address $AZ_WSL_IP_ADDRESS \
--end-ip-address $AZ_WSL_IP_ADDRESS \
--output tsv
Nem rendszergazdai PostgreSQL-felhasználó létrehozása és engedély megadása
Ezután hozzon létre egy nem rendszergazdai felhasználót, és adjon meg minden engedélyt az adatbázisnak.
Megjegyzés:
A PostgreSQL-felhasználók létrehozásáról az Azure Database for PostgreSQL-ben a Felhasználók létrehozása szolgáltatásban olvashat részletesebben.
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
CREATE ROLE "$AZ_POSTGRESQL_NON_ADMIN_USERNAME" WITH LOGIN PASSWORD '$AZ_POSTGRESQL_NON_ADMIN_PASSWORD';
GRANT ALL PRIVILEGES ON DATABASE $AZ_DATABASE_NAME TO "$AZ_POSTGRESQL_NON_ADMIN_USERNAME";
EOF
Ezután az alábbi paranccsal futtassa az SQL-szkriptet a Microsoft Entra nem rendszergazdai felhasználójának létrehozásához:
psql "host=$AZ_DATABASE_SERVER_NAME.postgres.database.azure.com user=$AZ_POSTGRESQL_ADMIN_USERNAME dbname=$AZ_DATABASE_NAME port=5432 password=$AZ_POSTGRESQL_ADMIN_PASSWORD sslmode=require" < create_user.sql
Most az alábbi paranccsal távolítsa el az ideiglenes SQL-szkriptfájlt:
rm create_user.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ő paranccsal:
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 PostgreSQL-illesztő implementációjának hozzáadása
Nyissa meg a létrehozott projekt pom.xml fájlját, majd adja hozzá a reaktív PostgreSQL-illesztőt a GitHub r2dbc-postgresql-adattárábó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-postgresql</artifactId>
<version>0.8.12.RELEASE</version>
<scope>runtime</scope>
</dependency>
A Spring Boot konfigurálása az Azure Database for PostgreSQL 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:postgres://$AZ_DATABASE_SERVER_NAME.postgres.database.azure.com:5432/$AZ_DATABASE_NAME
spring.r2dbc.username=nonspring
spring.r2dbc.password=$AZ_POSTGRESQL_NON_ADMIN_PASSWORD
spring.r2dbc.properties.sslMode=REQUIRE
Cserélje le a $AZ_DATABASE_SERVER_NAME
, $AZ_DATABASE_NAME
és $AZ_POSTGRESQL_NON_ADMIN_PASSWORD
változókat a cikk elején konfigurált értékekre.
Figyelmeztetés
Biztonsági okokból az Azure Database for PostgreSQL-nek SSL-kapcsolatokat kell használnia. Ezért kell hozzáadnia a spring.r2dbc.properties.sslMode=REQUIRE
konfigurációs tulajdonságot, különben az R2DBC PostgreSQL-illesztő nem biztonságos kapcsolattal próbál csatlakozni, ami sikertelen lesz.
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 SERIAL PRIMARY KEY, description VARCHAR(255), details VARCHAR(4096), done BOOLEAN);
Á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 a PostgreSQL-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 Database for PostgreSQL-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: