技术标签: --------秒杀系统 ☆项目成长 spring整合Redis 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=true
spring-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>
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可视化工具)
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;
}
文章浏览阅读1k次。1、HTML5 Web SQL 数据库 Web SQL 数据库 API 并不是 HTML5 规范的一部分,但是它是一个独立的规范,引入了一组使用 SQL 操作客户端数据库的 APIs。如果你是一个 Web 后端程序员,应该很容易理解 SQL 的操作。Web SQL 数据库可以在最新版的 Safari, Chrome 和 Opera 浏览器中工作。2、核心方法 以下是规范中定义的三个_方式准则的定义
文章浏览阅读4.1k次,点赞2次,收藏6次。spring Boot 中使用线程池异步执行多个定时任务在启动类中添加注解@EnableScheduling配置自定义线程池在启动类中添加注解@EnableScheduling第一步添加注解,这样才会使定时任务启动配置自定义线程池@Configurationpublic class ScheduleConfiguration implements SchedulingConfigurer..._springboot启动后自动开启多个线程程序
文章浏览阅读1.1k次。在项目的target文件夹下把之前"mvn clean package"生成的压缩包(我的是jar包)删掉重新执行"mvn clean package"再执行"mvn clean install"即可_mvn clean install有errors
文章浏览阅读974次。Navicat连接mysql数据库时,不断报1405错误,下面是针对这个的解决办法:MySQL服务器正在运行,停止它。如果是作为Windows服务运行的服务器,进入计算机管理--->服务和应用程序------>服务。如果服务器不是作为服务而运行的,可能需要使用任务管理器来强制停止它。创建1个文本文件(此处命名为mysql-init.txt),并将下述命令置于单一行中:SET PASSW..._nvarchar链接不上数据库
文章浏览阅读2.2k次。Python的requests模块是一个常用的HTTP库,用于发送HTTP请求和处理响应。_python requests 参数
文章浏览阅读2.7w次,点赞7次,收藏50次。APT攻击APT攻击是近几年来出现的一种高级攻击,具有难检测、持续时间长和攻击目标明确等特征。本文中,整理了近年来比较典型的几个APT攻击,并其攻击过程做了分析(为了加深自己对APT攻击的理解和学习)Google极光攻击2010年的Google Aurora(极光)攻击是一个十分著名的APT攻击。Google的一名雇员点击即时消息中的一条恶意链接,引发了一系列事件导致这个搜_2010谷歌网络被极光黑客攻击
文章浏览阅读1.1k次。JS代码 /** * 生命周期函数--监听页面加载 */ onLoad: function (options) { setTimeout( function(){ wx.showToast({ title: '黄菊华老师', }) },2000 ) },说明该代码只执行一次..._微信小程序 settimeout 向上层传值
文章浏览阅读48次。uploadify2.1.4如何能使按钮显示中文博客分类:uploadify网上关于这段话的搜索恐怕是太多了。方法多也试过了不知怎么,反正不行。最终自己想办法给解决了。当然首先还是要有fla源码。直接去管网就可以下载。[url]http://www.uploadify.com/wp-content/uploads/uploadify-v2.1.4...
文章浏览阅读9.6k次,点赞5次,收藏36次。戴尔服务器安装VMware ESXI6.7.0教程(U盘安装)一、前期准备1、下载镜像下载esxi6.7镜像:VMware-VMvisor-Installer-6.7.0-8169922.x86_64.iso这里推荐到戴尔官网下载,Baidu搜索“戴尔驱动下载”,选择进入官网,根据提示输入服务器型号搜索适用于该型号服务器的所有驱动下一步选择具体类型的驱动选择一项下载即可待下载完成后打开软碟通(UItraISO),在“文件”选项中打开刚才下载好的镜像文件然后选择启动_vmware-vcsa-all-6.7.0-8169922.iso
文章浏览阅读2k次。百度语音技术永久免费的语音自动转字幕介绍基于百度语音技术,识别率97%无时长限制,无文件大小限制永久免费,简单,易用,速度快支持中文,英文,粤语永久免费的语音转字幕网站: http://thinktothings.com视频介绍 https://www.bilibili.com/video/av42750807 ...
文章浏览阅读7.6k次,点赞2次,收藏9次。Instrumentation是一种直接修改程序二进制文件的方法。其可以用于程序的调试,优化,安全等等。对这个词一般的翻译是“插桩”,但这更多使用于软件测试领域。【找一些相关的例子】Dyninst可以动态或静态的修改程序的二进制代码。动态修改是在目标进程运行时插入代码(dynamic binary instrumentation)。静态修改则是直接向二进制文件插入代码(static b_dyninst
文章浏览阅读2.9k次。部署asp网站到云服务器 内容精选换一换通常情况下,需要结合客户的实际业务环境和具体需求进行业务改造评估,建议您进行服务咨询。这里仅描述一些通用的策略供您参考,主要分如下几方面进行考虑:业务迁移不管您的业务是否已经上线华为云,业务迁移的策略是一致的。建议您将时延敏感型,有快速批量就近部署需求的业务迁移至IEC;保留数据量大,且需要长期稳定运行的业务在中心云上。迁移方法请参见如何计算隔离独享计算资源..._nas asp网站