{"id":88574,"date":"2019-02-18T19:00:56","date_gmt":"2019-02-18T17:00:56","guid":{"rendered":"https:\/\/www.javacodegeeks.com\/?p=88574"},"modified":"2019-02-18T12:23:52","modified_gmt":"2019-02-18T10:23:52","slug":"asynchronous-rdbms-access-spring-r2dbc","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2019\/02\/asynchronous-rdbms-access-spring-r2dbc.html","title":{"rendered":"Asynchronous RDBMS access with Spring Data R2DBC"},"content":{"rendered":"

Not too long ago, a reactive variant of the JDBC driver was released. Known as R2DBC. It allows data to be streamed asynchronously to any endpoints that have subscribed to it. Using a reactive driver like R2DBC together with Spring WebFlux allows you to write a full application that handles receiving and sending of data asynchronously. In this post, we will focus on the database. From connecting to the database and then finally saving and retrieving data. To do this, we will be using Spring Data. As with all Spring Data modules, it provides us with out of the box configuration. Decreasing the amount of boilerplate code that we need to write to get our application setup. On top of that, it provides a layer upon the database driver that makes doing the simple tasks easier and the more difficult tasks a little less painful.<\/p>\n

For the content of this post, I am making use of a Postgres database. At the time of writing only Postgres, H2 and Microsoft SQL Server have their own implementations of R2DBC drivers.<\/p>\n

I have previously written two posts about reactive Spring Data libraries, one on Mongo<\/a> and another about Cassandra<\/a>. You might have noticed that neither of these databases are RDBMS databases. Now there are other reactive drivers available for a long time (I wrote the Mongo post nearly 2 years ago) but at the time of writing a reactive driver for a RDBMS database is still a pretty new thing. This post will follow a similar format to those.<\/p>\n

Furthermore, I have also written a post about using Spring WebFlux<\/a> which I mentioned in the introduction. Feel free to have a look at that if you are interested in producing a fully reactive web application.<\/p>\n

Dependencies<\/h3>\n
\n<dependencies>\n  <dependency>\n    <groupId>org.springframework.boot<\/groupId>\n    <artifactId>spring-boot-starter<\/artifactId>\n  <\/dependency>\n  <dependency>\n    <groupId>org.springframework.data<\/groupId>\n    <artifactId>spring-data-r2dbc<\/artifactId>\n    <version>1.0.0.M1<\/version>\n  <\/dependency>\n  <dependency>\n    <groupId>io.r2dbc<\/groupId>\n    <artifactId>r2dbc-postgresql<\/artifactId>\n    <version>1.0.0.M6<\/version>\n  <\/dependency>\n  <dependency>\n    <groupId>io.projectreactor<\/groupId>\n    <artifactId>reactor-core<\/artifactId>\n  <\/dependency>\n<\/dependencies>\n\n<repositories>\n  <repository>\n    <id>repository.spring.milestone<\/id>\n    <name>Spring Milestone Repository<\/name>\n    <url>http:\/\/repo.spring.io\/milestone<\/url>\n  <\/repository>\n<\/repositories>\n<\/pre>\n
There are a few things to point out here.<\/p>\n
The more you use Spring Boot, the more you will get used to importing a single spring-boot-starter<\/code> dependency for the cool thing that you want to do. For example, I hoped that there would have been a spring-boot-starter-r2dbc<\/code> dependency, but unfortunately, there is not one. Yet. Simply put, this library is on the newer side and at the time of writing, does not have its own Spring Boot module that contains any dependencies it needs along with faster setup via auto-configuration. I am sure these things will come at some point and make setting up a R2DBC driver even easier.<\/p>\n
For now, we will need to fill in a few extra dependencies manually.<\/p>\n
Furthermore, the R2DBC libraries only have Milestone releases (more proof of them being new) so we need to make sure we bring in the Spring Milestone repository. I will probably need to update this post in the future when it gets a release version.<\/p>\n
Connecting to the database<\/h3>\n
Thanks to Spring Data doing a lot of the work for us, the only Bean that needs to be created manually is the ConnectionFactory<\/code> that contains the database\u2019s connection details:<\/p>\n
\n@Configuration\n@EnableR2dbcRepositories\nclass DatabaseConfiguration(\n  @Value(\"\\${spring.data.postgres.host}\") private val host: String,\n  @Value(\"\\${spring.data.postgres.port}\") private val port: Int,\n  @Value(\"\\${spring.data.postgres.database}\") private val database: String,\n  @Value(\"\\${spring.data.postgres.username}\") private val username: String,\n  @Value(\"\\${spring.data.postgres.password}\") private val password: String\n) : AbstractR2dbcConfiguration() {\n\n  override fun connectionFactory(): ConnectionFactory {\n    return PostgresqlConnectionFactory(\n      PostgresqlConnectionConfiguration.builder()\n        .host(host)\n        .port(port)\n        .database(database)\n        .username(username)\n        .password(password).build()\n    )\n  }\n}\n<\/pre>\n
The first thing to notice here is the extension of AbstractR2dbcConfiguration<\/code>. This class contains a load of Beans that we no longer need to manually create. Implementing connectionFactory<\/code> is the only requirement of the class as it is required to create the DatabaseClient<\/code> Bean. This sort of structure is typical of Spring Data modules so it feels quite familiar when trying out a different one. Furthermore, I\u2019d expect this manual configuration to be removed once auto-configuration is available and be solely driven via the application.properties<\/code>.
 
<\/div> <\/div><\/p>\n
I have included the port<\/code> property here, but if you have not played around with your Postgres configuration then you can rely on the default value of 5432<\/code>.<\/p>\n
The four properties: host<\/code>, database<\/code>, username<\/code> and password<\/code> defined by the PostgresqlConnectionFactory<\/code> are the bare minimum to get it working. Any less and you will experience exceptions during startup.<\/p>\n
Using this configuration, Spring is able to connect to a running Postgres instance.<\/p>\n
The final piece of noteworthy information from this example is the use of @EnableR2dbcRepositories<\/code>. This annotation instructs Spring to find any repository interfaces that extend Spring\u2019s Repository<\/code> interface. This is used as the base interface for instrumenting Spring Data repositories. We will look at this a little closer in the next section. The main piece of information to take away from here is that you need to use the @EnableR2dbcRepositories<\/code> annotation to fully leverage Spring Data\u2019s capabilities.<\/p>\n
Creating a Spring Data Repository<\/h3>\n
As touched on above, in this section we will look at adding a Spring Data Repository. These repositories are a nice feature of Spring Data, meaning that you don\u2019t need to write out a load of extra code to simply write a query. Unfortunately, at least for now, Spring R2DBC cannot infer queries in the same way that other Spring Data modules currently do (I am sure this will be added at some point). This means that you will need to use the @Query<\/code> annotation and write the SQL by hand. Let\u2019s take a look:<\/p>\n
\n@Repository\ninterface PersonRepository : R2dbcRepository<Person, Int> {\n\n  @Query(\"SELECT * FROM people WHERE name = $1\")\n  fun findAllByName(name: String): Flux<Person>\n\n  @Query(\"SELECT * FROM people WHERE age = $1\")\n  fun findAllByAge(age: Int): Flux<Person>\n}\n<\/pre>\n
This interface extends R2dbcRepository<\/code>. This in turn extends ReactiveCrudRepository<\/code> and then down to Repository<\/code>. ReactiveCrudRepository<\/code> provides the standard CRUD functions and from what I understand, R2dbcRepository<\/code> does not provide any extra functions and is instead an interface created for better situational naming.<\/p>\n
R2dbcRepository<\/code> takes in two generic parameters, one being the entity class that it takes as input and produces as output. The second being the type of the Primary Key. Therefore in this situation, the Person<\/code> class is being managed by the PersonRepository<\/code> (makes sense) and the Primary Key field inside Person<\/code> is an Int<\/code>.<\/p>\n
The return types of functions in this class and the ones provided by ReactiveCrudRepository<\/code> are Flux<\/code> and Mono<\/code> (not seen here). These are Project Reactor types that Spring makes use of as the default Reactive Stream types. Flux<\/code> represents a stream of multiple elements whereas a Mono<\/code> is a single result.<\/p>\n
Finally, as I mentioned before the example, each function is annotated with @Query<\/code>. The syntax is quite straight forward, with the SQL being a string inside the annotation. The $1<\/code> ($2<\/code>, $3<\/code>, etc\u2026 for more inputs) represents the value input into the function. Once you have done this, Spring will handle the rest and pass the input(s) into their respective input parameter, gather the results and map it to the repository\u2019s designated entity class.<\/p>\n
A very quick look at the entity<\/h3>\n
Not going to say much here but simply show the Person<\/code> class used by the PersonRepository<\/code>.<\/p>\n
\n@Table(\"people\")\ndata class Person(\n  @Id val id: Int? = null,\n  val name: String,\n  val age: Int\n)\n<\/pre>\n
Actually, there is one point to make here. id<\/code> has been made nullable and provided a default value of null<\/code> to allow Postgres to generate the next suitable value itself. If this is not nullable and an id<\/code> value is provided, Spring will actually try to run an update instead of an insert upon saving. There are other ways around this, but I think this is good enough.<\/p>\n
This entity will map to the people<\/code> table defined below:<\/p>\n
\nCREATE TABLE people (\n  id SERIAL PRIMARY KEY, \n  name VARCHAR NOT NULL, \n  age INTEGER NOT NULL\n);\n<\/pre>\n
Seeing it all in action<\/h3>\n
Now let\u2019s have a look at it actually doing something. Below is some code that inserts a few records and retrieves them in a few different ways:<\/p>\n
\n@SpringBootApplication\nclass Application : CommandLineRunner {\n\n  @Autowired\n  private lateinit var personRepository: PersonRepository\n\n  override fun run(vararg args: String?) {\n    personRepository.saveAll(\n      listOf(\n        Person(name = \"Dan Newton\", age = 25),\n        Person(name = \"Laura So\", age = 23)\n      )\n    ).log().subscribe()\n    personRepository.findAll().subscribe { log.info(\"findAll - $it\") }\n    personRepository.findAllById(Mono.just(1)).subscribe { log.info(\"findAllById - $it\") }\n    personRepository.findAllByName(\"Laura So\").subscribe { log.info(\"findAllByName - $it\") }\n    personRepository.findAllByAge(25).subscribe { log.info(\"findAllByAge - $it\") }\n  }\n}\n<\/pre>\n
One thing I will mention about this code. There is a very real possibility that it executes without actually inserting or reading some of the records. But, when you think about it. It makes sense. Reactive applications are meant to do things asynchronously and therefore this application has started processing the function calls in different threads. Without blocking the main thread, these asynchronous processes might never fully execute. For this reason, there are some Thread.sleep<\/code> calls in this code, but I removed them from the example to keep everything tidy.<\/p>\n
The output for running the code above would look something like the below:<\/p>\n
\n2019-02-11 09:04:52.294  INFO 13226 --- [           main] reactor.Flux.ConcatMap.1                 : onSubscribe(FluxConcatMap.ConcatMapImmediate)\n2019-02-11 09:04:52.295  INFO 13226 --- [           main] reactor.Flux.ConcatMap.1                 : request(unbounded)\n2019-02-11 09:04:52.572  INFO 13226 --- [actor-tcp-nio-1] reactor.Flux.ConcatMap.1                 : onNext(Person(id=35, name=Dan Newton, age=25))\n2019-02-11 09:04:52.591  INFO 13226 --- [actor-tcp-nio-1] reactor.Flux.ConcatMap.1                 : onNext(Person(id=36, name=Laura So, age=23))\n2019-02-11 09:04:52.591  INFO 13226 --- [actor-tcp-nio-1] reactor.Flux.ConcatMap.1                 : onComplete()\n2019-02-11 09:04:54.472  INFO 13226 --- [actor-tcp-nio-2] com.lankydanblog.tutorial.Application    : findAll - Person(id=35, name=Dan Newton, age=25)\n2019-02-11 09:04:54.473  INFO 13226 --- [actor-tcp-nio-2] com.lankydanblog.tutorial.Application    : findAll - Person(id=36, name=Laura So, age=23)\n2019-02-11 09:04:54.512  INFO 13226 --- [actor-tcp-nio-4] com.lankydanblog.tutorial.Application    : findAllByName - Person(id=36, name=Laura So, age=23)\n2019-02-11 09:04:54.524  INFO 13226 --- [actor-tcp-nio-5] com.lankydanblog.tutorial.Application    : findAllByAge - Person(id=35, name=Dan Newton, age=25)<\/pre>\n
A few things to take away here:<\/p>\n