import org.hibernate.cache.spi.CacheKey; //导入依赖的package包/类
@Override
public final void beforeExecutions() throws CacheException {
	// we need to obtain the lock before any actions are executed, since this may be an inverse="true"
	// bidirectional association and it is one of the earlier entity actions which actually updates
	// the database (this action is responsible for second-level cache invalidation only)
	if ( persister.hasCache() ) {
		final CacheKey ck = session.generateCacheKey(
				key,
				persister.getKeyType(),
				persister.getRole()
		);
		final SoftLock lock = persister.getCacheAccessStrategy().lockItem( ck, null );
		// the old behavior used key as opposed to getKey()
		afterTransactionProcess = new CacheCleanupProcess( key, persister, lock );
	}
}
 

import org.hibernate.cache.spi.CacheKey; //导入依赖的package包/类
@Override
public void doAfterTransactionCompletion(boolean success, SessionImplementor session) throws CacheException {
	final EntityPersister persister = getPersister();
	if ( persister.hasCache() ) {
		
		final CacheKey ck = getSession().generateCacheKey(
				getId(),
				persister.getIdentifierType(), 
				persister.getRootEntityName()
		);
		
		if ( success && cacheEntry!=null /*!persister.isCacheInvalidationRequired()*/ ) {
			final boolean put = cacheAfterUpdate( persister, ck );

			if ( put && getSession().getFactory().getStatistics().isStatisticsEnabled() ) {
				getSession().getFactory().getStatisticsImplementor().secondLevelCachePut( getPersister().getCacheAccessStrategy().getRegion().getName() );
			}
		}
		else {
			persister.getCacheAccessStrategy().unlockItem( ck, lock );
		}
	}
	postCommitUpdate( success );
}
 

import org.hibernate.cache.spi.CacheKey; //导入依赖的package包/类
@Override
public void write(ObjectDataOutput out, CacheKey object)
        throws IOException {

    try {
        Object key = UNSAFE.getObject(object, KEY_OFFSET);
        Type type = (Type) UNSAFE.getObject(object, TYPE_OFFSET);
        String entityOrRoleName = (String) UNSAFE.getObject(object, ENTITY_OR_ROLE_NAME_OFFSET);
        String tenantId = (String) UNSAFE.getObject(object, TENANT_ID_OFFSET);
        int hashCode = UNSAFE.getInt(object, HASH_CODE_OFFSET);

        out.writeObject(key);
        out.writeObject(type);
        out.writeUTF(entityOrRoleName);
        out.writeUTF(tenantId);
        out.writeInt(hashCode);

    } catch (Exception e) {
        if (e instanceof IOException) {
            throw (IOException) e;
        }
        throw new IOException(e);
    }
}
 

import org.hibernate.cache.spi.CacheKey; //导入依赖的package包/类
@Override
public CacheKey read(ObjectDataInput in)
        throws IOException {

    try {
        Object key = in.readObject();
        Type type = in.readObject();
        String entityOrRoleName = in.readUTF();
        String tenantId = in.readUTF();
        int hashCode = in.readInt();

        CacheKey cacheKey = (CacheKey) UNSAFE.allocateInstance(CacheKey.class);
        UNSAFE.putObjectVolatile(cacheKey, KEY_OFFSET, key);
        UNSAFE.putObjectVolatile(cacheKey, TYPE_OFFSET, type);
        UNSAFE.putObjectVolatile(cacheKey, ENTITY_OR_ROLE_NAME_OFFSET, entityOrRoleName);
        UNSAFE.putObjectVolatile(cacheKey, TENANT_ID_OFFSET, tenantId);
        UNSAFE.putIntVolatile(cacheKey, HASH_CODE_OFFSET, hashCode);
        return cacheKey;

    } catch (Exception e) {
        if (e instanceof IOException) {
            throw (IOException) e;
        }
        throw new IOException(e);
    }
}
 

