You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@grails.apache.org by bo...@apache.org on 2026/09/09 23:41:19 UTC

(grails-core) 08/14: Convert grails-data-hibernate7-spring-orm batch 2 to Groovy

This is an automated email from the ASF dual-hosted git repository.

borinquenkid pushed a commit to branch 9.0.x-java-to-groovy
in repository https://gitbox.apache.org/repos/asf/grails-core.git

commit 932664df370febaa802377c4a172d1816e3d50bc
Author: Walter Duque de Estrada <wb...@mac.com>
AuthorDate: Tue Sep 8 21:27:02 2026 -0500

    Convert grails-data-hibernate7-spring-orm batch 2 to Groovy
    
    Converts SessionFactoryUtils, SpringBeanContainer, LocalSessionFactoryBuilder
    and support.OpenSessionInViewInterceptor to @CompileStatic Groovy, preserving
    the upstream Spring copyright headers verbatim. SessionFactoryUtils keeps its
    public SESSION_SYNCHRONIZATION_ORDER constant and package-private flush();
    the background-bootstrap proxy handler uses an explicit Callable closure and a
    classic switch in place of the Java method reference and switch expression.
    
    Verified with codenarcMain/checkstyleMain on spring-orm and the full
    grails-data-hibernate7-core, grails-data-hibernate7 and
    grails-data-hibernate7-spring-boot test suites.
    
    Co-Authored-By: Claude Fable 5.1 <no...@anthropic.com>
    Claude-Session: https://claude.ai/code/session_01E5dsQNQNLuSdFph84RRQdr
---
 ...lder.java => LocalSessionFactoryBuilder.groovy} | 383 ++++++++++-----------
 ...actoryUtils.java => SessionFactoryUtils.groovy} | 254 +++++++-------
 ...anContainer.java => SpringBeanContainer.groovy} | 221 ++++++------
 ...or.java => OpenSessionInViewInterceptor.groovy} | 153 ++++----
 4 files changed, 490 insertions(+), 521 deletions(-)

diff --git a/grails-data-hibernate7/spring-orm/src/main/groovy/org/grails/orm/hibernate/support/hibernate7/LocalSessionFactoryBuilder.java b/grails-data-hibernate7/spring-orm/src/main/groovy/org/grails/orm/hibernate/support/hibernate7/LocalSessionFactoryBuilder.groovy
similarity index 59%
rename from grails-data-hibernate7/spring-orm/src/main/groovy/org/grails/orm/hibernate/support/hibernate7/LocalSessionFactoryBuilder.java
rename to grails-data-hibernate7/spring-orm/src/main/groovy/org/grails/orm/hibernate/support/hibernate7/LocalSessionFactoryBuilder.groovy
index c0cfe30908..231999618d 100644
--- a/grails-data-hibernate7/spring-orm/src/main/groovy/org/grails/orm/hibernate/support/hibernate7/LocalSessionFactoryBuilder.java
+++ b/grails-data-hibernate7/spring-orm/src/main/groovy/org/grails/orm/hibernate/support/hibernate7/LocalSessionFactoryBuilder.groovy
@@ -13,63 +13,55 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
-package org.grails.orm.hibernate.support.hibernate7;
-
-import java.io.FileNotFoundException;
-import java.io.IOException;
-import java.lang.reflect.InvocationHandler;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.lang.reflect.Proxy;
-import java.util.Collections;
-import java.util.Set;
-import java.util.TreeSet;
-import java.util.concurrent.Callable;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
-
-import javax.sql.DataSource;
-
-import jakarta.persistence.AttributeConverter;
-import jakarta.persistence.Converter;
-import jakarta.persistence.Embeddable;
-import jakarta.persistence.Entity;
-import jakarta.persistence.MappedSuperclass;
-import jakarta.transaction.TransactionManager;
-
-import org.hibernate.HibernateException;
-import org.hibernate.MappingException;
-import org.hibernate.SessionFactory;
-import org.hibernate.boot.MetadataSources;
-import org.hibernate.boot.registry.BootstrapServiceRegistryBuilder;
-import org.hibernate.cache.spi.RegionFactory;
-import org.hibernate.cfg.AvailableSettings;
-import org.hibernate.cfg.Configuration;
-import org.hibernate.context.spi.CurrentTenantIdentifierResolver;
-import org.hibernate.engine.jdbc.connections.spi.MultiTenantConnectionProvider;
-import org.hibernate.engine.spi.SessionFactoryImplementor;
-import org.hibernate.resource.jdbc.spi.PhysicalConnectionHandlingMode;
-import org.jspecify.annotations.Nullable;
-
-import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
-import org.springframework.core.InfrastructureProxy;
-import org.springframework.core.SpringProperties;
-import org.springframework.core.io.Resource;
-import org.springframework.core.io.ResourceLoader;
-import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
-import org.springframework.core.io.support.ResourcePatternResolver;
-import org.springframework.core.io.support.ResourcePatternUtils;
-import org.springframework.core.task.AsyncTaskExecutor;
-import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
-import org.springframework.core.type.classreading.ClassFormatException;
-import org.springframework.core.type.classreading.MetadataReader;
-import org.springframework.core.type.classreading.MetadataReaderFactory;
-import org.springframework.core.type.filter.AnnotationTypeFilter;
-import org.springframework.core.type.filter.TypeFilter;
-import org.springframework.transaction.jta.JtaTransactionManager;
-import org.springframework.util.Assert;
-import org.springframework.util.ClassUtils;
+package org.grails.orm.hibernate.support.hibernate7
+
+import java.lang.reflect.InvocationHandler
+import java.lang.reflect.InvocationTargetException
+import java.lang.reflect.Method
+import java.lang.reflect.Proxy
+import java.util.concurrent.Callable
+import java.util.concurrent.ExecutionException
+import java.util.concurrent.Future
+
+import javax.sql.DataSource
+
+import groovy.transform.CompileStatic
+import jakarta.persistence.AttributeConverter
+import jakarta.persistence.Converter
+import jakarta.persistence.Embeddable
+import jakarta.persistence.Entity
+import jakarta.persistence.MappedSuperclass
+import jakarta.transaction.TransactionManager
+import org.hibernate.HibernateException
+import org.hibernate.MappingException
+import org.hibernate.SessionFactory
+import org.hibernate.boot.MetadataSources
+import org.hibernate.boot.registry.BootstrapServiceRegistryBuilder
+import org.hibernate.cache.spi.RegionFactory
+import org.hibernate.cfg.AvailableSettings
+import org.hibernate.cfg.Configuration
+import org.hibernate.context.spi.CurrentTenantIdentifierResolver
+import org.hibernate.engine.jdbc.connections.spi.MultiTenantConnectionProvider
+import org.hibernate.engine.spi.SessionFactoryImplementor
+import org.hibernate.resource.jdbc.spi.PhysicalConnectionHandlingMode
+import org.springframework.beans.factory.config.ConfigurableListableBeanFactory
+import org.springframework.core.InfrastructureProxy
+import org.springframework.core.SpringProperties
+import org.springframework.core.io.Resource
+import org.springframework.core.io.ResourceLoader
+import org.springframework.core.io.support.PathMatchingResourcePatternResolver
+import org.springframework.core.io.support.ResourcePatternResolver
+import org.springframework.core.io.support.ResourcePatternUtils
+import org.springframework.core.task.AsyncTaskExecutor
+import org.springframework.core.type.classreading.CachingMetadataReaderFactory
+import org.springframework.core.type.classreading.ClassFormatException
+import org.springframework.core.type.classreading.MetadataReader
+import org.springframework.core.type.classreading.MetadataReaderFactory
+import org.springframework.core.type.filter.AnnotationTypeFilter
+import org.springframework.core.type.filter.TypeFilter
+import org.springframework.transaction.jta.JtaTransactionManager
+import org.springframework.util.Assert
+import org.springframework.util.ClassUtils
 
 /**
  * A Spring-provided extension of the standard Hibernate {@link Configuration} class,
@@ -99,36 +91,37 @@ import org.springframework.util.ClassUtils;
  * @see #LocalSessionFactoryBuilder(DataSource, ResourceLoader, MetadataSources)
  * @see BootstrapServiceRegistryBuilder
  */
