Issue with JPARepository returning a Stream with Hibernate 6.6

[thees]

Hi,
originally I raised this issue as a spring boot issue here.
However, @wilkinsona said that this is not really a spring boot issue, but a change in hibernate 6.6 (compared to 6.5).

The new behavior breaks when the JPA Repository returns a Stream that is used to stream a response to a client through a spring Controller.

This means, that the JPA Stream interface cannot be used to stream data out of the application without "aggregating up" which allocates (too much) memory in the JVM.

I want to follow @wilkinsona 's advice and open an issue here.

Please see the details in the linked issue, there is also a demo project that can be executed to show the issue.
Thank you

[mp911de]

There is nothing we can do here. There are multiple issues with your code:

@RestController
class DemoController(
    private val demoService: DemoService,
) {
    data class DemoModelDto(
        val id: Long,
        val dtoString: String,
    )
    @GetMapping("/demo")
    @Transactional(readOnly = true)
    fun getDemoModels(): Flux<DemoModelDto> {
        val dtoStream = demoService.getDemoModels().map { t -> DemoModelDto(t.id!!, t.aString) }
        return Flux.fromStream(dtoStream)
    }
}

1. You're mixing reactive and imperative programming models. While with non-transactional sources that isn't an issue on its own, with Hibernate you're employing transactionality and resource control.
2. Using reactive return types with @Transactional causes reactive transaction management. Reactive transaction management isn't compatible with imperative transaction management as the underlying storage (thread locals vs. Reactor Subscriber Context) are different. There is no reactive transaction manager for JDBC
3. The actual transaction starts in your Repository, not the controller. Therefore, the transaction is closed with the call to the method returning a Stream

I think you could get away with returning a Java 8 Stream<DemoModelDto> in a manual transaction method and open-session-in-view.

Something along the lines of:

TransactionTemplate template = new TransactionTemplate(platformTransactionManager);
template.setReadOnly(true);
TransactionStatus status = platformTransactionManager.getTransaction(template);

try {
	return personRepository.findStreamBy().onClose(() -> {
		platformTransactionManager.commit(status);
	});
}
catch (RuntimeException e) {
	platformTransactionManager.rollback(status);
	throw e;
}

Managing transactions on your own comes with several aspects that you might not like such as loopholes for missing tx cleanup when using Java 8 Streams.

[djechelon]

We are facing a similar issue in a project I'm following.

From my investigation, SimpleJpaRepository is annotated @Transactional(readonly=true)
From my understanding of this topic, the stream, in order to survive the method scope, must either have its own transaction (like suggested above) or not have any.