Skip to content

cleanups around CallbackRegistryImpl #10337

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Jun 14, 2025
Merged

cleanups around CallbackRegistryImpl #10337

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
9 changes: 9 additions & 0 deletions hibernate-core/src/main/java/org/hibernate/internal/util/collections/ArrayHelper.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -212,6 +212,15 @@ public static <T> T[] join(T[] x, T... y) {
return result;
}

@SuppressWarnings("unchecked")
@AllowReflection
public static <T> T[] add(T[] x, T y) {
T[] result = (T[]) Array.newInstance( x.getClass().getComponentType(), x.length + 1 );
System.arraycopy( x, 0, result, 0, x.length );
result[x.length] = y;
return result;
}

public static final boolean[] TRUE = {true};
public static final boolean[] FALSE = {false};

Expand Down
4 changes: 2 additions & 2 deletions ...rnate-core/src/main/java/org/hibernate/internal/util/collections/MapBackedClassValue.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -18,7 +18,7 @@
* @author Sanne Grinovero
* @since 6.2
*/
public final class MapBackedClassValue<V> implements ReadOnlyMap<Class,V> {
public final class MapBackedClassValue<V> implements ReadOnlyMap<Class<?>,V> {

private volatile Map<Class<?>, V> map;

Expand All @@ -44,7 +44,7 @@ public MapBackedClassValue(final Map<Class<?>, V> map) {
}

@Override
public V get(Class key) {
public V get(Class<?> key) {
return classValue.get( key );
}

Expand Down
125 changes: 41 additions & 84 deletions hibernate-core/src/main/java/org/hibernate/jpa/event/internal/CallbackRegistryImpl.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -7,7 +7,6 @@
import java.util.HashMap;
import java.util.Map;

import jakarta.persistence.PersistenceException;

import org.hibernate.internal.build.AllowReflection;
import org.hibernate.internal.util.collections.ArrayHelper;
Expand All @@ -26,13 +25,13 @@
*/
final class CallbackRegistryImpl implements CallbackRegistry {

private final ReadOnlyMap<Class,Callback[]> preCreates;
private final ReadOnlyMap<Class,Callback[]> postCreates;
private final ReadOnlyMap<Class,Callback[]> preRemoves;
private final ReadOnlyMap<Class,Callback[]> postRemoves;
private final ReadOnlyMap<Class,Callback[]> preUpdates;
private final ReadOnlyMap<Class,Callback[]> postUpdates;
private final ReadOnlyMap<Class,Callback[]> postLoads;
private final ReadOnlyMap<Class<?>,Callback[]> preCreates;
private final ReadOnlyMap<Class<?>,Callback[]> postCreates;
private final ReadOnlyMap<Class<?>,Callback[]> preRemoves;
private final ReadOnlyMap<Class<?>,Callback[]> postRemoves;
private final ReadOnlyMap<Class<?>,Callback[]> preUpdates;
private final ReadOnlyMap<Class<?>,Callback[]> postUpdates;
private final ReadOnlyMap<Class<?>,Callback[]> postLoads;

public CallbackRegistryImpl(
Map<Class<?>, Callback[]> preCreates,
Expand All @@ -51,19 +50,15 @@ public CallbackRegistryImpl(
this.postLoads = createBackingMap( postLoads );
}

private static ReadOnlyMap<Class, Callback[]> createBackingMap(final Map<Class<?>, Callback[]> src) {
if ( src == null || src.isEmpty() ) {
return ReadOnlyMap.EMPTY;
}
else {
return new MapBackedClassValue<>( src );
}
private static ReadOnlyMap<Class<?>, Callback[]> createBackingMap(final Map<Class<?>, Callback[]> src) {
return src == null || src.isEmpty()
? ReadOnlyMap.EMPTY
: new MapBackedClassValue<>( src );
}

@Override
public boolean hasRegisteredCallbacks(Class<?> entityClass, CallbackType callbackType) {
final ReadOnlyMap<Class,Callback[]> map = determineAppropriateCallbackMap( callbackType );
return notEmpty( map.get( entityClass ) );
return notEmpty( getCallbackMap( callbackType ).get( entityClass ) );
}

@Override
Expand Down Expand Up @@ -128,39 +123,21 @@ private boolean callback(Callback[] callbacks, Object bean) {
}
}

private ReadOnlyMap<Class,Callback[]> determineAppropriateCallbackMap(CallbackType callbackType) {
if ( callbackType == CallbackType.PRE_PERSIST ) {
return preCreates;
}

if ( callbackType == CallbackType.POST_PERSIST ) {
return postCreates;
}

if ( callbackType == CallbackType.PRE_REMOVE ) {
return preRemoves;
}

if ( callbackType == CallbackType.POST_REMOVE ) {
return postRemoves;
}

if ( callbackType == CallbackType.PRE_UPDATE ) {
return preUpdates;
}

if ( callbackType == CallbackType.POST_UPDATE ) {
return postUpdates;
}

if ( callbackType == CallbackType.POST_LOAD ) {
return postLoads;
}

throw new PersistenceException( "Unrecognized JPA callback type [" + callbackType + "]" );
private ReadOnlyMap<Class<?>,Callback[]> getCallbackMap(CallbackType callbackType) {
return switch ( callbackType ) {
case PRE_PERSIST -> preCreates;
case POST_PERSIST -> postCreates;
case PRE_REMOVE -> preRemoves;
case POST_REMOVE -> postRemoves;
case PRE_UPDATE -> preUpdates;
case POST_UPDATE -> postUpdates;
case POST_LOAD -> postLoads;
};
}

public static class Builder {
private static final Callback[] NO_CALLBACKS = new Callback[0];

private final Map<Class<?>, Callback[]> preCreates = new HashMap<>();
private final Map<Class<?>, Callback[]> postCreates = new HashMap<>();
private final Map<Class<?>, Callback[]> preRemoves = new HashMap<>();
Expand All @@ -173,50 +150,30 @@ public static class Builder {
public void registerCallbacks(Class<?> entityClass, Callback[] callbacks) {
if ( callbacks != null ) {
for ( Callback callback : callbacks ) {
final Map<Class<?>, Callback[]> map = determineAppropriateCallbackMap( callback.getCallbackType() );
Callback[] entityCallbacks = map.get( entityClass );
if ( entityCallbacks == null ) {
entityCallbacks = new Callback[0];
}
entityCallbacks = ArrayHelper.join( entityCallbacks, callback );
map.put( entityClass, entityCallbacks );
addCallback( entityClass, callback );
}
}
}

private Map<Class<?>, Callback[]> determineAppropriateCallbackMap(CallbackType callbackType) {
if ( callbackType == CallbackType.PRE_PERSIST ) {
return preCreates;
}

if ( callbackType == CallbackType.POST_PERSIST ) {
return postCreates;
}

if ( callbackType == CallbackType.PRE_REMOVE ) {
return preRemoves;
}

if ( callbackType == CallbackType.POST_REMOVE ) {
return postRemoves;
}

if ( callbackType == CallbackType.PRE_UPDATE ) {
return preUpdates;
}

if ( callbackType == CallbackType.POST_UPDATE ) {
return postUpdates;
}

if ( callbackType == CallbackType.POST_LOAD ) {
return postLoads;
}
public void addCallback(Class<?> entityClass, Callback callback) {
final var callbackMap = getCallbackMap( callback.getCallbackType() );
final Callback[] existingCallbacks = callbackMap.getOrDefault( entityClass, NO_CALLBACKS );
callbackMap.put( entityClass, ArrayHelper.add( existingCallbacks, callback ) );
}

throw new PersistenceException( "Unrecognized JPA callback type [" + callbackType + "]" );
private Map<Class<?>, Callback[]> getCallbackMap(CallbackType callbackType) {
return switch ( callbackType ) {
case PRE_PERSIST -> preCreates;
case POST_PERSIST -> postCreates;
case PRE_REMOVE -> preRemoves;
case POST_REMOVE -> postRemoves;
case PRE_UPDATE -> preUpdates;
case POST_UPDATE -> postUpdates;
case POST_LOAD -> postLoads;
};
}

protected CallbackRegistryImpl build() {
protected CallbackRegistry build() {
return new CallbackRegistryImpl( preCreates, postCreates, preRemoves, postRemoves, preUpdates, postUpdates, postLoads );
}

Expand Down
Loading