@Bean public EhCacheManagerFactoryBean ehCacheManagerFactory() { EhCacheManagerFactoryBean cacheManagerFactoryBean = new EhCacheManagerFactoryBean(); cacheManagerFactoryBean.setConfigLocation(new ClassPathResource("ehcache.xml")); cacheManagerFactoryBean.setShared(true); return cacheManagerFactoryBean; }
public void testCacheManagerFromConfigFile() { EhCacheManagerFactoryBean cacheManagerFb = new EhCacheManagerFactoryBean(); cacheManagerFb.setConfigLocation(new ClassPathResource("testEhcache.xml", getClass())); cacheManagerFb.setCacheManagerName("myCacheManager"); cacheManagerFb.afterPropertiesSet(); try { CacheManager cm = cacheManagerFb.getObject(); assertTrue("Correct number of caches loaded", cm.getCacheNames().length == 1); Cache myCache1 = cm.getCache("myCache1"); assertFalse("myCache1 is not eternal", myCache1.getCacheConfiguration().isEternal()); assertTrue("myCache1.maxElements == 300", myCache1.getCacheConfiguration().getMaxEntriesLocalHeap() == 300); } finally { cacheManagerFb.destroy(); } }
/** * EhCache的配置 */ @Bean public EhCacheManagerFactoryBean ehcache() { EhCacheManagerFactoryBean ehCacheManagerFactoryBean = new EhCacheManagerFactoryBean(); ehCacheManagerFactoryBean.setConfigLocation(new ClassPathResource("ehcache.xml")); return ehCacheManagerFactoryBean; } }
@Test public void testBlankCacheManager() { EhCacheManagerFactoryBean cacheManagerFb = new EhCacheManagerFactoryBean(); cacheManagerFb.setCacheManagerName("myCacheManager"); assertEquals(CacheManager.class, cacheManagerFb.getObjectType()); assertTrue("Singleton property", cacheManagerFb.isSingleton()); cacheManagerFb.afterPropertiesSet(); try { CacheManager cm = cacheManagerFb.getObject(); assertTrue("Loaded CacheManager with no caches", cm.getCacheNames().length == 0); Cache myCache1 = cm.getCache("myCache1"); assertTrue("No myCache1 defined", myCache1 == null); } finally { cacheManagerFb.destroy(); } }
@Bean public EhCacheManagerFactoryBean ehcacheTicketCacheManager() { val cache = casProperties.getTicket().getRegistry().getEhcache(); val bean = new EhCacheManagerFactoryBean(); cache.getSystemProps().forEach((key, value) -> System.setProperty(key, value)); val configExists = ResourceUtils.doesResourceExist(cache.getConfigLocation()); if (configExists) { bean.setConfigLocation(cache.getConfigLocation()); } else { LOGGER.warn("Ehcache configuration file [{}] cannot be found", cache.getConfigLocation()); } bean.setShared(cache.isShared()); bean.setCacheManagerName(cache.getCacheManagerName()); return bean; }
@Test public void testEhCacheFactoryBeanWithBlockingCache() { EhCacheManagerFactoryBean cacheManagerFb = new EhCacheManagerFactoryBean(); cacheManagerFb.afterPropertiesSet(); try { CacheManager cm = cacheManagerFb.getObject(); EhCacheFactoryBean cacheFb = new EhCacheFactoryBean(); cacheFb.setCacheManager(cm); cacheFb.setCacheName("myCache1"); cacheFb.setBlocking(true); assertEquals(cacheFb.getObjectType(), BlockingCache.class); cacheFb.afterPropertiesSet(); Ehcache myCache1 = cm.getEhcache("myCache1"); assertTrue(myCache1 instanceof BlockingCache); } finally { cacheManagerFb.destroy(); } }
/** * 缓存管理器 使用Ehcache实现 */ @Bean public CacheManager getCacheShiroManager(EhCacheManagerFactoryBean ehcache) { EhCacheManager ehCacheManager = new EhCacheManager(); ehCacheManager.setCacheManager(ehcache.getObject()); return ehCacheManager; }
@Override public void afterPropertiesSet() { List<Resource> temp = new ArrayList<>(); if (mergedCacheConfigLocations != null && !mergedCacheConfigLocations.isEmpty()) { for (String location : mergedCacheConfigLocations) { temp.add(applicationContext.getResource(location)); } } if (configLocations != null && !configLocations.isEmpty()) { for (Resource resource : configLocations) { temp.add(resource); } } try { MergeXmlConfigResource merge = new MergeXmlConfigResource(); ResourceInputStream[] sources = new ResourceInputStream[temp.size()]; int j=0; for (Resource resource : temp) { sources[j] = new ResourceInputStream(resource.getInputStream(), resource.getURL().toString()); j++; } setConfigLocation(merge.getMergedConfigResource(sources)); } catch (Exception e) { throw new FatalBeanException("Unable to merge cache locations", e); } super.afterPropertiesSet(); }
@Override public void destroy() { super.destroy(); try { CacheManager cacheManager = getObject(); Field cacheManagerTimer = CacheManager.class.getDeclaredField("cacheManagerTimer"); cacheManagerTimer.setAccessible(true); Object failSafeTimer = cacheManagerTimer.get(cacheManager); Field timer = failSafeTimer.getClass().getDeclaredField("timer"); timer.setAccessible(true); Object time = timer.get(failSafeTimer); Field thread = time.getClass().getDeclaredField("thread"); thread.setAccessible(true); Thread item = (Thread) thread.get(time); item.setContextClassLoader(Thread.currentThread().getContextClassLoader().getParent()); } catch (NoSuchFieldException e) { throw new RuntimeException(e); } catch (IllegalAccessException e) { throw new RuntimeException(e); } }
@Bean(name = "ehCacheManagerFactoryBean") public EhCacheManagerFactoryBean ehCacheManagerFactoryBean() { EhCacheManagerFactoryBean ehCacheManagerFactoryBean = new EhCacheManagerFactoryBean(); ClassPathResource classPathResource = new ClassPathResource("cache/ehcache-local.xml"); ehCacheManagerFactoryBean.setConfigLocation(classPathResource); return ehCacheManagerFactoryBean; }
@Test public void testAcceptExistingCacheManager() { EhCacheManagerFactoryBean cacheManagerFb = new EhCacheManagerFactoryBean(); cacheManagerFb.setCacheManagerName("myCacheManager"); assertEquals(CacheManager.class, cacheManagerFb.getObjectType()); assertTrue("Singleton property", cacheManagerFb.isSingleton()); cacheManagerFb.afterPropertiesSet(); try { CacheManager cm = cacheManagerFb.getObject(); assertTrue("Loaded CacheManager with no caches", cm.getCacheNames().length == 0); Cache myCache1 = cm.getCache("myCache1"); assertTrue("No myCache1 defined", myCache1 == null); EhCacheManagerFactoryBean cacheManagerFb2 = new EhCacheManagerFactoryBean(); cacheManagerFb2.setCacheManagerName("myCacheManager"); cacheManagerFb2.setAcceptExisting(true); cacheManagerFb2.afterPropertiesSet(); CacheManager cm2 = cacheManagerFb2.getObject(); assertSame(cm, cm2); cacheManagerFb2.destroy(); } finally { cacheManagerFb.destroy(); } }
@Test public void testEhCacheFactoryBeanWithSelfPopulatingCache() { EhCacheManagerFactoryBean cacheManagerFb = new EhCacheManagerFactoryBean(); cacheManagerFb.afterPropertiesSet(); try { CacheManager cm = cacheManagerFb.getObject(); EhCacheFactoryBean cacheFb = new EhCacheFactoryBean(); cacheFb.setCacheManager(cm); cacheFb.setCacheName("myCache1"); cacheFb.setCacheEntryFactory(key -> key); assertEquals(cacheFb.getObjectType(), SelfPopulatingCache.class); cacheFb.afterPropertiesSet(); Ehcache myCache1 = cm.getEhcache("myCache1"); assertTrue(myCache1 instanceof SelfPopulatingCache); assertEquals("myKey1", myCache1.get("myKey1").getObjectValue()); } finally { cacheManagerFb.destroy(); } }
@Bean public EhCacheCacheManager ehCacheCacheManager() { EhCacheCacheManager cacheManager = new EhCacheCacheManager(); cacheManager.setCacheManager(ehCacheManagerFactory().getObject()); cacheManager.setTransactionAware(true); return cacheManager; } }
@Override public void afterPropertiesSet() { super.afterPropertiesSet(); //Now look for any custom configuration. CacheManager cm = (CacheManager) this.getObject(); if (cm != null) { String cacheNames[]= cm.getCacheNames(); //Check for old configuration properties. for (String cacheName:cacheNames) { if(serverConfigurationService.getString(cacheName) == null) { log.warn("Old cache configuration "+ cacheName+ " must be changed to memory."+ cacheName); } String config = serverConfigurationService.getString("memory."+ cacheName); if (config != null && config.length() > 0) { log.info("Found configuration override for cache: "+ cacheName+ " of: "+ config); Cache cache = cm.getCache(cacheName); if (cache != null) { new CacheInitializer().configure(config).initialize(cache.getCacheConfiguration()); } } } } } }
@Override public void destroy() { try { super.destroy(); } catch (IllegalStateException e) { if (e.getMessage().contains("Shutdown in progress")) { // ignore. It's because we're closing the application context // during shutdown. if (log.isDebugEnabled()) { log.debug("Ignoring \"Shutdown in progress\" error."); } } else { throw e; } } }
@Bean public EhCacheManagerFactoryBean ehCacheManagerFactoryBean() { EhCacheManagerFactoryBean cacheManagerFactoryBean = new EhCacheManagerFactoryBean(); cacheManagerFactoryBean.setConfigLocation(new ClassPathResource("ehcache.xml")); // 设置cache的基地是Spring独立用,还是与hibernate的Ehcache共享 cacheManagerFactoryBean.setShared(true); return cacheManagerFactoryBean; }
/** * EhCache的配置 */ @Bean public EhCacheManagerFactoryBean ehcacheManager() { EhCacheManagerFactoryBean ehCacheManagerFactoryBean = new EhCacheManagerFactoryBean(); Resource resource = new ClassPathResource("ehcache.xml"); ehCacheManagerFactoryBean.setConfigLocation(resource); return ehCacheManagerFactoryBean; }
assertTrue("Singleton property", cacheFb.isSingleton()); if (useCacheManagerFb) { cacheManagerFb = new EhCacheManagerFactoryBean(); cacheManagerFb.setConfigLocation(new ClassPathResource("testEhcache.xml", getClass())); cacheManagerFb.setCacheManagerName("cache"); cacheManagerFb.afterPropertiesSet(); cacheManagerFbInitialized = true; cacheFb.setCacheManager(cacheManagerFb.getObject()); cacheFb.setCacheManager(cacheManagerFb.getObject()); cacheFb.setCacheManager(cacheManagerFb.getObject()); cacheManagerFb.destroy();
@Test public void testCacheManagerConflict() { EhCacheManagerFactoryBean cacheManagerFb = new EhCacheManagerFactoryBean(); cacheManagerFb.setCacheManagerName("myCacheManager"); assertEquals(CacheManager.class, cacheManagerFb.getObjectType()); assertTrue("Singleton property", cacheManagerFb.isSingleton()); cacheManagerFb.afterPropertiesSet(); try { CacheManager cm = cacheManagerFb.getObject(); assertTrue("Loaded CacheManager with no caches", cm.getCacheNames().length == 0); Cache myCache1 = cm.getCache("myCache1"); assertTrue("No myCache1 defined", myCache1 == null); EhCacheManagerFactoryBean cacheManagerFb2 = new EhCacheManagerFactoryBean(); cacheManagerFb2.setCacheManagerName("myCacheManager"); cacheManagerFb2.afterPropertiesSet(); fail("Should have thrown CacheException because of naming conflict"); } catch (CacheException ex) { // expected } finally { cacheManagerFb.destroy(); } }
@Test public void testEhCacheFactoryBeanWithUpdatingSelfPopulatingCache() { EhCacheManagerFactoryBean cacheManagerFb = new EhCacheManagerFactoryBean(); cacheManagerFb.afterPropertiesSet(); try { CacheManager cm = cacheManagerFb.getObject(); EhCacheFactoryBean cacheFb = new EhCacheFactoryBean(); cacheFb.setCacheManager(cm); cacheFb.setCacheName("myCache1"); cacheFb.setCacheEntryFactory(new UpdatingCacheEntryFactory() { @Override public Object createEntry(Object key) { return key; } @Override public void updateEntryValue(Object key, Object value) { } }); assertEquals(cacheFb.getObjectType(), UpdatingSelfPopulatingCache.class); cacheFb.afterPropertiesSet(); Ehcache myCache1 = cm.getEhcache("myCache1"); assertTrue(myCache1 instanceof UpdatingSelfPopulatingCache); assertEquals("myKey1", myCache1.get("myKey1").getObjectValue()); } finally { cacheManagerFb.destroy(); } }