import org.hibernate.cache.spi.CacheKey; //导入依赖的package包/类
@Test
public void testAutoregistrationOnHibernate4Available()
        throws Exception {

    HazelcastInstance hz = Hazelcast.newHazelcastInstance();
    HazelcastInstanceImpl impl = (HazelcastInstanceImpl) ORIGINAL.get(hz);
    SerializationService ss = impl.getSerializationService();
    ConcurrentMap<Class, ?> typeMap = (ConcurrentMap<Class, ?>) TYPE_MAP.get(ss);

    boolean cacheKeySerializerFound = false;
    boolean cacheEntrySerializerFound = false;
    for (Class clazz : typeMap.keySet()) {
        if (clazz == CacheKey.class) {
            cacheKeySerializerFound = true;
        } else if (clazz == CacheEntry.class) {
            cacheEntrySerializerFound = true;
        }
    }

    assertTrue("CacheKey serializer not found", cacheKeySerializerFound);
    assertTrue("CacheEntry serializer not found", cacheEntrySerializerFound);
}
 

import org.hibernate.cache.spi.CacheKey; //导入依赖的package包/类
private void removeCache(String cacheRegion, Serializable key) {
    String cacheName = cacheRegion;
    if (key instanceof CacheKey) {
        cacheName = ((CacheKey) key).getEntityOrRoleName();
        key = ((CacheKey) key).getKey();
    }
    if (containsCache(cacheRegion, cacheName)) {
        HydratedCache cache = hydratedCacheContainer.get(cacheRegion + "_" + cacheName);
        String myKey = cacheRegion + "_" + cacheName + "_" + key;
        if (cache.containsKey(myKey)) {
            if (LOG.isInfoEnabled()) {
                LOG.info("Clearing hydrated cache for cache name: " + cacheRegion + "_" + cacheName + "_" + key);
            }
            cache.removeCacheElement(cacheRegion, cacheName, key);
        }
    }
}
 

import org.hibernate.cache.spi.CacheKey; //导入依赖的package包/类
protected void removeCache(String cacheRegion, Serializable key) {
    String cacheName = cacheRegion;
    if (key instanceof CacheKey) {
        cacheName = ((CacheKey) key).getEntityOrRoleName();
        key = ((CacheKey) key).getKey();
    }
    String nameKey = cacheRegion + '_' + cacheName + '_' + key;
    if (cacheMembersByEntity.containsKey(nameKey)) {
        String[] members = new String[cacheMembersByEntity.get(nameKey).size()];
        members = cacheMembersByEntity.get(nameKey).toArray(members);
        for (String myMember : members) {
            String itemKey = cacheRegion + '_' + cacheName + '_' + myMember + '_' + key;
            getHeap().remove(itemKey);
        }
        cacheMembersByEntity.remove(nameKey);
    }
}
 

import org.hibernate.cache.spi.CacheKey; //导入依赖的package包/类
protected void removeCache(String cacheRegion, Serializable key) {
    String cacheName = cacheRegion;
    if (key instanceof CacheKey) {
        cacheName = ((CacheKey) key).getEntityOrRoleName();
        key = ((CacheKey) key).getKey();
    }
    String nameKey = cacheRegion + '_' + cacheName + '_' + key;
    if (cacheMemberNamesByEntity.containsKey(nameKey)) {
        String[] members = new String[cacheMemberNamesByEntity.get(nameKey).size()];
        members = cacheMemberNamesByEntity.get(nameKey).toArray(members);
        for (String myMember : members) {
            String itemKey = cacheRegion + '_' + myMember + '_' + key;
            removeKeys.add(itemKey);
        }
        cacheMemberNamesByEntity.remove(nameKey);
    }
}
 

