with latest spring boot and kotlin I'd like to hav...

# spring

[Czar]

with latest spring boot and kotlin I'd like to have something like this:

@Component class MyComponent(...) {
  fun someFun() {
    /* do something non-transactional before the transaction */
    inTransaction(txType = TxType.REQUIRED, readOnly = false) {
      /* do something inside a transaction */
    }
    /* do something non-transactional after the transaction */
  }
}

What would be the best way to implement the inTransaction fun?

[Thiago Nerys]

@Component
class TransactionHelper {

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    fun <T> runOnSeparateTx(handler: () -> T): T {
        return handler()
    }

    @Async("limitedExecutor")
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    fun <T> runOnSeparateTxAsync(handler: () -> T?): CompletableFuture<T?> {
        return CompletableFuture.completedFuture(handler())
    }
}

[dmnk_89]

or checkout TransactionTemplate

[dmnk_89]

https://www.baeldung.com/spring-programmatic-transaction-management

[Czar]

Currently I have this:

@Component
class TransactionSupport : InitializingBean {

	@Autowired
	private lateinit var m: PlatformTransactionManager

	override fun afterPropertiesSet() {
		manager = this.m
	}

	companion object {

		private lateinit var manager: PlatformTransactionManager

		fun <R> inTransaction(txType: TxType = TxType.REQUIRED, readOnly: Boolean = false, block: () -> R): R? {
			val template = TransactionTemplate(manager, buildTransactionDefinition(txType, readOnly))
			return template.execute {
				block.invoke()
			}
		}

		private fun buildTransactionDefinition(txType: TxType, readOnly: Boolean): TransactionDefinition {
			val def = RuleBasedTransactionAttribute()
			def.isReadOnly = readOnly
			def.setPropagationBehaviorName(PREFIX_PROPAGATION + txType.toString())
			return def
		}
	}
}

[Czar]

I can easily rewrite this to have inTransaction as top-level function instead of a companion object one, but both seem dirty.
What I'm asking is if there is a better way to have nice API like in my usage example where I can just write inTransaction { /* stuff */ } and not inject a helper manually

[Thiago Nerys]

You could create a @Transactional method on a superclass and extend that wherever you want to use that inTransaction { }, or creating an Extension fun <T> Any.inTransaction() calling that "static" implementation.

[Czar]

when we're talking inheritance vs injection, I'll take injection any day 🙂 So that's not an option.
Any.inTransaction does not make sense to me, why would I need a receiver there? It also doesn't improve on the main problem - static stuff.
I guess it's either static or inheritance or injection?

[Thiago Nerys]

Any.inTransaction makes the inTransaction method available for any class - even String.
I don't see any other option.

[dmnk_89]

I would suggest using Configuration instead of Component - you can setup it later to use as Auto-Configuration

@Configuration
@ConditionalOnBean(PlatformTransactionManager::class)
class TransactionSupport(private val m: PlatformTransactionManager) {
    
    @PostConstruct
    fun setup() {
        manager = this.m
    }

[dmnk_89]

and consider a case when there can be more than one TransactionManager if you want to release it as library 🙂

[Jukka Siivonen]

Out of curiosity what you currently have is, why dont you just do

@Component
    class TransactionSupport(
        @Autowired transactionTemplate: TransactionTemplate
    ) {
        ...
    }

(this doesn't answer your original question though)

[Jukka Siivonen]

Oh, is it because you want to expose it by companion object?

[Czar]

That's because it needs to construct TransactionTemplate using supplied parameters, like isolation for example.
I actually have configuration based setup too for other stuff, the @Component here was to try this approach out.
Here's my configuration based Command.execute():

private lateinit var STATIC_COMMAND_SERVICE: CommandService

interface Command<T> : Serializable {
	fun execute(): T {
		return STATIC_COMMAND_SERVICE.execute(this)
	}
}

@Configuration
internal class CommandServiceKotlinInitializer(
	commandService: CommandService
) {
	init {
		STATIC_COMMAND_SERVICE = commandService
	}
}

with this I can do MyCommand(/* stuff */).execute()

[Czar]

I ended up doing inTransaction in a similar way to command service, via configuration and private top-level var and public top level function