Hibernate-reactive: Aprimoramento - Integração com a anotação spring @Transactional

Bem, suponho que o Spring tenha algum tipo de conceito de interceptor onde você possa usar anotações para vincular um interceptor a uma chamada de método bean. Se você chamar withTransaction() de dentro de um interceptor como esse e, em seguida, delegar ao método bean, isso é tudo que o gerenciamento de transações declarativo é. Realmente deve ser apenas algumas linhas de código. (Pelo menos seria em CDI, tenho menos certeza sobre a primavera.)

A única sutileza é que você precisa de uma maneira de detectar se há uma transação já vinculada ao fluxo reativo atual. Em nossa pilha isso seria feito usando MP Contexts. Não faço ideia de como isso é feito na terra da Primavera.

(OTOH, se você está perguntando sobre como integrar com um gerenciador de transações XA, bem, isso é uma lata de worms totalmente diferente e não é realmente prático com o driver reativo no momento. Ainda não temos nenhuma transação realmente reativa gerentes.)

No momento, não precisamos de transações distribuídas

Então um interceptor que chama SessionFactory.withTransaction() deve funcionar bem.

Vou tentar desta forma e atualizar. obrigado

@gavinking parece que o Spring implementa o @Transactional usando o Aspect. Não é realmente tão importante, mas também pode ser mais simples para nós implementarmos.
Mas acho que não podemos fazer isso apenas se você expor uma API para openTransaction() commitTransaction() e rollbackTransaction() na classe Stage, pois temos uma API openSession() e closeSession(). Acho que o objeto de transação é necessário, e o withTransaction não é suficiente.
Isso faz sentido ?

Deve haver algum tipo de noção de um interceptor "ao redor" que permite que você envolva e encaminhe para o método.

(É verdade que você não pode fazer isso com interceptores antes/depois.)

Eu acho que é este: https://howtodoinjava.com/spring-aop/aspectj-around-annotation-example/

@gavinking , você pode elaborar sobre o que escreveu antes "Em nossa pilha, isso seria feito usando MP Contexts". verificar se uma transação já está vinculada no fluxo atual? Você pode se referir ao código ou testes que foram escritos. O mesmo para a sessão, como posso entender que uma sessão já está aberta no fluxo atual.
Obrigado.

Olha, eu não tenho ideia de como você faz isso na primavera. Você precisa de algum tipo de construção que seja como um threadlocal, mas um local vinculado ao fluxo reativo atual em vez do thread. Tenho certeza que eles devem ter algo.

Atualmente, não vou usar spring @Transactional, mas implementar nossa própria anotação transacional para evitar aprofundar muito o Spring. Então, minha pergunta anterior estava relacionada à sua frase "Em nossa pilha, isso seria feito usando MP Contexts".

"nossa pilha" == Quarkus.

Estou dizendo que você precisa encontrar algo semelhante no ambiente Spring.

Porque se você não puder vincular um valor ao fluxo reativo atual, não poderá ter transações declarativas, simples assim, e terá que gerenciar as transações "manualmente". (O que na verdade é supersimples apenas chamando withTransaction() . Eu realmente não entendo por que as pessoas pensam que precisam de uma anotação para isso.)

Mas tenho certeza que deve haver alguma maneira de fazer isso. Você só está perguntando para a pessoa errada.

Pode ser isso, mas eu realmente não sei https://projectreactor.io/docs/core/3.4.0-M1/api/index.html?reactor/util/context/Context.html

Talvez isto? https://www.baeldung.com/spring-transaction-active

Fechamento: substituído por #782.

@yaakov-berkovitch com as coisas que estou colocando em prática com o #779, deve ser ainda mais fácil para você implementar isso.

@gavinking Obrigado!!