Springboot 整合 r2dbc

最新推荐文章于 2024-08-19 08:52:55 发布
最新推荐文章于 2024-08-19 08:52:55 发布
阅读量1.3k 收藏
点赞数
分类专栏： spring boot 文章标签： spring boot java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiamaocheng/article/details/126964070
版权

r2dbc:
init 源码：

public class R2dbcScriptDatabaseInitializer extends AbstractScriptDatabaseInitializer {

	private final ConnectionFactory connectionFactory;

	/**
	 * Creates a new {@code R2dbcScriptDatabaseInitializer} that will initialize the
	 * database recognized by the given {@code connectionFactory} using the given
	 * {@code settings}.
	 * @param connectionFactory connectionFactory for the database
	 * @param settings initialization settings
	 */
	public R2dbcScriptDatabaseInitializer(ConnectionFactory connectionFactory,
			DatabaseInitializationSettings settings) {
		super(settings);
		this.connectionFactory = connectionFactory;
	}

	@Override
	protected boolean isEmbeddedDatabase() {
		return EmbeddedDatabaseConnection.isEmbedded(this.connectionFactory);
	}

	@Override
	protected void runScripts(List<Resource> scripts, boolean continueOnError, String separator, Charset encoding) {
		ResourceDatabasePopulator populator = new ResourceDatabasePopulator();
		populator.setContinueOnError(continueOnError);
		populator.setSeparator(separator);
		if (encoding != null) {
			populator.setSqlScriptEncoding(encoding.name());
		}
		for (Resource script : scripts) {
			populator.addScript(script);
		}
		populator.populate(this.connectionFactory).block();
	}

}

class R2dbcScriptDatabaseInitializerDetector extends AbstractBeansOfTypeDatabaseInitializerDetector {

	@Override
	protected Set<Class<?>> getDatabaseInitializerBeanTypes() {
		return Collections.singleton(R2dbcScriptDatabaseInitializer.class);
	}

}

R2DBCScirpt 的方法：

