import javax.persistence.Cache; //导入依赖的package包/类
/**
 * Evicts all second-level cache elements which could get stale on entity updates
 */
protected void evictSecondLevelCache() {
    Cache cache = entityManager.getEntityManagerFactory().getCache();

    // If this DAO is cached, evict the collection regions, as we don't know which ones will point out to it
    if (hasCache) {
        synchronized (cache) {
            // We must invalidate all collection regions, as we don't know which other entities have many-to-many relationships with this one
            cache.evict(getEntityType());
        }
    }

    // Evict the query cache region
    if (queryCacheRegion != null) {
        synchronized (cache) {
            cache.evict(getEntityType());
        }
    }
}
 

import javax.persistence.Cache; //导入依赖的package包/类
@Test
public void test() {
    Cache cache = entityManager.getEntityManagerFactory().getCache();
    cache.evictAll();
    Statistics statistics = ((Session)(entityManager.getDelegate())).getSessionFactory().getStatistics();
    statistics.clear();
    
    CommonCourt commonCourt = testPersistenceObjectFactory.createCcCourt(CommonCourtType.APPEAL);
    
    commonCourtRepository.findOne(commonCourt.getId());
    commonCourtRepository.findOne(commonCourt.getId());

    Assert.assertTrue(cache.contains(CommonCourt.class, commonCourt.getId()));
    Assert.assertTrue(cache.contains(CommonCourtDivision.class, commonCourt.getDivisions().get(0).getId()));
    Assert.assertTrue(cache.contains(CommonCourtDivision.class, commonCourt.getDivisions().get(1).getId()));
    cache.evict(CommonCourt.class);
    cache.evict(CommonCourtDivision.class);
    Assert.assertFalse(cache.contains(CommonCourt.class, commonCourt.getId()));
    Assert.assertFalse(cache.contains(CommonCourtDivision.class, commonCourt.getDivisions().get(0).getId()));
    Assert.assertFalse(cache.contains(CommonCourtDivision.class, commonCourt.getDivisions().get(1).getId()));

    Assert.assertEquals(5, statistics.getSecondLevelCachePutCount()); // 1 commonCourt + 2 ccDivision + 2 ccDivisionType
    Assert.assertEquals(2, statistics.getSecondLevelCacheHitCount());
    Assert.assertEquals(0, statistics.getSecondLevelCacheMissCount());
    
}
 

import javax.persistence.Cache; //导入依赖的package包/类
@Test
public void createQueryCacheAndEvictAllThenRetry() throws Exception {
	List<Author> beforeResults = getAuthorsWithQuery("Author query", "어느나라");

	log.warn("#####################################################################");

	HibernateEntityManagerFactory entityManagerFactory = (HibernateEntityManagerFactory) EntityTestUtils.getEntityManagerFactory();
	org.hibernate.Cache cache = entityManagerFactory.getSessionFactory().getCache();
	cache.evictEntityRegions();
	cache.evictQueryRegions();
	cache.evictDefaultQueryRegion();
	cache.evictCollectionRegions();

	log.warn("just eviected all.");
	List<Author> againResults = getAuthorsWithQuery("Author query again after evict all", "어느나라");

	assertThat(againResults).isEqualTo(beforeResults);
	log.warn("#####################################################################");
}
 

import javax.persistence.Cache; //导入依赖的package包/类
public Cache getCache() {
	// TODO : cache the cache reference?
	if ( ! isOpen() ) {
		throw new IllegalStateException("EntityManagerFactory is closed");
	}
	return new JPACache( sessionFactory );
}
 

import javax.persistence.Cache; //导入依赖的package包/类
@Test
public void testRoomsAreCached() {
    Room room = getEntityManager().find(Room.class, WELL_KNOWN_ROOM_ID);

    assertThat(room, is(not(nullValue())));

    Cache cache = getEntityManager().getEntityManagerFactory().getCache();
    assertTrue("Rooms should be cached ", cache.contains(Room.class, room.getId()));
}
 

import javax.persistence.Cache; //导入依赖的package包/类
@Test
public void testTransientRoomsAreNotCached() {
    Room room = new Room("", RoomEquipment.BUDGET);

    Cache cache = getEntityManager().getEntityManagerFactory().getCache();
    assertFalse("Rooms should be cached ", cache.contains(Room.class, room.getId()));
}
 

import javax.persistence.Cache; //导入依赖的package包/类
public static void destroy() {
    if (emf == null) {
        return;
    }

    Cache cache = emf.getCache();
    log.debug("###### EVICT ALL ######");
    cache.evictAll();
    emf.close();
}
 

import javax.persistence.Cache; //导入依赖的package包/类
private void evict(Cache cache, VARSObject entity) {
    try {
        cache.evict(entity.getClass(), entity.getPrimaryKey());
    }
    catch (Exception e) {
        log.info("Failed to evict " + entity + " from cache", e);
    }
}
 

import javax.persistence.Cache; //导入依赖的package包/类
@Override
public Object invoke(Object... args) {
    Cache secondLevelCache = getEntityManagerFactory(args).getCache();
    if (secondLevelCache != null) {
        secondLevelCache.evictAll();
    }
    return null;
}
 

import javax.persistence.Cache; //导入依赖的package包/类
@Override
public Cache getCache() {
   return nativeEntityManagerFactory.getCache();
}
 

import javax.persistence.Cache; //导入依赖的package包/类
@Override
public Cache getCache() {
   return null;
}
 

import javax.persistence.Cache; //导入依赖的package包/类
public Cache getCache() {
    return delegate.getCache();
}
 

import javax.persistence.Cache; //导入依赖的package包/类
public Cache getCache() {
    return null;
}
 

import javax.persistence.Cache; //导入依赖的package包/类
public Cache getCache() {
    throw new UnsupportedOperationException("Not supported.");
}
 

import javax.persistence.Cache; //导入依赖的package包/类
@Override
public Cache getCache() {
    return null;
}
 

import javax.persistence.Cache; //导入依赖的package包/类
public Cache getCache() {
	return CacheDummy.getInstance();
}
 

import javax.persistence.Cache; //导入依赖的package包/类
@Override
public Cache getCache() {
  return null;
}
 

import javax.persistence.Cache; //导入依赖的package包/类
public Cache getCache() {
	return emf.getCache();
}
 

import javax.persistence.Cache; //导入依赖的package包/类
public Cache getCache() {
	return entityManagerFactory.getCache();
}
 

import javax.persistence.Cache; //导入依赖的package包/类
public DAO<T> clearCache() {
	Cache cache = entityManager.getEntityManagerFactory().getCache();
	cache.evict(entityClass);
	return this;
}