spring reactive get locale in repository #Query - spring-boot

Question

I have localized entities in a reactive spring boot application.
The current implementation works fine by depending on the Accept-Language header:
Controller
#RestController
class TaskController(val taskService: TaskService) {
#GetMapping("/tasks")
suspend fun getTasks(locale: Locale): Map<Long?,Task> {
return taskService.getTasks(locale).toList().associateBy(Task::id)
}
}
Service
#Service
class TaskServiceImpl(val taskRepository : TaskRepository) : TaskService {
override fun getTasks(locale: Locale): Flow<Task> {
return taskRepository.findWithLocale(locale.language)
}
Repository
interface TaskRepository : CoroutineCrudRepository<Task, Long> {
#Query("SELECT * FROM task t LEFT JOIN task_l10n tl10n ON tl10n.task_id=t.id WHERE tl10n.locale = :locale")
fun findWithLocale(locale: String): Flow<Task>
}
Question
As you can see, I need to pass down the locale from the controller to the service and then to the repository. Because a lot of our API will suffer from this noise/boilerplate I wonder if I somehow can use/inject the locale.language in a #Query("... where locale = :locale") without passing it as a parameter?
In MVC we could use LocaleContextHolder.getLocale() at least on the service level and get rid of some of the noise but it is not available in a reactive stack because it is bound to the thread and not to the coroutine.
APPROACH
From this spring.io post I hope to be able to setup the SpEL evaluation context in a request-aware way - i.e. to access the locale of the current request.
Something along the lines of this
#Query("... WHERE tl10n.locale = ?#{locale().language}"
But I cannot figure out these things:
how to put the reactive context on the SpEL context on a per request basis?
How to populate the reactive context with the request's locale?
Step 1
First I found that the exchange would provide access to the locale by debugging how Spring resolves the controller method's argument: it's done in ServerWebExchangeMethodArgumentResolver
exchange.getLocaleContext().getLocale()
So if I could access the exchange from a SpEL context, I would be happy.
?#{exchange.getLocaleContext().getLocale()}
which is not possible, because the SpEL context does not know about the reactive context:
Property or field 'exchange' cannot be found on object of type 'java.lang.Object[]' - maybe not public or not valid?
Step 2
Next I figured out that I can come up with a SpEL extension holding the locale and add the extension to the reactive repositories (actually I am using kotlin coroutines based CoroutineCrudRepository) by using a BeanPostProcessor on my repositories to make my custom SpEL extension available in the #Query("... ?#{locale()}") methods:
/**
* Adds extensions to the SpEL evaluation context.
*/
#Configuration
class RepositorySpELExtensionConfiguration {
companion object {
// list of provided extensions
val contextProviderWithExtensions =
ReactiveExtensionAwareQueryMethodEvaluationContextProvider(listOf(ReactiveLocaleAwareSpELExtension.INSTANCE))
}
/**
* Registers the customizer to the context to make spring aware of the bean post processor.
*/
#Bean
fun spELContextInRepositoriesCustomizer(): AddExtensionsToRepositoryBeanPostProcessor {
return AddExtensionsToRepositoryBeanPostProcessor()
}
/**
* Sets the [contextProviderWithExtensions] for SpEL in the [R2dbcRepositoryFactoryBean]s which makes the extensions
* usable in `#Query(...)` methods.
*/
class AddExtensionsToRepositoryBeanPostProcessor : BeanPostProcessor {
override fun postProcessBeforeInitialization(bean: Any, beanName: String): Any {
if (bean is R2dbcRepositoryFactoryBean<*, *, *>) {
bean.addRepositoryFactoryCustomizer { it.setEvaluationContextProvider(contextProviderWithExtensions) }
}
return bean
}
}
/**
* Makes the [LocaleAwareSpELExtension] available in a reactive context.
*/
enum class ReactiveLocaleAwareSpELExtension : ReactiveEvaluationContextExtension {
INSTANCE;
override fun getExtension(): Mono<out EvaluationContextExtension> {
return Mono.just(LocaleAwareSpELExtension("en"))
}
override fun getExtensionId(): String {
ReactiveQueryMethodEvaluationContextProvider.DEFAULT
return "localeAwareSpELExtension"
}
}
/**
* Provides the requests locale as SpEL extension.
*
* Use it like this:
* ```
* #Query("... WHERE locale = :#{locale()}")
* ```
*/
class LocaleAwareSpELExtension(private val locale: String) : EvaluationContextExtension {
override fun getRootObject(): LocaleAwareSpELExtension {
return this
}
override fun getExtensionId(): String {
return "localeAwareSpELExtension"
}
#Suppress("unused") // Potentially used by `#Query(...) methods.
fun locale(): String {
return locale
}
}
}
This works fine hurray - but as you can see, I hardcoded the locale to "en" when creating the extension.
override fun getExtension(): Mono<out EvaluationContextExtension> {
return Mono.just(LocaleAwareSpELExtension("en"))
}
When debugging this line, I know that it is executed on a per request basis, which makes me hope that I should be able to somehow use the request context to populate the locale.
Step 3
I am stuck on how to get the request context to populate the locale in the SpEL extension as shown in step 2. This is what I try:
override fun getExtension(): Mono<out EvaluationContextExtension> {
return Mono.deferContextual { it.get<Mono<ServerWebExchange>>(ServerWebExchangeContextFilter.EXCHANGE_CONTEXT_ATTRIBUTE) }
.map { it.localeContext.locale?.language ?: "en" }
.map { LocaleAwareSpELExtension(it) }
}
but the exchange is not available in the context:
Context does not contain key: org.springframework.web.filter.reactive.ServerWebExchangeContextFilter.EXCHANGE_CONTEXT
From what I understand the context is not populated, because the Mono is not returned from the spring controller but it is used in the Query SpEL and I guess this is not the same context chain?
I think it must be possible, because it is similar to how the principal and security context would be made available, but I not fully understand how ReactiveSecurityContextHolder works - especially not how exactly it is populated for the SpEL context. In fact, in my default configuration it is not even populated - again I think because it is not the same context chain. Another difference here is that spring explicitly sets the security context to the reactive context in the ReactorContextWebFilter.
I think I now could create my own reactive request filter to populate the locale context, but I don't know how to make the reactive context available to the SpEL context.

Answer 1

Turns out adding the filter works (s. below). I still don't fully understand how the context population of SpEL VS reactive context works in this scenario, but it works..
#Component
class ReactorContextLocaleWebFilter : WebFilter {
companion object {
val KEY = ReactorContextLocaleWebFilter::class.java
}
override fun filter(exchange: ServerWebExchange, chain: WebFilterChain): Mono<Void> {
return chain.filter(exchange).contextWrite { context: Context ->
if (context.hasKey(KEY))
context
else
withLocaleContext(context, exchange)
}
}
private fun withLocaleContext(mainContext: Context, exchange: ServerWebExchange): Context {
return mainContext
.putAll(Mono.just(exchange.localeContext.locale?.language ?: "en").`as` { lang: Mono<String> ->
Context.of(KEY, lang).readOnly()
})
}
}
and then adjusting the extension creation to use the web filter:
override fun getExtension(): Mono<out EvaluationContextExtension> {
return Mono.deferContextual { it.get<Mono<String>>(ReactorContextLocaleWebFilter.KEY) }
.map { LocaleAwareSpELExtension(it) }
}