private static final OptionsCapableWrapper optionsCapableWrapper;

	static {
		if (ClassUtils.isPresent("io.r2dbc.pool.ConnectionPool", ConnectionFactoryBuilder.class.getClassLoader())) {
			optionsCapableWrapper = new PoolingAwareOptionsCapableWrapper();
		}
		else {
			optionsCapableWrapper = new OptionsCapableWrapper();
		}
	}

	private static final String COLON = ":";

	private final Builder optionsBuilder;

	private ConnectionFactoryBuilder(Builder optionsBuilder) {
		this.optionsBuilder = optionsBuilder;
	}

	/**
	 * Initialize a new {@link ConnectionFactoryBuilder} based on the specified R2DBC url.
	 * @param url the url to use
	 * @return a new builder initialized with the options exposed in the specified url
	 * @see EmbeddedDatabaseConnection#getUrl(String)
	 */
	public static ConnectionFactoryBuilder withUrl(String url) {
		Assert.hasText(url, () -> "Url must not be null");
		return withOptions(ConnectionFactoryOptions.parse(url).mutate());
	}

	/**
	 * Initialize a new {@link ConnectionFactoryBuilder} based on the specified
	 * {@link Builder options}.
	 * @param options the options to use to initialize the builder
	 * @return a new builder initialized with the settings defined in the given
	 * {@link Builder options}
	 */
	public static ConnectionFactoryBuilder withOptions(Builder options) {
		return new ConnectionFactoryBuilder(options);
	}

	/**
	 * Initialize a new {@link ConnectionFactoryBuilder} derived from the options of the
	 * specified {@code connectionFactory}.
	 * @param connectionFactory the connection factory whose options are to be used to
	 * initialize the builder
	 * @return a new builder initialized with the options from the connection factory
	 * @since 2.5.1
	 */
	public static ConnectionFactoryBuilder derivedFrom(ConnectionFactory connectionFactory) {
		ConnectionFactoryOptions options = extractOptionsIfPossible(connectionFactory);
		if (options == null) {
			throw new IllegalArgumentException(
					"ConnectionFactoryOptions could not be extracted from " + connectionFactory);
		}
		return withOptions(options.mutate());
	}

	private static ConnectionFactoryOptions extractOptionsIfPossible(ConnectionFactory connectionFactory) {
		OptionsCapableConnectionFactory optionsCapable = OptionsCapableConnectionFactory.unwrapFrom(connectionFactory);
		if (optionsCapable != null) {
			return optionsCapable.getOptions();
		}
		return null;
	}

	/**
	 * Configure additional options.
	 * @param options a {@link Consumer} to customize the options
	 * @return this for method chaining
	 */
	public ConnectionFactoryBuilder configure(Consumer<Builder> options) {
		options.accept(this.optionsBuilder);
		return this;
	}

	/**
	 * Configure the {@linkplain ConnectionFactoryOptions#USER username}.
	 * @param username the connection factory username
	 * @return this for method chaining
	 */
	public ConnectionFactoryBuilder username(String username) {
		return configure((options) -> options.option(ConnectionFactoryOptions.USER, username));
	}

	/**
	 * Configure the {@linkplain ConnectionFactoryOptions#PASSWORD password}.
	 * @param password the connection factory password
	 * @return this for method chaining
	 */
	public ConnectionFactoryBuilder password(CharSequence password) {
		return configure((options) -> options.option(ConnectionFactoryOptions.PASSWORD, password));
	}

	/**
	 * Configure the {@linkplain ConnectionFactoryOptions#HOST host name}.
	 * @param host the connection factory hostname
	 * @return this for method chaining
	 */
	public ConnectionFactoryBuilder hostname(String host) {
		return configure((options) -> options.option(ConnectionFactoryOptions.HOST, host));
	}

	/**
	 * Configure the {@linkplain ConnectionFactoryOptions#PORT port}.
	 * @param port the connection factory port
	 * @return this for method chaining
	 */
	public ConnectionFactoryBuilder port(int port) {
		return configure((options) -> options.option(ConnectionFactoryOptions.PORT, port));
	}

	/**
	 * Configure the {@linkplain ConnectionFactoryOptions#DATABASE database}.
	 * @param database the connection factory database
	 * @return this for method chaining
	 */
	public ConnectionFactoryBuilder database(String database) {
		return configure((options) -> options.option(ConnectionFactoryOptions.DATABASE, database));
	}

	/**
	 * Build a {@link ConnectionFactory} based on the state of this builder.
	 * @return a connection factory
	 */
	public ConnectionFactory build() {
		ConnectionFactoryOptions options = buildOptions();
		return optionsCapableWrapper.buildAndWrap(options);
	}

	/**
	 * Build a {@link ConnectionFactoryOptions} based on the state of this builder.
	 * @return the options
	 */
	public ConnectionFactoryOptions buildOptions() {
		return this.optionsBuilder.build();
	}

	private static class OptionsCapableWrapper {

		ConnectionFactory buildAndWrap(ConnectionFactoryOptions options) {
			ConnectionFactory connectionFactory = ConnectionFactories.get(options);
			return new OptionsCapableConnectionFactory(options, connectionFactory);
		}

	}

	static final class PoolingAwareOptionsCapableWrapper extends OptionsCapableWrapper {

		private final PoolingConnectionFactoryProvider poolingProvider = new PoolingConnectionFactoryProvider();

		@Override
		ConnectionFactory buildAndWrap(ConnectionFactoryOptions options) {
			if (!this.poolingProvider.supports(options)) {
				return super.buildAndWrap(options);
			}
			ConnectionFactoryOptions delegateOptions = delegateFactoryOptions(options);
			ConnectionFactory connectionFactory = super.buildAndWrap(delegateOptions);
			ConnectionPoolConfiguration poolConfiguration = connectionPoolConfiguration(delegateOptions,
					connectionFactory);
			return new ConnectionPool(poolConfiguration);
		}

		private ConnectionFactoryOptions delegateFactoryOptions(ConnectionFactoryOptions options) {
			String protocol = toString(options.getRequiredValue(ConnectionFactoryOptions.PROTOCOL));
			if (protocol.trim().length() == 0) {
				throw new IllegalArgumentException(String.format("Protocol %s is not valid.", protocol));
			}
			String[] protocols = protocol.split(COLON, 2);
			String driverDelegate = protocols[0];
			String protocolDelegate = (protocols.length != 2) ? "" : protocols[1];
			return ConnectionFactoryOptions.builder().from(options)
					.option(ConnectionFactoryOptions.DRIVER, driverDelegate)
					.option(ConnectionFactoryOptions.PROTOCOL, protocolDelegate).build();
		}

		@SuppressWarnings("unchecked")
		ConnectionPoolConfiguration connectionPoolConfiguration(ConnectionFactoryOptions options,
				ConnectionFactory connectionFactory) {
			ConnectionPoolConfiguration.Builder builder = ConnectionPoolConfiguration.builder(connectionFactory);
			PropertyMapper map = PropertyMapper.get().alwaysApplyingWhenNonNull();
			map.from(options.getValue(PoolingConnectionFactoryProvider.BACKGROUND_EVICTION_INTERVAL))
					.as(this::toDuration).to(builder::backgroundEvictionInterval);
			map.from(options.getValue(PoolingConnectionFactoryProvider.INITIAL_SIZE)).as(this::toInteger)
					.to(builder::initialSize);
			map.from(options.getValue(PoolingConnectionFactoryProvider.MAX_SIZE)).as(this::toInteger)
					.to(builder::maxSize);
			map.from(options.getValue(PoolingConnectionFactoryProvider.ACQUIRE_RETRY)).as(this::toInteger)
					.to(builder::acquireRetry);
			map.from(options.getValue(PoolingConnectionFactoryProvider.MAX_LIFE_TIME)).as(this::toDuration)
					.to(builder::maxLifeTime);
			map.from(options.getValue(PoolingConnectionFactoryProvider.MAX_ACQUIRE_TIME)).as(this::toDuration)
					.to(builder::maxAcquireTime);
			map.from(options.getValue(PoolingConnectionFactoryProvider.MAX_IDLE_TIME)).as(this::toDuration)
					.to(builder::maxIdleTime);
			map.from(options.getValue(PoolingConnectionFactoryProvider.MAX_CREATE_CONNECTION_TIME)).as(this::toDuration)
					.to(builder::maxCreateConnectionTime);
			map.from(options.getValue(PoolingConnectionFactoryProvider.POOL_NAME)).as(this::toString).to(builder::name);
			map.from(options.getValue(PoolingConnectionFactoryProvider.PRE_RELEASE)).to((function) -> builder
					.preRelease((Function<? super Connection, ? extends Publisher<Void>>) function));
			map.from(options.getValue(PoolingConnectionFactoryProvider.POST_ALLOCATE)).to((function) -> builder
					.postAllocate((Function<? super Connection, ? extends Publisher<Void>>) function));
			map.from(options.getValue(PoolingConnectionFactoryProvider.REGISTER_JMX)).as(this::toBoolean)
					.to(builder::registerJmx);
			map.from(options.getValue(PoolingConnectionFactoryProvider.VALIDATION_QUERY)).as(this::toString)
					.to(builder::validationQuery);
			map.from(options.getValue(PoolingConnectionFactoryProvider.VALIDATION_DEPTH)).as(this::toValidationDepth)
					.to(builder::validationDepth);
			return builder.build();
		}

		private String toString(Object object) {
			return toType(String.class, object, String::valueOf);
		}

		private Integer toInteger(Object object) {
			return toType(Integer.class, object, Integer::valueOf);
		}

		private Duration toDuration(Object object) {
			return toType(Duration.class, object, Duration::parse);
		}

		private Boolean toBoolean(Object object) {
			return toType(Boolean.class, object, Boolean::valueOf);
		}

		private ValidationDepth toValidationDepth(Object object) {
			return toType(ValidationDepth.class, object,
					(string) -> ValidationDepth.valueOf(string.toUpperCase(Locale.ENGLISH)));
		}

		private <T> T toType(Class<T> type, Object object, Function<String, T> converter) {
			if (type.isInstance(object)) {
				return type.cast(object);
			}
			if (object instanceof String string) {
				return converter.apply(string);
			}
			throw new IllegalArgumentException("Cannot convert '" + object + "' to " + type.getName());
		}

	}

}