-@SuppressWarnings("serial")
-public class LocalSessionFactoryBuilder extends Configuration {
+@CompileStatic
+@SuppressWarnings('serial')
+class LocalSessionFactoryBuilder extends Configuration {
 
-    private static final String RESOURCE_PATTERN = "/**/*.class";
+    private static final String RESOURCE_PATTERN = '/**/*.class'
 
-    private static final String PACKAGE_INFO_SUFFIX = ".package-info";
+    private static final String PACKAGE_INFO_SUFFIX = '.package-info'
 
-    private static final TypeFilter[] DEFAULT_ENTITY_TYPE_FILTERS = new TypeFilter[] {
-        new AnnotationTypeFilter(Entity.class, false),
-        new AnnotationTypeFilter(Embeddable.class, false),
-        new AnnotationTypeFilter(MappedSuperclass.class, false)};
+    private static final TypeFilter[] DEFAULT_ENTITY_TYPE_FILTERS = [
+        new AnnotationTypeFilter(Entity, false),
+        new AnnotationTypeFilter(Embeddable, false),
+        new AnnotationTypeFilter(MappedSuperclass, false)] as TypeFilter[]
 
-    private static final TypeFilter CONVERTER_TYPE_FILTER = new AnnotationTypeFilter(Converter.class, false);
+    private static final TypeFilter CONVERTER_TYPE_FILTER = new AnnotationTypeFilter(Converter, false)
 
-    private static final String IGNORE_CLASSFORMAT_PROPERTY_NAME = "spring.classformat.ignore";
+    private static final String IGNORE_CLASSFORMAT_PROPERTY_NAME = 'spring.classformat.ignore'
 
-    private static final boolean shouldIgnoreClassFormatException =
-            SpringProperties.getFlag(IGNORE_CLASSFORMAT_PROPERTY_NAME);
+    private static final boolean SHOULD_IGNORE_CLASS_FORMAT_EXCEPTION =
+            SpringProperties.getFlag(IGNORE_CLASSFORMAT_PROPERTY_NAME)
 
-    private final ResourcePatternResolver resourcePatternResolver;
+    private final ResourcePatternResolver resourcePatternResolver
 
-    private TypeFilter[] entityTypeFilters = DEFAULT_ENTITY_TYPE_FILTERS;
+    private TypeFilter[] entityTypeFilters = DEFAULT_ENTITY_TYPE_FILTERS
 
     /**
      * Create a new LocalSessionFactoryBuilder for the given DataSource.
      * @param dataSource the JDBC DataSource that the resulting Hibernate SessionFactory should be using
      * (may be {@code null})
      */
-    public LocalSessionFactoryBuilder(@Nullable DataSource dataSource) {
-        this(dataSource, new PathMatchingResourcePatternResolver());
+    LocalSessionFactoryBuilder(DataSource dataSource) {
+        this(dataSource, new PathMatchingResourcePatternResolver())
     }
 
     /**
@@ -137,8 +130,8 @@ public class LocalSessionFactoryBuilder extends Configuration {
      * (may be {@code null})
      * @param classLoader the ClassLoader to load application classes from
      */
-    public LocalSessionFactoryBuilder(@Nullable DataSource dataSource, ClassLoader classLoader) {
-        this(dataSource, new PathMatchingResourcePatternResolver(classLoader));
+    LocalSessionFactoryBuilder(DataSource dataSource, ClassLoader classLoader) {
+        this(dataSource, new PathMatchingResourcePatternResolver(classLoader))
     }
 
     /**
@@ -147,9 +140,9 @@ public class LocalSessionFactoryBuilder extends Configuration {
      * (may be {@code null})
      * @param resourceLoader the ResourceLoader to load application classes from
      */
-    public LocalSessionFactoryBuilder(@Nullable DataSource dataSource, ResourceLoader resourceLoader) {
+    LocalSessionFactoryBuilder(DataSource dataSource, ResourceLoader resourceLoader) {
         this(dataSource, resourceLoader, new MetadataSources(
-                new BootstrapServiceRegistryBuilder().applyClassLoader(resourceLoader.getClassLoader()).build()));
+                new BootstrapServiceRegistryBuilder().applyClassLoader(resourceLoader.getClassLoader()).build()))
     }
 
     /**
@@ -160,20 +153,20 @@ public class LocalSessionFactoryBuilder extends Configuration {
      * @param metadataSources the Hibernate MetadataSources service to use (for example, reusing an existing one)
      * @since 4.3
      */
-    public LocalSessionFactoryBuilder(
-            @Nullable DataSource dataSource, ResourceLoader resourceLoader, MetadataSources metadataSources) {
+    LocalSessionFactoryBuilder(
+            DataSource dataSource, ResourceLoader resourceLoader, MetadataSources metadataSources) {
 
-        super(metadataSources);
+        super(metadataSources)
 
-        getProperties().put(AvailableSettings.CURRENT_SESSION_CONTEXT_CLASS, SpringSessionContext.class.getName());
+        getProperties().put(AvailableSettings.CURRENT_SESSION_CONTEXT_CLASS, SpringSessionContext.name)
         if (dataSource != null) {
-            getProperties().put(AvailableSettings.DATASOURCE, dataSource);
+            getProperties().put(AvailableSettings.DATASOURCE, dataSource)
         }
         getProperties().put(AvailableSettings.CONNECTION_HANDLING,
-                PhysicalConnectionHandlingMode.DELAYED_ACQUISITION_AND_HOLD);
+                PhysicalConnectionHandlingMode.DELAYED_ACQUISITION_AND_HOLD)
 
-        getProperties().put(AvailableSettings.CLASSLOADERS, Collections.singleton(resourceLoader.getClassLoader()));
-        this.resourcePatternResolver = ResourcePatternUtils.getResourcePatternResolver(resourceLoader);
+        getProperties().put(AvailableSettings.CLASSLOADERS, Collections.singleton(resourceLoader.getClassLoader()))
+        this.resourcePatternResolver = ResourcePatternUtils.getResourcePatternResolver(resourceLoader)
     }
 
     /**
@@ -187,39 +180,37 @@ public class LocalSessionFactoryBuilder extends Configuration {
      * <p>Note: If this is set, the Hibernate settings should not contain a JTA platform
      * setting to avoid meaningless double configuration.
      */
-    public LocalSessionFactoryBuilder setJtaTransactionManager(Object jtaTransactionManager) {
-        Assert.notNull(jtaTransactionManager, "Transaction manager reference must not be null");
+    LocalSessionFactoryBuilder setJtaTransactionManager(Object jtaTransactionManager) {
+        Assert.notNull(jtaTransactionManager, 'Transaction manager reference must not be null')
 
-        if (jtaTransactionManager instanceof JtaTransactionManager springJtaTm) {
-            boolean webspherePresent = ClassUtils.isPresent("com.ibm.wsspi.uow.UOWManager", getClass().getClassLoader());
+        if (jtaTransactionManager instanceof JtaTransactionManager) {
+            JtaTransactionManager springJtaTm = (JtaTransactionManager) jtaTransactionManager
+            boolean webspherePresent = ClassUtils.isPresent('com.ibm.wsspi.uow.UOWManager', getClass().getClassLoader())
             if (webspherePresent) {
                 getProperties().put(AvailableSettings.JTA_PLATFORM,
-                        "org.hibernate.engine.transaction.jta.platform.internal.WebSphereExtendedJtaPlatform");
-            }
-            else {
+                        'org.hibernate.engine.transaction.jta.platform.internal.WebSphereExtendedJtaPlatform')
+            } else {
                 if (springJtaTm.getTransactionManager() == null) {
                     throw new IllegalArgumentException(
-                            "Can only apply JtaTransactionManager which has a TransactionManager reference set");
+                            'Can only apply JtaTransactionManager which has a TransactionManager reference set')
                 }
                 getProperties().put(AvailableSettings.JTA_PLATFORM,
                         new ConfigurableJtaPlatform(springJtaTm.getTransactionManager(), springJtaTm.getUserTransaction(),
-                                springJtaTm.getTransactionSynchronizationRegistry()));
+                                springJtaTm.getTransactionSynchronizationRegistry()))
             }
-        }
-        else if (jtaTransactionManager instanceof TransactionManager jtaTm) {
+        } else if (jtaTransactionManager instanceof TransactionManager) {
             getProperties().put(AvailableSettings.JTA_PLATFORM,
-                    new ConfigurableJtaPlatform(jtaTm, null, null));
-        }
-        else {
+                    new ConfigurableJtaPlatform((TransactionManager) jtaTransactionManager, null, null))
+        } else {
             throw new IllegalArgumentException(
-                    "Unknown transaction manager type: " + jtaTransactionManager.getClass().getName());
+                    'Unknown transaction manager type: ' + jtaTransactionManager.getClass().getName())
         }
 
-        getProperties().put(AvailableSettings.TRANSACTION_COORDINATOR_STRATEGY, "jta");
+        getProperties().put(AvailableSettings.TRANSACTION_COORDINATOR_STRATEGY, 'jta')
         getProperties().put(AvailableSettings.CONNECTION_HANDLING,
-                PhysicalConnectionHandlingMode.DELAYED_ACQUISITION_AND_RELEASE_AFTER_STATEMENT);
+                PhysicalConnectionHandlingMode.DELAYED_ACQUISITION_AND_RELEASE_AFTER_STATEMENT)
 
-        return this;
+        return this
     }
 
     /**
@@ -230,9 +221,9 @@ public class LocalSessionFactoryBuilder extends Configuration {
      * @see SpringBeanContainer
      * @see AvailableSettings#BEAN_CONTAINER
      */
