diff --git a/src/main/java/org/redisson/spring/cache/CacheConfig.java b/src/main/java/org/redisson/spring/cache/CacheConfig.java new file mode 100644 index 000000000..be35dd5ae --- /dev/null +++ b/src/main/java/org/redisson/spring/cache/CacheConfig.java @@ -0,0 +1,73 @@ +/** + * Copyright 2014 Nikita Koksharov, Nickolay Borbit + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.redisson.spring.cache; + +import java.util.concurrent.TimeUnit; + +public class CacheConfig { + + private long ttl; + + private TimeUnit ttlUnit; + + private long maxIdleTime; + + private TimeUnit maxIdleUnit; + + public CacheConfig() { + } + + public CacheConfig(long ttl, TimeUnit ttlUnit, long maxIdleTime, TimeUnit maxIdleUnit) { + super(); + this.ttl = ttl; + this.ttlUnit = ttlUnit; + this.maxIdleTime = maxIdleTime; + this.maxIdleUnit = maxIdleUnit; + } + + public long getTTL() { + return ttl; + } + + public void setTTL(long ttl) { + this.ttl = ttl; + } + + public TimeUnit getTTLUnit() { + return ttlUnit; + } + + public void setTTLUnit(TimeUnit ttlUnit) { + this.ttlUnit = ttlUnit; + } + + public long getMaxIdleTime() { + return maxIdleTime; + } + + public void setMaxIdleTime(long maxIdleTime) { + this.maxIdleTime = maxIdleTime; + } + + public TimeUnit getMaxIdleUnit() { + return maxIdleUnit; + } + + public void setMaxIdleUnit(TimeUnit maxIdleUnit) { + this.maxIdleUnit = maxIdleUnit; + } + +} diff --git a/src/main/java/org/redisson/spring/cache/RedissonCache.java b/src/main/java/org/redisson/spring/cache/RedissonCache.java index c714025b0..f0c5e584a 100644 --- a/src/main/java/org/redisson/spring/cache/RedissonCache.java +++ b/src/main/java/org/redisson/spring/cache/RedissonCache.java @@ -16,6 +16,7 @@ package org.redisson.spring.cache; import org.redisson.core.RMap; +import org.redisson.core.RMapCache; import org.springframework.cache.Cache; import org.springframework.cache.support.SimpleValueWrapper; @@ -26,7 +27,17 @@ import org.springframework.cache.support.SimpleValueWrapper; */ public class RedissonCache implements Cache { - private final RMap map; + private RMapCache mapCache; + + private RMap map; + + private CacheConfig config; + + public RedissonCache(RMapCache mapCache, CacheConfig config) { + this.mapCache = mapCache; + this.map = mapCache; + this.config = config; + } public RedissonCache(RMap map) { this.map = map; @@ -63,11 +74,20 @@ public class RedissonCache implements Cache { @Override public void put(Object key, Object value) { - map.fastPut(key, value); + if (mapCache != null) { + mapCache.fastPut(key, value, config.getTTL(), config.getTTLUnit(), config.getMaxIdleTime(), config.getMaxIdleUnit()); + } else { + map.fastPut(key, value); + } } public ValueWrapper putIfAbsent(Object key, Object value) { - Object prevValue = map.putIfAbsent(key, value); + Object prevValue; + if (mapCache != null) { + prevValue = mapCache.putIfAbsent(key, value, config.getTTL(), config.getTTLUnit(), config.getMaxIdleTime(), config.getMaxIdleUnit()); + } else { + prevValue = map.putIfAbsent(key, value); + } return toValueWrapper(prevValue); } diff --git a/src/main/java/org/redisson/spring/cache/RedissonCacheManager.java b/src/main/java/org/redisson/spring/cache/RedissonCacheManager.java index c2bcea5a7..5dbb91650 100644 --- a/src/main/java/org/redisson/spring/cache/RedissonCacheManager.java +++ b/src/main/java/org/redisson/spring/cache/RedissonCacheManager.java @@ -17,8 +17,8 @@ package org.redisson.spring.cache; import java.util.Collection; import java.util.Collections; -import java.util.Set; -import java.util.concurrent.ConcurrentHashMap; +import java.util.HashMap; +import java.util.Map; import org.redisson.RedissonClient; import org.springframework.cache.Cache; @@ -31,15 +31,20 @@ import org.springframework.cache.CacheManager; */ public class RedissonCacheManager implements CacheManager { - private final Set cacheNames = Collections.newSetFromMap(new ConcurrentHashMap()); - private RedissonClient redisson; + private Map configMap = new HashMap(); + public RedissonCacheManager() { } - public RedissonCacheManager(RedissonClient redisson) { + public RedissonCacheManager(RedissonClient redisson, Map config) { this.redisson = redisson; + this.configMap = config; + } + + public void setConfig(Map config) { + this.configMap = config; } public void setRedisson(RedissonClient redisson) { @@ -48,13 +53,21 @@ public class RedissonCacheManager implements CacheManager { @Override public Cache getCache(String name) { - cacheNames.add(name); - return new RedissonCache(redisson.getMap(name)); + CacheConfig config = configMap.get(name); + if (config == null) { + config = new CacheConfig(); + configMap.put(name, config); + return new RedissonCache(redisson.getMap(name)); + } + if (config.getMaxIdleTime() == 0 && config.getTTL() == 0) { + return new RedissonCache(redisson.getMap(name)); + } + return new RedissonCache(redisson.getMapCache(name), config); } @Override public Collection getCacheNames() { - return Collections.unmodifiableSet(cacheNames); + return Collections.unmodifiableSet(configMap.keySet()); } } diff --git a/src/test/java/org/redisson/spring/cache/RedissonSpringCacheTest.java b/src/test/java/org/redisson/spring/cache/RedissonSpringCacheTest.java index 29c90a452..0e3e413eb 100644 --- a/src/test/java/org/redisson/spring/cache/RedissonSpringCacheTest.java +++ b/src/test/java/org/redisson/spring/cache/RedissonSpringCacheTest.java @@ -1,10 +1,13 @@ package org.redisson.spring.cache; -import org.assertj.core.api.Assertions; +import static org.assertj.core.api.Assertions.assertThat; + +import java.util.HashMap; +import java.util.Map; +import java.util.concurrent.TimeUnit; + import org.junit.After; -import org.junit.Assert; import org.junit.Before; -import org.junit.BeforeClass; import org.junit.Test; import org.redisson.Redisson; import org.redisson.RedissonClient; @@ -18,7 +21,6 @@ import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.Configuration; import org.springframework.stereotype.Service; -import static org.assertj.core.api.Assertions.*; public class RedissonSpringCacheTest { @@ -87,7 +89,9 @@ public class RedissonSpringCacheTest { @Bean CacheManager cacheManager(RedissonClient redissonClient) { - return new RedissonCacheManager(redissonClient); + Map config = new HashMap(); + config.put("testMap", new CacheConfig(24, TimeUnit.HOURS, 12, TimeUnit.SECONDS)); + return new RedissonCacheManager(redissonClient, config); } }