Kotlin 协程是 Kotlin
轻量级线程允许以命令式方式编写非阻塞代码。在语言方面,
挂起函数为异步操作提供了抽象,而在库端,kotlinx.coroutines 提供了 async { }
等函数和 Flow
等类型。
Spring Framework 在以下范围内提供对协程的支持:
-
暂停 Spring MVC 和 WebFlux 注释中的函数支持
@Controller
-
WebFlux.fn coRouter { } DSL
-
WebFlux
CoWeb过滤器
-
RSocket 注释方法中的挂起函数和支持
Flow
@MessageMapping
-
RSocketRequester
的扩展 -
春季 AOP
依赖
当类路径中存在依赖项时,将启用协程支持:kotlinx-coroutines-core
kotlinx-coroutines-reactor
build.gradle.kts
dependencies {
implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:${coroutinesVersion}")
implementation("org.jetbrains.kotlinx:kotlinx-coroutines-reactor:${coroutinesVersion}")
}
支持及以上版本。1.4.0
反应式如何转化为协程?
对于返回值,从响应式 API 到协程 API 的转换如下:
-
fun handler(): Mono<Void>
成为suspend fun handler()
-
fun handler(): Mono<T>
变为或取决于是否可以为空(优点是更静态类型)suspend fun handler(): T
suspend fun handler(): T?
Mono
-
fun handler(): Flux<T>
成为fun handler(): Flow<T>
对于输入参数:
-
如果不需要懒惰,则变为,因为可以调用挂起函数来获取 value 参数。
fun handler(mono: Mono<T>)
fun handler(value: T)
-
如果需要懒惰,则变成或
fun handler(mono: Mono<T>)
fun handler(supplier: suspend () → T)
fun handler(supplier: suspend () → T?)
流
在协程世界中是等价的,适用于热流或冷流,有限流或无限流,主要区别如下:Flux
-
Flow
是基于推送的,而是基于推拉混合的Flux
-
背压通过悬挂功能实现
-
借助协程,运算符易于实现
-
扩展允许将自定义运算符添加到
Flow
-
收集操作正在暂停功能
-
Map
Operator 支持异步操作(不需要 ),因为它需要挂起函数参数flatMap
阅读这篇关于使用 Spring、协程和 Kotlin Flow 进行响应的博文,了解更多详细信息,包括如何与协程并发运行代码。
控制器
下面是协程的示例。@RestController
@RestController
class CoroutinesRestController(client: WebClient, banner: Banner) {
@GetMapping("/suspend")
suspend fun suspendingEndpoint(): Banner {
delay(10)
return banner
}
@GetMapping("/flow")
fun flowEndpoint() = flow {
delay(10)
emit(banner)
delay(10)
emit(banner)
}
@GetMapping("/deferred")
fun deferredEndpoint() = GlobalScope.async {
delay(10)
banner
}
@GetMapping("/sequential")
suspend fun sequential(): List<Banner> {
val banner1 = client
.get()
.uri("/suspend")
.accept(MediaType.APPLICATION_JSON)
.awaitExchange()
.awaitBody<Banner>()
val banner2 = client
.get()
.uri("/suspend")
.accept(MediaType.APPLICATION_JSON)
.awaitExchange()
.awaitBody<Banner>()
return listOf(banner1, banner2)
}
@GetMapping("/parallel")
suspend fun parallel(): List<Banner> = coroutineScope {
val deferredBanner1: Deferred<Banner> = async {
client
.get()
.uri("/suspend")
.accept(MediaType.APPLICATION_JSON)
.awaitExchange()
.awaitBody<Banner>()
}
val deferredBanner2: Deferred<Banner> = async {
client
.get()
.uri("/suspend")
.accept(MediaType.APPLICATION_JSON)
.awaitExchange()
.awaitBody<Banner>()
}
listOf(deferredBanner1.await(), deferredBanner2.await())
}
@GetMapping("/error")
suspend fun error() {
throw IllegalStateException()
}
@GetMapping("/cancel")
suspend fun cancel() {
throw CancellationException()
}
}
还支持使用 a 进行视图渲染。@Controller
@Controller
class CoroutinesViewController(banner: Banner) {
@GetMapping("/")
suspend fun render(model: Model): String {
delay(10)
model["banner"] = banner
return "index"
}
}
WebFlux.fn
下面是通过 coRouter { } DSL 和相关处理程序定义的协程路由器示例。
@Configuration
class RouterConfiguration {
@Bean
fun mainRouter(userHandler: UserHandler) = coRouter {
GET("/", userHandler::listView)
GET("/api/user", userHandler::listApi)
}
}
class UserHandler(builder: WebClient.Builder) {
private val client = builder.baseUrl("...").build()
suspend fun listView(request: ServerRequest): ServerResponse =
ServerResponse.ok().renderAndAwait("users", mapOf("users" to
client.get().uri("...").awaitExchange().awaitBody<User>()))
suspend fun listApi(request: ServerRequest): ServerResponse =
ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).bodyAndAwait(
client.get().uri("...").awaitExchange().awaitBody<User>())
}
交易
协程上的事务通过 Reactive 的编程变体支持 从 Spring Framework 5.2 开始提供事务管理。
对于挂起功能,提供了一个扩展。TransactionalOperator.executeAndAwait
import org.springframework.transaction.reactive.executeAndAwait
class PersonRepository(private val operator: TransactionalOperator) {
suspend fun initDatabase() = operator.executeAndAwait {
insertPerson1()
insertPerson2()
}
private suspend fun insertPerson1() {
// INSERT SQL statement
}
private suspend fun insertPerson2() {
// INSERT SQL statement
}
}
对于 Kotlin ,提供了一个扩展。Flow
Flow<T>.transactional
import org.springframework.transaction.reactive.transactional
class PersonRepository(private val operator: TransactionalOperator) {
fun updatePeople() = findPeople().map(::updatePerson).transactional(operator)
private fun findPeople(): Flow<Person> {
// SELECT SQL statement
}
private suspend fun updatePerson(person: Person): Person {
// UPDATE SQL statement
}
}