关闭

Redis统计某个时间段订单数量(用Guava缓存辅助解决)

标签: redisguava
1468人阅读 评论(0) 收藏 举报
分类:

简介

公司有这么个需求,需用统计店铺某个时间段(按自然天计算,不超过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;
    }
}
0
0

猜你在找
【套餐】Hadoop生态系统零基础入门
【套餐】嵌入式Linux C编程基础
【套餐】2017软考系统集成项目——任铄
【套餐】Android 5.x顶级视频课程——李宁
【套餐】深度学习入门视频课程——唐宇迪
【直播】广义线性模型及其应用——李科
【直播】从0到1 区块链的概念到实践
【直播】计算机视觉原理及实战——屈教授
【直播】机器学习之凸优化——马博士
【直播】机器学习&数据挖掘7周实训--韦玮
查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:240291次
    • 积分:4296
    • 等级:
    • 排名:第7020名
    • 原创:190篇
    • 转载:15篇
    • 译文:1篇
    • 评论:59条
    最新评论