Usando R2DBC

El proyecto Conectividad reactiva de bases de datos relacionales (R2DBC) lleva la API de programación reactiva a bases de datos relacionales. io.r2dbc.spi.Connection de R2DBC proporciona un método estándar para tratar con conexiones de bases de datos sin bloqueo. Las conexiones se pasan usando ConnectionFactory, similar a DataSource en jdbc.

La configuración de ConnectionFactory está controlada por propiedades de configuración externas de spring.r2dbc.*. Por ejemplo, podría declarar la siguiente sección en application.properties:

spring.r2dbc.url=r2dbc:postgresql://localhost/test
spring.r2dbc.nombre de usuario=dbuser
spring.r2dbc.password=dbpass

spring:
  r2dbc:
    url: "r2dbc:postgresql://localhost/test"
    username: "dbuser"
    password: "dbpass"

Para personalizar las conexiones creadas por ConnectionFactory, es decir, para establecer ciertos parámetros que no desea (o no puede) configurar en la configuración de su base de datos central, puede utilizar un anotación @Bean bean ConnectionFactoryOptionsBuilderCustomizer. El siguiente ejemplo muestra cómo anular manualmente el puerto de la base de datos mientras el resto de las configuraciones se toman de la configuración de la aplicación:

import io.r2dbc.spi.ConnectionFactoryOptions;
import org.springframework.boot.autoconfigure.r2dbc.ConnectionFactoryOptionsBuilderCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration(proxyBeanMethods = false)
public class MyR2dbcConfiguration {
    @Bean
    public ConnectionFactoryOptionsBuilderCustomizer connectionFactoryPortCustomizer() {
        return (builder) -> builder.option(ConnectionFactoryOptions.PORT, 5432);
    }
}

importar io.r2dbc.spi.ConnectionFactoryOptions
importar org.springframework.boot.autoconfigure.r2dbc.ConnectionFactoryOptionsBuilderCustomizer
importar org.springframework.context.annotation.Bean
importar org.springframework.context.annotation.Configuration
@Configuration(proxyBeanMethods = false)
clase Configuración MyR2dbc {
    @Frijol
    divertido ConnectionFactoryPortCustomizer(): ConnectionFactoryOptionsBuilderCustomizer {
        return ConnectionFactoryOptionsBuilderCustomizer { constructor ->
            opción.constructor(ConnectionFactoryOptions.PORT, 5432)
        }
    }
}

Los siguientes ejemplos muestran cómo configurar algunos parámetros de conexión PostgreSQL:

import java.util.HashMap;
import java.util.Map;
import io.r2dbc.postgresql.PostgresqlConnectionFactoryProvider;
import org.springframework.boot.autoconfigure.r2dbc.ConnectionFactoryOptionsBuilderCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration(proxyBeanMethods = false)
public class MyPostgresR2dbcConfiguration {
    @Bean
    public ConnectionFactoryOptionsBuilderCustomizer postgresCustomizer() {
        Map<String, String> options = new HashMap<>();
        options.put("lock_timeout", "30s");
        options.put("statement_timeout", "60s");
        return (builder) -> builder.option(PostgresqlConnectionFactoryProvider.OPTIONS, options);
    }
}

import io.r2dbc.postgresql.PostgresqlConnectionFactoryProvider
import org.springframework.boot.autoconfigure.r2dbc.ConnectionFactoryOptionsBuilderCustomizer
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
@Configuration(proxyBeanMethods = false)
class MyPostgresR2dbcConfiguration {
    @Bean
    fun postgresCustomizer(): ConnectionFactoryOptionsBuilderCustomizer {
        val options: MutableMap<String, String> = HashMap()
        options["lock_timeout"] = "30s"
        options["statement_timeout"] = "60s"
        return ConnectionFactoryOptionsBuilderCustomizer { builder ->
            builder.option(PostgresqlConnectionFactoryProvider.OPTIONS, options)
        }
    }
}

Si hay presente un bean ConnectionFactory, la configuración automática normal para DataSource desde JDBC está deshabilitada. Si necesita conservar la configuración automática para DataSource de JDBC y se siente cómodo con el riesgo de utilizar una API JDBC de bloqueo en una aplicación reactiva, agregue @Import(DataSourceAutoConfiguration.class) a la clase marcada con la anotación @Configuration, en tu aplicación para volver a habilitarla.

Soporte para bases de datos integradas

Al igual que la compatibilidad con JDBC, el marco Spring Boot puede configurar automáticamente la base de datos integrada para uso reactivo. No es necesario que proporcione ninguna URL de conexión. Solo necesita agregar una dependencia de compilación a la base de datos integrada que desea usar, como se muestra en el siguiente ejemplo:

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

Usando el cliente de base de datos

El bean DatabaseClient es autoconfigurable, pero puede vincularlo mediante la anotación @Autowire directamente a sus propios beans, como se muestra en el siguiente ejemplo:

import java.util.Map;
import reactor.core.publisher.Flux;
import org.springframework.r2dbc.core.DatabaseClient;
import org.springframework.stereotype.Component;
@Component
public class MyBean {
    private final DatabaseClient databaseClient;
    public MyBean(DatabaseClient databaseClient) {
        this.databaseClient = databaseClient;
    }
 // ...
 public Flux<Map<String, Object>> someMethod() {
        return this.databaseClient.sql("select * from user").fetch().all();
    }
}

import org.springframework.r2dbc.core.DatabaseClient
import org.springframework.stereotype.Component
import reactor.core.publisher.Flux
@Component
class MyBean(private val databaseClient: DatabaseClient) {
 // ...
 fun someMethod(): Flux<Map<String, Any>> {
        return databaseClient.sql("select * from user").fetch().all()
    }
}

Repositorios Spring Data R2DBC

Los repositorios Spring Data R2DBC son interfaces que se pueden definir para acceder a los datos. Las consultas se crean automáticamente en función de los nombres de los métodos. Por ejemplo, la interfaz CityRepository podría declarar un método findAllByState(String state) para buscar todas las ciudades en un estado determinado.

Para consultas más complejas, puede anotar el método utilizando la anotación Query de Spring Data.

Los repositorios de Spring Data normalmente se amplían utilizando las interfaces Repository o CrudRepository. Si utiliza la configuración automática, los repositorios se buscan desde el paquete que contiene la clase de configuración principal (la que está anotada con @EnableAutoConfiguration o @SpringBootApplication) y hacia abajo en la jerarquía.

El siguiente ejemplo muestra una definición de interfaz típica para interactuar con un repositorio de Spring Data:

import reactor.core.publisher.Mono;
import org.springframework.data.repository.Repository;
public interface CityRepository extends Repository<City, Long> {
    Mono<City> findByNameAndStateAllIgnoringCase(String name, String state);
}

import org.springframework.data.repository.Repository
import reactor.core.publisher.Mono
interface CityRepository : Repository<City?, Long?> {
    fun findByNameAndStateAllIgnoringCase(name: String?, state: String?): Mono<City?>?
}