Java 与父实体一起逐出从属集合

我刚刚意识到，当一个对象从Hibernate缓存中退出时

对我来说，这是一个大型WTF：

• 很容易忘记逐出集合（例如，将新集合添加到对象映射时）
• 逐出从属集合的代码既难看又笨重，例如

  MyClass myObject=
  
  getHibernateTemplate（）.recit（myObject）
  
  缓存缓存=getHibernateTemplate（）.getSessionFactory（）.getCache（）
  
  cache.executeCollection（“my.package.MyClass.myCollection1，id）；
  
  
  …
  
  
  cache.executeCollection（“my.package.MyClass.myCollectionN，id”）
  

很明显，若父对象发生了变化，那个么保留它的集合几乎并没有意义，因为它们很可能是从父对象派生的

---

我是不是遗漏了什么？如果不手动编写所有代码，真的没有办法将对象及其所有子实体一起刷新吗？

它只是一个缓存。缓存只会减少对数据库的访问。当您逐出一个对象时，通常您没有对子对象进行任何修改，并且它们可以在下次从缓存中加载。此外，经常会发生子对象仍被其他父对象使用的情况（在本例中，“child”的名称不正确，因为它是一个n:1或m:n关系）。驱逐孩子可能会在其他地方引发非常奇怪的错误，而孩子对象仍在使用中

因此，驱逐孩子是否好取决于您的应用程序和数据库设计。因此，默认情况下hibernate不会逐出子对象

如果要自动逐出子对象，请在映射文件中使用cascade=“execute”

退出所有对象的一种更为灵活的方法是关闭会话并打开一个新的会话。然后该会话的所有对象都将被逐出。

这是一个旧会话。有一种方法可以挂接到hibernate，在插入、更新或删除集合引用的实体时逐出集合缓存。我有。修复程序计划在Hibernate 4.3.0.Beta5中运行，并将由以下属性激活：

hibernate.cache.auto_evict_collection_cache=true

只要没有实现此修复，您就可以通过自己向SessionFactory和SessionFactoryServiceRegistry注册CollectionCacheInvalidater来解决注入逐出逻辑的问题

import javax.persistence.OneToMany;
import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import my.own.library.BeanInformationFromClass;
import my.own.library.PropertyInformationFromClass;
import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;

import org.hibernate.engine.spi.SessionFactoryImplementor;
import org.hibernate.event.service.spi.EventListenerRegistry;
import org.hibernate.event.spi.EventSource;
import org.hibernate.event.spi.EventType;
import org.hibernate.event.spi.PostInsertEvent;
import org.hibernate.event.spi.PostInsertEventListener;
import org.hibernate.event.spi.PreDeleteEvent;
import org.hibernate.event.spi.PreDeleteEventListener;
import org.hibernate.event.spi.PreUpdateEvent;
import org.hibernate.event.spi.PreUpdateEventListener;
import org.hibernate.persister.collection.CollectionPersister;
import org.hibernate.persister.entity.EntityPersister;
import org.hibernate.persister.entity.Joinable;
import org.hibernate.service.spi.SessionFactoryServiceRegistry;

/**
 * @author Andreas Berger (latest modification by $Author$)
 * @version $Id$
 * @created 27.08.13 - 17:49
 */
public class CollectionCacheInvalidator
        implements PostInsertEventListener, PreDeleteEventListener, PreUpdateEventListener {

    private static final Logger LOGGER = Logger.getLogger( CollectionCacheInvalidator.class );

    private Map<String, String> mappedByFieldMapping;

    public void integrate(SessionFactoryImplementor sf, SessionFactoryServiceRegistry registry) {
        EventListenerRegistry eventListenerRegistry = registry.getService( EventListenerRegistry.class );
        eventListenerRegistry.appendListeners( EventType.POST_INSERT, this );
        eventListenerRegistry.appendListeners( EventType.PRE_DELETE, this );
        eventListenerRegistry.appendListeners( EventType.PRE_UPDATE, this );

        mappedByFieldMapping = new HashMap<String, String>();

        Map<String, CollectionPersister> persiters = sf.getCollectionPersisters();
        if ( persiters != null ) {
            for ( CollectionPersister collectionPersister : persiters.values() ) {
                if ( !collectionPersister.hasCache() ) {
                    continue;
                }
                if ( !(collectionPersister instanceof Joinable) ) {
                    continue;
                }
                String oneToManyFieldName = collectionPersister.getNodeName();
                EntityPersister ownerEntityPersister = collectionPersister.getOwnerEntityPersister();
                Class ownerClass = ownerEntityPersister.getMappedClass();

                // Logic to get the mappedBy attribute of the OneToMany annotation.
                BeanInformationFromClass bi = new BeanInformationFromClass( ownerClass );
                PropertyInformationFromClass prop = bi.getProperty( oneToManyFieldName );
                OneToMany oneToMany = prop.getAnnotation( OneToMany.class );
                String mappedBy = null;
                if ( oneToMany != null && StringUtils.isNotBlank( oneToMany.mappedBy() ) ) {
                    mappedBy = oneToMany.mappedBy();
                }
                mappedByFieldMapping.put( ((Joinable) collectionPersister).getName(), mappedBy );
            }
        }
    }

    @Override
    public void onPostInsert(PostInsertEvent event) {
        evictCache( event.getEntity(), event.getPersister(), event.getSession(), null );
    }

    @Override
    public boolean onPreDelete(PreDeleteEvent event) {
        evictCache( event.getEntity(), event.getPersister(), event.getSession(), null );
        return false;
    }

    @Override
    public boolean onPreUpdate(PreUpdateEvent event) {
        evictCache( event.getEntity(), event.getPersister(), event.getSession(), event.getOldState() );
        return false;
    }

    private void evictCache(Object entity, EntityPersister persister, EventSource session, Object[] oldState) {
        try {
            SessionFactoryImplementor factory = persister.getFactory();

            Set<String> collectionRoles = factory.getCollectionRolesByEntityParticipant( persister.getEntityName() );
            if ( collectionRoles == null || collectionRoles.isEmpty() ) {
                return;
            }
            for ( String role : collectionRoles ) {
                CollectionPersister collectionPersister = factory.getCollectionPersister( role );
                if ( !collectionPersister.hasCache() ) {
                    continue;
                }
                if ( !(collectionPersister instanceof Joinable) ) {
                    continue;
                }
                String mappedBy = mappedByFieldMapping.get( ((Joinable) collectionPersister).getName() );
                if ( mappedBy != null ) {
                    int i = persister.getEntityMetamodel().getPropertyIndex( mappedBy );
                    Serializable oldId = null;
                    if ( oldState != null ) {
                        oldId = session.getIdentifier( oldState[i] );
                    }
                    Object ref = persister.getPropertyValue( entity, i );
                    Serializable id = null;
                    if ( ref != null ) {
                        id = session.getIdentifier( ref );
                    }
                    if ( id != null && !id.equals( oldId ) ) {
                        evict( id, collectionPersister, session );
                        if ( oldId != null ) {
                            evict( id, collectionPersister, session );
                        }
                    }
                }
                else {
                    LOGGER.debug( "Evict CollectionRegion " + role );
                    collectionPersister.getCacheAccessStrategy().evictAll();
                }
            }
        }
        catch (Exception e) {
            LOGGER.error( "", e );
        }
    }

    private void evict(Serializable id, CollectionPersister collectionPersister, EventSource session) {
        LOGGER.debug( "Evict CollectionRegion " + collectionPersister.getRole() + " for id " + id );
        collectionPersister.getCacheAccessStrategy().evict(
                session.generateCacheKey(
                        id,
                        collectionPersister.getKeyType(),
                        collectionPersister.getRole()
                )
        );
    }
}

