diff --git a/hibernate-reactive-core/src/main/java/org/hibernate/reactive/persister/entity/mutation/GeneratorValueUtil.java b/hibernate-reactive-core/src/main/java/org/hibernate/reactive/persister/entity/mutation/GeneratorValueUtil.java index 19eac0cec..9514a1f5d 100644 --- a/hibernate-reactive-core/src/main/java/org/hibernate/reactive/persister/entity/mutation/GeneratorValueUtil.java +++ b/hibernate-reactive-core/src/main/java/org/hibernate/reactive/persister/entity/mutation/GeneratorValueUtil.java @@ -6,7 +6,9 @@ package org.hibernate.reactive.persister.entity.mutation; import static org.hibernate.reactive.util.impl.CompletionStages.completedFuture; + import java.util.concurrent.CompletionStage; + import org.hibernate.engine.spi.SharedSessionContractImplementor; import org.hibernate.generator.BeforeExecutionGenerator; import org.hibernate.generator.EventType; @@ -22,27 +24,26 @@ final class GeneratorValueUtil { - private GeneratorValueUtil() { - } - - - static CompletionStage generateValue( - SharedSessionContractImplementor session, Object entity, Object currentValue, - BeforeExecutionGenerator generator, EventType eventType) { - if (generator instanceof StageGenerator) { - final Stage.Session stageSession = new StageSessionImpl( (ReactiveSession) session ); - return ((StageGenerator) generator).generate(stageSession, entity, currentValue, eventType); - } - - if (generator instanceof MutinyGenerator) { - MutinySessionFactoryImpl mutinyFactory = new MutinySessionFactoryImpl( (SessionFactoryImpl) session.getFactory() ); - Mutiny.Session mutinySession = new MutinySessionImpl( (ReactiveSession) session, mutinyFactory ); - return ((MutinyGenerator) generator).generate(mutinySession, entity, currentValue, eventType).subscribeAsCompletionStage(); - } - - - // We should throw an exception, but I don't want to break things for people using @CreationTimestamp or similar - // annotations. We need an alternative for Hibernate Reactive. - return completedFuture( generator.generate( session, entity, currentValue, eventType) ); - } + private GeneratorValueUtil() { + } + + static CompletionStage generateValue( + SharedSessionContractImplementor session, Object entity, Object currentValue, + BeforeExecutionGenerator generator, EventType eventType) { + if ( generator instanceof StageGenerator ) { + final Stage.Session stageSession = new StageSessionImpl( (ReactiveSession) session ); + return ( (StageGenerator) generator ).generate( stageSession, entity, currentValue, eventType ); + } + + if ( generator instanceof MutinyGenerator ) { + MutinySessionFactoryImpl mutinyFactory = new MutinySessionFactoryImpl( (SessionFactoryImpl) session.getFactory() ); + Mutiny.Session mutinySession = new MutinySessionImpl( (ReactiveSession) session, mutinyFactory ); + return ( (MutinyGenerator) generator ).generate( mutinySession, entity, currentValue, eventType ) + .subscribeAsCompletionStage(); + } + + // We should throw an exception, but I don't want to break things for people using @CreationTimestamp or similar + // annotations. We need an alternative for Hibernate Reactive. + return completedFuture( generator.generate( session, entity, currentValue, eventType ) ); + } } diff --git a/hibernate-reactive-core/src/main/java/org/hibernate/reactive/tuple/MutinyGenerator.java b/hibernate-reactive-core/src/main/java/org/hibernate/reactive/tuple/MutinyGenerator.java index cb7c564c3..20c9ce6fb 100644 --- a/hibernate-reactive-core/src/main/java/org/hibernate/reactive/tuple/MutinyGenerator.java +++ b/hibernate-reactive-core/src/main/java/org/hibernate/reactive/tuple/MutinyGenerator.java @@ -16,11 +16,9 @@ public abstract class MutinyGenerator implements BeforeExecutionGenerator { @Override - public Object generate(SharedSessionContractImplementor session, Object owner, Object currentValue, - EventType eventType) { + public Object generate(SharedSessionContractImplementor session, Object owner, Object currentValue, EventType eventType) { throw new UnsupportedOperationException( "Use generate(Mutiny.Session, Object, Object, EventType) instead" ); } - public abstract Uni generate(Mutiny.Session session, Object owner, Object currentValue, - EventType eventType); + public abstract Uni generate(Mutiny.Session session, Object owner, Object currentValue, EventType eventType); } diff --git a/hibernate-reactive-core/src/test/java/org/hibernate/reactive/CurrentUser.java b/hibernate-reactive-core/src/test/java/org/hibernate/reactive/CurrentUser.java index 7b19ceec4..2220c0c49 100644 --- a/hibernate-reactive-core/src/test/java/org/hibernate/reactive/CurrentUser.java +++ b/hibernate-reactive-core/src/test/java/org/hibernate/reactive/CurrentUser.java @@ -91,8 +91,7 @@ public EnumSet getEventTypes() { public static abstract class AbstractLoggedUserGeneratorWithMutiny extends MutinyGenerator { @Override - public Uni generate(Mutiny.Session session, Object owner, Object currentValue, - EventType eventType) { + public Uni generate(Mutiny.Session session, Object owner, Object currentValue, EventType eventType) { Objects.requireNonNull( session ); String value = CurrentUser.INSTANCE.get(); return Uni.createFrom().item( value ); diff --git a/hibernate-reactive-core/src/test/java/org/hibernate/reactive/MutinySequenceGeneratorTest.java b/hibernate-reactive-core/src/test/java/org/hibernate/reactive/MutinySequenceGeneratorTest.java index 514da7395..384bdde9d 100644 --- a/hibernate-reactive-core/src/test/java/org/hibernate/reactive/MutinySequenceGeneratorTest.java +++ b/hibernate-reactive-core/src/test/java/org/hibernate/reactive/MutinySequenceGeneratorTest.java @@ -34,50 +34,48 @@ protected Collection> annotatedEntities() { @Test public void testSequenceGenerator(VertxTestContext context) { - SequenceId b = new SequenceId(); b.string = "Hello World"; - test( context, - getMutinySessionFactory() - .withSession( s -> s.persist(b).call( s::flush ) ) - .call( () -> getMutinySessionFactory().withSession( - s2 -> s2.find( SequenceId.class, b.getId() ) - .map( bb -> { - assertNotNull( bb ); - assertEquals( bb.id, 5 ); - assertEquals( bb.string, b.string ); - assertEquals( bb.version, 0 ); - - bb.string = "Goodbye"; - return null; - } ) - .call( s2::flush ) - .chain( () -> s2.find( SequenceId.class, b.getId() ) ) - .map( bt -> { - assertEquals( bt.version, 1 ); - return null; - } ) - ) ) - .call( () -> getMutinySessionFactory().withSession( - s3 -> s3.find( SequenceId.class, b.getId() ) - .map( bb -> { - assertEquals( bb.version, 1 ); - assertEquals( bb.string, "Goodbye" ); - return null; - } ) - ) ) + test( context, getMutinySessionFactory() + .withSession( s -> s.persist( b ).call( s::flush ) ) + .call( () -> getMutinySessionFactory().withSession( + s2 -> s2.find( SequenceId.class, b.getId() ) + .map( bb -> { + assertNotNull( bb ); + assertEquals( bb.id, 5 ); + assertEquals( bb.string, b.string ); + assertEquals( bb.version, 0 ); + + bb.string = "Goodbye"; + return null; + } ) + .call( s2::flush ) + .chain( () -> s2.find( SequenceId.class, b.getId() ) ) + .map( bt -> { + assertEquals( bt.version, 1 ); + return null; + } ) + ) ) + .call( () -> getMutinySessionFactory().withSession( + s3 -> s3.find( SequenceId.class, b.getId() ) + .map( bb -> { + assertEquals( bb.version, 1 ); + assertEquals( bb.string, "Goodbye" ); + return null; + } ) + ) ) ); } @Entity - @SequenceGenerator(name = "seq", - sequenceName = "test_id_seq", - initialValue = 5) + @SequenceGenerator(name = "seq", sequenceName = "test_id_seq", initialValue = 5) public static class SequenceId { - @Id @GeneratedValue(generator = "seq") + @Id + @GeneratedValue(generator = "seq") Integer id; - @Version Integer version; + @Version + Integer version; String string; public SequenceId() { @@ -118,12 +116,12 @@ public boolean equals(Object o) { return false; } SequenceId sequenceId = (SequenceId) o; - return Objects.equals(string, sequenceId.string); + return Objects.equals( string, sequenceId.string ); } @Override public int hashCode() { - return Objects.hash(string); + return Objects.hash( string ); } } }