Change scope of private methods for Hibernate Reactive

hibernate-core/src/main/java/org/hibernate/internal/AbstractSharedSessionContract.java

@@ -977,15 +977,18 @@ private <T> NativeQueryImplementor<T> buildNativeQuery(String sql, @Nullable Cla
 		}
 	}
 
-	final EntityPersister requireEntityPersister(Class<?> entityClass) {
+	// Hibernate Reactive may need to use this
+	protected final EntityPersister requireEntityPersister(Class<?> entityClass) {
 		return getMappingMetamodel().getEntityDescriptor( entityClass );
 	}
 
-	final EntityPersister requireEntityPersister(String entityName) {
+	// Hibernate Reactive may need to use this
+	protected final EntityPersister requireEntityPersister(String entityName) {
 		return getMappingMetamodel().getEntityDescriptor( entityName );
 	}
 
-	final CollectionPersister requireCollectionPersister(String roleName) {
+	// Hibernate Reactive may need to use this
+	protected final CollectionPersister requireCollectionPersister(String roleName) {
 		return getMappingMetamodel().getCollectionDescriptor( roleName );
 	}
 

hibernate-core/src/main/java/org/hibernate/internal/SessionImpl.java

@@ -1141,7 +1141,8 @@ public Object loadFromSecondLevelCache(
 	 * Helper to avoid creating many new instances of {@link PostLoadEvent}.
 	 * It's an allocation hot spot.
 	 */
-	private PostLoadEvent makePostLoadEvent(EntityPersister persister, Object id, Object entity) {
+	// Hibernate Reactive may need to use this
+	protected PostLoadEvent makePostLoadEvent(EntityPersister persister, Object id, Object entity) {
 		final PostLoadEvent event = postLoadEvent;
 		if ( event == null ) {
 			return new PostLoadEvent( id, persister, entity, this );
@@ -1159,7 +1160,8 @@ private PostLoadEvent makePostLoadEvent(EntityPersister persister, Object id, Ob
 	 * Helper to avoid creating many new instances of {@link LoadEvent}.
 	 * It's an allocation hot spot.
 	 */
-	private LoadEvent makeLoadEvent(String entityName, Object id, Boolean readOnly, LockOptions lockOptions) {
+	// Hibernate Reactive may need to use this
+	protected LoadEvent makeLoadEvent(String entityName, Object id, Boolean readOnly, LockOptions lockOptions) {
 		final LoadEvent event = loadEvent;
 		if ( event == null ) {
 			return new LoadEvent( id, entityName, lockOptions, this, readOnly );
@@ -1180,7 +1182,8 @@ private LoadEvent makeLoadEvent(String entityName, Object id, Boolean readOnly,
 	 * Helper to avoid creating many new instances of {@link LoadEvent}.
 	 * It's an allocation hot spot.
 	 */
-	private LoadEvent makeLoadEvent(String entityName, Object id, Boolean readOnly, boolean isAssociationFetch) {
+	// Hibernate Reactive may need to use this
+	protected LoadEvent makeLoadEvent(String entityName, Object id, Boolean readOnly, boolean isAssociationFetch) {
 		final LoadEvent event = loadEvent;
 		if ( event == null ) {
 			return new LoadEvent( id, entityName, isAssociationFetch, this, readOnly );
@@ -1197,7 +1200,8 @@ private LoadEvent makeLoadEvent(String entityName, Object id, Boolean readOnly,
 		}
 	}
 
-	private void releasePostLoadEvent(PostLoadEvent event) {
+	// Hibernate Reactive may need to use this
+	protected void releasePostLoadEvent(PostLoadEvent event) {
 		if ( postLoadEvent == null ) {
 			event.setEntity( null );
 			event.setId( null );
@@ -1206,7 +1210,8 @@ private void releasePostLoadEvent(PostLoadEvent event) {
 		}
 	}
 
-	private void releaseLoadEvent(LoadEvent event) {
+	// Hibernate Reactive may need to use this
+	protected void releaseLoadEvent(LoadEvent event) {
 		if ( loadEvent == null ) {
 			event.setEntityClassName( null );
 			event.setEntityId( null );
@@ -2619,7 +2624,8 @@ public <T> T find(EntityGraph<T> entityGraph, Object primaryKey, FindOption... o
 		return loadAccess.withLoadGraph( graph ).load( primaryKey );
 	}
 
-	private void checkTransactionNeededForLock(LockMode lockMode) {
+	// Hibernate Reactive may need to use this
+	protected void checkTransactionNeededForLock(LockMode lockMode) {
 		// OPTIMISTIC and OPTIMISTIC_FORCE_INCREMENT require a transaction
 		// because they involve a version check at the end of the transaction
 		// All flavors of PESSIMISTIC lock also clearly require a transaction
@@ -2628,7 +2634,8 @@ private void checkTransactionNeededForLock(LockMode lockMode) {
 		}
 	}
 
-	private static Boolean readOnlyHint(Map<String, Object> properties) {
+	// Hibernate Reactive may need to use this
+	protected static Boolean readOnlyHint(Map<String, Object> properties) {
 		if ( properties == null ) {
 			return null;
 		}
@@ -3116,7 +3123,8 @@ private void readObject(ObjectInputStream ois) throws IOException, ClassNotFound
 		eventListenerGroups = getFactory().getEventListenerGroups();
 	}
 
-	private Boolean getReadOnlyFromLoadQueryInfluencers() {
+	// Used by Hibernate reactive
+	protected Boolean getReadOnlyFromLoadQueryInfluencers() {
 		return loadQueryInfluencers != null ? loadQueryInfluencers.getReadOnly() : null;
 	}
 }

hibernate-core/src/main/java/org/hibernate/internal/StatelessSessionImpl.java

@@ -501,7 +501,8 @@ public void upsert(String entityName, Object entity) {
 		}
 	}
 
-	private Object versionToUpsert(Object entity, EntityPersister persister, Object[] state) {
+	// Hibernate Reactive calls this
+	protected Object versionToUpsert(Object entity, EntityPersister persister, Object[] state) {
 		if ( persister.isVersioned() ) {
 			final Object oldVersion = persister.getVersion( entity );
 			final Boolean knownTransient =
@@ -528,7 +529,8 @@ private Object versionToUpsert(Object entity, EntityPersister persister, Object[
 		}
 	}
 
-	private Object idToUpsert(Object entity, EntityPersister persister) {
+	// Hibernate Reactive calls this
+	protected Object idToUpsert(Object entity, EntityPersister persister) {
 		final Object id = persister.getIdentifier( entity, this );
 		final Boolean unsaved =
 				persister.getIdentifierMapping()
@@ -543,7 +545,8 @@ private Object idToUpsert(Object entity, EntityPersister persister) {
 
 	// event processing ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-	private boolean firePreInsert(Object entity, Object id, Object[] state, EntityPersister persister) {
+	// Hibernate Reactive may need to call this
+	protected boolean firePreInsert(Object entity, Object id, Object[] state, EntityPersister persister) {
 		if ( eventListenerGroups.eventListenerGroup_PRE_INSERT.isEmpty() ) {
 			return false;
 		}
@@ -557,7 +560,8 @@ private boolean firePreInsert(Object entity, Object id, Object[] state, EntityPe
 		}
 	}
 
-	private boolean firePreUpdate(Object entity, Object id, Object[] state, EntityPersister persister) {
+	// Hibernate Reactive may need to call this
+	protected boolean firePreUpdate(Object entity, Object id, Object[] state, EntityPersister persister) {
 		if ( eventListenerGroups.eventListenerGroup_PRE_UPDATE.isEmpty() ) {
 			return false;
 		}
@@ -571,7 +575,8 @@ private boolean firePreUpdate(Object entity, Object id, Object[] state, EntityPe
 		}
 	}
 
-	private boolean firePreUpsert(Object entity, Object id, Object[] state, EntityPersister persister) {
+	// Hibernate Reactive may need to call this
+	protected boolean firePreUpsert(Object entity, Object id, Object[] state, EntityPersister persister) {
 		if ( eventListenerGroups.eventListenerGroup_PRE_UPSERT.isEmpty() ) {
 			return false;
 		}
@@ -585,7 +590,8 @@ private boolean firePreUpsert(Object entity, Object id, Object[] state, EntityPe
 		}
 	}
 
-	private boolean firePreDelete(Object entity, Object id, EntityPersister persister) {
+	// Hibernate Reactive may need to call this
+	protected boolean firePreDelete(Object entity, Object id, EntityPersister persister) {
 		if ( eventListenerGroups.eventListenerGroup_PRE_DELETE.isEmpty() ) {
 			return false;
 		}
@@ -599,69 +605,80 @@ private boolean firePreDelete(Object entity, Object id, EntityPersister persiste
 		}
 	}
 
-	private void firePostInsert(Object entity, Object id, Object[] state, EntityPersister persister) {
+	// Hibernate Reactive may need to call this
+	protected void firePostInsert(Object entity, Object id, Object[] state, EntityPersister persister) {
 		eventListenerGroups.eventListenerGroup_POST_INSERT.fireLazyEventOnEachListener(
 				() -> new PostInsertEvent( entity, id, state, persister, null ),
 				PostInsertEventListener::onPostInsert );
 	}
 
-	private void firePostUpdate(Object entity, Object id, Object[] state, EntityPersister persister) {
+	// Hibernate Reactive may need to call this
+	protected void firePostUpdate(Object entity, Object id, Object[] state, EntityPersister persister) {
 		eventListenerGroups.eventListenerGroup_POST_UPDATE.fireLazyEventOnEachListener(
 				() -> new PostUpdateEvent( entity, id, state, null, null, persister, null ),
 				PostUpdateEventListener::onPostUpdate );
 	}
 
-	private void firePostUpsert(Object entity, Object id, Object[] state, EntityPersister persister) {
+	// Hibernate Reactive may need to call this
+	protected void firePostUpsert(Object entity, Object id, Object[] state, EntityPersister persister) {
 		eventListenerGroups.eventListenerGroup_POST_UPSERT.fireLazyEventOnEachListener(
 				() -> new PostUpsertEvent( entity, id, state, null, persister, null ),
 				PostUpsertEventListener::onPostUpsert );
 	}
 
-	private void firePostDelete(Object entity, Object id, EntityPersister persister) {
+	// Hibernate Reactive may need to call this
+	protected void firePostDelete(Object entity, Object id, EntityPersister persister) {
 		eventListenerGroups.eventListenerGroup_POST_DELETE.fireLazyEventOnEachListener(
 				() -> new PostDeleteEvent( entity, id, null, persister, null ),
 				PostDeleteEventListener::onPostDelete );
 	}
 
-	private void firePreRecreate(PersistentCollection<?> collection, CollectionPersister persister) {
+	// Hibernate Reactive may need to call this
+	protected void firePreRecreate(PersistentCollection<?> collection, CollectionPersister persister) {
 		eventListenerGroups.eventListenerGroup_PRE_COLLECTION_RECREATE.fireLazyEventOnEachListener(
 				() -> new PreCollectionRecreateEvent(  persister, collection, null ),
 				PreCollectionRecreateEventListener::onPreRecreateCollection );
 	}
 
-	private void firePreUpdate(PersistentCollection<?> collection, CollectionPersister persister) {
+	// Hibernate Reactive may need to call this
+	protected void firePreUpdate(PersistentCollection<?> collection, CollectionPersister persister) {
 		eventListenerGroups.eventListenerGroup_PRE_COLLECTION_UPDATE.fireLazyEventOnEachListener(
 				() -> new PreCollectionUpdateEvent(  persister, collection, null ),
 				PreCollectionUpdateEventListener::onPreUpdateCollection );
 	}
 
-	private void firePreRemove(PersistentCollection<?> collection, Object owner, CollectionPersister persister) {
+	// Hibernate Reactive may need to call this
+	protected void firePreRemove(PersistentCollection<?> collection, Object owner, CollectionPersister persister) {
 		eventListenerGroups.eventListenerGroup_PRE_COLLECTION_REMOVE.fireLazyEventOnEachListener(
 				() -> new PreCollectionRemoveEvent(  persister, collection, null, owner ),
 				PreCollectionRemoveEventListener::onPreRemoveCollection );
 	}
 
-	private void firePostRecreate(PersistentCollection<?> collection, CollectionPersister persister) {
+	// Hibernate Reactive may need to call this
+	protected void firePostRecreate(PersistentCollection<?> collection, CollectionPersister persister) {
 		eventListenerGroups.eventListenerGroup_POST_COLLECTION_RECREATE.fireLazyEventOnEachListener(
 				() -> new PostCollectionRecreateEvent(  persister, collection, null ),
 				PostCollectionRecreateEventListener::onPostRecreateCollection );
 	}
 
-	private void firePostUpdate(PersistentCollection<?> collection, CollectionPersister persister) {
+	// Hibernate Reactive may need to call this
+	protected void firePostUpdate(PersistentCollection<?> collection, CollectionPersister persister) {
 		eventListenerGroups.eventListenerGroup_POST_COLLECTION_UPDATE.fireLazyEventOnEachListener(
 				() -> new PostCollectionUpdateEvent(  persister, collection, null ),
 				PostCollectionUpdateEventListener::onPostUpdateCollection );
 	}
 
-	private void firePostRemove(PersistentCollection<?> collection, Object owner, CollectionPersister persister) {
+	// Hibernate Reactive may need to call this
+	protected void firePostRemove(PersistentCollection<?> collection, Object owner, CollectionPersister persister) {
 		eventListenerGroups.eventListenerGroup_POST_COLLECTION_REMOVE.fireLazyEventOnEachListener(
 				() -> new PostCollectionRemoveEvent(  persister, collection, null, owner ),
 				PostCollectionRemoveEventListener::onPostRemoveCollection );
 	}
 
 	// collections ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-	private void forEachOwnedCollection(
+	// Hibernate Reactive overrides this
+	protected void forEachOwnedCollection(
 			Object entity, Object key,
 			EntityPersister persister, BiConsumer<CollectionPersister, PersistentCollection<?>> action) {
 		persister.visitAttributeMappings( attribute -> {
@@ -691,13 +708,15 @@ private void forEachOwnedCollection(
 		} );
 	}
 
-	private PersistentCollection<?> instantiateEmpty(Object key, CollectionPersister descriptor) {
+	// Hibernate Reactive calls this
+	protected PersistentCollection<?> instantiateEmpty(Object key, CollectionPersister descriptor) {
 		return descriptor.getCollectionSemantics().instantiateWrapper(key, descriptor, this);
 	}
 
 	//TODO: is this the right way to do this?
+	// Hibernate Reactive calls this
 	@SuppressWarnings({"rawtypes", "unchecked"})
-	private PersistentCollection<?> wrap(CollectionPersister descriptor, Object collection) {
+	protected PersistentCollection<?> wrap(CollectionPersister descriptor, Object collection) {
 		final CollectionSemantics collectionSemantics = descriptor.getCollectionSemantics();
 		return collectionSemantics.wrap(collection, descriptor, this);
 	}
@@ -969,7 +988,6 @@ public Object internalLoad(
 			final EntityMetamodel entityMetamodel = persister.getEntityMetamodel();
 			final BytecodeEnhancementMetadata enhancementMetadata = entityMetamodel.getBytecodeEnhancementMetadata();
 			if ( enhancementMetadata.isEnhancedForLazyLoading() ) {
-
 				// if the entity defines a HibernateProxy factory, see if there is an
 				// existing proxy associated with the PC - and if so, use it
 				if ( persister.getRepresentationStrategy().getProxyFactory() != null ) {
@@ -1015,7 +1033,11 @@ else if ( !entityMetamodel.hasSubclasses() ) {
 		}
 
 		// otherwise immediately materialize it
+		return internalLoadGet( entityName, id, persistenceContext );
+	}
 
+	// For Hibernate Reactive
+	protected Object internalLoadGet(String entityName, Object id, PersistenceContext persistenceContext) {
 		// IMPLEMENTATION NOTE: increment/decrement the load count before/after getting the value
 		//                      to ensure that #get does not clear the PersistenceContext.
 		persistenceContext.beforeLoad();

hibernate-core/src/main/java/org/hibernate/loader/internal/IdentifierLoadAccessImpl.java

@@ -129,7 +129,8 @@ protected T doGetReference(Object id) {
 				concreteType.getEntityName(), lockOptions, isReadOnly( session ) );
 	}
 
-	private Boolean isReadOnly(SessionImplementor session) {
+	// Hibernate Reactive might need to call this
+	protected Boolean isReadOnly(SessionImplementor session) {
 		return readOnly != null
 				? readOnly
 				: session.getLoadQueryInfluencers().getReadOnly();