@sdeleuze Awesome presentation! So much packed into so little time! 🙂

Thanks, glad you liked it. I tried to target both advanced developers and beginners, not easy but I did my best 🙂

I'm especially happy to see

kotlinx.serialization

in Spring Boot! We have so many unpleasing workaround for Jackson+Kotlin, this will be nice to have a Kotlin native way to serialize json.

Yeah that's my favorite as well, multiplatform FTW 😉

I'm super excited about the idea of being able to import/convert `@Configuration`into spring-fu.

that could allow for a more gradual migration instead of rewriting everything all at once

Yeah but mostly for infrastructure purpose for now, but maybe we could extend the scope later. You can try it -> https://github.com/spring-projects-experimental/spring-init

ah yeah I remember looking at spring-init. cool stuff. I also tring to wrap my head around how to modularize / resuse functional spring configurations. like if I have multiple ApplicationContextInitializer but I want 1 to make sure another is loaded so it can safely use beans created in the other

context is that I maintain an internal highly opinionated framework built on top of spring used by 100+ microservices, and it is modular

I have also thought about 1 big ApplicationContextInitializer with an api to enable/disable different parts of the framework

that seems like what spring-fu is doign under the hood

For now modular support is done via

enable(configFoo)

and is pretty basic, mainly additive for beans, replace for other, see related https://github.com/spring-projects-experimental/spring-fu/issues/292. I am open to explore improvements with concrete use cases.

hmm maybe I can start putting my configuration into AbstractDsl implementations, that can be invoked via

enable

in spring fu or just called within a Configuration / autoconfig provided by the library in traditional applications

Hey people is there any good read on

spring boot + coroutines

? I’m curious to figure out how they work together and if there are any concerns about leaks and creating additional threads outside of the spring scope

I believe spring data is

i’m trying to get into the reactive/co-routine stuff “learning by doing”-style i’ve a nice reactive application from R2DBC repo to router repo return a

Flux<T>

/

Mono<T>

where

T

is the entity i play with i’ve a caching service that checks first whether an entity is in the cache and returns it from here before querying the repo and the controller transforms the

Flux<T>

/

Mono<T>

to a

Mono<ServerResponse>

Hey guys, is there a way to access the coroutine context from an exception handler? Example:

data class CustomContext(val value: String) : AbstractCoroutineContextElement(Key) {
    object Key : CoroutineContext.Key<CustomContext>
}

@SpringBootApplication
class Application {

    @Bean
    fun router() = coRouter {
        GET("/test") { request ->
            withContext(CustomContext(value = "test")) {
                println(coroutineContext[CustomContext.Key]?.value)
                throw IllegalArgumentException()
            }
        }

        onError<IllegalArgumentException> { throwable, request ->
            println(coroutineContext[CustomContext.Key]?.value)
            status(INTERNAL_SERVER_ERROR).buildAndAwait()
        }
    }
}

The

CustomContext

is null inside

onError

function. Any ideas?

Anyone get Spring Boot 2.3.5.RELEASE" to work with webflux and coroutines 1.4.1 I tried

configurations.all {
        resolutionStrategy {
            force ("org.jetbrains.kotlinx:kotlinx-coroutines-core:$kotlinCoroutinesVersion")
        }
    }

Still didn't work getting error

Caused by: java.lang.NoSuchMethodError: kotlinx.coroutines.reactive.FlowSubscription.<init>(Lkotlinx/coroutines/flow/Flow;Lorg/reactivestreams/Subscriber;Lkotlin/coroutines/CoroutineContext;)V at kotlinx.coroutines.reactor.FlowAsFlux.subscribe(ReactorFlow.kt:39) at

My deps

+--- org.jetbrains.kotlinx:kotlinx-coroutines-reactor:1.4.1
|    +--- org.jetbrains.kotlinx:kotlinx-coroutines-core:1.4.1 (*)
|    +--- io.projectreactor:reactor-core:3.2.5.RELEASE -> 3.3.11.RELEASE (*)
|    +--- org.jetbrains.kotlinx:kotlinx-coroutines-reactive:1.4.1 -> 1.3.8
|    |    +--- org.jetbrains.kotlin:kotlin-stdlib:1.3.71 -> 1.4.10 (*)
|    |    +--- org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.8 -> 1.4.1 (*)
|    |    \--- org.reactivestreams:reactive-streams:1.0.2 -> 1.0.3
|    \--- org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.4.0 -> 1.4.10 (*)

👋🏽 I’m working with

spring-fu/kofu

and so far I’m a fan. However, I’m having a hard time rendering my

index.html

which exists in the

build/resources/main/static/

folder. My app is pretty small so far but the error I’m getting is the following. I believe when I visit

<http://localhost:8080/>

my

index.html

should render

javax.servlet.ServletException: Circular view path [index]: would dispatch back to the current handler URL [/index] again. Check your ViewResolver setup! (Hint: This may be the result of an unspecified view, due to default view name generation.)
	org.springframework.web.servlet.view.InternalResourceView.prepareForRendering(InternalResourceView.java:210)
	org.springframework.web.servlet.view.InternalResourceView.renderMergedOutputModel(InternalResourceView.java:148)
	org.springframework.web.servlet.view.AbstractView.render(AbstractView.java:316)

val app: KofuApplication = webApplication {
    webMvc {
        converters {
            resource()
        }

        router {
            accept(MediaType.TEXT_HTML).nest {
                GET("/") {
                    ServerResponse.ok().render("index")
                }
            }
            resources("/**", ClassPathResource("static/"))
        }
    }
}

fun main(args: Array<String>) {
    app.run(args)
}

I have significantly refined Kotlin Serialization support in Spring Framework

5.3.2-SNAPSHOT

, see https://github.com/spring-projects/spring-framework/commit/43faa439ab567c382e50ae670560024cebdf63d2 for more details, and feel free to test it with Spring Boot

2.4.0

or

2.4.1-SNAPSHOT

by defining

spring-framework.version=5.3.2-SNAPSHOT

in

gradle.properties

to check it behaves as expected. No more need for jackson exclusion.

Does that mean, that when you have serialization gradle plugin applied, kotlinx.serialization within project dependencies and

@Serializable

class, Kotlin serialization will be automatically used?

How about a use case with multiplatform project, when I have a class that is

@Serializable

on the client side but not on the server side (I use contextual serialization and use some types which are not automatically serializable). I think it will break things. It's not a hypothetical question - my KVision works that way (Kotlin seralization on the client side, Jackson on the server side).

I know Spring likes to detect things based on the classpath settings, but I think a simple property in the

application.yml

to select the serialization engine would be very useful.

I integrate Kotlin serialization in a wider ecosystem, and I need to follow Spring Framework and Spring Boot ways of dealing with featuer based on classpath detection. As you I like do things more explicitly hence Spring Fu but that's out of the scope here.

In Spring Framework 5.3.1 / Spring Boot 2.4.0, you had to exclude Jackson to make Kotlin serialization classpath detection effective. It was one or the other.

With Spring Framework 5.3.2 / Spring Boot 2.4.1, both will be configured if on the classpath, Kotlin serialization will be evaluated first (only takes care of Kotlin

@Serializable

and collection of those + collection of primitive types). Then forwarded to Jackson.

Without that Spring Boot error handling and actuators are broken.