public enum EmbeddedDatabaseConnection {

	/**
	 * No Connection.
	 */
	NONE(null, null, (options) -> false),

	/**
	 * H2 Database Connection.
	 */
	H2("io.r2dbc.h2.H2ConnectionFactoryProvider", "r2dbc:h2:mem:///%s?options=DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE",
			(options) -> options.getValue(ConnectionFactoryOptions.DRIVER).equals("h2")
					&& options.getValue(ConnectionFactoryOptions.PROTOCOL).equals("mem"));

	private final String driverClassName;

	private final String url;

	private Predicate<ConnectionFactoryOptions> embedded;

	EmbeddedDatabaseConnection(String driverClassName, String url, Predicate<ConnectionFactoryOptions> embedded) {
		this.driverClassName = driverClassName;
		this.url = url;
		this.embedded = embedded;
	}

	/**
	 * Returns the driver class name.
	 * @return the driver class name
	 */
	public String getDriverClassName() {
		return this.driverClassName;
	}

	/**
	 * Returns the R2DBC URL for the connection using the specified {@code databaseName}.
	 * @param databaseName the name of the database
	 * @return the connection URL
	 */
	public String getUrl(String databaseName) {
		Assert.hasText(databaseName, "DatabaseName must not be empty");
		return (this.url != null) ? String.format(this.url, databaseName) : null;
	}