import org.hibernate.cache.spi.CacheKey; //导入依赖的package包/类
public Object initializeLazyProperty(String fieldName, Object entity, SessionImplementor session)
		throws HibernateException {

	final Serializable id = session.getContextEntityIdentifier( entity );

	final EntityEntry entry = session.getPersistenceContext().getEntry( entity );
	if ( entry == null ) {
		throw new HibernateException( "entity is not associated with the session: " + id );
	}

	if ( LOG.isTraceEnabled() ) {
		LOG.tracev( "Initializing lazy properties of: {0}, field access: {1}", MessageHelper.infoString( this, id, getFactory() ), fieldName );
	}

	if ( session.getCacheMode().isGetEnabled() && hasCache() ) {
		final CacheKey cacheKey = session.generateCacheKey( id, getIdentifierType(), getEntityName() );
		final Object ce = CacheHelper.fromSharedCache( session, cacheKey, getCacheAccessStrategy() );
		if ( ce != null ) {
			final CacheEntry cacheEntry = (CacheEntry) getCacheEntryStructure().destructure(ce, factory);
			if ( !cacheEntry.areLazyPropertiesUnfetched() ) {
				//note early exit here:
				return initializeLazyPropertiesFromCache( fieldName, entity, session, entry, cacheEntry );
			}
		}
	}

	return initializeLazyPropertiesFromDatastore( fieldName, entity, session, id, entry );

}
 

import org.hibernate.cache.spi.CacheKey; //导入依赖的package包/类
private boolean isCached(EntityKey entityKey, EntityPersister persister) {
	if ( context.getSession().getCacheMode().isGetEnabled() && persister.hasCache() ) {
		final CacheKey key = context.getSession().generateCacheKey(
				entityKey.getIdentifier(),
				persister.getIdentifierType(),
				entityKey.getEntityName()
		);
		return CacheHelper.fromSharedCache( context.getSession(), key, persister.getCacheAccessStrategy() ) != null;
	}
	return false;
}
 

import org.hibernate.cache.spi.CacheKey; //导入依赖的package包/类
public Map getEntries() {
	Map map = new HashMap();
	Iterator iter = region.toMap().entrySet().iterator();
	while (iter.hasNext()) {
		Map.Entry me = (Map.Entry) iter.next();
		map.put(((CacheKey) me.getKey()).getKey(), me.getValue());
	}
	return map;
}
 

import org.hibernate.cache.spi.CacheKey; //导入依赖的package包/类
private CacheKey buildCacheKey(Serializable identifier, EntityPersister p) {
	return new CacheKey(
			identifier,
			p.getIdentifierType(),
			p.getRootEntityName(),
			null,                         // have to assume non tenancy
			sessionFactory
	);
}
 

import org.hibernate.cache.spi.CacheKey; //导入依赖的package包/类
@Override
public void evictCollection(String role, Serializable ownerIdentifier) {
	CollectionPersister p = sessionFactory.getCollectionPersister( role );
	if ( p.hasCache() ) {
		if ( LOG.isDebugEnabled() ) {
			LOG.debugf(
					"Evicting second-level cache: %s",
					MessageHelper.collectionInfoString( p, ownerIdentifier, sessionFactory )
			);
		}
		CacheKey cacheKey = buildCacheKey( ownerIdentifier, p );
		p.getCacheAccessStrategy().evict( cacheKey );
	}
}
 

import org.hibernate.cache.spi.CacheKey; //导入依赖的package包/类
@Override
	public void refresh(String entityName, Object entity, LockMode lockMode) {
		final EntityPersister persister = this.getEntityPersister( entityName, entity );
		final Serializable id = persister.getIdentifier( entity, this );
		if ( LOG.isTraceEnabled() ) {
			LOG.tracev( "Refreshing transient {0}", MessageHelper.infoString( persister, id, this.getFactory() ) );
		}
		// TODO : can this ever happen???
//		EntityKey key = new EntityKey( id, persister, source.getEntityMode() );
//		if ( source.getPersistenceContext().getEntry( key ) != null ) {
//			throw new PersistentObjectException(
//					"attempted to refresh transient instance when persistent " +
//					"instance was already associated with the Session: " +
//					MessageHelper.infoString( persister, id, source.getFactory() )
//			);
//		}

		if ( persister.hasCache() ) {
			final CacheKey ck = generateCacheKey( id, persister.getIdentifierType(), persister.getRootEntityName() );
			persister.getCacheAccessStrategy().evict( ck );
		}

		String previousFetchProfile = this.getFetchProfile();
		Object result = null;
		try {
			this.setFetchProfile( "refresh" );
			result = persister.load( id, entity, lockMode, this );
		}
		finally {
			this.setFetchProfile( previousFetchProfile );
		}
		UnresolvableObjectException.throwIfNull( result, id, persister.getEntityName() );
	}
 

