Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/hantsy/spring-kotlin-coroutines-sample
Spring Kotlin Coroutines sample
https://github.com/hantsy/spring-kotlin-coroutines-sample
kotlin-coroutines spring-boot spring-data-mongodb-reactive spring-data-neo4j spring-data-r2dbc
Last synced: 19 days ago
JSON representation
Spring Kotlin Coroutines sample
- Host: GitHub
- URL: https://github.com/hantsy/spring-kotlin-coroutines-sample
- Owner: hantsy
- License: gpl-3.0
- Created: 2019-04-14T13:40:54.000Z (over 5 years ago)
- Default Branch: master
- Last Pushed: 2024-01-31T08:24:59.000Z (10 months ago)
- Last Synced: 2024-10-10T18:44:08.456Z (about 1 month ago)
- Topics: kotlin-coroutines, spring-boot, spring-data-mongodb-reactive, spring-data-neo4j, spring-data-r2dbc
- Language: Kotlin
- Size: 137 KB
- Stars: 54
- Watchers: 4
- Forks: 16
- Open Issues: 2
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# Using Kotlin Coroutines with Spring
Before Spring 5.2, you can experience Kotlin Coroutines by the effort from community, eg. [spring-kotlin-coroutine ](https://github.com/konrad-kaminski/spring-kotlin-coroutine) on Github. There are several features introduced in Spring 5.2, besides [the functional programming style introduced in Spring MVC](https://github.com/hantsy/spring-webmvc-functional-sample), another attractive feature is that Kotlin Coroutines is finally got official support.
Kotlin coroutines provides an alternative approach to write asynchronous applications with Spring Reactive stack, but coding in an imperative style.
In this post, I will rewrite [my previous reactive sample](https://github.com/hantsy/spring-reactive-sample) using Kotlin Coroutines with Spring.
Generate a Spring Boot project using [Spring initializr](https://start.spring.io). Choose the following options in the Web UI, others accept the default options.
* Language: Kotlin
* Spring Boot version : 2.2.0.BUILD-SNAPSHOT
* Dependencies: Web Reactive
Extract the files into your local disk. Open the *pom.xml* file in the project root folder, add some modification to get Kotlin Coroutines work in this project.
Add kotlin-coroutines related dependencies in the *dependencies* section.
```xml
org.jetbrains.kotlinx
kotlinx-coroutines-core
${kotlinx-coroutines.version}
org.jetbrains.kotlinx
kotlinx-coroutines-reactor
${kotlinx-coroutines.version}
```
Define a **kotlin-coroutines.version** in the properties using the latest 1.2.0 version.
```xml
1.2.0
```
Kotlin coroutines 1.2.0 is compatible with Kotlin 1.3.30, define a `kotlin.version` property to override the default value in the parent BOM.
```xml
1.3.30
```
Currently Spring Data project is busy in adding Kotlin Coroutines support. At the moment Spring Data R2DBC got basic coroutines support in its `DatabaseClient`. In this sample, we use Spring Data R2DBC for data operations.
Add Spring Data R2DBC related dependencies, and use PostgresSQL as the backend database.
```xml
org.springframework.data
spring-data-r2dbc
${spring-data-r2dbc.version}
org.postgresql
postgresql
io.r2dbc
r2dbc-postgresql
```
Declare a `spring-data-r2dbc.version` property to use latest Spring Data R2DBC .
```xml
1.0.0.BUILD-SNAPSHOT
```
Enables Data R2dbc support by subclassing `AbstractR2dbcConfiguration`.
```java
@Configuration
@EnableR2dbcRepositories
class DatabaseConfig : AbstractR2dbcConfiguration() {
override fun connectionFactory(): ConnectionFactory {
return PostgresqlConnectionFactory(
PostgresqlConnectionConfiguration.builder()
.host("localhost")
.database("test")
.username("user")
.password("password")
.build()
)
}
}
```
Create a Kotlin data class, annotate it with `@Table` which indicates it is mapped to the table `posts`.
```java
@Table("posts")
data class Post(@Id val id: Long? = null,
@Column("title") val title: String? = null,
@Column("content") val content: String? = null
)
```
Follow the [Reactive stack to Kotlin Coroutines translation guide](https://docs.spring.io/spring/docs/5.2.0.M1/spring-framework-reference/languages.html#how-reactive-translates-to-coroutines) provided in Spring reference documentation, we create a repository class for CRUD operations of `Post`.
```java
@Component
class PostRepository(private val client: DatabaseClient) {
suspend fun count(): Long =
client.execute().sql("SELECT COUNT(*) FROM posts")
.asType().fetch().awaitOne()
fun findAll(): Flow =
client.select().from("posts").asType().fetch().flow()
suspend fun findOne(id: Long): Post? =
client.execute()
.sql("SELECT * FROM posts WHERE id = \$1")
.bind(0, id).asType()
.fetch()
.awaitOneOrNull()
suspend fun deleteAll() =
client.execute()
.sql("DELETE FROM posts")
.fetch()
.rowsUpdated()
.awaitSingle()
suspend fun save(post: Post) =
client.insert()
.into()
.table("posts")
.using(post)
.await()
suspend fun init() {
save(Post(title = "My first post title", content = "Content of my first post"))
save(Post(title = "My second post title", content = "Content of my second post"))
}
}
```
It is easy to understand the above codes, for the return type of these functions.
* The `Flux` is changed to Kotlin Coroutines `Flow` type.
* The `Mono` type is unboxed to parameterized type, and add a `suspend` modifier to the function. If the return result can be null, add a `?` to the return type, eg. `Post?`.
* The `awaitXXX` or `flow()` converts the Reactive APIs to Kotlin Coroutines world.
Create a Controller class for `Post`, Kotlin Coroutines is also supported in the annotated controllers.
```java
@RestController
@RequestMapping("/posts")
class PostController(
private val postRepository: PostRepository
) {
@GetMapping("")
fun findAll(): Flow =
postRepository.findAll()
@GetMapping("{id}")
suspend fun findOne(@PathVariable id: Long): Post? =
postRepository.findOne(id) ?: throw PostNotFoundException(id)
@PostMapping("")
suspend fun save(@RequestBody post: Post) =
postRepository.save(post)
@GetMapping("{id}/comments")
fun findCommentsByPostId(@PathVariable id: Long): Flow =
commentRepository.findByPostId(id)
}
```
You can also initialize data in a `CommandLineRunner` bean or listen the `@ApplicationReadyEvent`, use a `runBlocking` to wrap coroutines tasks.
```kotlin
runBlocking {
val deleted = postRepository.deleteAll()
println(" $deleted posts was cleared.")
postRepository.init()
}
```
To run the application successfully, make sure there is a running PostgreSQL server. I prepared a [docker compose file](https://github.com/hantsy/spring-kotlin-coroutines-sample/docker-compose.yml) to simply run a PostgresSQL server and initialize the database schema in a docker container.
```sh
docker-compose up
```
Run the application now, it should work well as [the previous Reactive examples](https://github.com/hantsy/spring-reactive-sample).
In additional to the annotated controllers, Kotlin Coroutines is also supported in functional RouterFunction DSL using the `coRouter` to define your routing rules.
```kotlin
@Configuration
class RouterConfiguration {
@Bean
fun routes(postHandler: PostHandler) = coRouter {
"/posts".nest {
GET("", postHandler::all)
GET("/{id}", postHandler::get)
POST("", postHandler::create)
PUT("/{id}", postHandler::update)
DELETE("/{id}", postHandler::delete)
}
}
}
```
Like the changes in the controller, the `PostHandler` is written in an imperative style.
```kotlin
@Component
class PostHandler(private val posts: PostRepository) {
suspend fun all(req: ServerRequest): ServerResponse {
return ok().bodyAndAwait(this.posts.findAll())
}
suspend fun create(req: ServerRequest): ServerResponse {
val body = req.awaitBody()
val createdPost = this.posts.save(body)
return created(URI.create("/posts/$createdPost")).buildAndAwait()
}
suspend fun get(req: ServerRequest): ServerResponse {
println("path variable::${req.pathVariable("id")}")
val foundPost = this.posts.findOne(req.pathVariable("id").toLong())
println("found post:$foundPost")
return when {
foundPost != null -> ok().bodyAndAwait(foundPost)
else -> notFound().buildAndAwait()
}
}
suspend fun update(req: ServerRequest): ServerResponse {
val foundPost = this.posts.findOne(req.pathVariable("id").toLong())
val body = req.awaitBody()
return when {
foundPost != null -> {
this.posts.update(foundPost.copy(title = body.title, content = body.content))
noContent().buildAndAwait()
}
else -> notFound().buildAndAwait()
}
}
suspend fun delete(req: ServerRequest): ServerResponse {
val deletedCount = this.posts.deleteById(req.pathVariable("id").toLong())
println("$deletedCount posts was deleted")
return notFound().buildAndAwait()
}
}
```
Besides annotated controllers and functional router DSL, Spring `WebClient` also embrace Kotlin Coroutines.
```kotlin
@RestController
@RequestMapping("/posts")
class PostController(private val client: WebClient) {
@GetMapping("")
suspend fun findAll() =
client.get()
.uri("/posts")
.accept(MediaType.APPLICATION_JSON)
.awaitExchange()
.bodyToFlow()
@GetMapping("/{id}")
suspend fun findOne(@PathVariable id: Long): PostDetails = withDetails(id)
private suspend fun withDetails(id: Long): PostDetails {
val post =
client.get().uri("/posts/$id")
.accept(APPLICATION_JSON)
.awaitExchange().awaitBody()
val count =
client.get().uri("/posts/$id/comments/count")
.accept(APPLICATION_JSON)
.awaitExchange().awaitBody()
return PostDetails(post, count)
}
}
```
In the `withDetails` method, the post and count call the remote APIs one by one in a sequence.
If you want to perform coroutines in parallel, use `async` context to wrap every calls, and put all tasks in a `coroutineScope` context. To build the return result in `PostDetails`, use `await` to wait the completion of the remote calls.
```kotlin
private suspend fun withDetails(id: Long): PostDetails = coroutineScope {
val post = async {
client.get().uri("/posts/$id")
.accept(APPLICATION_JSON)
.awaitExchange().awaitBody()
}
val count = async {
client.get().uri("/posts/$id/comments/count")
.accept(APPLICATION_JSON)
.awaitExchange().awaitBody()
}
PostDetails(post.await(), count.await())
}
```
Check out the [codes](https://github.com/hantsy/spring-kotlin-coroutines-sample) from Github.