	/**
	 * Returns the most suitable {@link EmbeddedDatabaseConnection} for the given class
	 * loader.
	 * @param classLoader the class loader used to check for classes
	 * @return an {@link EmbeddedDatabaseConnection} or {@link #NONE}.
	 */
	public static EmbeddedDatabaseConnection get(ClassLoader classLoader) {
		for (EmbeddedDatabaseConnection candidate : EmbeddedDatabaseConnection.values()) {
			if (candidate != NONE && ClassUtils.isPresent(candidate.getDriverClassName(), classLoader)) {
				return candidate;
			}
		}
		return NONE;
	}

	/**
	 * Convenience method to determine if a given connection factory represents an
	 * embedded database type.
	 * @param connectionFactory the connection factory to interrogate
	 * @return true if the connection factory represents an embedded database
	 * @since 2.5.1
	 */
	public static boolean isEmbedded(ConnectionFactory connectionFactory) {
		OptionsCapableConnectionFactory optionsCapable = OptionsCapableConnectionFactory.unwrapFrom(connectionFactory);
		Assert.notNull(optionsCapable,
				() -> "Cannot determine database's type as ConnectionFactory is not options-capable. To be "
						+ "options-capable, a ConnectionFactory should be created with "
						+ ConnectionFactoryBuilder.class.getName());
		ConnectionFactoryOptions options = optionsCapable.getOptions();
		for (EmbeddedDatabaseConnection candidate : values()) {
			if (candidate.embedded.test(options)) {
				return true;
			}
		}
		return false;

	}

}


public class OptionsCapableConnectionFactory implements Wrapped<ConnectionFactory>, ConnectionFactory {

	private final ConnectionFactoryOptions options;

	private final ConnectionFactory delegate;

	/**
	 * Create a new {@code OptionsCapableConnectionFactory} that will provide access to
	 * the given {@code options} that were used to build the given {@code delegate}
	 * {@link ConnectionFactory}.
	 * @param options the options from which the connection factory was built
	 * @param delegate the delegate connection factory that was built with options
	 */
	public OptionsCapableConnectionFactory(ConnectionFactoryOptions options, ConnectionFactory delegate) {
		this.options = options;
		this.delegate = delegate;
	}

	public ConnectionFactoryOptions getOptions() {
		return this.options;
	}

	@Override
	public Publisher<? extends Connection> create() {
		return this.delegate.create();
	}

	@Override
	public ConnectionFactoryMetadata getMetadata() {
		return this.delegate.getMetadata();
	}

	@Override
	public ConnectionFactory unwrap() {
		return this.delegate;
	}

	/**
	 * Returns, if possible, an {@code OptionsCapableConnectionFactory} by unwrapping the
	 * given {@code connectionFactory} as necessary. If the given
	 * {@code connectionFactory} does not wrap an {@code OptionsCapableConnectionFactory}
	 * and is not itself an {@code OptionsCapableConnectionFactory}, {@code null} is
	 * returned.
	 * @param connectionFactory the connection factory to unwrap
	 * @return the {@code OptionsCapableConnectionFactory} or {@code null}
	 * @since 2.5.1
	 */
	public static OptionsCapableConnectionFactory unwrapFrom(ConnectionFactory connectionFactory) {
		if (connectionFactory instanceof OptionsCapableConnectionFactory) {
			return (OptionsCapableConnectionFactory) connectionFactory;
		}
		if (connectionFactory instanceof Wrapped) {
			Object unwrapped = ((Wrapped<?>) connectionFactory).unwrap();
			if (unwrapped instanceof ConnectionFactory) {
				return unwrapFrom((ConnectionFactory) unwrapped);
			}
		}
		return null;

	}

}

R2DBC 是 "Reactive Relational Database Connectivity"的简称。
R2DBC 是一个 API 规范的倡议，声明对于访问关系型数据库驱动实现了一些响应式的API。
R2DBC的诞生为了非阻塞的应用栈， 使用很少的线程可以处理大量的并发同时减少硬件资源。大量的应用还是使用的关系型数据库，然而很多 NoSQL 数据提供了响应式客户端，并不是所有的项目都适合迁移到 NoSQL。因此，R2DBC 应运而生。

