Spring/spring-integration
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Fix compatibility with Reactor & Spring Data

Browse Source
This commit is contained in:
Artem Bilan
2020-08-05 15:33:24 -04:00
parent acdc25a172
commit cd63763bb4
18 changed files with 213 additions and 186 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
build.gradle
View File

@@ -645,6 +645,7 @@ project('spring-integration-r2dbc') {
api ('org.springframework.data:spring-data-r2dbc') {
exclude group: 'org.springframework'
}
api 'org.springframework:spring-r2dbc'
testImplementation "io.r2dbc:r2dbc-h2:$r2dbch2Version"
}
}

15
spring-integration-core/src/main/java/org/springframework/integration/channel/FluxMessageChannel.java
View File

@@ -25,9 +25,8 @@ import org.springframework.util.Assert;
import reactor.core.Disposable;
import reactor.core.Disposables;
import reactor.core.publisher.Flux;
import reactor.core.publisher.FluxIdentityProcessor;
import reactor.core.publisher.FluxProcessor;
import reactor.core.publisher.FluxSink;
import reactor.core.publisher.Processors;
import reactor.core.publisher.Sinks;
import reactor.core.scheduler.Schedulers;
@@ -44,17 +43,17 @@ import reactor.core.scheduler.Schedulers;
public class FluxMessageChannel extends AbstractMessageChannel
implements Publisher<Message<?>>, ReactiveStreamsSubscribableChannel {
private final FluxIdentityProcessor<Message<?>> processor;
private final FluxProcessor<Message<?>, Message<?>> processor;
private final FluxSink<Message<?>> sink;
private final Sinks.StandaloneFluxSink<Boolean> subscribedSignal = Sinks.replay(1);
private final Sinks.Many<Boolean> subscribedSignal = Sinks.many().replay().limit(1);
private final Disposable.Composite upstreamSubscriptions = Disposables.composite();
@SuppressWarnings("deprecation")
public FluxMessageChannel() {
this.processor = Processors.more().multicast(1, false);
this.processor = FluxProcessor.fromSink(Sinks.many().multicast().onBackpressureBuffer(1, false));
this.sink = this.processor.sink(FluxSink.OverflowStrategy.BUFFER);
}
@@ -69,9 +68,9 @@ public class FluxMessageChannel extends AbstractMessageChannel
@Override
public void subscribe(Subscriber<? super Message<?>> subscriber) {
this.processor
.doFinally((s) -> this.subscribedSignal.next(this.processor.hasDownstreams()))
.doFinally((s) -> this.subscribedSignal.emitNext(this.processor.hasDownstreams()))
.subscribe(subscriber);
this.subscribedSignal.next(this.processor.hasDownstreams());
this.subscribedSignal.emitNext(this.processor.hasDownstreams());
}
@Override
@@ -93,7 +92,7 @@ public class FluxMessageChannel extends AbstractMessageChannel
@Override
public void destroy() {
this.subscribedSignal.next(false);
this.subscribedSignal.emitNext(false);
this.upstreamSubscriptions.dispose();
this.processor.onComplete();
super.destroy();

22
spring-integration-core/src/main/java/org/springframework/integration/dsl/Transformers.java
View File

@@ -319,22 +319,20 @@ public abstract class Transformers {
return Flux.from(publisher)
.flatMap(message ->
Mono.subscriberContext()
.map(ctx -> {
ctx.get(RequestMessageHolder.class).set(message);
return message;
}))
Mono.deferContextual(ctx -> {
ctx.get(RequestMessageHolder.class).set(message);
return Mono.just(message);
}))
.transform(fluxFunction)
.flatMap(data ->
data instanceof Message<?>
? Mono.just((Message<O>) data)
: Mono.subscriberContext()
.map(ctx -> ctx.get(RequestMessageHolder.class).get())
.map(requestMessage ->
MessageBuilder.withPayload(data)
.copyHeaders(requestMessage.getHeaders())
.build()))
.subscriberContext(ctx -> ctx.put(RequestMessageHolder.class, new RequestMessageHolder()));
: Mono.deferContextual(ctx -> Mono.just(ctx.get(RequestMessageHolder.class).get()))
.map(requestMessage ->
MessageBuilder.withPayload(data)
.copyHeaders(requestMessage.getHeaders())
.build()))
.contextWrite(ctx -> ctx.put(RequestMessageHolder.class, new RequestMessageHolder()));
}

2
spring-integration-core/src/main/java/org/springframework/integration/endpoint/ReactiveMessageSourceProducer.java
View File

@@ -47,7 +47,7 @@ public class ReactiveMessageSourceProducer extends MessageProducerSupport {
Assert.notNull(messageSource, "'messageSource' must not be null");
this.messageFlux =
IntegrationReactiveUtils.messageSourceToFlux(messageSource)
.subscriberContext((ctx) ->
.contextWrite((ctx) ->
ctx.put(IntegrationReactiveUtils.DELAY_WHEN_EMPTY_KEY, this.delayWhenEmpty));
}

34
spring-integration-core/src/main/java/org/springframework/integration/endpoint/ReactiveStreamsConsumer.java
View File

@@ -39,6 +39,7 @@ import org.springframework.util.ErrorHandler;
import reactor.core.CoreSubscriber;
import reactor.core.Disposable;
import reactor.core.publisher.BaseSubscriber;
import reactor.core.publisher.Flux;
@@ -172,17 +173,28 @@ public class ReactiveStreamsConsumer extends AbstractEndpoint implements Integra
else if (this.subscriber != null) {
this.subscription =
Flux.from(this.publisher)
.subscribe((data) -> {
try {
this.subscriber.onNext(data);
}
catch (Exception ex) {
this.errorHandler.handleError(ex);
}
},
null,
this.subscriber::onComplete,
this.subscriber::onSubscribe);
.subscribeWith(new BaseSubscriber<Message<?>>() {
@Override
protected void hookOnSubscribe(Subscription subscription) {
ReactiveStreamsConsumer.this.subscriber.onSubscribe(subscription);
}
@Override
protected void hookOnNext(Message<?> value) {
try {
ReactiveStreamsConsumer.this.subscriber.onNext(value);
}
catch (Exception ex) {
ReactiveStreamsConsumer.this.errorHandler.handleError(ex);
}
}
@Override
protected void hookOnComplete() {
ReactiveStreamsConsumer.this.subscriber.onComplete();
}
});
}
}

