此版本仍在开发中，尚未被视为稳定版本。对于最新的稳定版本，请使用 Spring Framework 6.1.10！Spring中文文档

此版本仍在开发中，尚未被视为稳定版本。对于最新的稳定版本，请使用 Spring Framework 6.1.10！Spring中文文档

Kotlin 协程是 Kotlin 轻量级线程允许以命令式方式编写非阻塞代码。在语言方面， 挂起函数为异步操作提供了抽象，而在库端，kotlinx.coroutines 提供了 async { } 等函数和 Flow 等类型。Spring中文文档

Spring Framework 在以下范围内提供对协程的支持：Spring中文文档

依赖

当类路径中存在依赖项时，将启用协程支持：kotlinx-coroutines-corekotlinx-coroutines-reactorSpring中文文档

build.gradle.ktsSpring中文文档

dependencies {

	implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:${coroutinesVersion}")
	implementation("org.jetbrains.kotlinx:kotlinx-coroutines-reactor:${coroutinesVersion}")
}

支持及以上版本。1.4.0Spring中文文档

反应式如何转化为协程？

对于返回值，从响应式 API 到协程 API 的转换如下：Spring中文文档

  • fun handler(): Mono<Void>成为suspend fun handler()Spring中文文档

  • fun handler(): Mono<T>变为或取决于是否可以为空（优点是更静态类型）suspend fun handler(): Tsuspend fun handler(): T?MonoSpring中文文档

  • fun handler(): Flux<T>成为fun handler(): Flow<T>Spring中文文档

对于输入参数：Spring中文文档

  • 如果不需要懒惰，则变为，因为可以调用挂起函数来获取 value 参数。fun handler(mono: Mono<T>)fun handler(value: T)Spring中文文档

  • 如果需要懒惰，则变成或fun handler(mono: Mono<T>)fun handler(supplier: suspend () → T)fun handler(supplier: suspend () → T?)Spring中文文档

流在协程世界中是等价的，适用于热流或冷流，有限流或无限流，主要区别如下：FluxSpring中文文档

阅读这篇关于使用 Spring、协程和 Kotlin Flow 进行响应的博文，了解更多详细信息，包括如何与协程并发运行代码。Spring中文文档

控制器

下面是协程的示例。@RestControllerSpring中文文档

@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 进行视图渲染。@ControllerSpring中文文档

@Controller
class CoroutinesViewController(banner: Banner) {

	@GetMapping("/")
	suspend fun render(model: Model): String {
		delay(10)
		model["banner"] = banner
		return "index"
	}
}

WebFlux.fn

下面是通过 coRouter { } DSL 和相关处理程序定义的协程路由器示例。Spring中文文档

@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 开始提供事务管理。Spring中文文档

对于挂起功能，提供了一个扩展。TransactionalOperator.executeAndAwaitSpring中文文档

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 ，提供了一个扩展。FlowFlow<T>.transactionalSpring中文文档

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