R2DBC 特点
对于 R2DBC 的驱动实例，Spring 支持基于Java 的@Connfiguration的配置
R2dbcEntityTemplate 作为实体绑定的核心操作类
整合了Spring Conversion Service 丰富的对象映射
基于注解元数据映射关系
自动实现 Reposity 接口，包含支持自定义的查询方法

方法：

import com.example.springreactivedemo.model.Person;
import io.r2dbc.spi.ConnectionFactories;
import io.r2dbc.spi.ConnectionFactory;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
import reactor.test.StepVerifier;

public class Test1 {

    private static final Log log = LogFactory.getLog(Test1.class);

    public static void main(String[] args) {
        ConnectionFactory connectionFactory = ConnectionFactories.get("r2dbc:h2:mem:///test?options=DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE");


        R2dbcEntityTemplate template = new R2dbcEntityTemplate(connectionFactory);

        template.getDatabaseClient().sql("CREATE TABLE person" +
                        "(id VARCHAR(255) PRIMARY KEY," +
                        "name VARCHAR(255)," +
                        "age INT)")
                .fetch()
                .rowsUpdated()
                .as(StepVerifier::create)
                .expectNextCount(1)
                .verifyComplete();

        template.insert(Person.class)
                .using(new Person("joe", "Joe", 34))
                .as(StepVerifier::create)
                .expectNextCount(1)
                .verifyComplete();

        template.select(Person.class)
                .first()
                .doOnNext(it -> log.info(it))
                .as(StepVerifier::create)
                .expectNextCount(1)
                .verifyComplete();
    }
}
执于代码
关注
专栏目录
【项目实战】WebFlux整合r2dbc-mysql实战
本本本添哥
03-02 1504
R2DBC全称Reactive Relational Database Connectivity，也就是反应式关系型数据库连接。R2DBC是基于Reactive Streams标准来设计的。通过使用R2DBC，你可以使用reactive API来操作数据。
Spring Boot整合WebFlux + R2DBC+Mysql
xiaopengJava的博客
04-07 1791
R2DBC 基于 Reactive Streams 反应流规范，它是一个开放的规范，为驱动程序供应商和使用方提供接口（ r2dbc-spi ），与 JDBC 的阻塞特性不同，它提供了完全反应式的非阻塞 API 与 关系型数据库 交互。简单说， R2DBC 项目是支持使用反应式编程 API 访问关系型数据库的桥梁，定义统一接口规范，不同数据库厂家通过实现该规范提供驱动程序包。
springboot-r2dbc-study:Spring启动R2dbc研究
04-10
R2dbc MySQL测试 服务器应用程序为R2dbc + MySQL测试提供简单的API 环境 开发环境：Mac，Java 11 终端命令的执行基于项目的根文件夹 数据库设置 必需：docker-compose可用环境 # Start Mysql instance $ docker-compose -f ./docker/mysql/docker-compose.yml up -d # Set DB Scheme $ ./mvnw -Dflyway.configFiles=src/main/resources/db/migration/flyway.conf flyway:migrate 运行Spring Boot $ ./mvnw spring-boot:run
79、SpringBoot 整合 R2DBC --- R2DBC 就是 JDBC 的 反应式版本， R2DBC 是 JDBC 的升级版。
Java 领域技术分享
09-21 3042
SpringBoot 整合 R2DBC --- R2DBC 就是 JDBC 的 反应式版本， R2DBC 是 JDBC 的升级版。
SpringBoot响应式编程（3）R2DBC
最新发布
qq_62377885的博客
08-19 1238
Bean//1-1： 结合自定义 Converter。
（七）springboot实战——springboot3集成R2DBC实现webflux响应式编程服务案例
厉害哥哥的博客
01-26 1588
本节主要内容是关于使用新版springboot3集成响应式数据库R2DBC,完成响应式web服务案例。需要注意的是，此次项目使用的JDK版本是JDK17，springboot版本使用3.2.2版本。WebFlux 是一个基于响应式编程模型的框架，适用于构建异步、非阻塞的高性能 Web 应用程序。它具有高并发能力、函数式编程风格、与其他 Spring 框架的集成能力等优势，可以满足对性能要求高或需要处理大量并发请求的场景。
SpringBoot整合 R2DBC
qq_63438013的博客
03-10 643
1、导入R2DBC依赖。
响应式编程——R2DBC
weixin_50458070的博客
01-24 481
Web、网络、IO（存储）、中间件（Redis、MySQL）
R2DBC，最新java下载教程
m0_64867003的博客
12-10 211
官方文档：https://docs.spring.io/spring-data/r2dbc/docs/1.1.0.RELEASE/reference/html/#r2dbc.datbaseclient.fluent-api 1.简介(摘自官网) R2DBC是 Reactive Relational Database Connectivity 的首字母缩写词。R2DBC 是一个 API 规范倡议，它声明了一个响应式 API，由驱动程序供应商实现以访问他们的关系数据库。 关于为什么创建 R2DBC.
R2DBC，手持4个大厂offer的我
m0_64867896的博客
12-22 338
R2DBC是 Reactive Relational Database Connectivity 的首字母缩写词。R2DBC 是一个 API 规范倡议，它声明了一个响应式 API，由驱动程序供应商实现以访问他们的关系数据库。 关于为什么创建 R2DBC 的部分答案是需要一个非阻塞应用程序堆栈来处理具有少量线程的并发并使用较少的硬件资源进行扩展。重用标准化的关系数据库访问 API（即 JDBC）无法满足这种需求，因为 JDBC 是一个完全阻塞的 API。尝试使用 a 来补偿阻塞行为ThreadPoo..
redis devops(二) springboot 2.4.2 集成r2dbc
markren的博客
12-21 1774
Spring boot 开发 本节内容的版本声明: <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding> <java.version&
SpringBoot 2 使用 R2DBC 来并发访问关系型数据库
纽雪澳诺加海美德的博客
03-26 8936
开篇词 该指南将引导你构建使用 Spring Data R2DBC 反应式数据库驱动在关系数据库中存储和检索数据的应用。   你将创建的应用 我们将构建一个应用，该应用将 Customer POJO（经典的 Java 对象）存储在基于内存的数据库中。   你将需要的工具 大概 15 分钟左右； 你最喜欢的文本编辑器或集成开发环境（IDE） JDK 1.8 或更高版本； Gra...
springboot3+r2dbc——响应式编程实践
麒思妙想
02-11 4181
Spring boot3已经M1了，最近群佬们也开始蠢蠢欲动的开始整活Reactive+Spring Boot3,跟着大家的步伐，我也来整一篇工程入门，我们将用java17+Spring Boot3+r2dbc+Reactive栈来讲述，欢迎大家来讨论。（关于响应式，请大家异步到之前的文章里，有详细介绍。） r2dbc Reactor还有基于其之上的Spring WebFlux框架。包括vert.x，rxjava等等reactive技术。我们实际上在应用层已经有很多优秀的响应式处理框架。 但是有一个问题就.
SpringBoot 官方文档示例：(68)使用R2DBC操作Postgresql
amadeus_liu2的博客
02-05 1797
boot
Spring Data R2DBC 1.0 M2 and Spring Boot starter released
BLOG域名:programb.blog.csdn.net
05-14 476
Releases Mark Paluch May 15, 2019 Spring Data R2DBC On behalf of the community and everyone who contributed, I’m delighted to announce the availability of the second milestone of Spring Data R2DBC 1.0. It is based on the recently released Moore M4 release
Spring Data R2DBC
BLOG域名:programb.blog.csdn.net
03-26 420
Spring Data R2DBC, part of the larger Spring Data family, makes it easy to implement R2DBC based repositories. R2DBC stands for Reactive Relational Database Connectivity, an incubator to integrate rel...
Spring Framework：使用R2DBC进行数据访问
听海边涛声
03-16 1203
Spring Framework：使用R2DBC进行数据访问
R2DBC在spring boot 2.3.7版本下多主键CRUD的方式
markren的博客
11-06 628
很久没写博客了，因为又被拉去带搞spring了！ 本文内容基于spring boot 2.3.7.RELEASE。 R2DBC接入在1月份的文章有讲，但是注意版本差异，后面的版本R2DBC从整个包都发生了迁移。选择2.3.7是因为这是能比较好适配nacos的最高版本的spring boot。在spring cloud alibaba下，对新版本的兼容是非常滞后的。题外话！ R2DBC ReactiveCrudRepository 并不支持多主键（至少在2.3.7我没有找到支持的方式）。第一个，你就找不到合适
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

执于代码

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值