/** * Run a task defined by the {@link Runnable} instance with a {@link CachingProvider} making sure * that the caching provider is closed after use. * * @param r task to execute with caching provider */ public static void withCachingProvider(JCacheRunnable r) { ClassLoader tccl = Thread.currentThread().getContextClassLoader(); CachingProvider p = Caching.getCachingProvider(new TestClassLoader(tccl)); try { r.run(p); } finally { p.close(); } }
@Bean public JCacheCacheManager cacheManager() { System.out.println("hoge"); CacheManager cacheManager = Caching.getCachingProvider().getCacheManager(); MutableConfiguration<Object, Domain> configuration = new MutableConfiguration<>(); configuration.setExpiryPolicyFactory(new SampleExpiryFactory()); configuration.setStoreByValue(false); cacheManager.createCache("domainCache", configuration); return new JCacheCacheManager(cacheManager); }
@Test public void testCacheLoader() { final CacheLoader<String, Integer> cacheLoader = new CacheLoader<String, Integer>() { @Override public Integer load(String key) throws CacheLoaderException { return Integer.valueOf(key); } @Override public Map<String, Integer> loadAll(Iterable<? extends String> keys) throws CacheLoaderException { Map<String, Integer> map = new HashMap<>(); for (String key : keys) { map.put(key, Integer.valueOf(key)); } return map; } }; try (CachingProvider cachingProvider = Caching.getCachingProvider(GuavaCachingProvider.class.getName())) { CacheManager cacheManager = cachingProvider.getCacheManager(); MutableConfiguration<String, Integer> custom = new MutableConfiguration<>(); custom.setStoreByValue(false); custom.setTypes(String.class, Integer.class); custom.setReadThrough(true); custom.setCacheLoaderFactory( new Factory<CacheLoader<String, Integer>>() { @Override public CacheLoader<String, Integer> create() { return cacheLoader; } }); Cache<String, Integer> loadingCache = cacheManager.createCache("loadingCache", custom); assertEquals(Integer.valueOf(1), loadingCache.get("1")); assertEquals(Integer.valueOf(2), loadingCache.get("2")); assertEquals(Integer.valueOf(3), loadingCache.get("3")); Set<String> keys = Sets.newHashSet("4", "5", "6"); Map<String, Integer> map = loadingCache.getAll(keys); assertEquals(3, map.size()); assertEquals(Integer.valueOf(4), map.get("4")); assertEquals(Integer.valueOf(5), map.get("5")); assertEquals(Integer.valueOf(6), map.get("6")); } }
@Test public void testWithoutEhcacheExplicitDependencyCanSpecifyXML() throws Exception { // tag::jsr107UsingXMLConfigExample[] CachingProvider cachingProvider = Caching.getCachingProvider(); CacheManager manager = cachingProvider.getCacheManager( // <1> getClass().getResource("/org/ehcache/docs/ehcache-jsr107-config.xml").toURI(), // <2> getClass().getClassLoader()); // <3> Cache<Long, Product> readyCache = manager.getCache("ready-cache", Long.class, Product.class); // <4> // end::jsr107UsingXMLConfigExample[] assertThat(readyCache, notNullValue()); }
@Test public void testJCacheGettingStarted() { try (CachingProvider provider = Caching.getCachingProvider(); CacheManager manager = provider.getCacheManager(); Cache<String, String> cache = manager.createCache("testCache", new MutableConfiguration<>())) { cache.put("key", "value"); assertThat(cache.get("key")).isEqualTo("value"); cache.remove("key"); assertThat(cache.get("key")).isNull(); } }
@Test public void hazelcastAsJCacheWithCaches() { String cachingProviderFqn = HazelcastCachingProvider.class.getName(); try { load( DefaultCacheConfiguration.class, "spring.cache.type=jcache", "spring.cache.jcache.provider=" + cachingProviderFqn, "spring.cache.cacheNames[0]=foo", "spring.cache.cacheNames[1]=bar"); JCacheCacheManager cacheManager = validateCacheManager(JCacheCacheManager.class); assertThat(cacheManager.getCacheNames(), containsInAnyOrder("foo", "bar")); assertThat(cacheManager.getCacheNames(), hasSize(2)); } finally { Caching.getCachingProvider(cachingProviderFqn).close(); } }
@Test public void testCacheExpired() throws Exception { Configuration<String, String> configuration = new MutableConfiguration<String, String>() .setExpiryPolicyFactory( AccessedExpiryPolicy.factoryOf(new Duration(TimeUnit.SECONDS, 3))); try (CachingProvider provider = Caching.getCachingProvider(); CacheManager manager = provider.getCacheManager(); Cache<String, String> cache = manager.createCache("testCache", configuration)) { cache.put("key1", "value1"); cache.put("key2", "value2"); TimeUnit.SECONDS.sleep(1); cache.get("key2"); TimeUnit.SECONDS.sleep(2); assertThat(cache.get("key1")).isNull(); assertThat(cache.get("key2")).isEqualTo("value2"); } }
@Ignore @Test public void testWithHazelcastConfiguration() throws Exception { // wrong use!! ClassLoader classLoader = Thread.currentThread().getContextClassLoader(); URI uri = classLoader.getResource("hazelcast-jcache.xml").toURI(); try (CachingProvider provider = Caching.getCachingProvider(); CacheManager manager = provider.getCacheManager(uri, classLoader); Cache<String, String> cache = manager.getCache("testCache")) { cache.put("key1", "value1"); cache.put("key2", "value2"); TimeUnit.SECONDS.sleep(1); cache.get("key2"); TimeUnit.SECONDS.sleep(2); assertThat(cache.get("key1")).isNull(); assertThat(cache.get("key2")).isEqualTo("value2"); } }
@Before public void setUp() throws Exception { cachingProvider = Caching.getCachingProvider(); cacheManager = cachingProvider.getCacheManager(); }
protected CachingProvider getCachingProvider() { return Caching.getCachingProvider(); }
/** * Instantiates a new caching attributes principal factory. * * @param config the config * @param cacheProviderFullClassName the cache provider full class name */ private CachingPrincipalAttributesRepository( final MutableConfiguration<String, Map<String, Object>> config, final String cacheProviderFullClassName) { this(config, Caching.getCachingProvider(cacheProviderFullClassName).getCacheManager()); }
@Test(timeout = 5000L) public void testCacheLoaderAsyncLoadAll() throws InterruptedException { final AtomicInteger loads = new AtomicInteger(); final CacheLoader<String, Integer> cacheLoader = new CacheLoader<String, Integer>() { @Override public Integer load(String key) throws CacheLoaderException { loads.incrementAndGet(); return Integer.valueOf(key); } @Override public Map<String, Integer> loadAll(Iterable<? extends String> keys) throws CacheLoaderException { throw new UnsupportedOperationException("Not supported yet."); } }; final AtomicBoolean completed = new AtomicBoolean(false); final CompletionListener completionListener = new CompletionListener() { @Override public void onCompletion() { completed.set(true); } @Override public void onException(Exception e) { System.err.println(e); } }; try (CachingProvider cachingProvider = Caching.getCachingProvider(GuavaCachingProvider.class.getName())) { CacheManager cacheManager = cachingProvider.getCacheManager(); MutableConfiguration<String, Integer> custom = new MutableConfiguration<>(); custom.setStoreByValue(false); custom.setTypes(String.class, Integer.class); custom.setReadThrough(true); custom.setCacheLoaderFactory( new Factory<CacheLoader<String, Integer>>() { @Override public CacheLoader<String, Integer> create() { return cacheLoader; } }); Cache<String, Integer> loadingCache = cacheManager.createCache("loadingCache", custom); loadingCache.put("1", 1); loadingCache.put("2", 2); loadingCache.put("3", 3); Set<String> keys = Sets.newHashSet("1", "2", "3", "4", "5", "6"); loadingCache.loadAll(keys, false, completionListener); while (!completed.get()) { Thread.sleep(250); } assertEquals(3, loads.getAndSet(0)); completed.set(false); loadingCache.loadAll(keys, true, completionListener); while (!completed.get()) { Thread.sleep(250); } assertEquals(6, loads.get()); assertEquals(Integer.valueOf(1), loadingCache.getAndRemove("1")); assertEquals(Integer.valueOf(2), loadingCache.getAndRemove("2")); assertEquals(Integer.valueOf(3), loadingCache.getAndRemove("3")); assertEquals(Integer.valueOf(4), loadingCache.getAndRemove("4")); assertEquals(Integer.valueOf(5), loadingCache.getAndRemove("5")); assertEquals(Integer.valueOf(6), loadingCache.getAndRemove("6")); } }
@Override public void initialize(Class<K> keyClass, Class<T> persistentClass, Properties properties) { super.initialize(keyClass, persistentClass, properties); CachingProvider cachingProvider = Caching.getCachingProvider(properties.getProperty(GORA_DEFAULT_JCACHE_PROVIDER_KEY)); if (properties.getProperty(JCACHE_CACHE_NAMESPACE_PROPERTY_KEY) != null) { goraCacheNamespace = properties.getProperty(JCACHE_CACHE_NAMESPACE_PROPERTY_KEY); } try { this.persistentDataStore = DataStoreFactory.getDataStore(keyClass, persistentClass, new Configuration()); } catch (GoraException ex) { LOG.error("Couldn't initialize persistent DataStore.", ex); } if (properties .getProperty(GORA_DEFAULT_JCACHE_PROVIDER_KEY) .contains(HAZELCAST_SERVER_CACHE_PROVIDER_IDENTIFIER)) { Config config = new ClasspathXmlConfig(properties.getProperty(GORA_DEFAULT_JCACHE_HAZELCAST_CONFIG_KEY)); hazelcastInstance = Hazelcast.newHazelcastInstance(config); } else { try { ClientConfig config = new XmlClientConfigBuilder( properties.getProperty(GORA_DEFAULT_JCACHE_HAZELCAST_CONFIG_KEY)) .build(); hazelcastInstance = HazelcastClient.newHazelcastClient(config); } catch (IOException ex) { LOG.error("Couldn't locate the client side cache provider configuration.", ex); } } Properties providerProperties = new Properties(); providerProperties.setProperty( HazelcastCachingProvider.HAZELCAST_INSTANCE_NAME, hazelcastInstance.getName()); try { manager = cachingProvider.getCacheManager(new URI(goraCacheNamespace), null, providerProperties); } catch (URISyntaxException ex) { LOG.error("Couldn't initialize cache manager to bounded hazelcast instance.", ex); manager = cachingProvider.getCacheManager(); } if (((properties.getProperty(JCACHE_AUTO_CREATE_CACHE_PROPERTY_KEY) != null) && Boolean.valueOf(properties.getProperty(JCACHE_AUTO_CREATE_CACHE_PROPERTY_KEY))) || ((manager.getCache(super.getPersistentClass().getSimpleName(), keyClass, persistentClass) == null))) { cacheEntryList = new ConcurrentSkipListSet<>(); cacheConfig = new CacheConfig<K, T>(); cacheConfig.setTypes(keyClass, persistentClass); if (properties.getProperty(JCACHE_READ_THROUGH_PROPERTY_KEY) != null) { cacheConfig.setReadThrough( Boolean.valueOf(properties.getProperty(JCACHE_READ_THROUGH_PROPERTY_KEY))); } else { cacheConfig.setReadThrough(true); } if (properties.getProperty(JCACHE_WRITE_THROUGH_PROPERTY_KEY) != null) { cacheConfig.setWriteThrough( Boolean.valueOf(properties.getProperty(JCACHE_WRITE_THROUGH_PROPERTY_KEY))); } else { cacheConfig.setWriteThrough(true); } if (properties.getProperty(JCACHE_STORE_BY_VALUE_PROPERTY_KEY) != null) { cacheConfig.setStoreByValue( Boolean.valueOf(properties.getProperty(JCACHE_STORE_BY_VALUE_PROPERTY_KEY))); } if (properties.getProperty(JCACHE_STATISTICS_PROPERTY_KEY) != null) { cacheConfig.setStatisticsEnabled( Boolean.valueOf(properties.getProperty(JCACHE_STATISTICS_PROPERTY_KEY))); } if (properties.getProperty(JCACHE_MANAGEMENT_PROPERTY_KEY) != null) { cacheConfig.setStatisticsEnabled( Boolean.valueOf(properties.getProperty(JCACHE_MANAGEMENT_PROPERTY_KEY))); } if (properties.getProperty(JCACHE_EVICTION_POLICY_PROPERTY_KEY) != null) { cacheConfig .getEvictionConfig() .setEvictionPolicy( EvictionPolicy.valueOf( properties.getProperty(JCACHE_EVICTION_POLICY_PROPERTY_KEY))); } if (properties.getProperty(JCACHE_EVICTION_MAX_SIZE_POLICY_PROPERTY_KEY) != null) { cacheConfig .getEvictionConfig() .setMaximumSizePolicy( EvictionConfig.MaxSizePolicy.valueOf( properties.getProperty(JCACHE_EVICTION_MAX_SIZE_POLICY_PROPERTY_KEY))); } if (properties.getProperty(JCACHE_EVICTION_SIZE_PROPERTY_KEY) != null) { cacheConfig .getEvictionConfig() .setSize(Integer.valueOf(properties.getProperty(JCACHE_EVICTION_SIZE_PROPERTY_KEY))); } if (properties.getProperty(JCACHE_EXPIRE_POLICY_PROPERTY_KEY) != null) { String expiryPolicyIdentifier = properties.getProperty(JCACHE_EXPIRE_POLICY_PROPERTY_KEY); if (expiryPolicyIdentifier.equals(JCACHE_ACCESSED_EXPIRY_IDENTIFIER)) { cacheConfig.setExpiryPolicyFactory( FactoryBuilder.factoryOf( new AccessedExpiryPolicy( new Duration( TimeUnit.SECONDS, Integer.valueOf( properties.getProperty( JCACHE_EXPIRE_POLICY_DURATION_PROPERTY_KEY)))))); } else if (expiryPolicyIdentifier.equals(JCACHE_CREATED_EXPIRY_IDENTIFIER)) { cacheConfig.setExpiryPolicyFactory( FactoryBuilder.factoryOf( new CreatedExpiryPolicy( new Duration( TimeUnit.SECONDS, Integer.valueOf( properties.getProperty( JCACHE_EXPIRE_POLICY_DURATION_PROPERTY_KEY)))))); } else if (expiryPolicyIdentifier.equals(JCACHE_MODIFIED_EXPIRY_IDENTIFIER)) { cacheConfig.setExpiryPolicyFactory( FactoryBuilder.factoryOf( new ModifiedExpiryPolicy( new Duration( TimeUnit.SECONDS, Integer.valueOf( properties.getProperty( JCACHE_EXPIRE_POLICY_DURATION_PROPERTY_KEY)))))); } else if (expiryPolicyIdentifier.equals(JCACHE_TOUCHED_EXPIRY_IDENTIFIER)) { cacheConfig.setExpiryPolicyFactory( FactoryBuilder.factoryOf( new TouchedExpiryPolicy( new Duration( TimeUnit.SECONDS, Integer.valueOf( properties.getProperty( JCACHE_EXPIRE_POLICY_DURATION_PROPERTY_KEY)))))); } } if (properties.getProperty(HAZELCAST_CACHE_IN_MEMORY_FORMAT_PROPERTY_KEY) != null) { String inMemoryFormat = properties.getProperty(HAZELCAST_CACHE_IN_MEMORY_FORMAT_PROPERTY_KEY); if (inMemoryFormat.equals(HAZELCAST_CACHE_BINARY_IN_MEMORY_FORMAT_IDENTIFIER) || inMemoryFormat.equals(HAZELCAST_CACHE_OBJECT_IN_MEMORY_FORMAT_IDENTIFIER) || inMemoryFormat.equals(HAZELCAST_CACHE_NATIVE_IN_MEMORY_FORMAT_IDENTIFIER)) { cacheConfig.setInMemoryFormat(InMemoryFormat.valueOf(inMemoryFormat)); } } cacheConfig.setCacheLoaderFactory( JCacheCacheFactoryBuilder.factoryOfCacheLoader( this.persistentDataStore, keyClass, persistentClass)); cacheConfig.setCacheWriterFactory( JCacheCacheFactoryBuilder.factoryOfCacheWriter( this.persistentDataStore, keyClass, persistentClass)); cache = manager.createCache(persistentClass.getSimpleName(), cacheConfig).unwrap(ICache.class); } else { cache = manager .getCache(super.getPersistentClass().getSimpleName(), keyClass, persistentClass) .unwrap(ICache.class); this.populateLocalCacheEntrySet(cache); } cache.registerCacheEntryListener( new MutableCacheEntryListenerConfiguration<>( JCacheCacheFactoryBuilder.factoryOfEntryListener( new JCacheCacheEntryListener<K, T>(cacheEntryList)), null, true, true)); LOG.info("JCache Gora datastore initialized successfully."); }