利用Redis进行数据缓存的项目实践

/**
* 尝试获取锁
*
* @param key
* @return
*/
private boolean tryLock(String key) {
Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, “1”, 10, TimeUnit.SECONDS);
return BooleanUtil.isTrue(flag);
}

/**
* 删除锁
*
* @param key
*/
private void unLock(String key) {
stringRedisTemplate.delete(key);
}

public Shop queryWithMutex(Long id) throws InterruptedException {
//从Redis查询商铺缓存
String cacheShop = stringRedisTemplate.opsForValue().get(SHOPCACHEPREFIX + id);

//判断缓存中数据是否存在
if (!StringUtil.isNullOrEmpty(cacheShop)) {
//缓存中存在则直接返回
try {
// 将子字符串转换为对象
Shop shop = objectMapper.readValue(cacheShop, Shop.class);
return shop;
} catch (JsonProcessingException e) {
e.printStackTrace();
}
}

// 因为上面判断了cacheShop是否为空，如果进到这个方法里面则一定是空，直接过滤，不打到数据库
if (null != cacheShop) {
return null;
}

Shop shop = new Shop();
// 缓存击穿，获取锁
String lockKey = “lock:shop:” + id;
try{
boolean b = tryLock(lockKey);
if (!b) {
// 获取锁失败了
Thread.sleep(50);
return queryWithMutex(id);
}
//缓存中不存在，则从数据库里进行数据查询
shop = getById(id);

//数据库里不存在，返回404
if (null == shop) {
// 缓存空对象
stringRedisTemplate.opsForValue().set(SHOPCACHEPREFIX + id, “”, 2, TimeUnit.MINUTES);
return null;
}
//数据库里存在，则将信息写入Redis
try {
String shopJSon = objectMapper.writeValueAsString(shop);
stringRedisTemplate.opsForValue().set(SHOPCACHEPREFIX + id, shopJSon, 30, TimeUnit.MINUTES);
} catch (JsonProcessingException e) {
e.printStackTrace();
}
}catch (Exception e){

}finally {
// 释放互斥锁
unLock(lockKey);
}

//返回
return shop;

}

@Data
public class RedisData {
private LocalDateTime expireTime;
private Object data;
}

/**
* 逻辑过期时间对象写入缓存
* @param id
* @param expireSeconds
*/
public void saveShopToRedis(Long id,Long expireSeconds){
// 查询店铺数据
Shop shop = getById(id);
// 封装为逻辑过期
RedisData redisData = new RedisData();
redisData.setData(shop);
redisData.setExpireTime(LocalDateTime.now().plusSeconds(expireSeconds));
// 写入Redis
stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY+id, JSONUtil.toJsonStr(redisData));
}

/**
* 缓存击穿：逻辑过期解决
* @param id
* @return
* @throws InterruptedException
*/
public Shop queryWithPassLogicalExpire(Long id) throws InterruptedException {
//1. 从Redis查询商铺缓存
String cacheShop = stringRedisTemplate.opsForValue().get(SHOPCACHEPREFIX + id);

//2. 判断缓存中数据是否存在
if (StringUtil.isNullOrEmpty(cacheShop)) {
// 3. 不存在
return null;
}
// 4. 存在，判断是否过期
RedisData redisData = JSONUtil.toBean(cacheShop, RedisData.class);
JSONObject jsonObject = (JSONObject) redisData.getData();
Shop shop = JSONUtil.toBean(jsonObject, Shop.class);
LocalDateTime expireTime = redisData.getExpireTime();

// 5. 判断是否过期
if (expireTime.isAfter(LocalDateTime.now())){
// 5.1 未过期
return shop;
}
// 5.2 已过期
String lockKey = “lock:shop:”+id;
boolean flag = tryLock(lockKey);
if (flag){
// TODO 获取锁成功，开启独立线程，实现缓存重建，建议使用线程池去做
CACHE_REBUILD_EXECUTOR.submit(()->{
try {
// 重建缓存
this.saveShopToRedis(id,1800L);
}catch (Exception e){

}finally {
// 释放锁
unLock(lockKey);
}

});

}
// 获取锁失败，返回过期的信息
return shop;
}

/**
* 线程池
*/
private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);