import org.hibernate.cache.spi.CacheKey; //导入依赖的package包/类
/**
 * If the class to be loaded has been configured with a cache, then lock
 * given id in that cache and then perform the load.
 *
 * @param event The initiating load request event
 * @param persister The persister corresponding to the entity to be loaded
 * @param keyToLoad The key of the entity to be loaded
 * @param options The defined load options
 * @param source The originating session
 *
 * @return The loaded entity
 *
 * @throws HibernateException
 */
protected Object lockAndLoad(
		final LoadEvent event,
		final EntityPersister persister,
		final EntityKey keyToLoad,
		final LoadEventListener.LoadType options,
		final SessionImplementor source) {
	SoftLock lock = null;
	final CacheKey ck;
	if ( persister.hasCache() ) {
		ck = source.generateCacheKey(
				event.getEntityId(),
				persister.getIdentifierType(),
				persister.getRootEntityName()
		);
		lock = persister.getCacheAccessStrategy().lockItem( ck, null );
	}
	else {
		ck = null;
	}

	Object entity;
	try {
		entity = load( event, persister, keyToLoad, options );
	}
	finally {
		if ( persister.hasCache() ) {
			persister.getCacheAccessStrategy().unlockItem( ck, lock );
		}
	}

	return event.getSession().getPersistenceContext().proxyFor( persister, keyToLoad, entity );
}
 

import org.hibernate.cache.spi.CacheKey; //导入依赖的package包/类
@Override
public void doAfterTransactionCompletion(boolean success, SessionImplementor session) throws HibernateException {
	if ( getPersister().hasCache() ) {
		final CacheKey ck = getSession().generateCacheKey(
				getId(),
				getPersister().getIdentifierType(),
				getPersister().getRootEntityName()
		);
		getPersister().getCacheAccessStrategy().unlockItem( ck, lock );
	}
	postCommitDelete( success );
}
 

import org.hibernate.cache.spi.CacheKey; //导入依赖的package包/类
private boolean cacheInsert(EntityPersister persister, CacheKey ck) {
	try {
		getSession().getEventListenerManager().cachePutStart();
		return persister.getCacheAccessStrategy().insert( ck, cacheEntry, version );
	}
	finally {
		getSession().getEventListenerManager().cachePutEnd();
	}
}
 

import org.hibernate.cache.spi.CacheKey; //导入依赖的package包/类
@Override
public void doAfterTransactionCompletion(boolean success, SessionImplementor session) throws HibernateException {
	final EntityPersister persister = getPersister();
	if ( success && isCachePutEnabled( persister, getSession() ) ) {
		final CacheKey ck = getSession().generateCacheKey( getId(), persister.getIdentifierType(), persister.getRootEntityName() );
		final boolean put = cacheAfterInsert( persister, ck );

		if ( put && getSession().getFactory().getStatistics().isStatisticsEnabled() ) {
			getSession().getFactory().getStatisticsImplementor()
					.secondLevelCachePut( getPersister().getCacheAccessStrategy().getRegion().getName() );
		}
	}
	postCommitInsert( success );
}
 

import org.hibernate.cache.spi.CacheKey; //导入依赖的package包/类
private boolean cacheAfterInsert(EntityPersister persister, CacheKey ck) {
	try {
		getSession().getEventListenerManager().cachePutStart();
		return persister.getCacheAccessStrategy().afterInsert( ck, cacheEntry, version );
	}
	finally {
		getSession().getEventListenerManager().cachePutEnd();
	}
}
 

import org.hibernate.cache.spi.CacheKey; //导入依赖的package包/类
protected final void evict() throws CacheException {
	if ( persister.hasCache() ) {
		final CacheKey ck = session.generateCacheKey(
				key, 
				persister.getKeyType(), 
				persister.getRole()
		);
		persister.getCacheAccessStrategy().remove( ck );
	}
}