implementation 'org.springframework.boot:spring-boot-starter-cache'

@EnableCaching

@Repository
class SomeRepository {
    @Cacheable("items")
    suspend fun loadSomeItem(id: String): SomeItem { ... }
}

Error:

500 Server Error for HTTP GET "/api/endpoint" java.lang.IllegalStateException: The returnType class java.lang.Object on public java.lang.Object com.mybackend.controller.Controller.get(java.util.Map,java.lang.String,kotlin.coroutines.Continuation) must return an instance of org.reactivestreams.Publisher (i.e. Mono / Flux) in order to support Reactor Context\n at org.springframework.security.access.prepost.PrePostAdviceReactiveMethodInterceptor.invoke(PrePostAdviceReactiveMethodInterceptor.java:76)\n Suppressed:

@RestController
@RequestMapping("/api/endpoint")
class Controller(private val service: MyService) {
 @GetMapping("")
 suspend fun get(@RequestParam queryParams: Map<String, String>,
                 @RequestHeader("authorization") token: String): ResponseEntity<out ApiResponse> {
    return service.item().awaitSingle()
 }
}

Mono

user

package kr.co.korbit.config

:::

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(entityManagerFactoryRef = "jpaKorbitEntityManagerFactory",
        transactionManagerRef = "jpaKorbitTransactionManager",
        basePackages = ["kr.co.korbit.jpa.korbit.repository", "kr.co.korbit.jpa.korbit.repository.custom", "kr.co.korbit.jpa.korbit.repository.impl"])
class JpaKorbitConfig {

    @Autowired(required = false)
    private val persistenceUnitManager: PersistenceUnitManager? = null


    @Bean(name = ["jpaKorbitDataSource"])
    @ConfigurationProperties(prefix = "spring.datasource.korbit")
    @Primary
    fun jpaKorbitDataSource(): DataSource {
        val dataSource = DataSourceBuilder.create().type(HikariDataSource::class.java).build()
        //dataSource.connectionInitSql = "SET NAMES utf8mb4; set @@session.time_zone = '+00:00'"
        return dataSource
    }


    @Bean(name = ["jpaKorbitEntityManagerFactoryBuilder"])
    @Primary
    fun jpaKorbitEntityManagerFactoryBuilder(): EntityManagerFactoryBuilder {
        val adapter = HibernateJpaVendorAdapter()
        adapter.setShowSql(true)
        adapter.setPrepareConnection(true)
        adapter.setDatabase(Database.MYSQL)
        adapter.setDatabasePlatform(Env.dialect)
        adapter.setGenerateDdl(false)
        val properties = HashMap<String, String?>()
        properties["hibernate.ddl-auto"] = Env.ddlAuto
        properties["hibernate.default_batch_fetch_size"] = "300"
        properties["show_sql"] = Env.showSqlFlag
        properties["format_sql"] = "true"
        properties["use_sql_comments"] = Env.useSqlCommentFlag
        properties["hibernate.naming.implicit-strategy}"] = Env.implicitStrategy
        properties["hibernate.naming.physical-strategy}"] = Env.physicalStrategy
        properties["hibernate.use-new-id-generator-mappings"] = Env.useNewIdGeneratorMappingsFlag
        //builder.setCallback(getVendorCallback());
        return EntityManagerFactoryBuilder(
                adapter, properties, persistenceUnitManager)
    }


    @Bean(name = ["jpaKorbitEntityManagerFactory"])
    @Primary
    fun jpaKorbitEntityManagerFactory(
            @Qualifier("jpaKorbitEntityManagerFactoryBuilder") builder: EntityManagerFactoryBuilder,
            @Qualifier("jpaKorbitDataSource") jpaKorbitDataSource: DataSource?): LocalContainerEntityManagerFactoryBean {
        val factory =  builder
                .dataSource(jpaKorbitDataSource)
//                .packages("kr.co.korbit.gia.jpa.kotbit.model")
                .persistenceUnit("korbit")
                .build()

        factory.setPackagesToScan("kr.co.korbit.gia.jpa.korbit.model")
        return factory
    }


    @Bean(name = ["jpaKorbitTransactionManager"])
    @Primary
    fun jpaKorbitTransactionManager(
            @Qualifier("jpaKorbitEntityManagerFactory") jpaKorbitEntityManagerFactory: EntityManagerFactory): PlatformTransactionManager {
        return JpaTransactionManager(jpaKorbitEntityManagerFactory)
    }

    @Bean(name = ["jpaKorbitQueryFactory"])
    fun jpaKorbitQueryFactory(@Qualifier("jpaKorbitEntityManagerFactory") jpaKorbitEntityManagerFactory: EntityManagerFactory): JPAQueryFactory {

        return JPAQueryFactory(jpaKorbitEntityManagerFactory.createEntityManager())
    }
}

GcpFirestoreAutoConfiguration

@Repository
interface KorbitErrorWriterRepository : JpaRepository<KorbitError, String> {
}

@Repository
@Transactional(transactionManager = "jpaSecondTransactionManager")
interface LneQuestRepository: JpaRepository<LneQuest, Long> {