import javax.persistence.OneToMany；
导入java.io.Serializable；
导入java.util.HashMap；
导入java.util.Map；
导入java.util.Set；
从类导入my.own.library.beanInformation；
导入my.own.library.PropertyInformationFromClass；
导入org.apache.commons.lang.StringUtils；
导入org.apache.log4j.Logger；
导入org.hibernate.engine.spi.SessionFactoryImplementor；
导入org.hibernate.event.service.spi.EventListenerRegistry；
导入org.hibernate.event.spi.EventSource；
导入org.hibernate.event.spi.EventType；
导入org.hibernate.event.spi.PostInsertEvent；
导入org.hibernate.event.spi.PostInsertEventListener；
导入org.hibernate.event.spi.PreDeleteEvent；
导入org.hibernate.event.spi.PreDeleteEventListener；
导入org.hibernate.event.spi.PreUpdateEvent；
导入org.hibernate.event.spi.PreUpdateEventListener；
导入org.hibernate.persister.collection.CollectionPersister；
导入org.hibernate.persister.entity.EntityPersister；
导入org.hibernate.persister.entity.Joinable；
导入org.hibernate.service.spi.SessionFactoryServiceRegistry；
/**
*@author Andreas Berger（由$author$最新修改）
*@version$Id$
*@created 27.08.13-17:49
*/
公共类集合CacheInvalidater
实现PostInserteEventListener、PreDeleteEventListener、PreUpdateEventListener{
私有静态最终记录器记录器=Logger.getLogger（CollectionCacheInvalidater.class）；
私有地图映射通过字段映射；
public void integrate（SessionFactoryImplementor sf、SessionFactoryServiceRegistry注册表）{
EventListenerRegistry EventListenerRegistry=registry.getService（EventListenerRegistry.class）；
appendListeners（EventType.POST_INSERT，this）；
appendListeners（EventType.PRE_DELETE，this）；
appendListeners（EventType.PRE_UPDATE，this）；
mappedByFieldMapping=新建HashMap（）；
Map peristers=sf.getCollectionPersisters（）；
if（persters！=null）{
对于（CollectionPersister CollectionPersister:peristers.values（））{
如果（！collectionPersister.hasCache（））{
继续；
}
if（！（可连接的collectionPersister实例））{
继续；
}
字符串oneToManyFieldName=collectionPersister.getNodeName（）；
EntityPersister ownerEntityPersister=collectionPersister.getOwnerEntityPersister（）；
类ownerClass=ownerEntityPersister.getMappedClass（）；
//获取OneToMany注释的mappedBy属性的逻辑。
BeanInformationFromClass bi=新BeanInformationFromClass（所有者类）；
PropertyInformationFromClass prop=bi.getProperty（oneToManyFieldName）；
OneToMany OneToMany=prop.getAnnotation（OneToMany.class）；
字符串mappedBy=null；
if（oneToMany！=null&&StringUtils.isNotBlank（oneToMany.mappedBy（））{
mappedBy=oneToMany.mappedBy（）；
}
mappedByFieldMapping.put（（（可接合）collectionPersister.getName（），mappedBy）；
}
}
}
@凌驾
公共无效onPostInsert（PostInsertEvent事件）{
收回缓存（event.getEntity（），event.getPersister（），event.getSession（），null）；
}
@凌驾
公共布尔onPreDelete（predeleteent事件）{
收回缓存（event.getEntity（）、event.getPersister（）、event.getSess