【项目总结】秒杀系统の关于Redis_redis minevictableidletimemillis-程序员宅基地
技术标签： --------秒杀系统 ☆项目成长 spring整合Redis Redis
spring整合redis配置文件
redis.properties
redis.host=127.0.0.1
redis.port=6379
redis.sentinel.port=26879
redis.pwd=
redis.database=0
redis.timeout=1000
redis.userPool=true
redis.pool.maxIdle=100
redis.pool.minIdle=10
redis.pool.maxTotal=200
redis.pool.maxWaitMillis=10000
redis.pool.minEvictableIdleTimeMillis=300000
redis.pool.numTestsPerEvictionRun=10
redis.pool.timeBetweenEvictionRunsMillis=30000
redis.pool.testOnBorrow=true
redis.pool.testOnReturn=true
redis.pool.testWhileIdle=truespring-redis.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
<context:property-placeholder order="1" location="classpath:redis.properties" ignore-unresolvable="true"/>
<!-- Redis -->
<!--组件扫描，需要添加pom依赖 spring-context -->
<context:component-scan base-package="com.wj.redis" />
<!-- 连接池参数 -->
<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
<property name="maxIdle" value="${redis.pool.maxIdle}" />
<property name="minIdle" value="${redis.pool.minIdle}" />
<property name="maxTotal" value="${redis.pool.maxTotal}" />
<property name="maxWaitMillis" value="${redis.pool.maxWaitMillis}" />
<property name="minEvictableIdleTimeMillis" value="${redis.pool.minEvictableIdleTimeMillis}"></property>
<property name="numTestsPerEvictionRun" value="${redis.pool.numTestsPerEvictionRun}"></property>
<property name="timeBetweenEvictionRunsMillis" value="${redis.pool.timeBetweenEvictionRunsMillis}"></property>
<property name="testOnBorrow" value="${redis.pool.testOnBorrow}" />
<property name="testOnReturn" value="${redis.pool.testOnReturn}" />
<property name="testWhileIdle" value="${redis.pool.testWhileIdle}"></property>
</bean>
<bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
<property name="poolConfig" ref="jedisPoolConfig" />
<property name="hostName" value="${redis.host}" />
<property name="port" value="${redis.port}" />
<property name="password" value="${redis.pwd}" />
<property name="usePool" value="${redis.userPool} " />
<property name="database" value="${redis.database}" />
<property name="timeout" value="${redis.timeout}" />
</bean>
<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
<property name="connectionFactory" ref="jedisConnectionFactory" />
<!-- 序列化方式 建议key/hashKey采用StringRedisSerializer -->
<property name="keySerializer">
<bean
class="org.springframework.data.redis.serializer.StringRedisSerializer" />
</property>
<property name="valueSerializer">
<bean
class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" />
</property>
<property name="hashKeySerializer">
<bean
class="org.springframework.data.redis.serializer.StringRedisSerializer" />
</property>
<property name="hashValueSerializer">
<bean
class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" />
</property>
<!-- 开启REIDS事务支持 -->
<property name="enableTransactionSupport" value="false" />
</bean>
<!-- 对string操作的封装 -->
<bean id="stringRedisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate">
<constructor-arg ref="jedisConnectionFactory" />
<!-- 开启REIDS事务支持 -->
<property name="enableTransactionSupport" value="false" />
</bean>
</beans>redis键
public interface KeyPrefix {
public int expireSeconds();
public String getPrefix();
}public abstract class BasePrefix implements KeyPrefix {
private int expireSeconds;
private String prefix;
public BasePrefix(String prefix) {
this(0, prefix);
}
public BasePrefix(int expireSeconds, String prefix) {
this.expireSeconds = expireSeconds;
this.prefix = prefix;
}
@Override
public int expireSeconds() { //默认0代表永不过期
return expireSeconds;
}
@Override
public String getPrefix() {
String className = getClass().getSimpleName();
return className + ":" + prefix;
}
}public class GoodKey extends BasePrefix {
public static GoodKey goodsList = new GoodKey(120, "gl");
public static GoodKey goodsDetail = new GoodKey(60, "gd");
public static GoodKey seckillGoodsStock = new GoodKey(0, "gs");
private GoodKey(int expireSeconds, String prefix) {
super(expireSeconds, prefix);
}
}public class SeckillKey extends BasePrefix {
private SeckillKey(int expireSeconds, String prefix) {
super(expireSeconds, prefix);
}
public static SeckillKey isGoodsOver = new SeckillKey(0, "go");
public static SeckillKey getSeckillPath = new SeckillKey(60, "sp");
public static SeckillKey getSeckillVerifyCode = new SeckillKey(300, "verifyCode");
}这样做的好处：（Redis可视化工具）
RedisDao
public interface RedisDao {
boolean isEmpty(Object obj);
/**
* 构建缓存key值
*
* @param key 缓存key
* @return
*/
String buildKey(String key);
/**
* 返回缓存的前缀
*
* @return CACHE_PREFIX_FLAG
*/
String getCachePrefix();
/**
* 设置缓存的前缀
*
* @param cachePrefix
*/
void setCachePrefix(String cachePrefix);
/**
* 关闭缓存
*
* @return true:成功 false:失败
*/
boolean close();
/**
* 打开缓存
*
* @return true:存在 false:不存在
*/
boolean openCache();
/**
* 检查缓存是否开启
*
* @return true:已关闭 false:已开启
*/
boolean isClose();
/**
* 判断key值是否存在
*
* @param key 缓存的key
* @return true:存在 false:不存在
*/
boolean hasKey(String key);
/**
* 匹配符合正则的key
*
* @param patternKey
* @return key的集合
*/
Set<String> keys(String patternKey);
/**
* 根据key删除缓存
*
* @param key
* @return true:成功 false:失败
*/
boolean del(String... key);
/**
* 根据key删除缓存
*
* @param key
* @return true:成功 false:失败
*/
boolean delPattern(String key,long id);
/**
* 删除一组key值
*
* @param keys
* @return true:成功 false:失败
*/
boolean del(Set<String> keys);
/**
* 设置过期时间
*
* @param key 缓存key
* @param seconds 过期秒数
* @return true:成功 false:失败
*/
boolean setExp(String key, long seconds);
/**
* 查询过期时间
*
* @param key 缓存key
* @return 秒数
*/
Long getExpire(String key);
/**
* 缓存存入key-value
*
* @param key 缓存键
* @param value 缓存值
* @return true:成功 false:失败
*/
boolean setString(String key,long id, String value);
/**
* 缓存存入key-value
*
* @param key 缓存键
* @param value 缓存值
* @param seconds 秒数
* @return true:成功 false:失败
*/
boolean setString(String key, String value, long seconds);
/**
* 根据key取出String value
*
* @param key 缓存key值
* @return String 缓存的String
*/
String getString(String key,long id);
/**
* 去的缓存中的最大值并+1
*
* @param key 缓存key值
* @return long 缓存中的最大值+1
*/
long incr(String key);
/**
* 缓存中存入序列化的Object对象
*
* @param key 缓存key
* @param obj 存入的序列化对象
* @return true:成功 false:失败
*/
boolean set(String key, Object obj);
/**
* 缓存中存入序列化的Object对象
*
* @param key 缓存key
* @param obj 存入的序列化对象
* @return true:成功 false:失败
*/
boolean setObj(String key,long id, Object obj, long seconds);
/**
* 缓存中存入序列化的Object对象
*
* @param key 缓存key
* @param obj 存入的序列化对象
* @return true:成功 false:失败
*/
boolean setGood(String key,long id, Object obj);
/**
* 取出缓存中存储的序列化对象
*
* @param key 缓存key
* @param clazz 对象类
* @return <T> 序列化对象
*/
<T> T getObj(String key,long id, Class<T> clazz);
/**
* 存入Map数组
*
* @param <T>
* @param key 缓存key
* @param map 缓存map
* @return true:成功 false:失败
*/
<T> boolean setMap(String key, Map<String, T> map);
/**
* 取出缓存的map
*
* @param key 缓存key
* @return map 缓存的map
*/
@SuppressWarnings("rawtypes")
Map getMap(String key);
/**
* 查询缓存的map的集合大小
*
* @param key 缓存key
* @return int 缓存map的集合大小
*/
long getMapSize(String key);
/**
* 根据key以及hashKey取出对应的Object对象
*
* @param key 缓存key
* @param hashKey 对应map的key
* @return object map中的对象
*/
Object getMapKey(String key, String hashKey);
/**
* 取出缓存中map的所有key值
*
* @param key 缓存key
* @return Set<String> map的key值合集
*/
Set<Object> getMapKeys(String key);
/**
* 删除map中指定的key值
*
* @param key 缓存key
* @param hashKey map中指定的hashKey
* @return true:成功 false:失败
*/
boolean delMapKey(String key, String hashKey);
/**
* 存入Map数组
*
* @param <T>
* @param key 缓存key
* @param map 缓存map
* @param seconds 秒数
* @return true:成功 false:失败
*/
<T> boolean setMapExp(String key, Map<String, T> map, long seconds);
/**
* map中加入新的key
*
* @param <T>
* @param key 缓存key
* @param hashKey map的Key值
* @param value map的value值
* @return true:成功 false:失败
*/
<T> boolean addMap(String key, String hashKey, T value);
/**
* 缓存存入List
*
* @param <T>
* @param key 缓存key
* @param list 缓存List
* @return true:成功 false:失败
*/
<T> boolean setList(String key, List<T> list);
/**
* 根据key值取出对应的list合集
*
* @param key 缓存key
* @return List<Object> 缓存中对应的list合集
*/
<V> List<V> getList(String key);
/**
* 根据key值截取对应的list合集
*
* @param key 缓存key
* @param start 开始位置
* @param end 结束位置
* @return
*/
void trimList(String key, int start, int end);
/**
* 取出list合集中指定位置的对象
*
* @param key 缓存key
* @param index 索引位置
* @return Object list指定索引位置的对象
*/
Object getIndexList(String key, int index);
/**
* Object存入List
*
* @param prefix 缓存key
* @param value List中的值
* @return true:成功 false:失败
*/
boolean addList(KeyPrefix prefix, Object value);
/**
* 缓存存入List
*
* @param <T>
* @param prefix 缓存key,秒数
* @param list 缓存List
* @return true:成功 false:失败
*/
<T> boolean setList(KeyPrefix prefix, List<T> list);
/**
* set集合存入缓存
*
* @param <T>
* @param key 缓存key
* @param set 缓存set集合
* @return true:成功 false:失败
*/
<T> boolean setSet(String key, Set<T> set);
/**
* set集合中增加value
*
* @param key 缓存key
* @param value 增加的value
* @return true:成功 false:失败
*/
boolean addSet(String key, Object value);
/**
* set集合存入缓存
*
* @param <T>
* @param key 缓存key
* @param set 缓存set集合
* @param seconds 秒数
* @return true:成功 false:失败
*/
<T> boolean setSet(String key, Set<T> set, long seconds);
/**
* 取出缓存中对应的set合集
*
* @param <T>
* @param key 缓存key
* @return Set<Object> 缓存中的set合集
*/
<T> Set<T> getSet(String key);
/**
* 有序集合存入数值
*
* @param key 缓存key
* @param value 缓存value
* @param score 评分
* @return
*/
boolean addZSet(String key, Object value, double score);
/**
* 从有序集合中删除指定值
*
* @param key 缓存key
* @param value 缓存value
* @return
*/
boolean removeZSet(String key, Object value);
/**
* 从有序集合中删除指定位置的值
*
* @param key 缓存key
* @param start 起始位置
* @param end 结束为止
* @return
*/
boolean removeZSet(String key, long start, long end);
/**
* 从有序集合中获取指定位置的值
*
* @param key 缓存key
* @param start 起始位置
* @param end 结束为止
* @return
*/
<T> Set<T> getZSet(String key, long start, long end);
}
/**
* redis工具类
*/
@Service
public class RedisUtil implements RedisDao {
@Resource
private RedisTemplate<String, Object> redisTemplate;
@Resource
private StringRedisTemplate stringRedisTemplate;
private static final Logger LOG = LoggerFactory.getLogger(RedisUtil.class);
private static String CACHE_PREFIX;
private static boolean CACHE_CLOSED;
@Override
@SuppressWarnings("rawtypes")
public boolean isEmpty(Object obj) {
if (obj == null) {
return true;
}
if (obj instanceof String) {
String str = obj.toString();
if ("".equals(str.trim())) {
return true;
}
return false;
}
if (obj instanceof List) {
List<Object> list = (List<Object>) obj;
if (list.isEmpty()) {
return true;
}
return false;
}
if (obj instanceof Map) {
Map map = (Map) obj;
if (map.isEmpty()) {
return true;
}
return false;
}
if (obj instanceof Set) {
Set set = (Set) obj;
if (set.isEmpty()) {
return true;
}
return false;
}
if (obj instanceof Object[]) {
Object[] objs = (Object[]) obj;
if (objs.length <= 0) {
return true;
}
return false;
}
return false;
}
/**
* 构建缓存key值
*
* @param key 缓存key
* @return
*/
@Override
public String buildKey(String key) {
if (CACHE_PREFIX == null || "".equals(CACHE_PREFIX)) {
return key;
}
return CACHE_PREFIX + ":" + key;
}
/**
* 返回缓存的前缀
*
* @return CACHE_PREFIX_FLAG
*/
@Override
public String getCachePrefix() {
return CACHE_PREFIX;
}
/**
* 设置缓存的前缀
*
* @param cachePrefix
*/
@Override
public void setCachePrefix(String cachePrefix) {
if (cachePrefix != null && !"".equals(cachePrefix.trim())) {
CACHE_PREFIX = cachePrefix.trim();
}
}
/**
* 关闭缓存
*
* @return true:成功 false:失败
*/
@Override
public boolean close() {
LOG.debug(" cache closed ! ");
CACHE_CLOSED = true;
return true;
}
/**
* 打开缓存
*
* @return true:存在 false:不存在
*/
@Override
public boolean openCache() {
CACHE_CLOSED = false;
return true;
}
/**
* 检查缓存是否开启
*
* @return true:已关闭 false:已开启
*/
@Override
public boolean isClose() {
return CACHE_CLOSED;
}
/**
* 判断key值是否存在
*
* @param key 缓存的key
* @return true:存在 false:不存在
*/
@Override
public boolean hasKey(String key) {
LOG.debug(" hasKey key :{}", key);
try {
if (isClose() || isEmpty(key)) {
return false;
}
key = buildKey(key);
return redisTemplate.hasKey(key);
} catch (Exception e) {
LOG.error(e.getMessage(), e);
}
return false;
}
/**
* 匹配符合正则的key
*
* @param patternKey
* @return key的集合
*/
@Override
public Set<String> keys(String patternKey) {
LOG.debug(" keys key :{}", patternKey);
try {
if (isClose() || isEmpty(patternKey)) {
return Collections.emptySet();
}
return redisTemplate.keys(patternKey);
} catch (Exception e) {
LOG.error(e.getMessage(), e);
}
return Collections.emptySet();
}
/**
* 根据key删除缓存
*
* @param key
* @return true:成功 false:失败
*/
@Override
public boolean del(String... key) {
LOG.debug(" delete key :{}", key.toString());
try {
if (isClose() || isEmpty(key)) {
return false;
}
Set<String> keySet = new HashSet<>();
for (String str : key) {
keySet.add(buildKey(str));
}
redisTemplate.delete(keySet);
return true;
} catch (Exception e) {
LOG.error(e.getMessage(), e);
}
return false;
}
/**
* 根据key删除缓存
*
* @param key
* @return true:成功 false:失败
*/
@Override
public boolean delPattern(String key,long id) {
LOG.debug(" delete Pattern keys :{}", key);
try {
if (isClose() || isEmpty(key)) {
return false;
}
key = buildKey(key+id);
redisTemplate.delete(redisTemplate.keys(key));
return true;
} catch (Exception e) {
LOG.error(e.getMessage(), e);
}
return false;
}
/**
* 删除一组key值
*
* @param keys
* @return true:成功 false:失败
*/
@Override
public boolean del(Set<String> keys) {
LOG.debug(" delete keys :{}", keys.toString());
try {
if (isClose() || isEmpty(keys)) {
return false;
}
Set<String> keySet = new HashSet<>();
for (String str : keys) {
keySet.add(buildKey(str));
}
redisTemplate.delete(keySet);
return true;
} catch (Exception e) {
LOG.error(e.getMessage(), e);
}
return false;
}
/**
* 设置过期时间
*
* @param key 缓存key
* @param seconds 过期秒数
* @return true:成功 false:失败
*/
@Override
public boolean setExp(String key, long seconds) {
LOG.debug(" setExp key :{}, seconds: {}", key, seconds);
try {
if (isClose() || isEmpty(key) || seconds > 0) {
return false;
}
key = buildKey(key);
return redisTemplate.expire(key, seconds, TimeUnit.SECONDS);
} catch (Exception e) {
LOG.error(e.getMessage(), e);
}
return false;
}
/**
* 查询过期时间
*
* @param key 缓存key
* @return 秒数
*/
@Override
public Long getExpire(String key) {
LOG.debug(" getExpire key :{}", key);
try {
if (isClose() || isEmpty(key)) {
return 0L;
}
key = buildKey(key);
return redisTemplate.getExpire(key, TimeUnit.SECONDS);
} catch (Exception e) {
LOG.error(e.getMessage(), e);
}
return 0L;
}
/**
* 缓存存入key-value
*
* @param key 缓存键
* @param value 缓存值
* @return true:成功 false:失败
*/
@Override
public boolean setString(String key,long id, String value) {
LOG.debug(" setString key :{}, value: {}", key, value);
try {
if (isClose() || isEmpty(key) || isEmpty(value)) {
return false;
}
key = buildKey(key+id);
stringRedisTemplate.opsForValue().set(key, value);
return true;
} catch (Exception e) {
LOG.error(e.getMessage(), e);
}
return false;
}
/**
* 缓存存入key-value
*
* @param key 缓存键
* @param value 缓存值
* @param seconds 秒数
* @return true:成功 false:失败
*/
@Override
public boolean setString(String key, String value, long seconds) {
LOG.debug(" setString key :{}, value: {}, timeout:{}", key, value, seconds);
try {
if (isClose() || isEmpty(key) || isEmpty(value)) {
return false;
}
key = buildKey(key);
stringRedisTemplate.opsForValue().set(key, value, seconds, TimeUnit.SECONDS);
return true;
} catch (Exception e) {
LOG.error(e.getMessage(), e);
}
return false;
}
/**
* 根据key取出String value
*
* @param key 缓存key值
* @return String 缓存的String
*/
@Override
public String getString(String key,long id) {
LOG.debug(" getString key :{}", key);
try {
if (isClose() || isEmpty(key)) {
return null;
}
key = buildKey(key+id);
return stringRedisTemplate.opsForValue().get(key);
} catch (Exception e) {
LOG.error(e.getMessage(), e);
}
return null;
}
/**
* 去的缓存中的最大值并+1
*
* @param key 缓存key值
* @return long 缓存中的最大值+1
*/
@Override
public long incr(String key) {
LOG.debug(" incr key :{}", key);
try {
if (isClose() || isEmpty(key)) {
return 0;
}
key = buildKey(key);
return redisTemplate.opsForValue().increment(key, 1);
} catch (Exception e) {
LOG.error(e.getMessage(), e);
}
return 0;
}
/**
* 缓存中存入序列化的Object对象
*
* @param key 缓存key
* @param obj 存入的序列化对象
* @return true:成功 false:失败
*/
@Override
public boolean set(String key, Object obj) {
LOG.debug(" set key :{}, value:{}", key, obj);
try {
if (isClose() || isEmpty(key) || isEmpty(obj)) {
return false;
}
key = buildKey(key);
redisTemplate.opsForValue().set(key, obj);
} catch (Exception e) {
LOG.error(e.getMessage(), e);
}
return false;
}
/**
* 缓存中存入序列化的Object对象
*
* @param key 缓存key
* @param obj 存入的序列化对象
* @return true:成功 false:失败
*/
@Override
public boolean setObj(String key,long id, Object obj, long seconds) {
LOG.debug(" set key :{}, value:{}, seconds:{}", key, obj, seconds);
try {
if (isClose() || isEmpty(key) || isEmpty(obj)) {
return false;
}
key = buildKey(key+id);
redisTemplate.opsForValue().set(key, obj);
if (seconds > 0) {
redisTemplate.expire(key, seconds, TimeUnit.SECONDS);
}
return true;
} catch (Exception e) {
LOG.error(e.getMessage(), e);
}
return false;
}
@Override
public boolean setGood(String key, long id, Object obj) {
LOG.debug(" set key :{}, value:{}, seconds:{}", key, obj);
try {
if (isClose() || isEmpty(key) || isEmpty(obj)) {
return false;
}
key = buildKey(key+id);
redisTemplate.opsForValue().set(key, obj);
return true;
} catch (Exception e) {
LOG.error(e.getMessage(), e);
}
return false;
}
/**
* 取出缓存中存储的序列化对象
*
* @param key 缓存key
* @param clazz 对象类
* @return <T> 序列化对象
*/
@Override
public <T> T getObj(String key,long id, Class<T> clazz) {
LOG.debug(" get key :{}", key);
try {
if (isClose() || isEmpty(key)) {
return null;
}
key = buildKey(key+id);
return (T) redisTemplate.opsForValue().get(key);
} catch (Exception e) {
LOG.error(e.getMessage(), e);
}
return null;
}
/**
* 存入Map数组
*
* @param <T>
* @param key 缓存key
* @param map 缓存map
* @return true:成功 false:失败
*/
@Override
public <T> boolean setMap(String key, Map<String, T> map) {
try {
if (isClose() || isEmpty(key) || isEmpty(map)) {
return false;
}
key = buildKey(key);
redisTemplate.opsForHash().putAll(key, map);
return true;
} catch (Exception e) {
LOG.error(e.getMessage(), e);
}
return false;
}
/**
* 取出缓存的map
*
* @param key 缓存key
* @return map 缓存的map
*/
@SuppressWarnings("rawtypes")
@Override
public Map getMap(String key) {
LOG.debug(" getMap key :{}", key);
try {
if (isClose() || isEmpty(key)) {
return null;
}
key = buildKey(key);
return redisTemplate.opsForHash().entries(key);
} catch (Exception e) {
LOG.error(e.getMessage(), e);
}
return null;
}
/**
* 查询缓存的map的集合大小
*
* @param key 缓存key
* @return int 缓存map的集合大小
*/
@Override
public long getMapSize(String key) {
LOG.debug(" getMap key :{}", key);
try {
if (isClose() || isEmpty(key)) {
return 0;
}
key = buildKey(key);
return redisTemplate.opsForHash().size(key);
} catch (Exception e) {
LOG.error(e.getMessage(), e);
}
return 0;
}
/**
* 根据key以及hashKey取出对应的Object对象
*
* @param key 缓存key
* @param hashKey 对应map的key
* @return object map中的对象
*/
@Override
public Object getMapKey(String key, String hashKey) {
LOG.debug(" getMapkey :{}, hashKey:{}", key, hashKey);
try {
if (isClose() || isEmpty(key) || isEmpty(hashKey)) {
return null;
}
key = buildKey(key);
return redisTemplate.opsForHash().get(key, hashKey);
} catch (Exception e) {
LOG.error(e.getMessage(), e);
}
return null;
}
/**
* 取出缓存中map的所有key值
*
* @param key 缓存key
* @return Set<String> map的key值合集
*/
@Override
public Set<Object> getMapKeys(String key) {
LOG.debug(" getMapKeys key :{}", key);
try {
if (isClose() || isEmpty(key)) {
return null;
}
key = buildKey(key);
return redisTemplate.opsForHash().keys(key);
} catch (Exception e) {
LOG.error(e.getMessage(), e);
}
return null;
}
/**
* 删除map中指定的key值
*
* @param key 缓存key
* @param hashKey map中指定的hashKey
* @return true:成功 false:失败
*/
@Override
public boolean delMapKey(String key, String hashKey) {
LOG.debug(" delMapKey key :{}, hashKey:{}", key, hashKey);
try {
if (isClose() || isEmpty(key) || isEmpty(hashKey)) {
return false;
}
key = buildKey(key);
redisTemplate.opsForHash().delete(key, hashKey);
return true;
} catch (Exception e) {
LOG.error(e.getMessage(), e);
}
return false;
}
/**
* 存入Map数组
*
* @param <T>
* @param key 缓存key
* @param map 缓存map
* @param seconds 秒数
* @return true:成功 false:失败
*/
@Override
public <T> boolean setMapExp(String key, Map<String, T> map, long seconds) {
LOG.debug(" setMapExp key :{}, value: {}, seconds:{}", key, map, seconds);
try {
if (isClose() || isEmpty(key) || isEmpty(map)) {
return false;
}
key = buildKey(key);
redisTemplate.opsForHash().putAll(key, map);
redisTemplate.expire(key, seconds, TimeUnit.SECONDS);
return true;
} catch (Exception e) {
LOG.error(e.getMessage(), e);
}
return false;
}
/**
* map中加入新的key
*
* @param <T>
* @param key 缓存key
* @param hashKey map的Key值
* @param value map的value值
* @return true:成功 false:失败
*/
@Override
public <T> boolean addMap(String key, String hashKey, T value) {
LOG.debug(" addMap key :{}, hashKey: {}, value:{}", key, hashKey, value);
try {
if (isClose() || isEmpty(key) || isEmpty(hashKey) || isEmpty(value)) {
return false;
}
key = buildKey(key);
redisTemplate.opsForHash().put(key, hashKey, value);
return true;
} catch (Exception e) {
LOG.error(e.getMessage(), e);
}
return false;
}
/**
* 缓存存入List
*
* @param <T>
* @param key 缓存key
* @param list 缓存List
* @return true:成功 false:失败
*/
@Override
public <T> boolean setList(String key, List<T> list) {
LOG.debug(" setList key :{}, list: {}", key, list);
try {
if (isClose() || isEmpty(key) || isEmpty(list)) {
return false;
}
key = buildKey(key);
redisTemplate.opsForList().leftPushAll(key, list.toArray());
} catch (Exception e) {
LOG.error(e.getMessage(), e);
}
return false;
}
/**
* 根据key值取出对应的list合集
*
* @param key 缓存key
* @return List<Object> 缓存中对应的list合集
*/
@Override
public <V> List<V> getList(String key) {
LOG.debug(" getList key :{}", key);
try {
if (isClose() || isEmpty(key)) {
return null;
}
key = buildKey(key);
return (List<V>) redisTemplate.opsForList().range(key, 0, -1);
} catch (Exception e) {
LOG.error(e.getMessage(), e);
}
return null;
}
/**
* 根据key值截取对应的list合集
*
* @param key 缓存key
* @param start 开始位置
* @param end 结束位置
* @return
*/
@Override
public void trimList(String key, int start, int end) {
LOG.debug(" trimList key :{}", key);
try {
if (isClose() || isEmpty(key)) {
return;
}
key = buildKey(key);
redisTemplate.opsForList().trim(key, start, end);
} catch (Exception e) {
LOG.error(e.getMessage(), e);
}
}
/**
* 取出list合集中指定位置的对象
*
* @param key 缓存key
* @param index 索引位置
* @return Object list指定索引位置的对象
*/
@Override
public Object getIndexList(String key, int index) {
LOG.debug(" getIndexList key :{}, index:{}", key, index);
try {
if (isClose() || isEmpty(key) || index < 0) {
return null;
}
key = buildKey(key);
return redisTemplate.opsForList().index(key, index);
} catch (Exception e) {
LOG.error(e.getMessage(), e);
}
return null;
}
/**
* Object存入List
*
* @param prefix 缓存key
* @param value List中的值
* @return true:成功 false:失败
*/
@Override
public boolean addList(KeyPrefix prefix, Object value) {
LOG.debug(" addList key :{}, value:{}", prefix, value);
try {
if (isClose() || isEmpty(prefix.getPrefix()) || isEmpty(value)) {
return false;
}
String key = buildKey(prefix.getPrefix());
redisTemplate.opsForList().leftPush(key, value);
return true;
} catch (Exception e) {
LOG.error(e.getMessage(), e);
}
return false;
}
/**
* 缓存存入List
*
* @param <T>
* @param prefix 缓存key,秒数
* @param list 缓存List
* @return true:成功 false:失败
*/
@Override
public <T> boolean setList(KeyPrefix prefix, List<T> list) {
LOG.debug(" setList key :{}, value:{}, seconds:{}", prefix.getPrefix(), list, prefix.expireSeconds());
try {
if (isClose() || isEmpty(prefix.getPrefix()) || isEmpty(list)) {
return false;
}
String key = buildKey(prefix.getPrefix());
redisTemplate.opsForList().leftPushAll(key, list.toArray());
if (prefix.expireSeconds() > 0) {
redisTemplate.expire(key, prefix.expireSeconds(), TimeUnit.SECONDS);
}
return true;
} catch (Exception e) {
LOG.error(e.getMessage(), e);
}
return false;
}
/**
* set集合存入缓存
*
* @param <T>
* @param key 缓存key
* @param set 缓存set集合
* @return true:成功 false:失败
*/
@Override
public <T> boolean setSet(String key, Set<T> set) {
LOG.debug(" setSet key :{}, value:{}", key, set);
try {
if (isClose() || isEmpty(key) || isEmpty(set)) {
return false;
}
key = buildKey(key);
redisTemplate.opsForSet().add(key, set.toArray());
return true;
} catch (Exception e) {
LOG.error(e.getMessage(), e);
}
return false;
}
/**
* set集合中增加value
*
* @param key 缓存key
* @param value 增加的value
* @return true:成功 false:失败
*/
@Override
public boolean addSet(String key, Object value) {
LOG.debug(" addSet key :{}, value:{}", key, value);
try {
if (isClose() || isEmpty(key) || isEmpty(value)) {
return false;
}
key = buildKey(key);
redisTemplate.opsForSet().add(key, value);
return true;
} catch (Exception e) {
LOG.error(e.getMessage(), e);
}
return false;
}
/**
* set集合存入缓存
*
* @param <T>
* @param key 缓存key
* @param set 缓存set集合
* @param seconds 秒数
* @return true:成功 false:失败
*/
@Override
public <T> boolean setSet(String key, Set<T> set, long seconds) {
LOG.debug(" setSet key :{}, value:{}, seconds:{}", key, set, seconds);
try {
if (isClose() || isEmpty(key) || isEmpty(set)) {
return false;
}
key = buildKey(key);
redisTemplate.opsForSet().add(key, set.toArray());
if (seconds > 0) {
redisTemplate.expire(key, seconds, TimeUnit.SECONDS);
}
return true;
} catch (Exception e) {
LOG.error(e.getMessage(), e);
}
return false;
}
/**
* 取出缓存中对应的set合集
*
* @param <T>
* @param key 缓存key
* @return Set<Object> 缓存中的set合集
*/
@Override
public <T> Set<T> getSet(String key) {
LOG.debug(" getSet key :{}", key);
try {
if (isClose() || isEmpty(key)) {
return null;
}
key = buildKey(key);
return (Set<T>) redisTemplate.opsForSet().members(key);
} catch (Exception e) {
LOG.error(e.getMessage(), e);
}
return null;
}
/**
* 有序集合存入数值
*
* @param key 缓存key
* @param value 缓存value
* @param score 评分
* @return
*/
@Override
public boolean addZSet(String key, Object value, double score) {
LOG.debug(" addZSet key :{},value:{}, score:{}", key, value, score);
try {
if (isClose() || isEmpty(key) || isEmpty(value)) {
return false;
}
key = buildKey(key);
return redisTemplate.opsForZSet().add(key, value, score);
} catch (Exception e) {
LOG.error(e.getMessage(), e);
}
return false;
}
/**
* 从有序集合中删除指定值
*
* @param key 缓存key
* @param value 缓存value
* @return
*/
@Override
public boolean removeZSet(String key, Object value) {
LOG.debug(" removeZSet key :{},value:{}", key, value);
try {
if (isClose() || isEmpty(key) || isEmpty(value)) {
return false;
}
key = buildKey(key);
redisTemplate.opsForZSet().remove(key, value);
return true;
} catch (Exception e) {
LOG.error(e.getMessage(), e);
}
return false;
}
/**
* 从有序集合中删除指定位置的值
*
* @param key 缓存key
* @param start 起始位置
* @param end 结束为止
* @return
*/
@Override
public boolean removeZSet(String key, long start, long end) {
LOG.debug(" removeZSet key :{},start:{}, end:{}", key, start, end);
try {
if (isClose() || isEmpty(key)) {
return false;
}
key = buildKey(key);
redisTemplate.opsForZSet().removeRange(key, start, end);
return true;
} catch (Exception e) {
LOG.error(e.getMessage(), e);
}
return false;
}
/**
* 从有序集合中获取指定位置的值
*
* @param key 缓存key
* @param start 起始位置
* @param end 结束为止
* @return
*/
@Override
public <T> Set<T> getZSet(String key, long start, long end) {
LOG.debug(" getZSet key :{},start:{}, end:{}", key, start, end);
try {
if (isClose() || isEmpty(key)) {
return Collections.emptySet();
}
key = buildKey(key);
return (Set<T>) redisTemplate.opsForZSet().range(key, start, end);
} catch (Exception e) {
LOG.error(e.getMessage(), e);
}
return Collections.emptySet();
}
}使用
public List<PageData> getListAll() {
List<PageData> list = redisDao.getList(GoodKey.goodsList.getPrefix());
Map<Long,Boolean> localOverMap=MapUtil.getInstance();
if (null == list || list.isEmpty()) {
list = goodMapper.getListAll();
redisDao.setList(GoodKey.goodsList, list);
for (PageData pd : list) {
long id= (Long) pd.get("id");
redisDao.setGood(GoodKey.goodsDetail.getPrefix(),id,pd);
localOverMap.put(id, false);
}
}
return list;
}
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
智能推荐
李开复揭密微软成功之道 寄语中国软件业(4)_在微软许多人都像我一样主动从事发现人才、跟踪人才和吸引人才的工作....-程序员宅基地
文章浏览阅读1k次。http://www.sina.com.cn 2005年04月07日 11:19 新浪科技 文/李开复 人才：微软的立业之本 微软公司把重视人才的管理理念视为公司的核心财富。在信息时代里，人才的价值尤为重要。在工业时代里，一个优秀技工和一个普通技工的效率差异可能是30%，但在信息时代里，一个高级程序员和一个普通程序员的效率差异可能高达10倍以上。 ad1= "打造校_在微软许多人都像我一样主动从事发现人才、跟踪人才和吸引人才的工作....
python量化交易pdf书籍微盘,python量化交易编程自学_python 量化交易 pdf 百度网盘-程序员宅基地
文章浏览阅读836次，点赞21次，收藏19次。大家好，小编为大家解答python量化交易教程电子书的问题。很多人还不知道python量化交易pdf书籍微盘，现在让我们一起来看看吧！_python 量化交易 pdf 百度网盘
OFDM802.11a的FPGA实现（七）一级交织：分组交织器（含verilog和matlab代码）
在前面的文章中讲解了卷积编码和删余，实现了1/2、2/3、3/4编码速率的输出。数据域在编码之后，下一个部分就是交织。今天对交织进行具体实现。
移动硬盘无法读取？学会这3个方法，快速解决问题！_新硬盘无法识别-程序员宅基地
文章浏览阅读648次。移动硬盘在目前工作和学习中都是一个比较重要的工具。如果遇到移动硬盘无法读取的情况，应该如何解决呢？小编给大家总结了几个简单有效的操作方法，记得收藏起来哦！_新硬盘无法识别
微信小程序红包 php,如何用微信小程序发红包-程序员宅基地
文章浏览阅读250次。在目前的小程序版本尚不支持发红包这个功能，开发者们表面笑嘻嘻，心里妈卖批！在这里，提供一种已经实践过的解决思路。详细解析，就是下面的几个步骤1、首先是在小程序里面的领红包入口2、点击后跳转webview， 附带当前的小程序的token给webview验证，webview 的src 指向具备付款能力的服务号的一个获取openid页面，根据附加的token来判断用户是否可以领取红包，此时用户拥有两个o..._小程序 可以用微信支付 现金红包php
视频教程-跟一夫学UI设计 APPUI综合设计与图标实战案例视频教程 photoshop绘制icon案例-UI-程序员宅基地
文章浏览阅读104次。跟一夫学UI设计 APPUI综合设计与图标实战案例视频教程 photoshop绘制icon案例 ..._app风格案例视频
随便推点
VBOX报错"Kernel driver not installed(rc=-1908)"-程序员宅基地
文章浏览阅读129次。根据报错提示先安装dkms包[root@OS4 ~]# rpm-ivh dkms-2.2.0.3-3.2.noarch.rpm warning: dkms-2.2.0.3-3.2.noarch.rp..._vboxheadless: error -1908 in suplibosinit! vboxheadless: kernel driver not i
vue.js的手脚架vue-cli项目搭建的步骤-程序员宅基地
文章浏览阅读90次。手脚架是什么？众所周知，现在的前端项目发展得越渐越大，我们前端程序员要从0开始去搭建一套完整的项目很费时，所以这时候前端工程的手脚架就出现了。我用得vue-cli也是其中之一，还有其他的我也说不清，我就说一下我接触比较多的这款vue-cli，但是所有手脚架的核心：都是为了能够快速搭建一个完整的项目的结构，开发者只需要在生成的项目结构的基础上进行开发即可，非常简单高效。然后..._如何上线vue-cli手脚架项目到服务器
python进程和线程-程序员宅基地
文章浏览阅读794次，点赞19次，收藏19次。2、multiprocessing.Process类的join()方法可以阻塞主进程，当子进程没有进行完成的时候，主进程hold。2、threading.Thread类的join()方法可以阻塞主进程，当子线程没有进行完成的时候，主线程hold。3、可以通过继承multiprocessing.Process并重写run()函数的方法来实现多线程。1、线程通过multiprocessing.Process类的start()方法启动。1、线程通过threading.Thread类的start()方法启动。
使用OkHttp 缓存 API 调用提高Android应用性能
要能够将 API 调用的响应本地存储到缓存中，首先，我们需要定义缓存并通知客户端。在下面的代码片段中，我们使用 okhttp 库中的 Cache 类定义了缓存。我们将此缓存的最大大小设置为 5 MB。然后，在初始化 okhttpclient 参数时使用cache()函数。.build()如果设备连接到互联网：如果最后一次 API 响应是在不到 30 分钟之前检索的，则显示缓存的响应；否则，获取新的响应并将其存储在缓存中。如果设备离线：使用最多 1 天前的 API 响应以保持应用程序功能。
一键实现在VS Code中绘制流程图
而其较为出众的一点，就是较好的可拓展性，即丰富的插件应用，这些应用可以极大地提高生产效率，并优化日常使用。可以发现，其整体格局和我们常见的流程图编辑应用较为类似，其主题颜色也与我们的VS Code保持一致，在这里为了编辑方便，我们还是将编辑器主题改为浅色。当然，其功能仍存在局限，不能够完全代替我们传统的图形绘制工具，但也可以作为我们日常工作的有益补充，帮助我们完成一些特定情景下的项目。整体布局也十分明晰，与我们常用的Visio极为类似：左侧为形状选项卡，中间为画布容器，右侧为样式编辑。
go http框架下的静态资源代理实现（压缩，缓存验证自定义）
之前在说了我的第一版静态资源代理，后面我又完善了一下：照着以上思路，可以在其他语言其他框架中实现，因为对框架没有依赖，都是使用的一些基本功能。