-    public LocalSessionFactoryBuilder setBeanContainer(ConfigurableListableBeanFactory beanFactory) {
-        getProperties().put(AvailableSettings.BEAN_CONTAINER, new SpringBeanContainer(beanFactory));
-        return this;
+    LocalSessionFactoryBuilder setBeanContainer(ConfigurableListableBeanFactory beanFactory) {
+        getProperties().put(AvailableSettings.BEAN_CONTAINER, new SpringBeanContainer(beanFactory))
+        return this
     }
 
     /**
@@ -243,9 +234,9 @@ public class LocalSessionFactoryBuilder extends Configuration {
      * @since 5.1
      * @see AvailableSettings#CACHE_REGION_FACTORY
      */
-    public LocalSessionFactoryBuilder setCacheRegionFactory(RegionFactory cacheRegionFactory) {
-        getProperties().put(AvailableSettings.CACHE_REGION_FACTORY, cacheRegionFactory);
-        return this;
+    LocalSessionFactoryBuilder setCacheRegionFactory(RegionFactory cacheRegionFactory) {
+        getProperties().put(AvailableSettings.CACHE_REGION_FACTORY, cacheRegionFactory)
+        return this
     }
 
     /**
@@ -253,9 +244,9 @@ public class LocalSessionFactoryBuilder extends Configuration {
      * @since 4.3
      * @see AvailableSettings#MULTI_TENANT_CONNECTION_PROVIDER
      */
-    public LocalSessionFactoryBuilder setMultiTenantConnectionProvider(MultiTenantConnectionProvider multiTenantConnectionProvider) {
-        getProperties().put(AvailableSettings.MULTI_TENANT_CONNECTION_PROVIDER, multiTenantConnectionProvider);
-        return this;
+    LocalSessionFactoryBuilder setMultiTenantConnectionProvider(MultiTenantConnectionProvider multiTenantConnectionProvider) {
+        getProperties().put(AvailableSettings.MULTI_TENANT_CONNECTION_PROVIDER, multiTenantConnectionProvider)
+        return this
     }
 
     /**
@@ -264,10 +255,10 @@ public class LocalSessionFactoryBuilder extends Configuration {
      * @see AvailableSettings#MULTI_TENANT_IDENTIFIER_RESOLVER
      */
     @Override
-    public Configuration setCurrentTenantIdentifierResolver(CurrentTenantIdentifierResolver<?> currentTenantIdentifierResolver) {
-        getProperties().put(AvailableSettings.MULTI_TENANT_IDENTIFIER_RESOLVER, currentTenantIdentifierResolver);
-        super.setCurrentTenantIdentifierResolver(currentTenantIdentifierResolver);
-        return this;
+    Configuration setCurrentTenantIdentifierResolver(CurrentTenantIdentifierResolver<?> currentTenantIdentifierResolver) {
+        getProperties().put(AvailableSettings.MULTI_TENANT_IDENTIFIER_RESOLVER, currentTenantIdentifierResolver)
+        super.setCurrentTenantIdentifierResolver(currentTenantIdentifierResolver)
+        return this
     }
 
     /**
@@ -277,9 +268,9 @@ public class LocalSessionFactoryBuilder extends Configuration {
      * or {@code @jakarta.persistence.MappedSuperclass}.
      * @see #scanPackages
      */
-    public LocalSessionFactoryBuilder setEntityTypeFilters(TypeFilter... entityTypeFilters) {
-        this.entityTypeFilters = entityTypeFilters;
-        return this;
+    LocalSessionFactoryBuilder setEntityTypeFilters(TypeFilter... entityTypeFilters) {
+        this.entityTypeFilters = entityTypeFilters
+        return this
     }
 
     /**
@@ -287,11 +278,11 @@ public class LocalSessionFactoryBuilder extends Configuration {
      * @see #addAnnotatedClass
      * @see #scanPackages
      */
-    public LocalSessionFactoryBuilder addAnnotatedClasses(Class<?>... annotatedClasses) {
+    LocalSessionFactoryBuilder addAnnotatedClasses(Class<?>... annotatedClasses) {
         for (Class<?> annotatedClass : annotatedClasses) {
-            addAnnotatedClass(annotatedClass);
+            addAnnotatedClass(annotatedClass)
         }
-        return this;
+        return this
     }
 
     /**
@@ -299,11 +290,11 @@ public class LocalSessionFactoryBuilder extends Configuration {
      * @see #addPackage
      * @see #scanPackages
      */
-    public LocalSessionFactoryBuilder addPackages(String... annotatedPackages) {
+    LocalSessionFactoryBuilder addPackages(String... annotatedPackages) {
         for (String annotatedPackage : annotatedPackages) {
-            addPackage(annotatedPackage);
+            addPackage(annotatedPackage)
         }
-        return this;
+        return this
     }
 
     /**
@@ -312,64 +303,57 @@ public class LocalSessionFactoryBuilder extends Configuration {
      * @param packagesToScan one or more Java package names
      * @throws HibernateException if scanning fails for any reason
      */
-    @SuppressWarnings("unchecked")
-    public LocalSessionFactoryBuilder scanPackages(String... packagesToScan) throws HibernateException {
-        Set<String> entityClassNames = new TreeSet<>();
-        Set<String> converterClassNames = new TreeSet<>();
-        Set<String> packageNames = new TreeSet<>();
+    @SuppressWarnings('unchecked')
+    LocalSessionFactoryBuilder scanPackages(String... packagesToScan) throws HibernateException {
+        Set<String> entityClassNames = new TreeSet<>()
+        Set<String> converterClassNames = new TreeSet<>()
+        Set<String> packageNames = new TreeSet<>()
         try {
             for (String pkg : packagesToScan) {
                 String pattern = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
-                        ClassUtils.convertClassNameToResourcePath(pkg) + RESOURCE_PATTERN;
-                Resource[] resources = this.resourcePatternResolver.getResources(pattern);
-                MetadataReaderFactory readerFactory = new CachingMetadataReaderFactory(this.resourcePatternResolver);
+                        ClassUtils.convertClassNameToResourcePath(pkg) + RESOURCE_PATTERN
+                Resource[] resources = this.resourcePatternResolver.getResources(pattern)
+                MetadataReaderFactory readerFactory = new CachingMetadataReaderFactory(this.resourcePatternResolver)
                 for (Resource resource : resources) {
                     try {
-                        MetadataReader reader = readerFactory.getMetadataReader(resource);
-                        String className = reader.getClassMetadata().getClassName();
+                        MetadataReader reader = readerFactory.getMetadataReader(resource)
+                        String className = reader.getClassMetadata().getClassName()
                         if (matchesEntityTypeFilter(reader, readerFactory)) {
-                            entityClassNames.add(className);
-                        }
-                        else if (CONVERTER_TYPE_FILTER.match(reader, readerFactory)) {
-                            converterClassNames.add(className);
+                            entityClassNames.add(className)
+                        } else if (CONVERTER_TYPE_FILTER.match(reader, readerFactory)) {
+                            converterClassNames.add(className)
+                        } else if (className.endsWith(PACKAGE_INFO_SUFFIX)) {
+                            packageNames.add(className.substring(0, className.length() - PACKAGE_INFO_SUFFIX.length()))
                         }
-                        else if (className.endsWith(PACKAGE_INFO_SUFFIX)) {
-                            packageNames.add(className.substring(0, className.length() - PACKAGE_INFO_SUFFIX.length()));
-                        }
-                    }
-                    catch (FileNotFoundException ex) {
+                    } catch (FileNotFoundException ignored) {
                         // Ignore non-readable resource
-                    }
-                    catch (ClassFormatException ex) {
-                        if (!shouldIgnoreClassFormatException) {
-                            throw new MappingException("Incompatible class format in " + resource, ex);
+                    } catch (ClassFormatException ex) {
+                        if (!SHOULD_IGNORE_CLASS_FORMAT_EXCEPTION) {
+                            throw new MappingException('Incompatible class format in ' + resource, ex)
                         }
-                    }
-                    catch (Throwable ex) {
-                        throw new MappingException("Failed to read candidate component class: " + resource, ex);
+                    } catch (Throwable ex) {
+                        throw new MappingException('Failed to read candidate component class: ' + resource, ex)
                     }
                 }
             }
-        }
-        catch (IOException ex) {
-            throw new MappingException("Failed to scan classpath for unlisted classes", ex);
+        } catch (IOException ex) {
+            throw new MappingException('Failed to scan classpath for unlisted classes', ex)
         }
         try {
-            ClassLoader cl = this.resourcePatternResolver.getClassLoader();
+            ClassLoader cl = this.resourcePatternResolver.getClassLoader()
             for (String className : entityClassNames) {
-                addAnnotatedClass(ClassUtils.forName(className, cl));
+                addAnnotatedClass(ClassUtils.forName(className, cl))
             }
             for (String className : converterClassNames) {
-                addAttributeConverter((Class<? extends AttributeConverter<?, ?>>) ClassUtils.forName(className, cl));
+                addAttributeConverter((Class<? extends AttributeConverter<?, ?>>) ClassUtils.forName(className, cl))
             }
             for (String packageName : packageNames) {
-                addPackage(packageName);
+                addPackage(packageName)
             }
+        } catch (ClassNotFoundException ex) {
+            throw new MappingException('Failed to load annotated classes from classpath', ex)
         }
-        catch (ClassNotFoundException ex) {
-            throw new MappingException("Failed to load annotated classes from classpath", ex);
-        }
-        return this;
+        return this
     }
 
     /**
@@ -379,10 +363,10 @@ public class LocalSessionFactoryBuilder extends Configuration {
     private boolean matchesEntityTypeFilter(MetadataReader reader, MetadataReaderFactory readerFactory) throws IOException {
         for (TypeFilter filter : this.entityTypeFilters) {
             if (filter.match(reader, readerFactory)) {
-                return true;
+                return true
             }
         }
-        return false;
+        return false
     }
 
     /**
@@ -399,11 +383,11 @@ public class LocalSessionFactoryBuilder extends Configuration {
      * @since 4.3
      * @see #buildSessionFactory()
      */
-    public SessionFactory buildSessionFactory(AsyncTaskExecutor bootstrapExecutor) {
-        Assert.notNull(bootstrapExecutor, "AsyncTaskExecutor must not be null");
+    SessionFactory buildSessionFactory(AsyncTaskExecutor bootstrapExecutor) {
+        Assert.notNull(bootstrapExecutor, 'AsyncTaskExecutor must not be null')
         return (SessionFactory) Proxy.newProxyInstance(this.resourcePatternResolver.getClassLoader(),
-                new Class<?>[] {SessionFactoryImplementor.class, InfrastructureProxy.class},
-                new BootstrapSessionFactoryInvocationHandler(bootstrapExecutor));
+                [SessionFactoryImplementor, InfrastructureProxy] as Class<?>[],
+                new BootstrapSessionFactoryInvocationHandler(bootstrapExecutor))
     }
 
     /**
@@ -413,54 +397,55 @@ public class LocalSessionFactoryBuilder extends Configuration {
      */
     private class BootstrapSessionFactoryInvocationHandler implements InvocationHandler {
 
-        private final Future<SessionFactory> sessionFactoryFuture;
+        private final Future<SessionFactory> sessionFactoryFuture
 
-        public BootstrapSessionFactoryInvocationHandler(AsyncTaskExecutor bootstrapExecutor) {
+        BootstrapSessionFactoryInvocationHandler(AsyncTaskExecutor bootstrapExecutor) {
             this.sessionFactoryFuture = bootstrapExecutor.submit(
-                    (Callable<SessionFactory>) LocalSessionFactoryBuilder.this::buildSessionFactory);
+                    { -> LocalSessionFactoryBuilder.this.buildSessionFactory() } as Callable<SessionFactory>)
         }
 
         @Override
-        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
-            return switch (method.getName()) {
-                // Only consider equal when proxies are identical.
-                case "equals" -> (proxy == args[0]);
-                // Use hashCode of EntityManagerFactory proxy.
-                case "hashCode" -> System.identityHashCode(proxy);
-                case "getProperties" -> getProperties();
-                // Call coming in through InfrastructureProxy interface...
-                case "getWrappedObject" -> getSessionFactory();
-                default -> {
+        Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+            switch (method.getName()) {
+                case 'equals':
+                    // Only consider equal when proxies are identical.
+                    return proxy.is(args[0])
+                case 'hashCode':
+                    // Use hashCode of EntityManagerFactory proxy.
+                    return System.identityHashCode(proxy)
+                case 'getProperties':
+                    return LocalSessionFactoryBuilder.this.getProperties()
+                case 'getWrappedObject':
+                    // Call coming in through InfrastructureProxy interface...
+                    return getSessionFactory()
+                default:
                     try {
                         // Regular delegation to the target SessionFactory,
                         // enforcing its full initialization...
-                        yield method.invoke(getSessionFactory(), args);
+                        return method.invoke(getSessionFactory(), args)
+                    } catch (InvocationTargetException ex) {
+                        throw ex.getTargetException()
                     }
-                    catch (InvocationTargetException ex) {
-                        throw ex.getTargetException();
-                    }
-                }
-            };
+            }
         }
 
         private SessionFactory getSessionFactory() {
             try {
-                return this.sessionFactoryFuture.get();
-            }
-            catch (InterruptedException ex) {
-                Thread.currentThread().interrupt();
-                throw new IllegalStateException("Interrupted during initialization of Hibernate SessionFactory", ex);
-            }
-            catch (ExecutionException ex) {
-                Throwable cause = ex.getCause();
-                if (cause instanceof HibernateException hibernateException) {
+                return this.sessionFactoryFuture.get()
+            } catch (InterruptedException ex) {
+                Thread.currentThread().interrupt()
+                throw new IllegalStateException('Interrupted during initialization of Hibernate SessionFactory', ex)
+            } catch (ExecutionException ex) {
+                Throwable cause = ex.getCause()
+                if (cause instanceof HibernateException) {
                     // Rethrow a provider configuration exception (possibly with a nested cause) directly
-                    throw hibernateException;
+                    throw (HibernateException) cause
                 }
-                throw new IllegalStateException("Failed to asynchronously initialize Hibernate SessionFactory: " +
-                        ex.getMessage(), cause);
+                throw new IllegalStateException('Failed to asynchronously initialize Hibernate SessionFactory: ' +
+                        ex.getMessage(), cause)
             }
         }
+
     }
 
 }
diff --git a/grails-data-hibernate7/spring-orm/src/main/groovy/org/grails/orm/hibernate/support/hibernate7/SessionFactoryUtils.java b/grails-data-hibernate7/spring-orm/src/main/groovy/org/grails/orm/hibernate/support/hibernate7/SessionFactoryUtils.groovy
similarity index 52%
rename from grails-data-hibernate7/spring-orm/src/main/groovy/org/grails/orm/hibernate/support/hibernate7/SessionFactoryUtils.java
rename to grails-data-hibernate7/spring-orm/src/main/groovy/org/grails/orm/hibernate/support/hibernate7/SessionFactoryUtils.groovy
index 7d45a02d54..223fb276c2 100644
--- a/grails-data-hibernate7/spring-orm/src/main/groovy/org/grails/orm/hibernate/support/hibernate7/SessionFactoryUtils.java
+++ b/grails-data-hibernate7/spring-orm/src/main/groovy/org/grails/orm/hibernate/support/hibernate7/SessionFactoryUtils.groovy
@@ -13,60 +13,57 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+package org.grails.orm.hibernate.support.hibernate7
 
-package org.grails.orm.hibernate.support.hibernate7;
+import java.lang.reflect.Method
 
-import java.lang.reflect.Method;
-import java.util.Map;
+import javax.sql.DataSource
 
-import javax.sql.DataSource;
-
-import jakarta.persistence.PersistenceException;
-
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-import org.hibernate.HibernateException;
-import org.hibernate.JDBCException;
-import org.hibernate.NonUniqueObjectException;
-import org.hibernate.NonUniqueResultException;
-import org.hibernate.ObjectDeletedException;
-import org.hibernate.PersistentObjectException;
-import org.hibernate.PessimisticLockException;
-import org.hibernate.PropertyValueException;
-import org.hibernate.QueryException;
-import org.hibernate.QueryTimeoutException;
-import org.hibernate.Session;
-import org.hibernate.SessionFactory;
-import org.hibernate.StaleObjectStateException;
-import org.hibernate.StaleStateException;
-import org.hibernate.TransientObjectException;
-import org.hibernate.UnresolvableObjectException;
-import org.hibernate.WrongClassException;
-import org.hibernate.cfg.Environment;
-import org.hibernate.dialect.lock.OptimisticEntityLockException;
-import org.hibernate.dialect.lock.PessimisticEntityLockException;
-import org.hibernate.engine.jdbc.connections.spi.ConnectionProvider;
-import org.hibernate.engine.spi.SessionFactoryImplementor;
-import org.hibernate.exception.ConstraintViolationException;
-import org.hibernate.exception.DataException;
-import org.hibernate.exception.JDBCConnectionException;
-import org.hibernate.exception.LockAcquisitionException;
-import org.hibernate.exception.SQLGrammarException;
-import org.hibernate.service.UnknownServiceException;
-import org.jspecify.annotations.Nullable;
-
-import org.springframework.dao.CannotAcquireLockException;
-import org.springframework.dao.DataAccessException;
-import org.springframework.dao.DataAccessResourceFailureException;
-import org.springframework.dao.DataIntegrityViolationException;
-import org.springframework.dao.DuplicateKeyException;
-import org.springframework.dao.IncorrectResultSizeDataAccessException;
-import org.springframework.dao.InvalidDataAccessApiUsageException;
-import org.springframework.dao.InvalidDataAccessResourceUsageException;
-import org.springframework.dao.PessimisticLockingFailureException;
-import org.springframework.jdbc.datasource.DataSourceUtils;
-import org.springframework.util.ClassUtils;
-import org.springframework.util.ReflectionUtils;
+import groovy.transform.CompileStatic
+import groovy.transform.PackageScope
+import jakarta.persistence.PersistenceException
+import org.apache.commons.logging.Log
+import org.apache.commons.logging.LogFactory
+import org.hibernate.HibernateException
+import org.hibernate.JDBCException
+import org.hibernate.NonUniqueObjectException
+import org.hibernate.NonUniqueResultException
+import org.hibernate.ObjectDeletedException
+import org.hibernate.PersistentObjectException
+import org.hibernate.PessimisticLockException
+import org.hibernate.PropertyValueException
+import org.hibernate.QueryException
+import org.hibernate.QueryTimeoutException
+import org.hibernate.Session
+import org.hibernate.SessionFactory
+import org.hibernate.StaleObjectStateException
+import org.hibernate.StaleStateException
+import org.hibernate.TransientObjectException
+import org.hibernate.UnresolvableObjectException
+import org.hibernate.WrongClassException
+import org.hibernate.cfg.Environment
+import org.hibernate.dialect.lock.OptimisticEntityLockException
+import org.hibernate.dialect.lock.PessimisticEntityLockException
+import org.hibernate.engine.jdbc.connections.spi.ConnectionProvider
+import org.hibernate.engine.spi.SessionFactoryImplementor
+import org.hibernate.exception.ConstraintViolationException
+import org.hibernate.exception.DataException
+import org.hibernate.exception.JDBCConnectionException
+import org.hibernate.exception.LockAcquisitionException
+import org.hibernate.exception.SQLGrammarException
+import org.hibernate.service.UnknownServiceException
+import org.springframework.dao.CannotAcquireLockException
+import org.springframework.dao.DataAccessException
+import org.springframework.dao.DataAccessResourceFailureException
+import org.springframework.dao.DataIntegrityViolationException
+import org.springframework.dao.DuplicateKeyException
+import org.springframework.dao.IncorrectResultSizeDataAccessException
+import org.springframework.dao.InvalidDataAccessApiUsageException
+import org.springframework.dao.InvalidDataAccessResourceUsageException
+import org.springframework.dao.PessimisticLockingFailureException
+import org.springframework.jdbc.datasource.DataSourceUtils
+import org.springframework.util.ClassUtils
+import org.springframework.util.ReflectionUtils
 
 /**
  * Helper class featuring methods for Hibernate Session handling.
@@ -80,7 +77,8 @@ import org.springframework.util.ReflectionUtils;
  * @see HibernateExceptionTranslator
  * @see HibernateTransactionManager
  */
-public abstract class SessionFactoryUtils {
+@CompileStatic
+abstract class SessionFactoryUtils {
 
     /**
      * Order value for TransactionSynchronization objects that clean up Hibernate Sessions.
@@ -88,10 +86,11 @@ public abstract class SessionFactoryUtils {
      * to execute Session cleanup before JDBC Connection cleanup, if any.
      * @see DataSourceUtils#CONNECTION_SYNCHRONIZATION_ORDER
      */
-    public static final int SESSION_SYNCHRONIZATION_ORDER =
-            DataSourceUtils.CONNECTION_SYNCHRONIZATION_ORDER - 100;
+    static final int SESSION_SYNCHRONIZATION_ORDER =
+            DataSourceUtils.CONNECTION_SYNCHRONIZATION_ORDER - 100
 
-    static final Log logger = LogFactory.getLog(SessionFactoryUtils.class);
+    @PackageScope
+    static final Log LOGGER = LogFactory.getLog(SessionFactoryUtils)
 
     /**
      * Trigger a flush on the given Hibernate Session, converting regular
@@ -102,26 +101,23 @@ public abstract class SessionFactoryUtils {
      * @throws DataAccessException in case of flush failures
      * @since 4.3.2
      */
+    @PackageScope
     static void flush(Session session, boolean synch) throws DataAccessException {
         if (synch) {
-            logger.debug("Flushing Hibernate Session on transaction synchronization");
-        }
-        else {
-            logger.debug("Flushing Hibernate Session on explicit request");
+            LOGGER.debug('Flushing Hibernate Session on transaction synchronization')
+        } else {
+            LOGGER.debug('Flushing Hibernate Session on explicit request')
         }
         try {
-            session.flush();
-        }
-        catch (HibernateException ex) {
-            throw convertHibernateAccessException(ex);
-        }
-        catch (PersistenceException ex) {
-            if (ex.getCause() instanceof HibernateException hibernateException) {
-                throw convertHibernateAccessException(hibernateException);
+            session.flush()
+        } catch (HibernateException ex) {
+            throw convertHibernateAccessException(ex)
+        } catch (PersistenceException ex) {
+            if (ex.getCause() instanceof HibernateException) {
+                throw convertHibernateAccessException((HibernateException) ex.getCause())
             }
-            throw ex;
+            throw ex
         }
-
     }
 
     /**
@@ -130,15 +126,14 @@ public abstract class SessionFactoryUtils {
      * @param session the Hibernate Session to close (may be {@code null})
      * @see Session#close()
      */
-    public static void closeSession(@Nullable Session session) {
+    static void closeSession(Session session) {
         if (session != null) {
             try {
                 if (session.isOpen()) {
-                    session.close();
+                    session.close()
                 }
-            }
-            catch (Throwable ex) {
-                logger.error("Failed to release Hibernate Session", ex);
+            } catch (Throwable ex) {
+                LOGGER.error('Failed to release Hibernate Session', ex)
             }
         }
     }
@@ -149,32 +144,31 @@ public abstract class SessionFactoryUtils {
      * @return the DataSource, or {@code null} if none found
      * @see ConnectionProvider
      */
-    @Nullable
-    public static DataSource getDataSource(SessionFactory sessionFactory) {
-        Method getProperties = ClassUtils.getMethodIfAvailable(sessionFactory.getClass(), "getProperties");
+    static DataSource getDataSource(SessionFactory sessionFactory) {
+        Method getProperties = ClassUtils.getMethodIfAvailable(sessionFactory.getClass(), 'getProperties')
         if (getProperties != null) {
-            Map<?, ?> props = (Map<?, ?>) ReflectionUtils.invokeMethod(getProperties, sessionFactory);
+            Map<?, ?> props = (Map<?, ?>) ReflectionUtils.invokeMethod(getProperties, sessionFactory)
             if (props != null) {
-                Object dataSourceValue = props.get(Environment.DATASOURCE);
-                if (dataSourceValue instanceof DataSource dataSource) {
-                    return dataSource;
+                Object dataSourceValue = props.get(Environment.DATASOURCE)
+                if (dataSourceValue instanceof DataSource) {
+                    return (DataSource) dataSourceValue
                 }
             }
         }
-        if (sessionFactory instanceof SessionFactoryImplementor sfi) {
+        if (sessionFactory instanceof SessionFactoryImplementor) {
+            SessionFactoryImplementor sfi = (SessionFactoryImplementor) sessionFactory
             try {
-                ConnectionProvider cp = sfi.getServiceRegistry().getService(ConnectionProvider.class);
+                ConnectionProvider cp = sfi.getServiceRegistry().getService(ConnectionProvider)
                 if (cp != null) {
-                    return cp.unwrap(DataSource.class);
+                    return cp.unwrap(DataSource)
                 }
-            }
-            catch (UnknownServiceException ex) {
-                if (logger.isDebugEnabled()) {
-                    logger.debug("No ConnectionProvider found - cannot determine DataSource for SessionFactory: " + ex);
+            } catch (UnknownServiceException ex) {
+                if (LOGGER.isDebugEnabled()) {
+                    LOGGER.debug('No ConnectionProvider found - cannot determine DataSource for SessionFactory: ' + ex)
                 }
             }
         }
-        return null;
+        return null
     }
 
     /**
@@ -185,79 +179,85 @@ public abstract class SessionFactoryUtils {
      * @see HibernateExceptionTranslator#convertHibernateAccessException
      * @see HibernateTransactionManager#convertHibernateAccessException
      */
-    public static DataAccessException convertHibernateAccessException(HibernateException ex) {
+    static DataAccessException convertHibernateAccessException(HibernateException ex) {
         if (ex instanceof JDBCConnectionException) {
-            return new DataAccessResourceFailureException(ex.getMessage(), ex);
+            return new DataAccessResourceFailureException(ex.getMessage(), ex)
         }
-        if (ex instanceof SQLGrammarException hibJdbcEx) {
-            return new InvalidDataAccessResourceUsageException(ex.getMessage() + "; SQL [" + hibJdbcEx.getSQL() + "]", ex);
+        if (ex instanceof SQLGrammarException) {
+            SQLGrammarException hibJdbcEx = (SQLGrammarException) ex
+            return new InvalidDataAccessResourceUsageException(ex.getMessage() + '; SQL [' + hibJdbcEx.getSQL() + ']', ex)
         }
-        if (ex instanceof QueryTimeoutException hibJdbcEx) {
-            return new org.springframework.dao.QueryTimeoutException(ex.getMessage() + "; SQL [" + hibJdbcEx.getSQL() + "]", ex);
+        if (ex instanceof QueryTimeoutException) {
+            QueryTimeoutException hibJdbcEx = (QueryTimeoutException) ex
+            return new org.springframework.dao.QueryTimeoutException(ex.getMessage() + '; SQL [' + hibJdbcEx.getSQL() + ']', ex)
         }
-        if (ex instanceof LockAcquisitionException hibJdbcEx) {
-            return new CannotAcquireLockException(ex.getMessage() + "; SQL [" + hibJdbcEx.getSQL() + "]", ex);
+        if (ex instanceof LockAcquisitionException) {
+            LockAcquisitionException hibJdbcEx = (LockAcquisitionException) ex
+            return new CannotAcquireLockException(ex.getMessage() + '; SQL [' + hibJdbcEx.getSQL() + ']', ex)
         }
-        if (ex instanceof PessimisticLockException hibJdbcEx) {
-            return new PessimisticLockingFailureException(ex.getMessage() + "; SQL [" + hibJdbcEx.getSQL() + "]", ex);
+        if (ex instanceof PessimisticLockException) {
+            PessimisticLockException hibJdbcEx = (PessimisticLockException) ex
+            return new PessimisticLockingFailureException(ex.getMessage() + '; SQL [' + hibJdbcEx.getSQL() + ']', ex)
         }
-        if (ex instanceof ConstraintViolationException hibJdbcEx) {
-            return new DataIntegrityViolationException(ex.getMessage() + "; SQL [" + hibJdbcEx.getSQL() +
-                    "]; constraint [" + hibJdbcEx.getConstraintName() + "]", ex);
+        if (ex instanceof ConstraintViolationException) {
+            ConstraintViolationException hibJdbcEx = (ConstraintViolationException) ex
+            return new DataIntegrityViolationException(ex.getMessage() + '; SQL [' + hibJdbcEx.getSQL() +
+                    ']; constraint [' + hibJdbcEx.getConstraintName() + ']', ex)
         }
-        if (ex instanceof DataException hibJdbcEx) {
-            return new DataIntegrityViolationException(ex.getMessage() + "; SQL [" + hibJdbcEx.getSQL() + "]", ex);
+        if (ex instanceof DataException) {
+            DataException hibJdbcEx = (DataException) ex
+            return new DataIntegrityViolationException(ex.getMessage() + '; SQL [' + hibJdbcEx.getSQL() + ']', ex)
         }
-        if (ex instanceof JDBCException hibJdbcEx) {
-            return new HibernateJdbcException(hibJdbcEx);
+        if (ex instanceof JDBCException) {
+            return new HibernateJdbcException((JDBCException) ex)
         }
         // end of JDBCException (subclass) handling
 
-        if (ex instanceof QueryException queryException) {
-            return new HibernateQueryException(queryException);
+        if (ex instanceof QueryException) {
+            return new HibernateQueryException((QueryException) ex)
         }
         if (ex instanceof NonUniqueResultException) {
-            return new IncorrectResultSizeDataAccessException(ex.getMessage(), 1, ex);
+            return new IncorrectResultSizeDataAccessException(ex.getMessage(), 1, ex)
         }
         if (ex instanceof NonUniqueObjectException) {
-            return new DuplicateKeyException(ex.getMessage(), ex);
+            return new DuplicateKeyException(ex.getMessage(), ex)
         }
         if (ex instanceof PropertyValueException) {
-            return new DataIntegrityViolationException(ex.getMessage(), ex);
+            return new DataIntegrityViolationException(ex.getMessage(), ex)
         }
         if (ex instanceof PersistentObjectException) {
-            return new InvalidDataAccessApiUsageException(ex.getMessage(), ex);
+            return new InvalidDataAccessApiUsageException(ex.getMessage(), ex)
         }
         if (ex instanceof TransientObjectException) {
-            return new InvalidDataAccessApiUsageException(ex.getMessage(), ex);
+            return new InvalidDataAccessApiUsageException(ex.getMessage(), ex)
         }
         if (ex instanceof ObjectDeletedException) {
-            return new InvalidDataAccessApiUsageException(ex.getMessage(), ex);
+            return new InvalidDataAccessApiUsageException(ex.getMessage(), ex)
         }
-        if (ex instanceof UnresolvableObjectException unresolvableObjectException) {
-            return new HibernateObjectRetrievalFailureException(unresolvableObjectException);
+        if (ex instanceof UnresolvableObjectException) {
+            return new HibernateObjectRetrievalFailureException((UnresolvableObjectException) ex)
         }
-        if (ex instanceof WrongClassException wrongClassException) {
-            return new HibernateObjectRetrievalFailureException(wrongClassException);
+        if (ex instanceof WrongClassException) {
+            return new HibernateObjectRetrievalFailureException((WrongClassException) ex)
         }
-        if (ex instanceof StaleObjectStateException staleObjectStateException) {
-            return new HibernateOptimisticLockingFailureException(staleObjectStateException);
+        if (ex instanceof StaleObjectStateException) {
+            return new HibernateOptimisticLockingFailureException((StaleObjectStateException) ex)
         }
-        if (ex instanceof StaleStateException staleStateException) {
-            return new HibernateOptimisticLockingFailureException(staleStateException);
+        if (ex instanceof StaleStateException) {
+            return new HibernateOptimisticLockingFailureException((StaleStateException) ex)
         }
-        if (ex instanceof OptimisticEntityLockException optimisticEntityLockException) {
-            return new HibernateOptimisticLockingFailureException(optimisticEntityLockException);
+        if (ex instanceof OptimisticEntityLockException) {
+            return new HibernateOptimisticLockingFailureException((OptimisticEntityLockException) ex)
         }
         if (ex instanceof PessimisticEntityLockException) {
             if (ex.getCause() instanceof LockAcquisitionException) {
-                return new CannotAcquireLockException(ex.getMessage(), ex.getCause());
+                return new CannotAcquireLockException(ex.getMessage(), ex.getCause())
             }
-            return new PessimisticLockingFailureException(ex.getMessage(), ex);
+            return new PessimisticLockingFailureException(ex.getMessage(), ex)
         }
 
         // fallback
-        return new HibernateSystemException(ex);
+        return new HibernateSystemException(ex)
     }
 
 }
diff --git a/grails-data-hibernate7/spring-orm/src/main/groovy/org/grails/orm/hibernate/support/hibernate7/SpringBeanContainer.java b/grails-data-hibernate7/spring-orm/src/main/groovy/org/grails/orm/hibernate/support/hibernate7/SpringBeanContainer.groovy
similarity index 55%
rename from grails-data-hibernate7/spring-orm/src/main/groovy/org/grails/orm/hibernate/support/hibernate7/SpringBeanContainer.java
rename to grails-data-hibernate7/spring-orm/src/main/groovy/org/grails/orm/hibernate/support/hibernate7/SpringBeanContainer.groovy
index 2c505e5dd9..3d6fabfd24 100644
--- a/grails-data-hibernate7/spring-orm/src/main/groovy/org/grails/orm/hibernate/support/hibernate7/SpringBeanContainer.java
+++ b/grails-data-hibernate7/spring-orm/src/main/groovy/org/grails/orm/hibernate/support/hibernate7/SpringBeanContainer.groovy
@@ -13,26 +13,24 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+package org.grails.orm.hibernate.support.hibernate7
 
-package org.grails.orm.hibernate.support.hibernate7;
+import java.util.function.Consumer
 
-import java.util.Map;
-import java.util.function.Consumer;
-
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-import org.hibernate.resource.beans.container.spi.BeanContainer;
-import org.hibernate.resource.beans.container.spi.ContainedBean;
-import org.hibernate.resource.beans.spi.BeanInstanceProducer;
-import org.hibernate.type.spi.TypeBootstrapContext;
-import org.jspecify.annotations.Nullable;
-
-import org.springframework.beans.BeansException;
-import org.springframework.beans.factory.BeanCreationException;
-import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
-import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
-import org.springframework.util.Assert;
-import org.springframework.util.ConcurrentReferenceHashMap;
+import groovy.transform.CompileStatic
+import org.apache.commons.logging.Log
+import org.apache.commons.logging.LogFactory
+import org.hibernate.resource.beans.container.spi.BeanContainer
+import org.hibernate.resource.beans.container.spi.BeanContainer.LifecycleOptions
+import org.hibernate.resource.beans.container.spi.ContainedBean
+import org.hibernate.resource.beans.spi.BeanInstanceProducer
+import org.hibernate.type.spi.TypeBootstrapContext
+import org.springframework.beans.BeansException
+import org.springframework.beans.factory.BeanCreationException
+import org.springframework.beans.factory.config.AutowireCapableBeanFactory
+import org.springframework.beans.factory.config.ConfigurableListableBeanFactory
+import org.springframework.util.Assert
+import org.springframework.util.ConcurrentReferenceHashMap
 
 /**
  * Spring's implementation of Hibernate's {@link BeanContainer} SPI,
@@ -75,65 +73,64 @@ import org.springframework.util.ConcurrentReferenceHashMap;
  * @see org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean#setJpaPropertyMap
  * @see org.hibernate.cfg.AvailableSettings#BEAN_CONTAINER
  */
-public final class SpringBeanContainer implements BeanContainer {
+@CompileStatic
+final class SpringBeanContainer implements BeanContainer {
 
-    private static final Log logger = LogFactory.getLog(SpringBeanContainer.class);
+    private static final Log LOGGER = LogFactory.getLog(SpringBeanContainer)
 
-    private final ConfigurableListableBeanFactory beanFactory;
+    private final ConfigurableListableBeanFactory beanFactory
 
-    private final Map<Object, SpringContainedBean<?>> beanCache = new ConcurrentReferenceHashMap<>();
+    private final Map<Object, SpringContainedBean<?>> beanCache = new ConcurrentReferenceHashMap<>()
 
     /**
      * Instantiate a new SpringBeanContainer for the given bean factory.
      * @param beanFactory the Spring bean factory to delegate to
      */
-    public SpringBeanContainer(ConfigurableListableBeanFactory beanFactory) {
-        Assert.notNull(beanFactory, "ConfigurableListableBeanFactory is required");
-        this.beanFactory = beanFactory;
+    SpringBeanContainer(ConfigurableListableBeanFactory beanFactory) {
+        Assert.notNull(beanFactory, 'ConfigurableListableBeanFactory is required')
+        this.beanFactory = beanFactory
     }
 
     @Override
-    @SuppressWarnings("unchecked")
-    public <B> ContainedBean<B> getBean(
+    @SuppressWarnings('unchecked')
+    def <B> ContainedBean<B> getBean(
             Class<B> beanType, LifecycleOptions lifecycleOptions, BeanInstanceProducer fallbackProducer) {
 
-        SpringContainedBean<?> bean;
+        SpringContainedBean<?> bean
         if (lifecycleOptions.canUseCachedReferences()) {
-            bean = this.beanCache.get(beanType);
+            bean = this.beanCache.get(beanType)
             if (bean == null) {
-                bean = createBean(beanType, lifecycleOptions, fallbackProducer);
-                this.beanCache.put(beanType, bean);
+                bean = createBean(beanType, lifecycleOptions, fallbackProducer)
+                this.beanCache.put(beanType, bean)
             }
+        } else {
+            bean = createBean(beanType, lifecycleOptions, fallbackProducer)
         }
-        else {
-            bean = createBean(beanType, lifecycleOptions, fallbackProducer);
-        }
-        return (SpringContainedBean<B>) bean;
+        return (SpringContainedBean<B>) bean
     }
 
     @Override
-    @SuppressWarnings("unchecked")
-    public <B> ContainedBean<B> getBean(
+    @SuppressWarnings('unchecked')
+    def <B> ContainedBean<B> getBean(
             String name, Class<B> beanType, LifecycleOptions lifecycleOptions, BeanInstanceProducer fallbackProducer) {
 
-        SpringContainedBean<?> bean;
+        SpringContainedBean<?> bean
         if (lifecycleOptions.canUseCachedReferences()) {
-            bean = this.beanCache.get(name);
+            bean = this.beanCache.get(name)
             if (bean == null) {
-                bean = createBean(name, beanType, lifecycleOptions, fallbackProducer);
-                this.beanCache.put(name, bean);
+                bean = createBean(name, beanType, lifecycleOptions, fallbackProducer)
+                this.beanCache.put(name, bean)
             }
+        } else {
+            bean = createBean(name, beanType, lifecycleOptions, fallbackProducer)
         }
-        else {
-            bean = createBean(name, beanType, lifecycleOptions, fallbackProducer);
-        }
-        return (SpringContainedBean<B>) bean;
+        return (SpringContainedBean<B>) bean
     }
 
     @Override
-    public void stop() {
-        this.beanCache.values().forEach(SpringContainedBean::destroyIfNecessary);
-        this.beanCache.clear();
+    void stop() {
+        this.beanCache.values().forEach { SpringContainedBean<?> bean -> bean.destroyIfNecessary() }
+        this.beanCache.clear()
     }
 
     private SpringContainedBean<?> createBean(
@@ -141,33 +138,29 @@ public final class SpringBeanContainer implements BeanContainer {
 
         try {
             if (lifecycleOptions.useJpaCompliantCreation()) {
-                return new SpringContainedBean<>(
+                return new SpringContainedBean<Object>(
                         this.beanFactory.createBean(beanType),
-                        this.beanFactory::destroyBean);
+                        { Object beanInstance -> this.beanFactory.destroyBean(beanInstance) })
+            } else {
+                return new SpringContainedBean<Object>(this.beanFactory.getBean(beanType))
             }
-            else {
-                return new SpringContainedBean<>(this.beanFactory.getBean(beanType));
-            }
-        }
-        catch (BeansException ex) {
-            if (logger.isDebugEnabled()) {
-                logger.debug("Falling back to Hibernate's default producer after bean creation failure for " +
-                        beanType + ": " + ex);
+        } catch (BeansException ex) {
+            if (LOGGER.isDebugEnabled()) {
+                LOGGER.debug('Falling back to Hibernate\'s default producer after bean creation failure for ' +
+                        beanType + ': ' + ex)
             }
             try {
-                return new SpringContainedBean<>(fallbackProducer.produceBeanInstance(beanType));
-            }
-            catch (RuntimeException ex2) {
+                return new SpringContainedBean<Object>(fallbackProducer.produceBeanInstance(beanType))
+            } catch (RuntimeException ex2) {
                 if (ex instanceof BeanCreationException) {
-                    if (logger.isDebugEnabled()) {
-                        logger.debug("Fallback producer failed for " + beanType + ": " + ex2);
+                    if (LOGGER.isDebugEnabled()) {
+                        LOGGER.debug('Fallback producer failed for ' + beanType + ': ' + ex2)
                     }
                     // Rethrow original Spring exception from first attempt.
-                    throw ex;
-                }
-                else {
+                    throw ex
+                } else {
                     // Throw fallback producer exception since original was probably NoSuchBeanDefinitionException.
-                    throw ex2;
+                    throw ex2
                 }
             }
         }
@@ -178,58 +171,54 @@ public final class SpringBeanContainer implements BeanContainer {
 
         try {
             if (lifecycleOptions.useJpaCompliantCreation()) {
-                Object bean = null;
+                Object bean = null
                 if (fallbackProducer instanceof TypeBootstrapContext) {
                     // Special Hibernate type construction rules, including TypeBootstrapContext resolution.
-                    bean = fallbackProducer.produceBeanInstance(name, beanType);
+                    bean = fallbackProducer.produceBeanInstance(name, beanType)
                 }
                 if (this.beanFactory.containsBean(name)) {
                     if (bean == null) {
-                        bean = this.beanFactory.autowire(beanType, AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR, false);
+                        bean = this.beanFactory.autowire(beanType, AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR, false)
                     }
-                    this.beanFactory.autowireBeanProperties(bean, AutowireCapableBeanFactory.AUTOWIRE_NO, false);
-                    this.beanFactory.applyBeanPropertyValues(bean, name);
-                    bean = this.beanFactory.initializeBean(bean, name);
-                    return new SpringContainedBean<>(bean, beanInstance -> this.beanFactory.destroyBean(name, beanInstance));
-                }
-                else if (bean != null) {
+                    this.beanFactory.autowireBeanProperties(bean, AutowireCapableBeanFactory.AUTOWIRE_NO, false)
+                    this.beanFactory.applyBeanPropertyValues(bean, name)
+                    bean = this.beanFactory.initializeBean(bean, name)
+                    return new SpringContainedBean<Object>(bean,
+                            { Object beanInstance -> this.beanFactory.destroyBean(name, beanInstance) })
+                } else if (bean != null) {
                     // No bean found by name but constructed with TypeBootstrapContext rules
-                    this.beanFactory.autowireBeanProperties(bean, AutowireCapableBeanFactory.AUTOWIRE_NO, false);
-                    bean = this.beanFactory.initializeBean(bean, name);
-                    return new SpringContainedBean<>(bean, this.beanFactory::destroyBean);
-                }
-                else {
+                    this.beanFactory.autowireBeanProperties(bean, AutowireCapableBeanFactory.AUTOWIRE_NO, false)
+                    bean = this.beanFactory.initializeBean(bean, name)
+                    return new SpringContainedBean<Object>(bean,
+                            { Object beanInstance -> this.beanFactory.destroyBean(beanInstance) })
+                } else {
                     // No bean found by name -> construct by type using createBean
-                    return new SpringContainedBean<>(
+                    return new SpringContainedBean<Object>(
                             this.beanFactory.createBean(beanType),
-                            this.beanFactory::destroyBean);
+                            { Object beanInstance -> this.beanFactory.destroyBean(beanInstance) })
                 }
-            }
-            else {
+            } else {
                 return (this.beanFactory.containsBean(name) ?
-                        new SpringContainedBean<>(this.beanFactory.getBean(name, beanType)) :
-                        new SpringContainedBean<>(this.beanFactory.getBean(beanType)));
+                        new SpringContainedBean<Object>(this.beanFactory.getBean(name, beanType)) :
+                        new SpringContainedBean<Object>(this.beanFactory.getBean(beanType)))
             }
-        }
-        catch (BeansException ex) {
-            if (logger.isDebugEnabled()) {
-                logger.debug("Falling back to Hibernate's default producer after bean creation failure for " +
-                        beanType + " with name '" + name + "': " + ex);
+        } catch (BeansException ex) {
+            if (LOGGER.isDebugEnabled()) {
+                LOGGER.debug('Falling back to Hibernate\'s default producer after bean creation failure for ' +
+                        beanType + ' with name \'' + name + '\': ' + ex)
             }
             try {
-                return new SpringContainedBean<>(fallbackProducer.produceBeanInstance(name, beanType));
-            }
-            catch (RuntimeException ex2) {
+                return new SpringContainedBean<Object>(fallbackProducer.produceBeanInstance(name, beanType))
+            } catch (RuntimeException ex2) {
                 if (ex instanceof BeanCreationException) {
-                    if (logger.isDebugEnabled()) {
-                        logger.debug("Fallback producer failed for " + beanType + " with name '" + name + "': " + ex2);
+                    if (LOGGER.isDebugEnabled()) {
+                        LOGGER.debug('Fallback producer failed for ' + beanType + ' with name \'' + name + '\': ' + ex2)
                     }
                     // Rethrow original Spring exception from first attempt.
-                    throw ex;
-                }
-                else {
+                    throw ex
+                } else {
                     // Throw fallback producer exception since original was probably NoSuchBeanDefinitionException.
-                    throw ex2;
+                    throw ex2
                 }
             }
         }
@@ -237,36 +226,36 @@ public final class SpringBeanContainer implements BeanContainer {
 
     private static final class SpringContainedBean<B> implements ContainedBean<B> {
 
-        private final B beanInstance;
+        private final B beanInstance
 
-        @Nullable
-        private Consumer<B> destructionCallback;
+        private Consumer<B> destructionCallback
 
-        public SpringContainedBean(B beanInstance) {
-            this.beanInstance = beanInstance;
+        SpringContainedBean(B beanInstance) {
+            this.beanInstance = beanInstance
         }
 
-        public SpringContainedBean(B beanInstance, Consumer<B> destructionCallback) {
-            this.beanInstance = beanInstance;
-            this.destructionCallback = destructionCallback;
+        SpringContainedBean(B beanInstance, Consumer<B> destructionCallback) {
+            this.beanInstance = beanInstance
+            this.destructionCallback = destructionCallback
         }
 
         @Override
-        public B getBeanInstance() {
-            return this.beanInstance;
+        B getBeanInstance() {
+            return this.beanInstance
         }
 
         @Override
-        @SuppressWarnings("unchecked")
-        public Class<B> getBeanClass() {
-            return this.beanInstance != null ? (Class<B>) this.beanInstance.getClass() : null;
+        @SuppressWarnings('unchecked')
+        Class<B> getBeanClass() {
+            return this.beanInstance != null ? (Class<B>) this.beanInstance.getClass() : null
         }
 
-        public void destroyIfNecessary() {
+        void destroyIfNecessary() {
             if (this.destructionCallback != null) {
-                this.destructionCallback.accept(this.beanInstance);
+                this.destructionCallback.accept(this.beanInstance)
             }
         }
+
     }
 
 }
diff --git a/grails-data-hibernate7/spring-orm/src/main/groovy/org/grails/orm/hibernate/support/hibernate7/support/OpenSessionInViewInterceptor.java b/grails-data-hibernate7/spring-orm/src/main/groovy/org/grails/orm/hibernate/support/hibernate7/support/OpenSessionInViewInterceptor.groovy
similarity index 70%
rename from grails-data-hibernate7/spring-orm/src/main/groovy/org/grails/orm/hibernate/support/hibernate7/support/OpenSessionInViewInterceptor.java
rename to grails-data-hibernate7/spring-orm/src/main/groovy/org/grails/orm/hibernate/support/hibernate7/support/OpenSessionInViewInterceptor.groovy
index 4dd7c0c479..5c01cda6d0 100644
--- a/grails-data-hibernate7/spring-orm/src/main/groovy/org/grails/orm/hibernate/support/hibernate7/support/OpenSessionInViewInterceptor.java
+++ b/grails-data-hibernate7/spring-orm/src/main/groovy/org/grails/orm/hibernate/support/hibernate7/support/OpenSessionInViewInterceptor.groovy
@@ -13,30 +13,28 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
-package org.grails.orm.hibernate.support.hibernate7.support;
-
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
-import org.hibernate.FlushMode;
-import org.hibernate.HibernateException;
-import org.hibernate.Session;
-import org.hibernate.SessionFactory;
-import org.jspecify.annotations.Nullable;
-
-import org.springframework.dao.DataAccessException;
-import org.springframework.dao.DataAccessResourceFailureException;
-import org.springframework.transaction.support.TransactionSynchronizationManager;
-import org.springframework.ui.ModelMap;
-import org.springframework.util.Assert;
-import org.springframework.web.context.request.AsyncWebRequestInterceptor;
-import org.springframework.web.context.request.WebRequest;
-import org.springframework.web.context.request.async.CallableProcessingInterceptor;
-import org.springframework.web.context.request.async.WebAsyncManager;
-import org.springframework.web.context.request.async.WebAsyncUtils;
-
-import org.grails.orm.hibernate.support.hibernate7.SessionFactoryUtils;
-import org.grails.orm.hibernate.support.hibernate7.SessionHolder;
+package org.grails.orm.hibernate.support.hibernate7.support
+
+import groovy.transform.CompileStatic
+import org.apache.commons.logging.Log
+import org.apache.commons.logging.LogFactory
+import org.hibernate.FlushMode
+import org.hibernate.HibernateException
+import org.hibernate.Session
+import org.hibernate.SessionFactory
+import org.springframework.dao.DataAccessException
+import org.springframework.dao.DataAccessResourceFailureException
+import org.springframework.transaction.support.TransactionSynchronizationManager
+import org.springframework.ui.ModelMap
+import org.springframework.util.Assert
+import org.springframework.web.context.request.AsyncWebRequestInterceptor
+import org.springframework.web.context.request.WebRequest
+import org.springframework.web.context.request.async.CallableProcessingInterceptor
+import org.springframework.web.context.request.async.WebAsyncManager
+import org.springframework.web.context.request.async.WebAsyncUtils
+
+import org.grails.orm.hibernate.support.hibernate7.SessionFactoryUtils
+import org.grails.orm.hibernate.support.hibernate7.SessionHolder
 
 /**
  * Spring web request interceptor that binds a Hibernate {@code Session} to the
@@ -69,7 +67,8 @@ import org.grails.orm.hibernate.support.hibernate7.SessionHolder;
  * @see TransactionSynchronizationManager
  * @see SessionFactory#getCurrentSession()
  */
-public class OpenSessionInViewInterceptor implements AsyncWebRequestInterceptor {
+@CompileStatic
+class OpenSessionInViewInterceptor implements AsyncWebRequestInterceptor {
 
     /**
      * Suffix that gets appended to the {@code SessionFactory}
@@ -77,32 +76,30 @@ public class OpenSessionInViewInterceptor implements AsyncWebRequestInterceptor
      * session handling" request attribute.
      * @see #getParticipateAttributeName
      */
-    public static final String PARTICIPATE_SUFFIX = ".PARTICIPATE";
+    static final String PARTICIPATE_SUFFIX = '.PARTICIPATE'
 
-    protected final Log logger = LogFactory.getLog(getClass());
+    protected final Log logger = LogFactory.getLog(getClass())
 
-    @Nullable
-    private SessionFactory sessionFactory;
+    private SessionFactory sessionFactory
 
     /**
      * Set the Hibernate SessionFactory that should be used to create Hibernate Sessions.
      */
-    public void setSessionFactory(@Nullable SessionFactory sessionFactory) {
-        this.sessionFactory = sessionFactory;
+    void setSessionFactory(SessionFactory sessionFactory) {
+        this.sessionFactory = sessionFactory
     }
 
     /**
      * Return the Hibernate SessionFactory that should be used to create Hibernate Sessions.
      */
-    @Nullable
-    public SessionFactory getSessionFactory() {
-        return this.sessionFactory;
+    SessionFactory getSessionFactory() {
+        return this.sessionFactory
     }
 
     private SessionFactory obtainSessionFactory() {
-        SessionFactory sf = getSessionFactory();
-        Assert.state(sf != null, "No SessionFactory set");
-        return sf;
+        SessionFactory sf = getSessionFactory()
+        Assert.state(sf != null, 'No SessionFactory set')
+        return sf
     }
 
     /**
@@ -110,34 +107,34 @@ public class OpenSessionInViewInterceptor implements AsyncWebRequestInterceptor
      * {@link TransactionSynchronizationManager}.
      */
     @Override
-    public void preHandle(WebRequest request) throws DataAccessException {
-        String key = getParticipateAttributeName();
-        WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
+    void preHandle(WebRequest request) throws DataAccessException {
+        String key = getParticipateAttributeName()
+        WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request)
         if (asyncManager.hasConcurrentResult() && applySessionBindingInterceptor(asyncManager, key)) {
-            return;
+            return
         }
 
         if (TransactionSynchronizationManager.hasResource(obtainSessionFactory())) {
             // Do not modify the Session: just mark the request accordingly.
-            Integer count = (Integer) request.getAttribute(key, WebRequest.SCOPE_REQUEST);
-            int newCount = (count != null ? count + 1 : 1);
-            request.setAttribute(getParticipateAttributeName(), newCount, WebRequest.SCOPE_REQUEST);
-        }
-        else {
-            logger.debug("Opening Hibernate Session in OpenSessionInViewInterceptor");
-            Session session = openSession();
-            SessionHolder sessionHolder = new SessionHolder(session);
-            TransactionSynchronizationManager.bindResource(obtainSessionFactory(), sessionHolder);
+            Integer count = (Integer) request.getAttribute(key, WebRequest.SCOPE_REQUEST)
+            int newCount = (count != null ? count + 1 : 1)
+            request.setAttribute(getParticipateAttributeName(), newCount, WebRequest.SCOPE_REQUEST)
+        } else {
+            logger.debug('Opening Hibernate Session in OpenSessionInViewInterceptor')
+            Session session = openSession()
+            SessionHolder sessionHolder = new SessionHolder(session)
+            TransactionSynchronizationManager.bindResource(obtainSessionFactory(), sessionHolder)
 
             AsyncRequestInterceptor asyncRequestInterceptor =
-                    new AsyncRequestInterceptor(obtainSessionFactory(), sessionHolder);
-            asyncManager.registerCallableInterceptor(key, asyncRequestInterceptor);
-            asyncManager.registerDeferredResultInterceptor(key, asyncRequestInterceptor);
+                    new AsyncRequestInterceptor(obtainSessionFactory(), sessionHolder)
+            asyncManager.registerCallableInterceptor(key, asyncRequestInterceptor)
+            asyncManager.registerDeferredResultInterceptor(key, asyncRequestInterceptor)
         }
     }
 
     @Override
-    public void postHandle(WebRequest request, @Nullable ModelMap model) {
+    void postHandle(WebRequest request, ModelMap model) {
+        // no-op
     }
 
     /**
@@ -145,35 +142,34 @@ public class OpenSessionInViewInterceptor implements AsyncWebRequestInterceptor
      * @see TransactionSynchronizationManager
      */
     @Override
-    public void afterCompletion(WebRequest request, @Nullable Exception ex) throws DataAccessException {
+    void afterCompletion(WebRequest request, Exception ex) throws DataAccessException {
         if (!decrementParticipateCount(request)) {
             SessionHolder sessionHolder =
-                    (SessionHolder) TransactionSynchronizationManager.unbindResource(obtainSessionFactory());
-            logger.debug("Closing Hibernate Session in OpenSessionInViewInterceptor");
-            SessionFactoryUtils.closeSession(sessionHolder.getSession());
+                    (SessionHolder) TransactionSynchronizationManager.unbindResource(obtainSessionFactory())
+            logger.debug('Closing Hibernate Session in OpenSessionInViewInterceptor')
+            SessionFactoryUtils.closeSession(sessionHolder.getSession())
         }
     }
 
     private boolean decrementParticipateCount(WebRequest request) {
-        String participateAttributeName = getParticipateAttributeName();
-        Integer count = (Integer) request.getAttribute(participateAttributeName, WebRequest.SCOPE_REQUEST);
+        String participateAttributeName = getParticipateAttributeName()
+        Integer count = (Integer) request.getAttribute(participateAttributeName, WebRequest.SCOPE_REQUEST)
         if (count == null) {
-            return false;
+            return false
         }
         // Do not modify the Session: just clear the marker.
         if (count > 1) {
-            request.setAttribute(participateAttributeName, count - 1, WebRequest.SCOPE_REQUEST);
+            request.setAttribute(participateAttributeName, count - 1, WebRequest.SCOPE_REQUEST)
+        } else {
+            request.removeAttribute(participateAttributeName, WebRequest.SCOPE_REQUEST)
         }
-        else {
-            request.removeAttribute(participateAttributeName, WebRequest.SCOPE_REQUEST);
-        }
-        return true;
+        return true
     }
 
     @Override
-    public void afterConcurrentHandlingStarted(WebRequest request) {
+    void afterConcurrentHandlingStarted(WebRequest request) {
         if (!decrementParticipateCount(request)) {
-            TransactionSynchronizationManager.unbindResource(obtainSessionFactory());
+            TransactionSynchronizationManager.unbindResource(obtainSessionFactory())
         }
     }
 
@@ -187,12 +183,11 @@ public class OpenSessionInViewInterceptor implements AsyncWebRequestInterceptor
      */
     protected Session openSession() throws DataAccessResourceFailureException {
         try {
-            Session session = obtainSessionFactory().openSession();
-            session.setHibernateFlushMode(FlushMode.MANUAL);
-            return session;
-        }
-        catch (HibernateException ex) {
-            throw new DataAccessResourceFailureException("Could not open Hibernate Session", ex);
+            Session session = obtainSessionFactory().openSession()
+            session.setHibernateFlushMode(FlushMode.MANUAL)
+            return session
+        } catch (HibernateException ex) {
+            throw new DataAccessResourceFailureException('Could not open Hibernate Session', ex)
         }
     }
 
@@ -203,16 +198,16 @@ public class OpenSessionInViewInterceptor implements AsyncWebRequestInterceptor
      * of the {@code SessionFactory} instance and appends {@link #PARTICIPATE_SUFFIX}.
      */
     protected String getParticipateAttributeName() {
-        return obtainSessionFactory().toString() + PARTICIPATE_SUFFIX;
+        return obtainSessionFactory().toString() + PARTICIPATE_SUFFIX
     }
 
     private boolean applySessionBindingInterceptor(WebAsyncManager asyncManager, String key) {
-        CallableProcessingInterceptor cpi = asyncManager.getCallableInterceptor(key);
+        CallableProcessingInterceptor cpi = asyncManager.getCallableInterceptor(key)
         if (cpi == null) {
-            return false;
+            return false
         }
-        ((AsyncRequestInterceptor) cpi).bindSession();
-        return true;
+        ((AsyncRequestInterceptor) cpi).bindSession()
+        return true
     }
 
 }