This is an automated email from the ASF dual-hosted git repository. borinquenkid pushed a commit to branch 8.0.x-hibernate7-dev in repository https://gitbox.apache.org/repos/asf/grails-core.git
commit 470051ded3dcc85d21f5cd98b129c92366c7cf4f Author: Walter Duque de Estrada <[email protected]> AuthorDate: Tue Mar 3 18:53:54 2026 -0600 refactor(hibernate7): merge AbstractHibernateDatastore into HibernateDatastore --- .../grails/orm/HibernateCriteriaBuilder.java | 10 +- .../orm/hibernate/AbstractHibernateDatastore.java | 512 --------------------- .../AbstractHibernateGormValidationApi.groovy | 4 +- .../orm/hibernate/AbstractHibernateSession.java | 4 +- .../grails/orm/hibernate/HibernateDatastore.java | 448 +++++++++++++++++- .../orm/hibernate/HibernateGormStaticApi.groovy | 6 +- .../listener/AbstractHibernateEventListener.java | 8 +- .../event/listener/HibernateEventListener.java | 6 +- .../multitenancy/MultiTenantEventListener.java | 8 +- .../support/ClosureEventTriggeringInterceptor.java | 6 +- .../hibernate/support/DataSourceFactoryBean.groovy | 6 +- .../support/HibernateDatastoreFactoryBean.groovy | 6 +- .../HibernateDatastoreIntegrationSpec.groovy | 32 +- .../listener/HibernateEventListenerSpec.groovy | 2 +- .../MultiTenantEventListenerSpec.groovy | 26 +- ...urceAggregatePersistenceContextInterceptor.java | 6 +- .../AggregatePersistenceContextInterceptor.java | 6 +- .../GrailsOpenSessionInViewInterceptor.java | 4 +- .../HibernatePersistenceContextInterceptor.java | 6 +- 19 files changed, 503 insertions(+), 603 deletions(-) diff --git a/grails-data-hibernate7/core/src/main/groovy/grails/orm/HibernateCriteriaBuilder.java b/grails-data-hibernate7/core/src/main/groovy/grails/orm/HibernateCriteriaBuilder.java index ce45e5d4b9..c2ed1d8d83 100644 --- a/grails-data-hibernate7/core/src/main/groovy/grails/orm/HibernateCriteriaBuilder.java +++ b/grails-data-hibernate7/core/src/main/groovy/grails/orm/HibernateCriteriaBuilder.java @@ -41,7 +41,7 @@ import org.grails.datastore.mapping.query.api.BuildableCriteria; import org.grails.datastore.mapping.query.api.Criteria; import org.grails.datastore.mapping.query.api.ProjectionList; import org.grails.datastore.mapping.query.api.QueryableCriteria; -import org.grails.orm.hibernate.AbstractHibernateDatastore; +import org.grails.orm.hibernate.HibernateDatastore; import org.grails.orm.hibernate.AbstractHibernateSession; import org.grails.orm.hibernate.GrailsHibernateTemplate; import org.grails.orm.hibernate.query.HibernateQuery; @@ -79,7 +79,7 @@ import org.springframework.core.convert.ConversionService; * <h2>Programmatic instantiation</h2> * * <p>The builder requires a {@link SessionFactory}, the target persistent class, and the {@link - * org.grails.orm.hibernate.AbstractHibernateDatastore} that owns the session: + * org.grails.orm.hibernate.HibernateDatastore} that owns the session: * * <pre> * new HibernateCriteriaBuilder(Account, sessionFactory, datastore).list { @@ -127,7 +127,7 @@ public class HibernateCriteriaBuilder extends GroovyObjectSupport protected boolean paginationEnabledList = false; protected ConversionService conversionService; protected int defaultFlushMode; - protected AbstractHibernateDatastore datastore; + protected HibernateDatastore datastore; protected org.hibernate.query.criteria.HibernateCriteriaBuilder cb; protected Root root; protected HibernateQuery hibernateQuery; @@ -142,7 +142,7 @@ public class HibernateCriteriaBuilder extends GroovyObjectSupport @SuppressWarnings("rawtypes") public HibernateCriteriaBuilder( - Class targetClass, SessionFactory sessionFactory, AbstractHibernateDatastore datastore) { + Class targetClass, SessionFactory sessionFactory, HibernateDatastore datastore) { this.targetClass = targetClass; setDatastore(datastore); this.sessionFactory = sessionFactory; @@ -154,7 +154,7 @@ public class HibernateCriteriaBuilder extends GroovyObjectSupport setDefaultFlushMode(GrailsHibernateTemplate.FLUSH_AUTO); } - public final void setDatastore(AbstractHibernateDatastore datastore) { + public final void setDatastore(HibernateDatastore datastore) { this.datastore = datastore; if (MultiTenant.class.isAssignableFrom(targetClass) && datastore.getMultiTenancyMode() == MultiTenancySettings.MultiTenancyMode.DISCRIMINATOR) { diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/AbstractHibernateDatastore.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/AbstractHibernateDatastore.java deleted file mode 100644 index 3695900780..0000000000 --- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/AbstractHibernateDatastore.java +++ /dev/null @@ -1,512 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * https://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, - * software distributed under the License is distributed on an - * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY - * KIND, either express or implied. See the License for the - * specific language governing permissions and limitations - * under the License. - */ -package org.grails.orm.hibernate; - -import grails.gorm.multitenancy.Tenants; -import groovy.lang.Closure; -import jakarta.annotation.PreDestroy; -import java.io.Closeable; -import java.io.IOException; -import java.io.Serializable; -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; -import java.util.concurrent.Callable; -import javax.sql.DataSource; -import org.grails.datastore.gorm.events.AutoTimestampEventListener; -import org.grails.datastore.gorm.jdbc.schema.DefaultSchemaHandler; -import org.grails.datastore.gorm.jdbc.schema.SchemaHandler; -import org.grails.datastore.gorm.validation.registry.support.ValidatorRegistries; -import org.grails.datastore.mapping.config.Settings; -import org.grails.datastore.mapping.core.AbstractDatastore; -import org.grails.datastore.mapping.core.Datastore; -import org.grails.datastore.mapping.core.DatastoreAware; -import org.grails.datastore.mapping.core.connections.*; -import org.grails.datastore.mapping.model.MappingContext; -import org.grails.datastore.mapping.model.config.GormProperties; -import org.grails.datastore.mapping.multitenancy.*; -import org.grails.datastore.mapping.multitenancy.exceptions.TenantNotFoundException; -import org.grails.datastore.mapping.multitenancy.resolvers.FixedTenantResolver; -import org.grails.datastore.mapping.transactions.TransactionCapableDatastore; -import org.grails.datastore.mapping.validation.ValidatorRegistry; -import org.grails.orm.hibernate.cfg.HibernateMappingContext; -import org.grails.orm.hibernate.connections.HibernateConnectionSource; -import org.grails.orm.hibernate.connections.HibernateConnectionSourceSettings; -import org.grails.orm.hibernate.event.listener.AbstractHibernateEventListener; -import org.hibernate.Session; -import org.hibernate.SessionFactory; -import org.springframework.beans.BeanUtils; -import org.springframework.context.*; -import org.springframework.core.env.PropertyResolver; - -/** - * Datastore implementation that uses a Hibernate SessionFactory underneath. - * - * @author Graeme Rocher - * @since 2.0 - */ -@SuppressWarnings({"PMD.CloseResource", "PMD.AvoidFieldNameMatchingMethodName"}) -public abstract class AbstractHibernateDatastore extends AbstractDatastore - implements ApplicationContextAware, - Settings, - SchemaMultiTenantCapableDatastore<SessionFactory, HibernateConnectionSourceSettings>, - TransactionCapableDatastore, - Closeable, - MessageSourceAware, - MultipleConnectionSourceCapableDatastore { - - /** The config property cache queries. */ - public static final String CONFIG_PROPERTY_CACHE_QUERIES = "grails.hibernate.cache.queries"; - - /** The config property osiv readonly. */ - public static final String CONFIG_PROPERTY_OSIV_READONLY = "grails.hibernate.osiv.readonly"; - - /** The config property pass readonly to hibernate. */ - public static final String CONFIG_PROPERTY_PASS_READONLY_TO_HIBERNATE = - "grails.hibernate.pass.readonly"; - - /** The session factory. */ - protected final SessionFactory sessionFactory; - - /** The connection sources. */ - protected final ConnectionSources<SessionFactory, HibernateConnectionSourceSettings> - connectionSources; - - /** The default flush mode name. */ - protected final String defaultFlushModeName; - - /** The multi tenant mode. */ - protected final MultiTenancySettings.MultiTenancyMode multiTenantMode; - - /** The schema handler. */ - protected final SchemaHandler schemaHandler; - - /** The event triggering interceptor. */ - protected AbstractHibernateEventListener eventTriggeringInterceptor; - - /** The auto timestamp event listener. */ - protected AutoTimestampEventListener autoTimestampEventListener; - - /** The osiv read only. */ - protected final boolean osivReadOnly; - - /** The pass read only to hibernate. */ - protected final boolean passReadOnlyToHibernate; - - /** The is cache queries. */ - protected final boolean isCacheQueries; - - /** The default flush mode. */ - protected final int defaultFlushMode; - - /** The fail on error. */ - protected final boolean failOnError; - - /** The mark dirty. */ - protected final boolean markDirty; - - /** The data source name. */ - protected final String dataSourceName; - - /** The tenant resolver. */ - protected final TenantResolver tenantResolver; - - private boolean destroyed; - - /** Creates a new {@link AbstractHibernateDatastore} instance. */ - protected AbstractHibernateDatastore( - ConnectionSources<SessionFactory, HibernateConnectionSourceSettings> connectionSources, - HibernateMappingContext mappingContext) { - super(mappingContext, connectionSources.getBaseConfiguration(), null); - this.connectionSources = connectionSources; - final HibernateConnectionSource defaultConnectionSource = - (HibernateConnectionSource) connectionSources.getDefaultConnectionSource(); - this.dataSourceName = defaultConnectionSource.getName(); - this.sessionFactory = defaultConnectionSource.getSource(); - HibernateConnectionSourceSettings settings = defaultConnectionSource.getSettings(); - HibernateConnectionSourceSettings.HibernateSettings hibernateSettings = settings.getHibernate(); - this.osivReadOnly = hibernateSettings.getOsiv().isReadonly(); - this.passReadOnlyToHibernate = hibernateSettings.isReadOnly(); - this.isCacheQueries = hibernateSettings.getCache().isQueries(); - this.failOnError = settings.isFailOnError(); - Boolean markDirty = settings.getMarkDirty(); - this.markDirty = markDirty == null ? false : markDirty; - FlushMode flushMode = FlushMode.valueOf(hibernateSettings.getFlush().getMode().name()); - this.defaultFlushModeName = flushMode.name(); - this.defaultFlushMode = flushMode.getLevel(); - - MultiTenancySettings multiTenancySettings = settings.getMultiTenancy(); - final TenantResolver multiTenantResolver = multiTenancySettings.getTenantResolver(); - - this.multiTenantMode = multiTenancySettings.getMode(); - Class<? extends SchemaHandler> schemaHandlerClass = settings.getDataSource().getSchemaHandler(); - this.schemaHandler = BeanUtils.instantiateClass(schemaHandlerClass); - this.tenantResolver = multiTenantResolver; - if (multiTenantResolver instanceof DatastoreAware) { - ((DatastoreAware) multiTenantResolver).setDatastore(this); - } - } - - /** Creates a new {@link AbstractHibernateDatastore} instance. */ - protected AbstractHibernateDatastore( - MappingContext mappingContext, - SessionFactory sessionFactory, - PropertyResolver config, - ApplicationContext applicationContext, - String dataSourceName) { - super(mappingContext, config, (ConfigurableApplicationContext) applicationContext); - this.connectionSources = - new SingletonConnectionSources<>( - new HibernateConnectionSource(dataSourceName, sessionFactory, null, null), config); - this.sessionFactory = sessionFactory; - this.dataSourceName = dataSourceName; - initializeConverters(mappingContext); - if (applicationContext != null) { - setApplicationContext(applicationContext); - } - - osivReadOnly = config.getProperty(CONFIG_PROPERTY_OSIV_READONLY, Boolean.class, false); - passReadOnlyToHibernate = - config.getProperty(CONFIG_PROPERTY_PASS_READONLY_TO_HIBERNATE, Boolean.class, false); - isCacheQueries = config.getProperty(CONFIG_PROPERTY_CACHE_QUERIES, Boolean.class, false); - - if (config.getProperty(SETTING_AUTO_FLUSH, Boolean.class, false)) { - this.defaultFlushModeName = FlushMode.AUTO.name(); - defaultFlushMode = FlushMode.AUTO.level; - } else { - FlushMode flushMode = - config.getProperty(SETTING_FLUSH_MODE, FlushMode.class, FlushMode.COMMIT); - this.defaultFlushModeName = flushMode.name(); - defaultFlushMode = flushMode.level; - } - failOnError = config.getProperty(SETTING_FAIL_ON_ERROR, Boolean.class, false); - markDirty = config.getProperty(SETTING_MARK_DIRTY, Boolean.class, false); - this.tenantResolver = new FixedTenantResolver(); - this.multiTenantMode = MultiTenancySettings.MultiTenancyMode.NONE; - this.schemaHandler = new DefaultSchemaHandler(); - } - - /** Creates a new {@link AbstractHibernateDatastore} instance. */ - public AbstractHibernateDatastore( - MappingContext mappingContext, SessionFactory sessionFactory, PropertyResolver config) { - this(mappingContext, sessionFactory, config, null, ConnectionSource.DEFAULT); - } - - @Override - public void setMessageSource(MessageSource messageSource) { - ValidatorRegistry validatorRegistry = createValidatorRegistry(messageSource); - this.mappingContext.setValidatorRegistry(validatorRegistry); - } - - /** Create validator registry. */ - protected ValidatorRegistry createValidatorRegistry(MessageSource messageSource) { - return ValidatorRegistries.createValidatorRegistry( - mappingContext, - getConnectionSources().getDefaultConnectionSource().getSettings(), - messageSource); - } - - @Override - public MultiTenancySettings.MultiTenancyMode getMultiTenancyMode() { - return this.multiTenantMode == MultiTenancySettings.MultiTenancyMode.SCHEMA - ? MultiTenancySettings.MultiTenancyMode.DATABASE - : this.multiTenantMode; - } - - @Override - public Datastore getDatastoreForTenantId(Serializable tenantId) { - if (getMultiTenancyMode() == MultiTenancySettings.MultiTenancyMode.DATABASE) { - return getDatastoreForConnection(tenantId.toString()); - } else { - return this; - } - } - - @Override - public TenantResolver getTenantResolver() { - return this.tenantResolver; - } - - @Override - public ConnectionSources<SessionFactory, HibernateConnectionSourceSettings> - getConnectionSources() { - return this.connectionSources; - } - - /** - * Obtain a child datastore for the given connection name - * - * @param connectionName The name of the connection - * @return The child data store - */ - public abstract AbstractHibernateDatastore getDatastoreForConnection(String connectionName); - - /** Resolve tenant ids. */ - public Iterable<Serializable> resolveTenantIds() { - if (this.tenantResolver instanceof AllTenantsResolver) { - return ((AllTenantsResolver) tenantResolver).resolveTenantIds(); - } else if (this.multiTenantMode == MultiTenancySettings.MultiTenancyMode.DATABASE) { - List<Serializable> tenantIds = new ArrayList<>(); - for (ConnectionSource connectionSource : this.connectionSources.getAllConnectionSources()) { - if (!ConnectionSource.DEFAULT.equals(connectionSource.getName())) { - tenantIds.add(connectionSource.getName()); - } - } - return tenantIds; - } else { - return Collections.emptyList(); - } - } - - /** Resolve tenant identifier. */ - public Serializable resolveTenantIdentifier() throws TenantNotFoundException { - return Tenants.currentId(this); - } - - /** Returns whether auto flush. */ - public boolean isAutoFlush() { - return defaultFlushMode == FlushMode.AUTO.level; - } - - /** - * @return Obtains the default flush mode level - */ - public int getDefaultFlushMode() { - return defaultFlushMode; - } - - /** - * @return The name of the default value flush - */ - public String getDefaultFlushModeName() { - return defaultFlushModeName; - } - - /** Returns whether fail on error. */ - public boolean isFailOnError() { - return failOnError; - } - - /** Returns whether osiv read only. */ - public boolean isOsivReadOnly() { - return osivReadOnly; - } - - /** Returns whether pass read only to hibernate. */ - public boolean isPassReadOnlyToHibernate() { - return passReadOnlyToHibernate; - } - - /** Returns whether cache queries. */ - public boolean isCacheQueries() { - return isCacheQueries; - } - - /** - * @return The Hibernate {@link SessionFactory} being used by this datastore instance - */ - public SessionFactory getSessionFactory() { - return sessionFactory; - } - - /** - * @return The {@link DataSource} being used by this datastore instance - */ - public DataSource getDataSource() { - return ((HibernateConnectionSource) this.connectionSources.getDefaultConnectionSource()) - .getDataSource(); - } - - /** TODO: Add description. */ - // for testing - public AbstractHibernateEventListener getEventTriggeringInterceptor() { - return eventTriggeringInterceptor; - } - - /** - * @return The event listener that populates lastUpdated and dateCreated - */ - public AutoTimestampEventListener getAutoTimestampEventListener() { - return autoTimestampEventListener; - } - - @Override - public boolean hasCurrentSession() { - // Consider a session present only if a bound session exists and is connected - org.grails.datastore.mapping.transactions.SessionHolder sessionHolder = - (org.grails.datastore.mapping.transactions.SessionHolder) - org.springframework.transaction.support.TransactionSynchronizationManager.getResource( - this); - if (sessionHolder == null) { - return false; - } - return sessionHolder.getValidatedSession() != null; - } - - /** - * @return The data source name being used - */ - public String getDataSourceName() { - return this.dataSourceName; - } - - /** - * Execute the given operation with the given flush mode - * - * @param flushMode the flush mode - * @param callable The callable - */ - public abstract void withFlushMode(FlushMode flushMode, Callable<Boolean> callable); - - /** - * We use a separate enum here because the classes differ between Hibernate 3 and 4 - * - * @see org.hibernate.FlushMode - */ - public enum FlushMode { - /** The manual constant. */ - MANUAL(0), - /** The commit constant. */ - COMMIT(5), - /** The auto constant. */ - AUTO(10), - /** The always constant. */ - ALWAYS(20); - - private final int level; - - FlushMode(int level) { - this.level = level; - } - - /** Gets the level. */ - public int getLevel() { - return level; - } - } - - @Override - public void destroy() { - if (!this.destroyed) { - super.destroy(); - HibernateGormInstanceApi.resetInsertActive(); - try { - connectionSources.close(); - } catch (IOException e) { - LOG.error("There was an error shutting down GORM for an entity: " + e.getMessage(), e); - } - destroyed = true; - } - } - - @Override - @PreDestroy - public void close() { - try { - destroy(); - } catch (Exception e) { - LOG.error("Error closing hibernate datastore: " + e.getMessage(), e); - } - } - - /** - * Obtains a hibernate template for the given flush mode - * - * @param flushMode The flush mode - * @return The IHibernateTemplate - */ - public abstract IHibernateTemplate getHibernateTemplate(int flushMode); - - /** Gets the hibernate template. */ - public IHibernateTemplate getHibernateTemplate() { - return getHibernateTemplate(defaultFlushMode); - } - - /** - * @return Opens a session - */ - public abstract Session openSession(); - - @Override - public <T> T withSession(final Closure<T> callable) { - Closure<T> multiTenantCallable = prepareMultiTenantClosure(callable); - return getHibernateTemplate().execute(multiTenantCallable); - } - - /** With new session. */ - public <T> T withNewSession(final Closure<T> callable) { - Closure<T> multiTenantCallable = prepareMultiTenantClosure(callable); - return getHibernateTemplate().executeWithNewSession(multiTenantCallable); - } - - @Override - public <T1> T1 withNewSession(Serializable tenantId, Closure<T1> callable) { - if (getMultiTenancyMode() == MultiTenancySettings.MultiTenancyMode.DATABASE) { - AbstractHibernateDatastore datastore = getDatastoreForConnection(tenantId.toString()); - SessionFactory sessionFactory = datastore.getSessionFactory(); - - return datastore - .getHibernateTemplate() - .executeWithExistingOrCreateNewSession(sessionFactory, callable); - } else { - return withNewSession(callable); - } - } - - /** Enable the tenant id filter for the given datastore and entity */ - public void enableMultiTenancyFilter() { - Serializable currentId = Tenants.currentId(this); - if (ConnectionSource.DEFAULT.equals(currentId)) { - disableMultiTenancyFilter(); - } else { - getHibernateTemplate() - .getSessionFactory() - .getCurrentSession() - .enableFilter(GormProperties.TENANT_IDENTITY) - .setParameter(GormProperties.TENANT_IDENTITY, currentId); - } - } - - /** Disable the tenant id filter for the given datastore and entity */ - public void disableMultiTenancyFilter() { - getHibernateTemplate() - .getSessionFactory() - .getCurrentSession() - .disableFilter(GormProperties.TENANT_IDENTITY); - } - - /** Prepare multi tenant closure. */ - protected <T> Closure<T> prepareMultiTenantClosure(final Closure<T> callable) { - final boolean isMultiTenant = - getMultiTenancyMode() == MultiTenancySettings.MultiTenancyMode.DISCRIMINATOR; - return isMultiTenant - ? new Closure<T>(this) { - @Override - public T call(Object... args) { - enableMultiTenancyFilter(); - try { - return callable.call(args); - } finally { - disableMultiTenancyFilter(); - } - } - } - : callable; - } -} diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/AbstractHibernateGormValidationApi.groovy b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/AbstractHibernateGormValidationApi.groovy index c20a5a6ccf..4b90b3f9c8 100644 --- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/AbstractHibernateGormValidationApi.groovy +++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/AbstractHibernateGormValidationApi.groovy @@ -36,10 +36,10 @@ abstract class AbstractHibernateGormValidationApi<D> extends GormValidationApi<D protected ClassLoader classLoader - protected AbstractHibernateDatastore datastore + protected HibernateDatastore datastore protected IHibernateTemplate hibernateTemplate - protected AbstractHibernateGormValidationApi(Class<D> persistentClass, AbstractHibernateDatastore datastore, ClassLoader classLoader) { + protected AbstractHibernateGormValidationApi(Class<D> persistentClass, HibernateDatastore datastore, ClassLoader classLoader) { super(persistentClass, datastore) this.classLoader = classLoader this.datastore = datastore diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/AbstractHibernateSession.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/AbstractHibernateSession.java index 5e679d69eb..c95cfe30bd 100644 --- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/AbstractHibernateSession.java +++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/AbstractHibernateSession.java @@ -47,7 +47,7 @@ public abstract class AbstractHibernateSession extends AbstractAttributeStoringS implements QueryAliasAwareSession { /** The datastore. */ - protected AbstractHibernateDatastore datastore; + protected HibernateDatastore datastore; /** The connected. */ protected boolean connected = true; @@ -57,7 +57,7 @@ public abstract class AbstractHibernateSession extends AbstractAttributeStoringS /** Creates a new {@link AbstractHibernateSession} instance. */ protected AbstractHibernateSession( - AbstractHibernateDatastore hibernateDatastore, SessionFactory sessionFactory) { + HibernateDatastore hibernateDatastore, SessionFactory sessionFactory) { datastore = hibernateDatastore; } diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/HibernateDatastore.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/HibernateDatastore.java index cad9f8cf06..605149a7a1 100644 --- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/HibernateDatastore.java +++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/HibernateDatastore.java @@ -19,6 +19,10 @@ package org.grails.orm.hibernate; import grails.gorm.MultiTenant; +import grails.gorm.multitenancy.Tenants; +import groovy.lang.Closure; +import jakarta.annotation.PreDestroy; +import java.io.Closeable; import java.io.IOException; import java.io.Serializable; import java.sql.Connection; @@ -35,12 +39,17 @@ import org.grails.datastore.gorm.jdbc.MultiTenantDataSource; import org.grails.datastore.gorm.jdbc.connections.DataSourceConnectionSource; import org.grails.datastore.gorm.jdbc.connections.DataSourceConnectionSourceFactory; import org.grails.datastore.gorm.jdbc.connections.DataSourceSettings; +import org.grails.datastore.gorm.jdbc.schema.DefaultSchemaHandler; +import org.grails.datastore.gorm.jdbc.schema.SchemaHandler; import org.grails.datastore.gorm.utils.ClasspathEntityScanner; import org.grails.datastore.gorm.validation.constraints.MappingContextAwareConstraintFactory; import org.grails.datastore.gorm.validation.constraints.builtin.UniqueConstraint; import org.grails.datastore.gorm.validation.constraints.registry.ConstraintRegistry; +import org.grails.datastore.gorm.validation.registry.support.ValidatorRegistries; +import org.grails.datastore.mapping.core.AbstractDatastore; import org.grails.datastore.mapping.core.ConnectionNotFoundException; import org.grails.datastore.mapping.core.Datastore; +import org.grails.datastore.mapping.core.DatastoreAware; import org.grails.datastore.mapping.core.DatastoreUtils; import org.grails.datastore.mapping.core.Session; import org.grails.datastore.mapping.core.connections.*; @@ -49,8 +58,15 @@ import org.grails.datastore.mapping.engine.event.DatastoreInitializedEvent; import org.grails.datastore.mapping.model.DatastoreConfigurationException; import org.grails.datastore.mapping.model.MappingContext; import org.grails.datastore.mapping.model.PersistentEntity; +import org.grails.datastore.mapping.model.config.GormProperties; import org.grails.datastore.mapping.multitenancy.AllTenantsResolver; import org.grails.datastore.mapping.multitenancy.MultiTenancySettings; +import org.grails.datastore.mapping.multitenancy.SchemaMultiTenantCapableDatastore; +import org.grails.datastore.mapping.multitenancy.TenantResolver; +import org.grails.datastore.mapping.multitenancy.exceptions.TenantNotFoundException; +import org.grails.datastore.mapping.multitenancy.resolvers.FixedTenantResolver; +import org.grails.datastore.mapping.core.connections.MultipleConnectionSourceCapableDatastore; +import org.grails.datastore.mapping.transactions.TransactionCapableDatastore; import org.grails.datastore.mapping.validation.ValidatorRegistry; import org.grails.orm.hibernate.cfg.HibernateMappingContext; import org.grails.orm.hibernate.cfg.MappingCacheHolder; @@ -58,6 +74,7 @@ import org.grails.orm.hibernate.cfg.Settings; import org.grails.orm.hibernate.connections.HibernateConnectionSource; import org.grails.orm.hibernate.connections.HibernateConnectionSourceFactory; import org.grails.orm.hibernate.connections.HibernateConnectionSourceSettings; +import org.grails.orm.hibernate.event.listener.AbstractHibernateEventListener; import org.grails.orm.hibernate.event.listener.HibernateEventListener; import org.grails.orm.hibernate.multitenancy.MultiTenantEventListener; import org.grails.orm.hibernate.support.ClosureEventTriggeringInterceptor; @@ -71,6 +88,7 @@ import org.hibernate.service.ServiceRegistry; import org.hibernate.tool.schema.Action; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import org.springframework.beans.BeanUtils; import org.springframework.beans.BeansException; import org.springframework.context.*; import org.springframework.context.support.StaticMessageSource; @@ -88,11 +106,77 @@ import org.springframework.transaction.support.TransactionSynchronizationManager @SuppressWarnings({ "PMD.CloseResource", "PMD.DataflowAnomalyAnalysis", - "PMD.ConstructorCallsOverridableMethod" + "PMD.ConstructorCallsOverridableMethod", + "PMD.AvoidFieldNameMatchingMethodName" }) -public class HibernateDatastore extends AbstractHibernateDatastore implements MessageSourceAware { +public class HibernateDatastore extends AbstractDatastore + implements ApplicationContextAware, + Settings, + SchemaMultiTenantCapableDatastore<SessionFactory, HibernateConnectionSourceSettings>, + TransactionCapableDatastore, + Closeable, + MessageSourceAware, + MultipleConnectionSourceCapableDatastore { private static final Logger LOG = LoggerFactory.getLogger(HibernateDatastore.class); + /** The config property cache queries. */ + public static final String CONFIG_PROPERTY_CACHE_QUERIES = "grails.hibernate.cache.queries"; + + /** The config property osiv readonly. */ + public static final String CONFIG_PROPERTY_OSIV_READONLY = "grails.hibernate.osiv.readonly"; + + /** The config property pass readonly to hibernate. */ + public static final String CONFIG_PROPERTY_PASS_READONLY_TO_HIBERNATE = + "grails.hibernate.pass.readonly"; + + /** The session factory. */ + protected final SessionFactory sessionFactory; + + /** The connection sources. */ + protected final ConnectionSources<SessionFactory, HibernateConnectionSourceSettings> + connectionSources; + + /** The default flush mode name. */ + protected final String defaultFlushModeName; + + /** The multi tenant mode. */ + protected final MultiTenancySettings.MultiTenancyMode multiTenantMode; + + /** The schema handler. */ + protected final SchemaHandler schemaHandler; + + /** The event triggering interceptor. */ + protected AbstractHibernateEventListener eventTriggeringInterceptor; + + /** The auto timestamp event listener. */ + protected AutoTimestampEventListener autoTimestampEventListener; + + /** The osiv read only. */ + protected final boolean osivReadOnly; + + /** The pass read only to hibernate. */ + protected final boolean passReadOnlyToHibernate; + + /** The is cache queries. */ + protected final boolean isCacheQueries; + + /** The default flush mode. */ + protected final int defaultFlushMode; + + /** The fail on error. */ + protected final boolean failOnError; + + /** The mark dirty. */ + protected final boolean markDirty; + + /** The data source name. */ + protected final String dataSourceName; + + /** The tenant resolver. */ + protected final TenantResolver tenantResolver; + + private boolean destroyed; + protected final GrailsHibernateTransactionManager transactionManager; protected ConfigurableApplicationEventPublisher eventPublisher; protected final HibernateGormEnhancer gormEnhancer; @@ -111,12 +195,35 @@ public class HibernateDatastore extends AbstractHibernateDatastore implements Me final ConnectionSources<SessionFactory, HibernateConnectionSourceSettings> connectionSources, final HibernateMappingContext mappingContext, final ConfigurableApplicationEventPublisher eventPublisher) { - super(connectionSources, mappingContext); + super(mappingContext, connectionSources.getBaseConfiguration(), null); + this.connectionSources = connectionSources; + final HibernateConnectionSource defaultConnectionSource = + (HibernateConnectionSource) connectionSources.getDefaultConnectionSource(); + this.dataSourceName = defaultConnectionSource.getName(); + this.sessionFactory = defaultConnectionSource.getSource(); + HibernateConnectionSourceSettings settings = defaultConnectionSource.getSettings(); + HibernateConnectionSourceSettings.HibernateSettings hibernateSettings = settings.getHibernate(); + this.osivReadOnly = hibernateSettings.getOsiv().isReadonly(); + this.passReadOnlyToHibernate = hibernateSettings.isReadOnly(); + this.isCacheQueries = hibernateSettings.getCache().isQueries(); + this.failOnError = settings.isFailOnError(); + Boolean markDirty = settings.getMarkDirty(); + this.markDirty = markDirty == null ? false : markDirty; + FlushMode flushMode = FlushMode.valueOf(hibernateSettings.getFlush().getMode().name()); + this.defaultFlushModeName = flushMode.name(); + this.defaultFlushMode = flushMode.getLevel(); + MultiTenancySettings multiTenancySettings = settings.getMultiTenancy(); + final TenantResolver multiTenantResolver = multiTenancySettings.getTenantResolver(); + this.multiTenantMode = multiTenancySettings.getMode(); + Class<? extends SchemaHandler> schemaHandlerClass = settings.getDataSource().getSchemaHandler(); + this.schemaHandler = BeanUtils.instantiateClass(schemaHandlerClass); + this.tenantResolver = multiTenantResolver; + if (multiTenantResolver instanceof DatastoreAware) { + ((DatastoreAware) multiTenantResolver).setDatastore(this); + } this.metadata = getMetadataInternal(); - HibernateConnectionSource defaultConnectionSource = - (HibernateConnectionSource) connectionSources.getDefaultConnectionSource(); this.transactionManager = new GrailsHibernateTransactionManager( defaultConnectionSource.getSource(), @@ -126,9 +233,6 @@ public class HibernateDatastore extends AbstractHibernateDatastore implements Me this.eventTriggeringInterceptor = new HibernateEventListener(this); this.autoTimestampEventListener = new AutoTimestampEventListener(this); - HibernateConnectionSourceSettings settings = defaultConnectionSource.getSettings(); - HibernateConnectionSourceSettings.HibernateSettings hibernateSettings = settings.getHibernate(); - ClosureEventTriggeringInterceptor interceptor = (ClosureEventTriggeringInterceptor) hibernateSettings.getEventTriggeringInterceptor(); interceptor.setDatastore(this); @@ -407,6 +511,68 @@ public class HibernateDatastore extends AbstractHibernateDatastore implements Me this(new ClasspathEntityScanner().scan(packageToScan)); } + /** + * Legacy constructor used by {@code HibernateDatastoreFactoryBean} and similar factory helpers. + * + * @param mappingContext The mapping context + * @param sessionFactory The session factory + * @param config The property resolver configuration + * @param applicationContext The application context (may be null) + * @param dataSourceName The data source name + */ + protected HibernateDatastore( + MappingContext mappingContext, + SessionFactory sessionFactory, + PropertyResolver config, + ApplicationContext applicationContext, + String dataSourceName) { + super(mappingContext, config, (ConfigurableApplicationContext) applicationContext); + this.connectionSources = + new SingletonConnectionSources<>( + new HibernateConnectionSource(dataSourceName, sessionFactory, null, null), config); + this.sessionFactory = sessionFactory; + this.dataSourceName = dataSourceName; + initializeConverters(mappingContext); + if (applicationContext != null) { + setApplicationContext(applicationContext); + } + + this.osivReadOnly = config.getProperty(CONFIG_PROPERTY_OSIV_READONLY, Boolean.class, false); + this.passReadOnlyToHibernate = + config.getProperty(CONFIG_PROPERTY_PASS_READONLY_TO_HIBERNATE, Boolean.class, false); + this.isCacheQueries = + config.getProperty(CONFIG_PROPERTY_CACHE_QUERIES, Boolean.class, false); + + if (config.getProperty(SETTING_AUTO_FLUSH, Boolean.class, false)) { + this.defaultFlushModeName = FlushMode.AUTO.name(); + this.defaultFlushMode = FlushMode.AUTO.level; + } else { + FlushMode fm = config.getProperty(SETTING_FLUSH_MODE, FlushMode.class, FlushMode.COMMIT); + this.defaultFlushModeName = fm.name(); + this.defaultFlushMode = fm.level; + } + this.failOnError = config.getProperty(SETTING_FAIL_ON_ERROR, Boolean.class, false); + this.markDirty = config.getProperty(SETTING_MARK_DIRTY, Boolean.class, false); + this.tenantResolver = new FixedTenantResolver(); + this.multiTenantMode = MultiTenancySettings.MultiTenancyMode.NONE; + this.schemaHandler = new DefaultSchemaHandler(); + this.transactionManager = null; + this.gormEnhancer = null; + this.metadata = null; + } + + /** + * Legacy three-argument constructor delegating to the five-argument constructor. + * + * @param mappingContext The mapping context + * @param sessionFactory The session factory + * @param config The property resolver configuration + */ + public HibernateDatastore( + MappingContext mappingContext, SessionFactory sessionFactory, PropertyResolver config) { + this(mappingContext, sessionFactory, config, null, ConnectionSource.DEFAULT); + } + @Override public ApplicationEventPublisher getApplicationEventPublisher() { return this.eventPublisher; @@ -575,12 +741,10 @@ public class HibernateDatastore extends AbstractHibernateDatastore implements Me } } - @Override public IHibernateTemplate getHibernateTemplate(int flushMode) { return new GrailsHibernateTemplate(getSessionFactory(), this, flushMode); } - @Override public void withFlushMode(FlushMode flushMode, Callable<Boolean> callable) { final org.hibernate.Session session = sessionFactory.getCurrentSession(); org.hibernate.FlushMode previousMode = null; @@ -602,7 +766,6 @@ public class HibernateDatastore extends AbstractHibernateDatastore implements Me } } - @Override public org.hibernate.Session openSession() { org.hibernate.Session session = this.sessionFactory.openSession(); session.setHibernateFlushMode(org.hibernate.FlushMode.valueOf(defaultFlushModeName)); @@ -618,14 +781,25 @@ public class HibernateDatastore extends AbstractHibernateDatastore implements Me @Override public void destroy() { - try { - super.destroy(); - } finally { - MappingCacheHolder.getInstance().clear(); + if (!this.destroyed) { try { - this.gormEnhancer.close(); - } catch (IOException e) { - LOG.error("There was an error shutting down GORM enhancer", e); + super.destroy(); + HibernateGormInstanceApi.resetInsertActive(); + try { + connectionSources.close(); + } catch (IOException e) { + LOG.error("There was an error shutting down GORM for an entity: " + e.getMessage(), e); + } + } finally { + MappingCacheHolder.getInstance().clear(); + try { + if (this.gormEnhancer != null) { + this.gormEnhancer.close(); + } + } catch (IOException e) { + LOG.error("There was an error shutting down GORM enhancer", e); + } + destroyed = true; } } } @@ -786,4 +960,242 @@ public class HibernateDatastore extends AbstractHibernateDatastore implements Me }); return hibernateConnectionSourceFactory; } + + /** Create validator registry. */ + protected ValidatorRegistry createValidatorRegistry(MessageSource messageSource) { + return ValidatorRegistries.createValidatorRegistry( + mappingContext, + getConnectionSources().getDefaultConnectionSource().getSettings(), + messageSource); + } + + @Override + public MultiTenancySettings.MultiTenancyMode getMultiTenancyMode() { + return this.multiTenantMode == MultiTenancySettings.MultiTenancyMode.SCHEMA + ? MultiTenancySettings.MultiTenancyMode.DATABASE + : this.multiTenantMode; + } + + @Override + public Datastore getDatastoreForTenantId(Serializable tenantId) { + if (getMultiTenancyMode() == MultiTenancySettings.MultiTenancyMode.DATABASE) { + return getDatastoreForConnection(tenantId.toString()); + } else { + return this; + } + } + + @Override + public TenantResolver getTenantResolver() { + return this.tenantResolver; + } + + @Override + public ConnectionSources<SessionFactory, HibernateConnectionSourceSettings> + getConnectionSources() { + return this.connectionSources; + } + + /** Resolve tenant ids. */ + public Iterable<Serializable> resolveTenantIds() { + if (this.tenantResolver instanceof AllTenantsResolver) { + return ((AllTenantsResolver) tenantResolver).resolveTenantIds(); + } else if (this.multiTenantMode == MultiTenancySettings.MultiTenancyMode.DATABASE) { + List<Serializable> tenantIds = new ArrayList<>(); + for (ConnectionSource connectionSource : this.connectionSources.getAllConnectionSources()) { + if (!ConnectionSource.DEFAULT.equals(connectionSource.getName())) { + tenantIds.add(connectionSource.getName()); + } + } + return tenantIds; + } else { + return Collections.emptyList(); + } + } + + /** Resolve tenant identifier. */ + public Serializable resolveTenantIdentifier() throws TenantNotFoundException { + return Tenants.currentId(this); + } + + /** Returns whether auto flush. */ + public boolean isAutoFlush() { + return defaultFlushMode == FlushMode.AUTO.level; + } + + /** + * @return Obtains the default flush mode level + */ + public int getDefaultFlushMode() { + return defaultFlushMode; + } + + /** + * @return The name of the default flush mode + */ + public String getDefaultFlushModeName() { + return defaultFlushModeName; + } + + /** Returns whether fail on error. */ + public boolean isFailOnError() { + return failOnError; + } + + /** Returns whether osiv read only. */ + public boolean isOsivReadOnly() { + return osivReadOnly; + } + + /** Returns whether pass read only to hibernate. */ + public boolean isPassReadOnlyToHibernate() { + return passReadOnlyToHibernate; + } + + /** Returns whether cache queries. */ + public boolean isCacheQueries() { + return isCacheQueries; + } + + /** + * @return The Hibernate {@link SessionFactory} being used by this datastore instance + */ + public SessionFactory getSessionFactory() { + return sessionFactory; + } + + /** + * @return The {@link DataSource} being used by this datastore instance + */ + public DataSource getDataSource() { + return ((HibernateConnectionSource) this.connectionSources.getDefaultConnectionSource()) + .getDataSource(); + } + + /** For testing: returns the event triggering interceptor. */ + public AbstractHibernateEventListener getEventTriggeringInterceptor() { + return eventTriggeringInterceptor; + } + + /** + * @return The event listener that populates lastUpdated and dateCreated + */ + public AutoTimestampEventListener getAutoTimestampEventListener() { + return autoTimestampEventListener; + } + + /** + * @return The data source name being used + */ + public String getDataSourceName() { + return this.dataSourceName; + } + + /** Gets the hibernate template using the default flush mode. */ + public IHibernateTemplate getHibernateTemplate() { + return getHibernateTemplate(defaultFlushMode); + } + + @Override + public <T> T withSession(final Closure<T> callable) { + Closure<T> multiTenantCallable = prepareMultiTenantClosure(callable); + return getHibernateTemplate().execute(multiTenantCallable); + } + + /** Execute the given closure in a new session. */ + public <T> T withNewSession(final Closure<T> callable) { + Closure<T> multiTenantCallable = prepareMultiTenantClosure(callable); + return getHibernateTemplate().executeWithNewSession(multiTenantCallable); + } + + @Override + public <T1> T1 withNewSession(Serializable tenantId, Closure<T1> callable) { + if (getMultiTenancyMode() == MultiTenancySettings.MultiTenancyMode.DATABASE) { + HibernateDatastore datastore = getDatastoreForConnection(tenantId.toString()); + SessionFactory sf = datastore.getSessionFactory(); + return datastore + .getHibernateTemplate() + .executeWithExistingOrCreateNewSession(sf, callable); + } else { + return withNewSession(callable); + } + } + + /** Enable the tenant id filter for the given datastore and entity */ + public void enableMultiTenancyFilter() { + Serializable currentId = Tenants.currentId(this); + if (ConnectionSource.DEFAULT.equals(currentId)) { + disableMultiTenancyFilter(); + } else { + getHibernateTemplate() + .getSessionFactory() + .getCurrentSession() + .enableFilter(GormProperties.TENANT_IDENTITY) + .setParameter(GormProperties.TENANT_IDENTITY, currentId); + } + } + + /** Disable the tenant id filter for the given datastore and entity */ + public void disableMultiTenancyFilter() { + getHibernateTemplate() + .getSessionFactory() + .getCurrentSession() + .disableFilter(GormProperties.TENANT_IDENTITY); + } + + /** Prepare multi tenant closure. */ + protected <T> Closure<T> prepareMultiTenantClosure(final Closure<T> callable) { + final boolean isMultiTenant = + getMultiTenancyMode() == MultiTenancySettings.MultiTenancyMode.DISCRIMINATOR; + return isMultiTenant + ? new Closure<T>(this) { + @Override + public T call(Object... args) { + enableMultiTenancyFilter(); + try { + return callable.call(args); + } finally { + disableMultiTenancyFilter(); + } + } + } + : callable; + } + + @Override + @PreDestroy + public void close() { + try { + destroy(); + } catch (Exception e) { + LOG.error("Error closing hibernate datastore: " + e.getMessage(), e); + } + } + + /** + * We use a separate enum here because the classes differ between Hibernate 3 and 4 + * + * @see org.hibernate.FlushMode + */ + public enum FlushMode { + /** The manual constant. */ + MANUAL(0), + /** The commit constant. */ + COMMIT(5), + /** The auto constant. */ + AUTO(10), + /** The always constant. */ + ALWAYS(20); + + private final int level; + + FlushMode(int level) { + this.level = level; + } + + /** Gets the level. */ + public int getLevel() { + return level; + } + } } diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/HibernateGormStaticApi.groovy b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/HibernateGormStaticApi.groovy index 7cc6a103c2..721525b217 100644 --- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/HibernateGormStaticApi.groovy +++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/HibernateGormStaticApi.groovy @@ -95,13 +95,13 @@ class HibernateGormStaticApi<D> extends GormStaticApi<D> { @Override public <T> T withNewSession(Closure<T> callable) { - AbstractHibernateDatastore hibernateDatastore = (AbstractHibernateDatastore) datastore + HibernateDatastore hibernateDatastore = (HibernateDatastore) datastore hibernateDatastore.withNewSession(callable) } @Override def <T> T withSession(Closure<T> callable) { - AbstractHibernateDatastore hibernateDatastore = (AbstractHibernateDatastore) datastore + HibernateDatastore hibernateDatastore = (HibernateDatastore) datastore hibernateDatastore.withSession(callable) } @@ -553,7 +553,7 @@ class HibernateGormStaticApi<D> extends GormStaticApi<D> { @Override GrailsCriteria createCriteria() { - def builder = new HibernateCriteriaBuilder(persistentClass, sessionFactory,(AbstractHibernateDatastore)datastore) + def builder = new HibernateCriteriaBuilder(persistentClass, sessionFactory,(HibernateDatastore)datastore) builder.conversionService = conversionService return builder } diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/event/listener/AbstractHibernateEventListener.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/event/listener/AbstractHibernateEventListener.java index f3834a4059..5007ac3ff4 100644 --- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/event/listener/AbstractHibernateEventListener.java +++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/event/listener/AbstractHibernateEventListener.java @@ -23,7 +23,7 @@ import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentMap; import org.grails.datastore.mapping.engine.event.AbstractPersistenceEvent; import org.grails.datastore.mapping.engine.event.AbstractPersistenceEventListener; -import org.grails.orm.hibernate.AbstractHibernateDatastore; +import org.grails.orm.hibernate.HibernateDatastore; import org.grails.orm.hibernate.connections.HibernateConnectionSourceSettings; import org.grails.orm.hibernate.support.SoftKey; import org.springframework.context.ApplicationEvent; @@ -49,7 +49,7 @@ public abstract class AbstractHibernateEventListener extends AbstractPersistence protected final List<?> failOnErrorPackages; /** Creates a new {@link AbstractHibernateEventListener} instance. */ - protected AbstractHibernateEventListener(AbstractHibernateDatastore datastore) { + protected AbstractHibernateEventListener(HibernateDatastore datastore) { super(datastore); HibernateConnectionSourceSettings settings = datastore.getConnectionSources().getDefaultConnectionSource().getSettings(); @@ -70,7 +70,7 @@ public abstract class AbstractHibernateEventListener extends AbstractPersistence /** * @return The hibernate datastore */ - protected AbstractHibernateDatastore getDatastore() { - return (AbstractHibernateDatastore) this.datastore; + protected HibernateDatastore getDatastore() { + return (HibernateDatastore) this.datastore; } } diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/event/listener/HibernateEventListener.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/event/listener/HibernateEventListener.java index 6e1b6ad5e9..bbd3005b67 100644 --- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/event/listener/HibernateEventListener.java +++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/event/listener/HibernateEventListener.java @@ -27,7 +27,7 @@ import org.grails.datastore.gorm.timestamp.TimestampProvider; import org.grails.datastore.mapping.engine.event.AbstractPersistenceEvent; import org.grails.datastore.mapping.engine.event.ValidationEvent; import org.grails.datastore.mapping.model.PersistentEntity; -import org.grails.orm.hibernate.AbstractHibernateDatastore; +import org.grails.orm.hibernate.HibernateDatastore; import org.grails.orm.hibernate.support.ClosureEventListener; import org.grails.orm.hibernate.support.SoftKey; import org.hibernate.Hibernate; @@ -49,7 +49,7 @@ public class HibernateEventListener extends AbstractHibernateEventListener { protected transient ConcurrentMap<SoftKey<Class<?>>, ClosureEventListener> eventListeners = new ConcurrentHashMap<>(); - public HibernateEventListener(AbstractHibernateDatastore datastore) { + public HibernateEventListener(HibernateDatastore datastore) { super(datastore); } @@ -208,7 +208,7 @@ public class HibernateEventListener extends AbstractHibernateEventListener { synchronized (cachedShouldTrigger) { eventListener = eventListeners.get(key); if (eventListener == null) { - AbstractHibernateDatastore datastore = getDatastore(); + HibernateDatastore datastore = getDatastore(); boolean isValidSessionFactory = MultiTenant.class.isAssignableFrom(clazz) || factory == null diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/multitenancy/MultiTenantEventListener.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/multitenancy/MultiTenantEventListener.java index b7e7677261..145fd11797 100644 --- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/multitenancy/MultiTenantEventListener.java +++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/multitenancy/MultiTenantEventListener.java @@ -30,7 +30,7 @@ import org.grails.datastore.mapping.multitenancy.MultiTenantCapableDatastore; import org.grails.datastore.mapping.multitenancy.exceptions.TenantException; import org.grails.datastore.mapping.query.Query; import org.grails.datastore.mapping.query.event.PreQueryEvent; -import org.grails.orm.hibernate.AbstractHibernateDatastore; +import org.grails.orm.hibernate.HibernateDatastore; import org.springframework.context.ApplicationEvent; /** @@ -50,7 +50,7 @@ public class MultiTenantEventListener implements PersistenceEventListener { @Override public boolean supportsSourceType(Class<?> sourceType) { - return AbstractHibernateDatastore.class.isAssignableFrom(sourceType); + return HibernateDatastore.class.isAssignableFrom(sourceType); } @SuppressWarnings("PMD.DataflowAnomalyAnalysis") @@ -65,7 +65,7 @@ public class MultiTenantEventListener implements PersistenceEventListener { if (entity.isMultiTenant()) { Datastore ds = (datastore != null) ? datastore : GormEnhancer.findDatastore(entity.getJavaClass()); - if (ds instanceof AbstractHibernateDatastore hibernateDatastore) { + if (ds instanceof HibernateDatastore hibernateDatastore) { hibernateDatastore.enableMultiTenancyFilter(); } } @@ -78,7 +78,7 @@ public class MultiTenantEventListener implements PersistenceEventListener { TenantId tenantId = entity.getTenantId(); Datastore ds = (datastore != null) ? datastore : GormEnhancer.findDatastore(entity.getJavaClass()); - if (ds instanceof AbstractHibernateDatastore hibernateDatastore) { + if (ds instanceof HibernateDatastore hibernateDatastore) { Serializable currentId; if (hibernateDatastore instanceof MultiTenantCapableDatastore) { diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/support/ClosureEventTriggeringInterceptor.java b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/support/ClosureEventTriggeringInterceptor.java index 7620b5986a..2c44fc1e3f 100644 --- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/support/ClosureEventTriggeringInterceptor.java +++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/support/ClosureEventTriggeringInterceptor.java @@ -31,7 +31,7 @@ import org.grails.datastore.mapping.model.MappingContext; import org.grails.datastore.mapping.model.PersistentEntity; import org.grails.datastore.mapping.model.types.Embedded; import org.grails.datastore.mapping.proxy.ProxyHandler; -import org.grails.orm.hibernate.AbstractHibernateDatastore; +import org.grails.orm.hibernate.HibernateDatastore; import org.hibernate.Hibernate; import org.hibernate.HibernateException; import org.hibernate.event.internal.DefaultMergeEventListener; @@ -134,7 +134,7 @@ public class ClosureEventTriggeringInterceptor extends AbstractClosureEventTrigg public static final String AFTER_LOAD_EVENT = AbstractPersistenceEvent.AFTER_LOAD_EVENT; /** The datastore. */ - protected AbstractHibernateDatastore datastore; + protected HibernateDatastore datastore; /** The event publisher. */ protected ConfigurableApplicationEventPublisher eventPublisher; @@ -143,7 +143,7 @@ public class ClosureEventTriggeringInterceptor extends AbstractClosureEventTrigg private ProxyHandler proxyHandler; /** Sets the datastore. */ - public void setDatastore(AbstractHibernateDatastore datastore) { + public void setDatastore(HibernateDatastore datastore) { this.datastore = datastore; this.mappingContext = datastore.getMappingContext(); this.proxyHandler = mappingContext.getProxyHandler(); diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/support/DataSourceFactoryBean.groovy b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/support/DataSourceFactoryBean.groovy index a0612596ab..f47bf74f54 100644 --- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/support/DataSourceFactoryBean.groovy +++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/support/DataSourceFactoryBean.groovy @@ -1,7 +1,7 @@ package org.grails.orm.hibernate.support import groovy.transform.CompileStatic -import org.grails.orm.hibernate.AbstractHibernateDatastore +import org.grails.orm.hibernate.HibernateDatastore import org.grails.orm.hibernate.connections.HibernateConnectionSource import org.springframework.beans.factory.FactoryBean import org.springframework.beans.factory.annotation.Autowired @@ -17,10 +17,10 @@ import javax.sql.DataSource @CompileStatic class DataSourceFactoryBean implements FactoryBean<DataSource> { - AbstractHibernateDatastore datastore + HibernateDatastore datastore String connectionName - DataSourceFactoryBean(AbstractHibernateDatastore datastore, String connectionName) { + DataSourceFactoryBean(HibernateDatastore datastore, String connectionName) { this.datastore = datastore this.connectionName = connectionName } diff --git a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/support/HibernateDatastoreFactoryBean.groovy b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/support/HibernateDatastoreFactoryBean.groovy index c04b4a64af..2c981dd653 100644 --- a/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/support/HibernateDatastoreFactoryBean.groovy +++ b/grails-data-hibernate7/core/src/main/groovy/org/grails/orm/hibernate/support/HibernateDatastoreFactoryBean.groovy @@ -2,7 +2,7 @@ package org.grails.orm.hibernate.support import groovy.transform.CompileStatic import org.grails.datastore.mapping.model.MappingContext -import org.grails.orm.hibernate.AbstractHibernateDatastore +import org.grails.orm.hibernate.HibernateDatastore import org.hibernate.SessionFactory import org.springframework.beans.BeansException import org.springframework.beans.factory.FactoryBean @@ -16,7 +16,7 @@ import org.springframework.core.env.PropertyResolver * @since 5.0 */ @CompileStatic -public class HibernateDatastoreFactoryBean<T extends AbstractHibernateDatastore> implements FactoryBean<T>, ApplicationContextAware { +public class HibernateDatastoreFactoryBean<T extends HibernateDatastore> implements FactoryBean<T>, ApplicationContextAware { private final Class<T> objectType; private final MappingContext mappingContext; @@ -40,7 +40,7 @@ public class HibernateDatastoreFactoryBean<T extends AbstractHibernateDatastore> @Override public T getObject() throws Exception { - AbstractHibernateDatastore datastore = objectType.newInstance(mappingContext, sessionFactory, configuration, dataSourceName) + HibernateDatastore datastore = objectType.newInstance(mappingContext, sessionFactory, configuration, dataSourceName) if(applicationContext != null) { diff --git a/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/HibernateDatastoreIntegrationSpec.groovy b/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/HibernateDatastoreIntegrationSpec.groovy index 1299d9bcd1..16c57a3ecd 100644 --- a/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/HibernateDatastoreIntegrationSpec.groovy +++ b/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/HibernateDatastoreIntegrationSpec.groovy @@ -103,7 +103,7 @@ class HibernateDatastoreIntegrationSpec extends HibernateGormDatastoreSpec { } // ------------------------------------------------------------------------- - // Configuration flags (AbstractHibernateDatastore) + // Configuration flags (HibernateDatastore) // ------------------------------------------------------------------------- void "dataSourceName defaults to DEFAULT"() { @@ -118,8 +118,8 @@ class HibernateDatastoreIntegrationSpec extends HibernateGormDatastoreSpec { void "defaultFlushMode is COMMIT level by default"() { expect: - // AbstractHibernateDatastore.FlushMode.COMMIT.level == 5 - datastore.defaultFlushMode == AbstractHibernateDatastore.FlushMode.COMMIT.level + // HibernateDatastore.FlushMode.COMMIT.level == 5 + datastore.defaultFlushMode == HibernateDatastore.FlushMode.COMMIT.level } void "defaultFlushModeName is COMMIT by default"() { @@ -148,24 +148,24 @@ class HibernateDatastoreIntegrationSpec extends HibernateGormDatastoreSpec { } // ------------------------------------------------------------------------- - // FlushMode enum (AbstractHibernateDatastore.FlushMode) + // FlushMode enum (HibernateDatastore.FlushMode) // ------------------------------------------------------------------------- void "FlushMode enum levels are correctly ordered"() { expect: - AbstractHibernateDatastore.FlushMode.MANUAL.level == 0 - AbstractHibernateDatastore.FlushMode.COMMIT.level == 5 - AbstractHibernateDatastore.FlushMode.AUTO.level == 10 - AbstractHibernateDatastore.FlushMode.ALWAYS.level == 20 + HibernateDatastore.FlushMode.MANUAL.level == 0 + HibernateDatastore.FlushMode.COMMIT.level == 5 + HibernateDatastore.FlushMode.AUTO.level == 10 + HibernateDatastore.FlushMode.ALWAYS.level == 20 } void "FlushMode enum values are all present"() { expect: - AbstractHibernateDatastore.FlushMode.values().size() == 4 - AbstractHibernateDatastore.FlushMode.valueOf('MANUAL') != null - AbstractHibernateDatastore.FlushMode.valueOf('COMMIT') != null - AbstractHibernateDatastore.FlushMode.valueOf('AUTO') != null - AbstractHibernateDatastore.FlushMode.valueOf('ALWAYS') != null + HibernateDatastore.FlushMode.values().size() == 4 + HibernateDatastore.FlushMode.valueOf('MANUAL') != null + HibernateDatastore.FlushMode.valueOf('COMMIT') != null + HibernateDatastore.FlushMode.valueOf('AUTO') != null + HibernateDatastore.FlushMode.valueOf('ALWAYS') != null } // ------------------------------------------------------------------------- @@ -239,7 +239,7 @@ class HibernateDatastoreIntegrationSpec extends HibernateGormDatastoreSpec { when: DatastoreBook.withTransaction { - datastore.withFlushMode(AbstractHibernateDatastore.FlushMode.AUTO) { + datastore.withFlushMode(HibernateDatastore.FlushMode.AUTO) { executed = true true } @@ -258,7 +258,7 @@ class HibernateDatastoreIntegrationSpec extends HibernateGormDatastoreSpec { def sess = sessionFactory.currentSession org.hibernate.FlushMode modeBefore = sess.hibernateFlushMode - datastore.withFlushMode(AbstractHibernateDatastore.FlushMode.ALWAYS) { true } + datastore.withFlushMode(HibernateDatastore.FlushMode.ALWAYS) { true } modeAfter = sess.hibernateFlushMode } @@ -304,7 +304,7 @@ class HibernateDatastoreIntegrationSpec extends HibernateGormDatastoreSpec { } // ------------------------------------------------------------------------- - // Event listeners (AbstractHibernateDatastore) + // Event listeners (HibernateDatastore) // ------------------------------------------------------------------------- void "eventTriggeringInterceptor is a HibernateEventListener"() { diff --git a/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/event/listener/HibernateEventListenerSpec.groovy b/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/event/listener/HibernateEventListenerSpec.groovy index 63cd62b491..fdd66b7dd7 100644 --- a/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/event/listener/HibernateEventListenerSpec.groovy +++ b/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/event/listener/HibernateEventListenerSpec.groovy @@ -15,7 +15,7 @@ class HibernateEventListenerSpec extends HibernateGormDatastoreSpec { HibernateMergeEvent lastMergeEvent HibernatePersistEvent lastPersistEvent - RecordingHibernateEventListener(org.grails.orm.hibernate.AbstractHibernateDatastore datastore) { + RecordingHibernateEventListener(org.grails.orm.hibernate.HibernateDatastore datastore) { super(datastore) } diff --git a/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/multitenancy/MultiTenantEventListenerSpec.groovy b/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/multitenancy/MultiTenantEventListenerSpec.groovy index 4a0ef0b324..56aa0a5cb7 100644 --- a/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/multitenancy/MultiTenantEventListenerSpec.groovy +++ b/grails-data-hibernate7/core/src/test/groovy/org/grails/orm/hibernate/multitenancy/MultiTenantEventListenerSpec.groovy @@ -26,7 +26,7 @@ import org.grails.datastore.mapping.model.types.TenantId import org.grails.datastore.mapping.multitenancy.MultiTenantCapableDatastore import org.grails.datastore.mapping.query.Query import org.grails.datastore.mapping.query.event.PreQueryEvent -import org.grails.orm.hibernate.AbstractHibernateDatastore +import org.grails.orm.hibernate.HibernateDatastore import org.springframework.context.ApplicationEvent import spock.lang.Specification import spock.lang.Unroll @@ -58,18 +58,18 @@ class MultiTenantEventListenerSpec extends Specification { // ─── supportsSourceType ─────────────────────────────────────────────────── - void "supportsSourceType returns true for AbstractHibernateDatastore itself"() { + void "supportsSourceType returns true for HibernateDatastore itself"() { expect: - listener.supportsSourceType(AbstractHibernateDatastore) + listener.supportsSourceType(HibernateDatastore) } - void "supportsSourceType returns true for a subclass of AbstractHibernateDatastore"() { + void "supportsSourceType returns true for a subclass of HibernateDatastore"() { given: // anonymous subclass simulates a concrete HibernateDatastore - def subclass = Mock(AbstractHibernateDatastore).class + def subclass = Mock(HibernateDatastore).class expect: - listener.supportsSourceType(AbstractHibernateDatastore) + listener.supportsSourceType(HibernateDatastore) } void "supportsSourceType returns false for plain Datastore"() { @@ -106,7 +106,7 @@ class MultiTenantEventListenerSpec extends Specification { void "onApplicationEvent PreQueryEvent on non-multi-tenant entity does not call enableMultiTenancyFilter"() { given: - def datastore = Mock(AbstractHibernateDatastore) + def datastore = Mock(HibernateDatastore) def entity = Mock(PersistentEntity) { isMultiTenant() >> false } def query = Mock(Query) { getEntity() >> entity } def event = new PreQueryEvent(datastore, query) @@ -122,7 +122,7 @@ class MultiTenantEventListenerSpec extends Specification { void "onApplicationEvent PreQueryEvent on multi-tenant entity calls enableMultiTenancyFilter"() { given: - def datastore = Mock(AbstractHibernateDatastore) + def datastore = Mock(HibernateDatastore) def entity = Mock(PersistentEntity) { isMultiTenant() >> true } def query = Mock(Query) { getEntity() >> entity } def event = new PreQueryEvent(datastore, query) @@ -135,7 +135,7 @@ class MultiTenantEventListenerSpec extends Specification { } void "onApplicationEvent PreQueryEvent with non-Hibernate source does not call enableMultiTenancyFilter"() { - given: "source is not an AbstractHibernateDatastore" + given: "source is not an HibernateDatastore" def nonHibernateDatastore = Mock(org.grails.datastore.mapping.core.Datastore) def entity = Mock(PersistentEntity) { isMultiTenant() >> true } def query = Mock(Query) { getEntity() >> entity } @@ -152,7 +152,7 @@ class MultiTenantEventListenerSpec extends Specification { void "onApplicationEvent PreInsertEvent on non-multi-tenant entity sets no tenant"() { given: - def datastore = Mock(AbstractHibernateDatastore) + def datastore = Mock(HibernateDatastore) def entity = Mock(PersistentEntity) { isMultiTenant() >> false } def entityAccess = Mock(org.grails.datastore.mapping.engine.EntityAccess) def event = new PreInsertEvent(datastore, entity, entityAccess) @@ -175,7 +175,7 @@ class MultiTenantEventListenerSpec extends Specification { getTenantId() >> tenantId } def entityAccess = Mock(org.grails.datastore.mapping.engine.EntityAccess) - def datastore = Mock(AbstractHibernateDatastore) { getTenantResolver() >> resolver } + def datastore = Mock(HibernateDatastore) { getTenantResolver() >> resolver } def event = new PreInsertEvent(datastore, entity, entityAccess) when: @@ -196,7 +196,7 @@ class MultiTenantEventListenerSpec extends Specification { getTenantId() >> tenantId } def entityAccess = Mock(org.grails.datastore.mapping.engine.EntityAccess) - def datastore = Mock(AbstractHibernateDatastore) { getTenantResolver() >> resolver } + def datastore = Mock(HibernateDatastore) { getTenantResolver() >> resolver } def event = new PreUpdateEvent(datastore, entity, entityAccess) when: @@ -217,7 +217,7 @@ class MultiTenantEventListenerSpec extends Specification { getTenantId() >> tenantId } def entityAccess = Mock(org.grails.datastore.mapping.engine.EntityAccess) - def datastore = Mock(AbstractHibernateDatastore) { getTenantResolver() >> resolver } + def datastore = Mock(HibernateDatastore) { getTenantResolver() >> resolver } def event = new ValidationEvent(datastore, entity, entityAccess) when: diff --git a/grails-data-hibernate7/grails-plugin/src/main/groovy/org/grails/plugin/hibernate/support/AbstractMultipleDataSourceAggregatePersistenceContextInterceptor.java b/grails-data-hibernate7/grails-plugin/src/main/groovy/org/grails/plugin/hibernate/support/AbstractMultipleDataSourceAggregatePersistenceContextInterceptor.java index 8fda4e23b4..be105e59e4 100644 --- a/grails-data-hibernate7/grails-plugin/src/main/groovy/org/grails/plugin/hibernate/support/AbstractMultipleDataSourceAggregatePersistenceContextInterceptor.java +++ b/grails-data-hibernate7/grails-plugin/src/main/groovy/org/grails/plugin/hibernate/support/AbstractMultipleDataSourceAggregatePersistenceContextInterceptor.java @@ -26,7 +26,7 @@ import org.hibernate.SessionFactory; import grails.persistence.support.PersistenceContextInterceptor; import org.grails.datastore.mapping.core.connections.ConnectionSource; import org.grails.datastore.mapping.core.connections.ConnectionSources; -import org.grails.orm.hibernate.AbstractHibernateDatastore; +import org.grails.orm.hibernate.HibernateDatastore; import org.grails.orm.hibernate.connections.HibernateConnectionSourceSettings; /** @@ -38,9 +38,9 @@ import org.grails.orm.hibernate.connections.HibernateConnectionSourceSettings; public abstract class AbstractMultipleDataSourceAggregatePersistenceContextInterceptor implements PersistenceContextInterceptor { protected final List<PersistenceContextInterceptor> interceptors = new ArrayList<>(); - protected final AbstractHibernateDatastore hibernateDatastore; + protected final HibernateDatastore hibernateDatastore; - public AbstractMultipleDataSourceAggregatePersistenceContextInterceptor(AbstractHibernateDatastore hibernateDatastore) { + public AbstractMultipleDataSourceAggregatePersistenceContextInterceptor(HibernateDatastore hibernateDatastore) { this.hibernateDatastore = hibernateDatastore; ConnectionSources<SessionFactory, HibernateConnectionSourceSettings> connectionSources = hibernateDatastore.getConnectionSources(); Iterable<ConnectionSource<SessionFactory, HibernateConnectionSourceSettings>> allConnectionSources = connectionSources.getAllConnectionSources(); diff --git a/grails-data-hibernate7/grails-plugin/src/main/groovy/org/grails/plugin/hibernate/support/AggregatePersistenceContextInterceptor.java b/grails-data-hibernate7/grails-plugin/src/main/groovy/org/grails/plugin/hibernate/support/AggregatePersistenceContextInterceptor.java index 060681f57d..b986415328 100644 --- a/grails-data-hibernate7/grails-plugin/src/main/groovy/org/grails/plugin/hibernate/support/AggregatePersistenceContextInterceptor.java +++ b/grails-data-hibernate7/grails-plugin/src/main/groovy/org/grails/plugin/hibernate/support/AggregatePersistenceContextInterceptor.java @@ -19,7 +19,7 @@ package org.grails.plugin.hibernate.support; -import org.grails.orm.hibernate.AbstractHibernateDatastore; +import org.grails.orm.hibernate.HibernateDatastore; /** * Concrete implementation of the {@link AbstractMultipleDataSourceAggregatePersistenceContextInterceptor} class for Hibernate 4 @@ -29,14 +29,14 @@ import org.grails.orm.hibernate.AbstractHibernateDatastore; */ public class AggregatePersistenceContextInterceptor extends AbstractMultipleDataSourceAggregatePersistenceContextInterceptor { - public AggregatePersistenceContextInterceptor(AbstractHibernateDatastore hibernateDatastore) { + public AggregatePersistenceContextInterceptor(HibernateDatastore hibernateDatastore) { super(hibernateDatastore); } @Override protected SessionFactoryAwarePersistenceContextInterceptor createPersistenceContextInterceptor(String dataSourceName) { HibernatePersistenceContextInterceptor interceptor = new HibernatePersistenceContextInterceptor(dataSourceName); - AbstractHibernateDatastore datastoreForConnection = hibernateDatastore.getDatastoreForConnection(dataSourceName); + HibernateDatastore datastoreForConnection = hibernateDatastore.getDatastoreForConnection(dataSourceName); interceptor.setHibernateDatastore(datastoreForConnection); return interceptor; } diff --git a/grails-data-hibernate7/grails-plugin/src/main/groovy/org/grails/plugin/hibernate/support/GrailsOpenSessionInViewInterceptor.java b/grails-data-hibernate7/grails-plugin/src/main/groovy/org/grails/plugin/hibernate/support/GrailsOpenSessionInViewInterceptor.java index 62bc0fdf0d..8ae79c6337 100644 --- a/grails-data-hibernate7/grails-plugin/src/main/groovy/org/grails/plugin/hibernate/support/GrailsOpenSessionInViewInterceptor.java +++ b/grails-data-hibernate7/grails-plugin/src/main/groovy/org/grails/plugin/hibernate/support/GrailsOpenSessionInViewInterceptor.java @@ -29,7 +29,7 @@ import org.springframework.transaction.support.TransactionSynchronizationManager import org.springframework.ui.ModelMap; import org.springframework.web.context.request.WebRequest; -import org.grails.orm.hibernate.AbstractHibernateDatastore; +import org.grails.orm.hibernate.HibernateDatastore; /** * Extends the default spring OSIV and doesn't flush the session if it has been set @@ -75,7 +75,7 @@ public class GrailsOpenSessionInViewInterceptor extends OpenSessionInViewInterce } } - public void setHibernateDatastore(AbstractHibernateDatastore hibernateDatastore) { + public void setHibernateDatastore(HibernateDatastore hibernateDatastore) { String defaultFlushModeName = hibernateDatastore.getDefaultFlushModeName(); if (hibernateDatastore.isOsivReadOnly()) { this.hibernateFlushMode = FlushMode.MANUAL; diff --git a/grails-data-hibernate7/grails-plugin/src/main/groovy/org/grails/plugin/hibernate/support/HibernatePersistenceContextInterceptor.java b/grails-data-hibernate7/grails-plugin/src/main/groovy/org/grails/plugin/hibernate/support/HibernatePersistenceContextInterceptor.java index bd8b2f41e5..1187426a7a 100644 --- a/grails-data-hibernate7/grails-plugin/src/main/groovy/org/grails/plugin/hibernate/support/HibernatePersistenceContextInterceptor.java +++ b/grails-data-hibernate7/grails-plugin/src/main/groovy/org/grails/plugin/hibernate/support/HibernatePersistenceContextInterceptor.java @@ -39,7 +39,7 @@ import grails.persistence.support.PersistenceContextInterceptor; import grails.validation.DeferredBindingActions; import org.grails.core.lifecycle.ShutdownOperations; import org.grails.datastore.mapping.core.connections.ConnectionSource; -import org.grails.orm.hibernate.AbstractHibernateDatastore; +import org.grails.orm.hibernate.HibernateDatastore; import org.grails.orm.hibernate.support.HibernateRuntimeUtils; /** @@ -49,7 +49,7 @@ import org.grails.orm.hibernate.support.HibernateRuntimeUtils; public class HibernatePersistenceContextInterceptor implements PersistenceContextInterceptor, SessionFactoryAwarePersistenceContextInterceptor { private static final Logger LOG = LoggerFactory.getLogger(HibernatePersistenceContextInterceptor.class); - private AbstractHibernateDatastore hibernateDatastore; + private HibernateDatastore hibernateDatastore; private static ThreadLocal<Map<String, Boolean>> participate = ThreadLocal.withInitial(HashMap::new); @@ -202,7 +202,7 @@ public class HibernatePersistenceContextInterceptor implements PersistenceContex return hibernateDatastore.getSessionFactory(); } - public void setHibernateDatastore(AbstractHibernateDatastore hibernateDatastore) { + public void setHibernateDatastore(HibernateDatastore hibernateDatastore) { this.hibernateDatastore = hibernateDatastore; }