21
spring-integration-core/src/main/java/org/springframework/integration/util/IntegrationReactiveUtils.java
View File

@@ -31,9 +31,8 @@ import org.springframework.messaging.PollableChannel;
import org.springframework.messaging.SubscribableChannel;
import reactor.core.publisher.Flux;
import reactor.core.publisher.FluxIdentityProcessor;
import reactor.core.publisher.Mono;
import reactor.core.publisher.Processors;
import reactor.core.publisher.Sinks;
import reactor.core.scheduler.Schedulers;
/**
@@ -75,8 +74,7 @@ public final class IntegrationReactiveUtils {
public static <T> Flux<Message<T>> messageSourceToFlux(MessageSource<T> messageSource) {
return Mono.
<Message<T>>create(monoSink ->
monoSink.onRequest(value ->
monoSink.success(messageSource.receive())))
monoSink.onRequest(value -> monoSink.success(messageSource.receive())))
.doOnSuccess((message) ->
AckUtils.autoAck(StaticMessageHeaderAccessor.getAcknowledgmentCallback(message)))
.doOnError(MessagingException.class,
@@ -89,10 +87,9 @@ public final class IntegrationReactiveUtils {
.subscribeOn(Schedulers.boundedElastic())
.repeatWhenEmpty((repeat) ->
repeat.flatMap((increment) ->
Mono.subscriberContext()
.flatMap(ctx ->
Mono.delay(ctx.getOrDefault(DELAY_WHEN_EMPTY_KEY,
DEFAULT_DELAY_WHEN_EMPTY)))))
Mono.deferContextual(ctx ->
Mono.delay(ctx.getOrDefault(DELAY_WHEN_EMPTY_KEY,
DEFAULT_DELAY_WHEN_EMPTY)))))
.repeat()
.retry();
}
@@ -102,7 +99,7 @@ public final class IntegrationReactiveUtils {
* - a {@link org.springframework.integration.channel.FluxMessageChannel}
* is returned as is because it is already a {@link Publisher};
* - a {@link SubscribableChannel} is subscribed with a {@link MessageHandler}
* for the {@link FluxIdentityProcessor#onNext(Object)} which is returned from this method;
* for the {@link Sinks.Many#emitNext(Object)} which is returned from this method;
* - a {@link PollableChannel} is wrapped into a {@link MessageSource} lambda and reuses
* {@link #messageSourceToFlux(MessageSource)}.
* @param messageChannel the {@link MessageChannel} to adapt.
@@ -128,11 +125,11 @@ public final class IntegrationReactiveUtils {
private static <T> Flux<Message<T>> adaptSubscribableChannelToPublisher(SubscribableChannel inputChannel) {
return Flux.defer(() -> {
FluxIdentityProcessor<Message<T>> publisher = Processors.more().multicast(1);
Sinks.Many<Message<T>> sink = Sinks.many().multicast().onBackpressureBuffer(1);
@SuppressWarnings("unchecked")
MessageHandler messageHandler = (message) -> publisher.onNext((Message<T>) message);
MessageHandler messageHandler = (message) -> sink.emitNext((Message<T>) message);
inputChannel.subscribe(messageHandler);
return publisher
return sink.asFlux()
.doOnCancel(() -> inputChannel.unsubscribe(messageHandler));
});
}

2
spring-integration-core/src/test/java/org/springframework/integration/channel/MessageChannelReactiveUtilsTests.java
View File

@@ -21,6 +21,7 @@ import static org.assertj.core.api.Assertions.assertThat;
import java.time.Duration;
import java.util.concurrent.atomic.AtomicInteger;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import org.springframework.integration.util.IntegrationReactiveUtils;
@@ -70,6 +71,7 @@ class MessageChannelReactiveUtilsTests {
}
@Test
@Disabled("Backpressure is not honored")
void testOverproducingWithSubscribableChannel() {
DirectChannel channel = new DirectChannel();
channel.setCountsEnabled(true);

4
spring-integration-core/src/test/java/org/springframework/integration/channel/reactive/FluxMessageChannelTests.java
View File

@@ -51,7 +51,7 @@ import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;
import reactor.core.Disposable;
import reactor.core.publisher.Flux;
import reactor.core.publisher.FluxIdentityProcessor;
import reactor.core.publisher.FluxProcessor;
/**
* @author Artem Bilan
@@ -141,7 +141,7 @@ public class FluxMessageChannelTests {
flowRegistration.destroy();
assertThat(TestUtils.getPropertyValue(flux, "processor", FluxIdentityProcessor.class).isTerminated()).isTrue();
assertThat(TestUtils.getPropertyValue(flux, "processor", FluxProcessor.class).isTerminated()).isTrue();
}
@Configuration

9
spring-integration-core/src/test/java/org/springframework/integration/channel/reactive/ReactiveStreamsConsumerTests.java
View File

@@ -58,9 +58,8 @@ import org.springframework.messaging.ReactiveMessageHandler;
import org.springframework.messaging.support.GenericMessage;
import reactor.core.publisher.Flux;
import reactor.core.publisher.FluxIdentityProcessor;
import reactor.core.publisher.Mono;
import reactor.core.publisher.Processors;
import reactor.core.publisher.Sinks;
import reactor.test.StepVerifier;
import reactor.util.Loggers;
@@ -299,11 +298,11 @@ public class ReactiveStreamsConsumerTests {
public void testReactiveStreamsConsumerFluxMessageChannelReactiveMessageHandler() {
FluxMessageChannel testChannel = new FluxMessageChannel();
FluxIdentityProcessor<Message<?>> processor = Processors.more().multicast(2, false);
Sinks.Many<Object> sink = Sinks.many().multicast().onBackpressureBuffer(2, false);
ReactiveMessageHandler messageHandler =
m -> {
processor.onNext(m);
sink.emitNext(m);
return Mono.empty();
};
@@ -327,7 +326,7 @@ public class ReactiveStreamsConsumerTests {
Message<?> testMessage2 = new GenericMessage<>("test2");
testChannel.send(testMessage2);
StepVerifier.create(processor)
StepVerifier.create(sink.asFlux())
.expectNext(testMessage, testMessage2)
.thenCancel()
.verify();

4
spring-integration-core/src/test/java/org/springframework/integration/config/annotation/MessagingAnnotationsWithBeanAnnotationTests.java
View File

@@ -429,7 +429,7 @@ public class MessagingAnnotationsWithBeanAnnotationTests {
return collector()::add;
}
Sinks.StandaloneMonoSink<Message<?>> messageMono = Sinks.promise();
Sinks.One<Message<?>> messageMono = Sinks.one();
@Bean
MessageChannel reactiveMessageHandlerChannel() {
@@ -440,7 +440,7 @@ public class MessagingAnnotationsWithBeanAnnotationTests {
@ServiceActivator(inputChannel = "reactiveMessageHandlerChannel")
public ReactiveMessageHandler reactiveMessageHandlerService() {
return (message) -> {
messageMono.success(message);
messageMono.emitValue(message);
return Mono.empty();
};
}

4
spring-integration-core/src/test/java/org/springframework/integration/config/xml/GatewayParserTests.java
View File

@@ -88,9 +88,9 @@ public class GatewayParserTests {
Message<?> result = channel.receive(10000);
assertThat(result.getPayload()).isEqualTo("foo");
Sinks.StandaloneMonoSink<Object> defaultMethodHandler = Sinks.promise();
Sinks.One<Object> defaultMethodHandler = Sinks.one();
this.errorChannel.subscribe(message -> defaultMethodHandler.success(message.getPayload()));
this.errorChannel.subscribe(message -> defaultMethodHandler.emitValue(message.getPayload()));
String defaultMethodPayload = "defaultMethodPayload";
service.defaultMethodGateway(defaultMethodPayload);

48
spring-integration-r2dbc/src/main/java/org/springframework/integration/r2dbc/inbound/R2dbcMessageSource.java
View File

@@ -21,8 +21,8 @@ import java.util.Map;
import org.reactivestreams.Publisher;
import org.springframework.data.r2dbc.core.DatabaseClient;
import org.springframework.data.r2dbc.core.FetchSpec;
import org.springframework.data.r2dbc.core.R2dbcEntityOperations;
import org.springframework.data.r2dbc.core.ReactiveDataAccessStrategy;
import org.springframework.expression.Expression;
import org.springframework.expression.TypeLocator;
import org.springframework.expression.common.LiteralExpression;
@@ -30,6 +30,7 @@ import org.springframework.expression.spel.support.StandardEvaluationContext;
import org.springframework.expression.spel.support.StandardTypeLocator;
import org.springframework.integration.endpoint.AbstractMessageSource;
import org.springframework.integration.expression.ExpressionUtils;
import org.springframework.r2dbc.core.RowsFetchSpec;
import org.springframework.util.Assert;
import reactor.core.publisher.Mono;
@@ -53,7 +54,9 @@ import reactor.core.publisher.Mono;
*/
public class R2dbcMessageSource extends AbstractMessageSource<Publisher<?>> {
private final DatabaseClient databaseClient;
private final R2dbcEntityOperations r2dbcEntityOperations;
private final ReactiveDataAccessStrategy dataAccessStrategy;
private final Expression queryExpression;
@@ -66,29 +69,30 @@ public class R2dbcMessageSource extends AbstractMessageSource<Publisher<?>> {
private volatile boolean initialized = false;
/**
* Create an instance with the provided {@link DatabaseClient} and SpEL expression
* Create an instance with the provided {@link R2dbcEntityOperations} and SpEL expression
* which should resolve to a Relational 'query' string.
* It assumes that the {@link DatabaseClient} is fully initialized and ready to be used.
* It assumes that the {@link R2dbcEntityOperations} is fully initialized and ready to be used.
* The 'query' will be evaluated on every call to the {@link #receive()} method.
* @param databaseClient The reactive database client for performing database calls.
* @param r2dbcEntityOperations The reactive database client for performing database calls.
* @param query The query String.
*/
public R2dbcMessageSource(DatabaseClient databaseClient, String query) {
this(databaseClient, new LiteralExpression(query));
public R2dbcMessageSource(R2dbcEntityOperations r2dbcEntityOperations, String query) {
this(r2dbcEntityOperations, new LiteralExpression(query));
}
/**
* Create an instance with the provided {@link DatabaseClient} and SpEL expression
* Create an instance with the provided {@link R2dbcEntityOperations} and SpEL expression
* which should resolve to a Relational 'query' string.
* It assumes that the {@link DatabaseClient} is fully initialized and ready to be used.
* It assumes that the {@link R2dbcEntityOperations} is fully initialized and ready to be used.
* The 'queryExpression' will be evaluated on every call to the {@link #receive()} method.
* @param databaseClient The reactive for performing database calls.
* @param r2dbcEntityOperations The reactive for performing database calls.
* @param queryExpression The query expression.
*/
public R2dbcMessageSource(DatabaseClient databaseClient, Expression queryExpression) {
Assert.notNull(databaseClient, "'databaseClient' must not be null");
public R2dbcMessageSource(R2dbcEntityOperations r2dbcEntityOperations, Expression queryExpression) {
Assert.notNull(r2dbcEntityOperations, "'r2dbcEntityOperations' must not be null");
Assert.notNull(queryExpression, "'queryExpression' must not be null");
this.databaseClient = databaseClient;
this.r2dbcEntityOperations = r2dbcEntityOperations;
this.dataAccessStrategy = this.r2dbcEntityOperations.getDataAccessStrategy();
this.queryExpression = queryExpression;
}
@@ -147,21 +151,21 @@ public class R2dbcMessageSource extends AbstractMessageSource<Publisher<?>> {
@Override
protected Object doReceive() {
Assert.isTrue(this.initialized, "This class is not yet initialized. Invoke its afterPropertiesSet() method");
Mono<FetchSpec<?>> queryMono =
Mono<RowsFetchSpec<?>> queryMono =
Mono.fromSupplier(() -> this.queryExpression.getValue(this.evaluationContext))
.map(this::prepareFetch);
if (this.expectSingleResult) {
return queryMono.flatMap(FetchSpec::one);
return queryMono.flatMap(RowsFetchSpec::one);
}
return queryMono.flatMapMany(FetchSpec::all);
return queryMono.flatMapMany(RowsFetchSpec::all);
}
private FetchSpec<?> prepareFetch(Object queryObject) {
private RowsFetchSpec<?> prepareFetch(Object queryObject) {
String queryString = evaluateQueryObject(queryObject);
return this.databaseClient
.execute(queryString)
.as(this.payloadType)
.fetch();
return this.r2dbcEntityOperations
.getDatabaseClient()
.sql(queryString)
.map(this.dataAccessStrategy.getRowMapper(this.payloadType));
}
private String evaluateQueryObject(Object queryObject) {

49
spring-integration-r2dbc/src/main/java/org/springframework/integration/r2dbc/outbound/R2dbcMessageHandler.java
View File

@@ -19,8 +19,8 @@ package org.springframework.integration.r2dbc.outbound;
import java.util.HashMap;
import java.util.Map;
import org.springframework.data.r2dbc.core.DatabaseClient;
import org.springframework.data.r2dbc.core.R2dbcEntityOperations;
import org.springframework.data.r2dbc.core.StatementMapper;
import org.springframework.data.relational.core.query.Criteria;
import org.springframework.data.relational.core.query.Update;
import org.springframework.data.relational.core.sql.SqlIdentifier;
@@ -34,6 +34,8 @@ import org.springframework.integration.expression.ValueExpression;
import org.springframework.integration.handler.AbstractReactiveMessageHandler;
import org.springframework.lang.Nullable;
import org.springframework.messaging.Message;
import org.springframework.r2dbc.core.Parameter;
import org.springframework.r2dbc.core.PreparedOperation;
import org.springframework.util.Assert;
import reactor.core.publisher.Mono;
@@ -52,6 +54,8 @@ public class R2dbcMessageHandler extends AbstractReactiveMessageHandler {
private final R2dbcEntityOperations r2dbcEntityOperations;
private final StatementMapper statementMapper;
private StandardEvaluationContext evaluationContext;
private Expression queryTypeExpression = new ValueExpression<>(Type.INSERT);
@@ -75,6 +79,7 @@ public class R2dbcMessageHandler extends AbstractReactiveMessageHandler {
public R2dbcMessageHandler(R2dbcEntityOperations r2dbcEntityOperations) {
Assert.notNull(r2dbcEntityOperations, "'r2dbcEntityOperations' must not be null");
this.r2dbcEntityOperations = r2dbcEntityOperations;
this.statementMapper = this.r2dbcEntityOperations.getDataAccessStrategy().getStatementMapper();
}
@@ -146,11 +151,12 @@ public class R2dbcMessageHandler extends AbstractReactiveMessageHandler {
if (this.tableNameExpression != null) {
String tableName = evaluateTableNameExpression(message);
Criteria criteria = evaluateCriteriaExpression(message);
DatabaseClient.DeleteMatchingSpec deleteSpec =
this.r2dbcEntityOperations.getDatabaseClient()
.delete()
.from(tableName);
return deleteSpec.matching(criteria)
StatementMapper.DeleteSpec deleteSpec =
this.statementMapper.createDelete(tableName)
.withCriteria(criteria);
PreparedOperation<?> operation = this.statementMapper.getMappedObject(deleteSpec);
return this.r2dbcEntityOperations.getDatabaseClient()
.sql(operation)
.then();
}
else {
@@ -165,11 +171,13 @@ public class R2dbcMessageHandler extends AbstractReactiveMessageHandler {
Map<String, Object> values = evaluateValuesExpression(message);
Map<SqlIdentifier, Object> updateMap = transformIntoSqlIdentifierMap(values);
Criteria criteria = evaluateCriteriaExpression(message);
DatabaseClient.GenericUpdateSpec updateSpec =
this.r2dbcEntityOperations.getDatabaseClient().update()
.table(tableName);
return updateSpec.using(Update.from(updateMap))
.matching(criteria)
StatementMapper.UpdateSpec updateSpec =
this.statementMapper.createUpdate(tableName, Update.from(updateMap))
.withCriteria(criteria);
PreparedOperation<?> operation = this.statementMapper.getMappedObject(updateSpec);
return this.r2dbcEntityOperations.getDatabaseClient()
.sql(operation)
.then();
}
else {
@@ -188,14 +196,18 @@ public class R2dbcMessageHandler extends AbstractReactiveMessageHandler {
if (this.tableNameExpression != null) {
String tableName = evaluateTableNameExpression(message);
Map<String, Object> values = evaluateValuesExpression(message);
DatabaseClient.GenericInsertSpec<Map<String, Object>> insertSpec =
this.r2dbcEntityOperations.getDatabaseClient()
.insert()
.into(tableName);
StatementMapper.InsertSpec insertSpec = this.statementMapper.createInsert(tableName);
for (Map.Entry<String, Object> entry : values.entrySet()) {
insertSpec = insertSpec.value(entry.getKey(), entry.getValue());
insertSpec = insertSpec.withColumn(entry.getKey(),
Parameter.fromOrEmpty(entry.getValue(), Object.class));
}
return insertSpec.then();
PreparedOperation<?> operation = this.statementMapper.getMappedObject(insertSpec);
return this.r2dbcEntityOperations.getDatabaseClient()
.sql(operation)
.then();
}
else {
return this.r2dbcEntityOperations.insert(message.getPayload())
@@ -223,8 +235,7 @@ public class R2dbcMessageHandler extends AbstractReactiveMessageHandler {
private Criteria evaluateCriteriaExpression(Message<?> message) {
Assert.notNull(this.criteriaExpression,
"'this.criteriaExpression' must not be null when 'tableNameExpression' mode is used");
Criteria criteria =
this.criteriaExpression.getValue(this.evaluationContext, message, Criteria.class);
Criteria criteria = this.criteriaExpression.getValue(this.evaluationContext, message, Criteria.class);
Assert.notNull(criteria, "'criteriaExpression' must not evaluate to null");
return criteria;
}

10
spring-integration-r2dbc/src/test/java/org/springframework/integration/r2dbc/config/R2dbcDatabaseConfiguration.java
View File

@@ -20,8 +20,10 @@ package org.springframework.integration.r2dbc.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.r2dbc.config.AbstractR2dbcConfiguration;
import org.springframework.data.r2dbc.core.DatabaseClient;
import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
import org.springframework.data.r2dbc.dialect.H2Dialect;
import org.springframework.data.r2dbc.repository.config.EnableR2dbcRepositories;
import org.springframework.r2dbc.core.DatabaseClient;
import io.r2dbc.h2.H2ConnectionConfiguration;
import io.r2dbc.h2.H2ConnectionFactory;
@@ -29,6 +31,7 @@ import io.r2dbc.spi.ConnectionFactory;
/**
* @author Rohan Mukesh
* @author Artem Bilan
*
* @since 5.4
*/
@@ -56,4 +59,9 @@ public class R2dbcDatabaseConfiguration extends AbstractR2dbcConfiguration {
return DatabaseClient.create(connectionFactory);
}
@Bean
public R2dbcEntityTemplate r2dbcEntityTemplate(DatabaseClient databaseClient) {
return new R2dbcEntityTemplate(databaseClient, H2Dialect.INSTANCE);
}
}

18
spring-integration-r2dbc/src/test/java/org/springframework/integration/r2dbc/inbound/R2dbcMessageSourceTests.java
View File

@@ -29,16 +29,16 @@ import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.data.r2dbc.core.DatabaseClient;
import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
import org.springframework.data.r2dbc.dialect.H2Dialect;
import org.springframework.integration.expression.ValueExpression;
import org.springframework.integration.r2dbc.config.R2dbcDatabaseConfiguration;
import org.springframework.integration.r2dbc.entity.Person;
import org.springframework.r2dbc.core.DatabaseClient;
import org.springframework.test.annotation.DirtiesContext;
import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Hooks;
import reactor.core.publisher.Mono;
import reactor.test.StepVerifier;
@@ -68,13 +68,12 @@ public class R2dbcMessageSourceTests {
@BeforeEach
public void setup() {
Hooks.onOperatorDebug();
entityTemplate = new R2dbcEntityTemplate(this.client);
this.entityTemplate = new R2dbcEntityTemplate(this.client, H2Dialect.INSTANCE);
List<String> statements = Arrays.asList(
"DROP TABLE IF EXISTS person;",
"CREATE table person (id INT AUTO_INCREMENT NOT NULL, name VARCHAR2, age INT NOT NULL);");
statements.forEach(it -> this.client.execute(it)
statements.forEach(it -> this.client.sql(it)
.fetch()
.rowsUpdated()
.as(StepVerifier::create)
@@ -143,11 +142,11 @@ public class R2dbcMessageSourceTests {
static class R2dbcMessageSourceConfiguration {
@Autowired
DatabaseClient databaseClient;
R2dbcEntityTemplate r2dbcEntityTemplate;
@Bean
public R2dbcMessageSource r2dbcMessageSourceSelectOne() {
R2dbcMessageSource r2dbcMessageSource = new R2dbcMessageSource(databaseClient,
R2dbcMessageSource r2dbcMessageSource = new R2dbcMessageSource(this.r2dbcEntityTemplate,
"select * from person Where id = 1");
r2dbcMessageSource.setPayloadType(Person.class);
return r2dbcMessageSource;
@@ -155,14 +154,15 @@ public class R2dbcMessageSourceTests {
@Bean
public R2dbcMessageSource r2dbcMessageSourceSelectMany() {
R2dbcMessageSource r2dbcMessageSource = new R2dbcMessageSource(databaseClient, "select * from person");
R2dbcMessageSource r2dbcMessageSource = new R2dbcMessageSource(this.r2dbcEntityTemplate,
"select * from person");
r2dbcMessageSource.setPayloadType(Person.class);
return r2dbcMessageSource;
}
@Bean
public R2dbcMessageSource r2dbcMessageSourceError() {
R2dbcMessageSource r2dbcMessageSource = new R2dbcMessageSource(databaseClient,
R2dbcMessageSource r2dbcMessageSource = new R2dbcMessageSource(this.r2dbcEntityTemplate,
new ValueExpression<>(new Object()));
r2dbcMessageSource.setPayloadType(Person.class);
return r2dbcMessageSource;

144
spring-integration-r2dbc/src/test/java/org/springframework/integration/r2dbc/outbound/R2dbcMessageHandlerTests.java
View File

@@ -32,7 +32,6 @@ import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.data.r2dbc.core.DatabaseClient;
import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
import org.springframework.data.relational.core.query.Criteria;
import org.springframework.integration.expression.FunctionExpression;
@@ -41,16 +40,16 @@ import org.springframework.integration.r2dbc.entity.Person;
import org.springframework.integration.r2dbc.repository.PersonRepository;
import org.springframework.integration.support.MessageBuilder;
import org.springframework.messaging.Message;
import org.springframework.r2dbc.core.DatabaseClient;
import org.springframework.test.annotation.DirtiesContext;
import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Hooks;
import reactor.core.publisher.Mono;
import reactor.test.StepVerifier;
/**
* @author Rohan Mukesh
* @author Artem Bilan
*
* @since 5.4
*/
@@ -61,6 +60,9 @@ public class R2dbcMessageHandlerTests {
@Autowired
DatabaseClient client;
@Autowired
R2dbcEntityTemplate r2dbcEntityTemplate;
@Autowired
PersonRepository personRepository;
@@ -69,14 +71,13 @@ public class R2dbcMessageHandlerTests {
@BeforeEach
public void setup() {
Hooks.onOperatorDebug();
r2dbcMessageHandler.setQueryType(R2dbcMessageHandler.Type.INSERT);
r2dbcMessageHandler.setTableNameExpression(null);
this.r2dbcMessageHandler.setQueryType(R2dbcMessageHandler.Type.INSERT);
this.r2dbcMessageHandler.setTableNameExpression(null);
List<String> statements = Arrays.asList(
"DROP TABLE IF EXISTS person;",
"CREATE table person (id INT AUTO_INCREMENT NOT NULL, name VARCHAR2, age INT NOT NULL);");
statements.forEach(it -> client.execute(it)
statements.forEach(it -> client.sql(it)
.fetch()
.rowsUpdated()
.as(StepVerifier::create)
@@ -87,9 +88,9 @@ public class R2dbcMessageHandlerTests {
@Test
public void validateMessageHandlingWithDefaultInsertCollection() {
Message<Person> message = MessageBuilder.withPayload(createPerson("Bob", 35)).build();
waitFor(r2dbcMessageHandler.handleMessage(message));
waitFor(this.r2dbcMessageHandler.handleMessage(message));
personRepository.findAll()
this.personRepository.findAll()
.as(StepVerifier::create)
.expectNextCount(1)
.verifyComplete();
@@ -97,18 +98,18 @@ public class R2dbcMessageHandlerTests {
@Test
public void validateMessageHandlingWithInsertQueryCollection() {
r2dbcMessageHandler.setValuesExpression(new FunctionExpression<Message<?>>(Message::getPayload));
r2dbcMessageHandler.setQueryType(R2dbcMessageHandler.Type.INSERT);
r2dbcMessageHandler.setTableName("person");
this.r2dbcMessageHandler.setValuesExpression(new FunctionExpression<Message<?>>(Message::getPayload));
this.r2dbcMessageHandler.setQueryType(R2dbcMessageHandler.Type.INSERT);
this.r2dbcMessageHandler.setTableName("person");
Map<String, Object> payload = new HashMap<>();
payload.put("name", "rohan");
payload.put("age", 35);
Message<?> message = MessageBuilder.withPayload(payload).build();
waitFor(r2dbcMessageHandler.handleMessage(message));
waitFor(this.r2dbcMessageHandler.handleMessage(message));
Flux<?> all = client.execute("SELECT name, age FROM person")
.fetch().all();
all.as(StepVerifier::create)
this.client.sql("SELECT name, age FROM person")
.fetch().all()
.as(StepVerifier::create)
.expectNextCount(1)
.verifyComplete();
@@ -117,24 +118,22 @@ public class R2dbcMessageHandlerTests {
@Test
public void validateMessageHandlingWithDefaultUpdateCollection() {
Message<Person> message = MessageBuilder.withPayload(createPerson("Bob", 35)).build();
waitFor(r2dbcMessageHandler.handleMessage(message));
waitFor(this.r2dbcMessageHandler.handleMessage(message));
r2dbcMessageHandler.setQueryType(R2dbcMessageHandler.Type.UPDATE);
this.r2dbcMessageHandler.setQueryType(R2dbcMessageHandler.Type.UPDATE);
Person person = this.client.select()
.from("person")
.as(Person.class)
.fetch()
.first()
.block();
Person person =
this.r2dbcEntityTemplate.select(Person.class)
.first()
.block();
person.setAge(40);
message = MessageBuilder.withPayload(person)
.build();
waitFor(r2dbcMessageHandler.handleMessage(message));
waitFor(this.r2dbcMessageHandler.handleMessage(message));
personRepository.findAll()
this.personRepository.findAll()
.as(StepVerifier::create)
.consumeNextWith(p -> Assert.assertEquals(Optional.of(40), Optional.ofNullable(p.getAge())))
.verifyComplete();
@@ -142,40 +141,40 @@ public class R2dbcMessageHandlerTests {
@Test
public void validateMessageHandlingWithUpdateQueryCollection() {
r2dbcMessageHandler.setValuesExpression(new FunctionExpression<Message<?>>(Message::getPayload));
r2dbcMessageHandler.setQueryType(R2dbcMessageHandler.Type.INSERT);
r2dbcMessageHandler.setTableName("person");
this.r2dbcMessageHandler.setValuesExpression(new FunctionExpression<Message<?>>(Message::getPayload));
this.r2dbcMessageHandler.setQueryType(R2dbcMessageHandler.Type.INSERT);
this.r2dbcMessageHandler.setTableName("person");
Map<String, Object> payload = new HashMap<>();
payload.put("name", "Bob");
payload.put("age", 35);
Message<?> message = MessageBuilder.withPayload(payload).build();
waitFor(r2dbcMessageHandler.handleMessage(message));
waitFor(this.r2dbcMessageHandler.handleMessage(message));
payload = new HashMap<>();
payload.put("name", "Rob");
payload.put("age", 43);
message = MessageBuilder.withPayload(payload).build();
waitFor(r2dbcMessageHandler.handleMessage(message));
waitFor(this.r2dbcMessageHandler.handleMessage(message));
payload = new HashMap<>();
r2dbcMessageHandler.setQueryType(R2dbcMessageHandler.Type.UPDATE);
this.r2dbcMessageHandler.setQueryType(R2dbcMessageHandler.Type.UPDATE);
Object insertedId = client.execute("SELECT id FROM person")
Object insertedId = client.sql("SELECT id FROM person")
.fetch()
.first()
.block()
.get("id");
r2dbcMessageHandler.setCriteriaExpression(
this.r2dbcMessageHandler.setCriteriaExpression(
new FunctionExpression<Message<?>>((m) -> Criteria.where("id").is(insertedId)));
payload.put("age", 40);
message = MessageBuilder.withPayload(payload).build();
waitFor(r2dbcMessageHandler.handleMessage(message));
waitFor(this.r2dbcMessageHandler.handleMessage(message));
Flux<?> all = client.execute("SELECT age,name FROM person where age=40")
.fetch().all();
all.as(StepVerifier::create)
this.client.sql("SELECT age,name FROM person where age=40")
.fetch().all()
.as(StepVerifier::create)
.consumeNextWith(response -> Assert.assertEquals("{AGE=40, NAME=Bob}", response.toString()))
.verifyComplete();
@@ -184,21 +183,18 @@ public class R2dbcMessageHandlerTests {
@Test
public void validateMessageHandlingWithDefaultDeleteCollection() {
Message<Person> message = MessageBuilder.withPayload(createPerson("Bob", 35)).build();
waitFor(r2dbcMessageHandler.handleMessage(message));
waitFor(this.r2dbcMessageHandler.handleMessage(message));
Person person = this.client
.select()
.from("person")
.as(Person.class)
.fetch()
.first()
.block();
Person person =
this.r2dbcEntityTemplate.select(Person.class)
.first()
.block();
r2dbcMessageHandler.setQueryType(R2dbcMessageHandler.Type.DELETE);
this.r2dbcMessageHandler.setQueryType(R2dbcMessageHandler.Type.DELETE);
message = MessageBuilder.withPayload(person).build();
waitFor(r2dbcMessageHandler.handleMessage(message));
waitFor(this.r2dbcMessageHandler.handleMessage(message));
personRepository.findAll()
this.personRepository.findAll()
.as(StepVerifier::create)
.expectNextCount(0)
.verifyComplete();
@@ -206,32 +202,32 @@ public class R2dbcMessageHandlerTests {
@Test
public void validateMessageHandlingWithDeleteQueryCollection() {
r2dbcMessageHandler.setValuesExpression(new FunctionExpression<Message<?>>(Message::getPayload));
r2dbcMessageHandler.setQueryType(R2dbcMessageHandler.Type.INSERT);
r2dbcMessageHandler.setTableName("person");
this.r2dbcMessageHandler.setValuesExpression(new FunctionExpression<Message<?>>(Message::getPayload));
this.r2dbcMessageHandler.setQueryType(R2dbcMessageHandler.Type.INSERT);
this.r2dbcMessageHandler.setTableName("person");
Map<String, Object> payload = new HashMap<>();
payload.put("name", "Bob");
payload.put("age", 35);
Message<?> message = MessageBuilder.withPayload(payload).build();
waitFor(r2dbcMessageHandler.handleMessage(message));
waitFor(this.r2dbcMessageHandler.handleMessage(message));
payload = new HashMap<>();
r2dbcMessageHandler.setQueryType(R2dbcMessageHandler.Type.DELETE);
this.r2dbcMessageHandler.setQueryType(R2dbcMessageHandler.Type.DELETE);
Object insertedId = client.execute("SELECT id FROM person")
Object insertedId = client.sql("SELECT id FROM person")
.fetch()
.first()
.block()
.get("id");
r2dbcMessageHandler.setCriteriaExpression(
this.r2dbcMessageHandler.setCriteriaExpression(
new FunctionExpression<Message<?>>((m) -> Criteria.where("id").is(insertedId)));
message = MessageBuilder.withPayload(payload).build();
waitFor(r2dbcMessageHandler.handleMessage(message));
waitFor(this.r2dbcMessageHandler.handleMessage(message));
Flux<?> all = client.execute("SELECT age,name FROM person where age=35")
.fetch().all();
all.as(StepVerifier::create)
client.sql("SELECT age,name FROM person where age=35")
.fetch().all()
.as(StepVerifier::create)
.expectNextCount(0)
.verifyComplete();
@@ -239,38 +235,38 @@ public class R2dbcMessageHandlerTests {
@Test
public void validateMessageHandlingWithDeleteQueryCollection_MultipleRows() {
r2dbcMessageHandler.setValuesExpression(new FunctionExpression<Message<?>>(Message::getPayload));
r2dbcMessageHandler.setQueryType(R2dbcMessageHandler.Type.INSERT);
r2dbcMessageHandler.setTableName("person");
this.r2dbcMessageHandler.setValuesExpression(new FunctionExpression<Message<?>>(Message::getPayload));
this.r2dbcMessageHandler.setQueryType(R2dbcMessageHandler.Type.INSERT);
this.r2dbcMessageHandler.setTableName("person");
Map<String, Object> payload = new HashMap<>();
payload.put("name", "Bob");
payload.put("age", 35);
Message<?> message = MessageBuilder.withPayload(payload).build();
waitFor(r2dbcMessageHandler.handleMessage(message));
waitFor(this.r2dbcMessageHandler.handleMessage(message));
payload = new HashMap<>();
payload.put("name", "Rob");
payload.put("age", 40);
message = MessageBuilder.withPayload(payload).build();
waitFor(r2dbcMessageHandler.handleMessage(message));
waitFor(this.r2dbcMessageHandler.handleMessage(message));
payload = new HashMap<>();
r2dbcMessageHandler.setQueryType(R2dbcMessageHandler.Type.DELETE);
this.r2dbcMessageHandler.setQueryType(R2dbcMessageHandler.Type.DELETE);
Object insertedId = client.execute("SELECT id FROM person")
Object insertedId = client.sql("SELECT id FROM person")
.fetch()
.first()
.block()
.get("id");
r2dbcMessageHandler.setCriteriaExpression(
this.r2dbcMessageHandler.setCriteriaExpression(
new FunctionExpression<Message<?>>((m) -> Criteria.where("id").is(insertedId)));
message = MessageBuilder.withPayload(payload).build();
waitFor(r2dbcMessageHandler.handleMessage(message));
waitFor(this.r2dbcMessageHandler.handleMessage(message));
Flux<?> all = client.execute("SELECT age,name FROM person where age=40")
.fetch().all();
all.as(StepVerifier::create)
client.sql("SELECT age,name FROM person where age=40")
.fetch().all()
.as(StepVerifier::create)
.expectNextCount(1)
.verifyComplete();
@@ -294,8 +290,8 @@ public class R2dbcMessageHandlerTests {
DatabaseClient databaseClient;
@Bean
public R2dbcMessageHandler r2dbcMessageHandler() {
return new R2dbcMessageHandler(new R2dbcEntityTemplate(databaseClient));
public R2dbcMessageHandler r2dbcMessageHandler(R2dbcEntityTemplate r2dbcEntityTemplate) {
return new R2dbcMessageHandler(r2dbcEntityTemplate);
}
}

4
spring-integration-rsocket/src/test/java/org/springframework/integration/rsocket/inbound/RSocketInboundGatewayIntegrationTests.java
View File

@@ -180,7 +180,7 @@ public class RSocketInboundGatewayIntegrationTests {
@EnableIntegration
static class ServerConfig extends CommonConfig {
final Sinks.StandaloneMonoSink<RSocketRequester> clientRequester = Sinks.promise();
final Sinks.One<RSocketRequester> clientRequester = Sinks.one();
@Bean
public CloseableChannel rsocketServer() {
@@ -203,7 +203,7 @@ public class RSocketInboundGatewayIntegrationTests {
@EventListener
public void onApplicationEvent(RSocketConnectedEvent event) {
this.clientRequester.success(event.getRequester());
this.clientRequester.emitValue(event.getRequester());
}
}

8
spring-integration-rsocket/src/test/java/org/springframework/integration/rsocket/outbound/RSocketOutboundGatewayIntegrationTests.java
View File

@@ -538,13 +538,13 @@ public class RSocketOutboundGatewayIntegrationTests {
@Controller
static class TestController {
final Sinks.StandaloneFluxSink<String> fireForgetPayloads = Sinks.replayAll();
final Sinks.Many<String> fireForgetPayloads = Sinks.many().replay().all();
final Sinks.StandaloneMonoSink<RSocketRequester> clientRequester = Sinks.promise();
final Sinks.One<RSocketRequester> clientRequester = Sinks.one();
@MessageMapping("receive")
void receive(String payload) {
this.fireForgetPayloads.next(payload);
this.fireForgetPayloads.emitNext(payload);
}
@MessageMapping("echo")
@@ -596,7 +596,7 @@ public class RSocketOutboundGatewayIntegrationTests {
@ConnectMapping("clientConnect")
void clientConnect(RSocketRequester requester) {
this.clientRequester.success(requester);
this.clientRequester.emitValue(requester);
}
}