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

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);
}
}