简介
公司有这么个需求,需用统计店铺某个时间段(按自然天计算,不超过24小时)类的订单数量。因为这些统计数据不用持久化,考虑到性能问题,准备用Redis做统计。
- 设计思路:用Reids的一个有序集合实现。店铺Id作为有序集合key,订单ID作为有序集合member,插入到Redis时间戳作为有序集合的score。增加的时候用zadd(cacheKey, System.currentTimeMillis(), orderId),统计的时候用zcount(cacheKey, beginTimestamp, endTimestamp)统计出某个时间段的订单数量。
- 思考:不能只是想着插入Redis,还必须想着怎么清理老的数据,也就是清理截止到昨天晚上23:59:59的老数据。自然的想法就是每次生成到昨天的时间戳,然后每次插入的时候清理以前的老数据。
- 问题:
- 1.每次生成昨天的时间戳即使不是个耗时操作,也是没有必要的,因为一天只需要生成一次就够了,其它生成都是浪费的。那怎么保证新开始一天重新生成昨天的时间戳呢?
- 2.每次插入的时候清理也是没必要的,只要每天清理一次就行了,因为我们是按自然天保存订单数量的。怎么一天清理一次呢?
- 解决:
总的方案是用guava的缓存,实现类似定时的功能。利用缓存key不存在自动加载;以及Guava的缓存移除触发器,清理Redis中的老数据。
- 问题1:根据我们自身业务情况,没有必要及时处理清理老的数据,只要保证Redis内存不爆掉就行了。晚几个小时甚至晚一天清理一般也不会出问题。所以第一次生成昨天的时间戳可以在本地缓存起来,后续需要的话直接从本地缓存获取就行了,这样没有必要每次都生成这个时间戳,等第二天重新再生成。
- 问题2:更新订单数量的时候,将店铺ID和最近清理的时间戳插入到guava缓存中,插入之前先清理老数据;当guava的缓存中的key被因为过期被清理的时候,触发监听器,再次清理老数据。
guava使用demo
public static void main(String[] args) throws ExecutionException, InterruptedException{
//缓存接口这里是LoadingCache,LoadingCache在缓存项不存在时可以自动加载缓存
LoadingCache<Integer,Student> studentCache
//CacheBuilder的构造函数是私有的,只能通过其静态方法newBuilder()来获得CacheBuilder的实例
= CacheBuilder.newBuilder()
//设置并发级别为8,并发级别是指可以同时写缓存的线程数
.concurrencyLevel(8)
//设置写缓存后8秒钟过期
.expireAfterWrite(8, TimeUnit.SECONDS)
//设置缓存容器的初始容量为10
.initialCapacity(10)
//设置缓存最大容量为100,超过100之后就会按照LRU最近虽少使用算法来移除缓存项
.maximumSize(100)
//设置要统计缓存的命中率
.recordStats()
//设置缓存的移除通知
.removalListener(new RemovalListener<Object, Object>() {
@Override
public void onRemoval(RemovalNotification<Object, Object> notification) {
System.out.println(notification.getKey() + " was removed, cause is " + notification.getCause());
}
})
//build方法中可以指定CacheLoader,在缓存不存在时通过CacheLoader的实现自动加载缓存
.build(
new CacheLoader<Integer, Student>() {
@Override
public Student load(Integer key) throws Exception {
System.out.println("load student " + key);
Student student = new Student();
student.setId(key);
student.setName("name " + key);
return student;
}
}
);
源码实现
public class RedisUtil {
private static final Logger logger = LoggerFactory.getLogger(RedisUtil.class);
private RedisUtil() {
}
private static final String YESTERDAY = "yesterday";
private static final RedisExtraService redisExtraService = SpringContext.getBean(RedisExtraService.class);
//缓存昨天最后时刻的时间戳,一天后会更新这个时间戳
private static final LoadingCache<String, Long> timeCache = CacheBuilder.newBuilder()
.maximumSize(1)
.expireAfterWrite(1, TimeUnit.DAYS)
.build(new CacheLoader<String, Long>() {
@Override
public Long load(String key) throws Exception {
return DateUtil.getYesterdayEndTime();
}
});
//缓存的key回收时会触发这个监听器
private static final RemovalListener<String, Long> removalListener = new RemovalListener<String, Long>() {
@Override
public void onRemoval(RemovalNotification<String, Long> notification) {
String key = notification.getKey();
Long recentNeedRemoveTime = notification.getValue();
//不等于时才清除老数据,因为等于情况说明创建key的时候已经清理了老数据
if (!recentNeedRemoveTime.equals(getRecentNeedRemoveTime()))
redisExtraService.zremrangeByScore(key, 0, recentNeedRemoveTime);
}
};
//缓存待清理的redis中的key
private static final Cache<String, Long> entityCache = CacheBuilder.newBuilder()
.maximumSize(10000)
.expireAfterWrite(1, TimeUnit.DAYS)
.removalListener(removalListener)
.build();
public static void updateOrderCount(final String entityId, final String orderId) {
checkArgument(entityId != null && orderId != null);
try {
entityCache.get(entityId, new Callable<Long>() {
@Override
public Long call() throws Exception {
//创建key的时候已经清理老数据,并将这时间戳记录下来,回收key的时候需要这个时间戳
Long recentNeedRemoveTime = getRecentNeedRemoveTime();
redisExtraService.zremrangeByScore(entityId, 0, recentNeedRemoveTime);
return recentNeedRemoveTime;
}
});
} catch (ExecutionException e) {
logger.error("从entityCache清理店铺昨天的订单数量失败, entityId: {}", entityId);
//再次尝试清理
redisExtraService.zremrangeByScore(entityId, 0, getRecentNeedRemoveTime());
}
String cacheKey = getRedisKey(entityId);
Jedis jedis = redisExtraService.getResource();
// long yesterdayEndTime = DateUtil.getYesterdayEndTime();
// long yesterdayEndTime;
// try {
// yesterdayEndTime = timeCache.get(YESTERDAY);
// } catch (ExecutionException e) {
// logger.error("从timeCache获取yesterdayEndTime失败");
// yesterdayEndTime = DateUtil.getYesterdayEndTime();
// }
try {
Pipeline pipeline = jedis.pipelined();
// pipeline.zremrangeByScore(cacheKey, 0, yesterdayEndTime);
pipeline.zadd(cacheKey, System.currentTimeMillis(), orderId);
pipeline.expire(cacheKey, OrderCacheConstant.EXPIRE_DAY);
pipeline.sync();
} finally {
redisExtraService.returnResource(jedis);
}
}
public static Long getOrderCount(String entityId, long beginTimestamp, long endTimestamp) {
checkArgument(entityId != null);
String cacheKey = getRedisKey(entityId);
return redisExtraService.zcount(cacheKey, beginTimestamp, endTimestamp);
}
protected static String getRedisKey(String entityId) {
return OrderCacheConstant.KEY_ORDER_COUNT + entityId;
}
/**
* 获取最近需要删除的时间,一般是昨天最后的时间
*
* @return
*/
private static Long getRecentNeedRemoveTime() {
Long yesterdayEndTime;
try {
yesterdayEndTime = timeCache.get(YESTERDAY);
} catch (ExecutionException e) {
logger.error("从timeCache获取yesterdayEndTime失败");
yesterdayEndTime = DateUtil.getYesterdayEndTime();
}
return yesterdayEndTime;
}
}