SpringBoot+Redis实现浏览量+1

当用户点击新闻查看详情后，数据库新闻的浏览量字段要加一，当在高并发场景下，很多人查看新闻详情直接操作数据库使浏览量字段加一对数据库压力过大，并且容易造成脏数据，这里结合redis实现浏览量加一。

业务逻辑：

①、项目初始化，缓存所有新闻的浏览量Map

②、点击详情后，相应新闻的浏览量自增加一

③、定时器使redis数据写入数据库

④、查询文章浏览量以redis为准

新闻entity：

@Data
@TableName(value ="app_news")
public class AppNews {
    @TableId
    private String newsId;

    private String newsTitle;

    private String newsContent;

    private Integer viewNum;

}

先来第一步，项目启动初始化把新闻浏览量存入redis：

在新闻业务实现类添加一个方法，使用@PostConstruct注解表示项目启动后自动执行该方法

@Resource
private RedisCache redisCache;

@PostConstruct
public void init() {
    log.info("新闻浏览量写入缓存开始==>");
    List<AppNews> appNewsList = list();
    Map<String, Integer> newsViewMap = appNewsList.stream().collect(Collectors.toMap(AppNews::getNewsId, AppNews::getViewNum));
    redisCache.setCacheMap(CacheConstants.NEWS_VIEW_NUM_KEY, newsViewMap);
    log.info("<==新闻浏览量写入缓存成功");
}

写入Map成功：新闻id对应浏览量

下面是新闻查看详情接口，新增业务新闻阅读量加一（ps：当然如果你想优雅也可以使用AOP）：

@Transactional
@GetMapping("/{newsId}")
public AjaxResult getDetails(@PathVariable(value = "newsId") String newsId) {
    AppNews appNews = appNewsService.getNewsDetails(newsId);
    // 新闻阅读量加一
    appNewsService.viewNumIncrease(newsId);
    return AjaxResult.success(appNews);
}

appNewsService.viewNumIncrease(newsId);方法具体实现：

@Override
public void viewNumIncrease(String newsId) {
    // 缓存中阅读量自增一
    redisCache.incrementCacheMapValue(CacheConstants.NEWS_VIEW_NUM_KEY, newsId, 1);
}

redisCache中封装对应方法：

public void incrementCacheMapValue(String key, String hKey, long v) {
    redisTemplate.boundHashOps(key).increment(hKey, v);
}

此时阅读量在缓存中自增一了，接下来查看新闻详情需要把redis的浏览量查出来返回而不是数据库

查询新闻详情方法修改：

@Override
public AppNews getNewsDetails(String newsId) {
    LambdaQueryWrapper<AppNews> queryWrapper = new LambdaQueryWrapper<>();
    queryWrapper.eq(StringUtil.isNotEmpty(newsId), AppNews::getNewsId, newsId);
    AppNews one = getOne(queryWrapper);
    this.getNewsViewNumFromRedis(one);
    return one;
}
private void getNewsViewNumFromRedis(AppNews appNews) {
    appNews.setViewNum(redisCache.getCacheMapValue(CacheConstants.NEWS_VIEW_NUM_KEY, appNews.getNewsId()));
}

再写一个定时器定时同步浏览量即可：

@Component
public class updateNewsViewNumTask {

    private static final Logger log = LoggerFactory.getLogger(updateNewsViewNumTask.class);

    @Resource
    private RedisCache redisCache;

    @Resource
    private AppNewsService appNewsService;

    @Scheduled(cron = "0/10 * * * * ?")
    public void updateViewCount() {
        log.info("开始从redis更新新闻浏览量==>");
        //获取redis中的浏览量
        Map<String, Integer> viewNumMap = redisCache.getCacheMap(CacheConstants.NEWS_VIEW_NUM_KEY);
        List<AppNews> newsList = viewNumMap.entrySet().stream().map(entry -> {
            AppNews an = new AppNews();
            an.setNewsId(entry.getKey());
            an.setViewNum(entry.getValue());
            return an;
        }).collect(Collectors.toList());
        //更新数据库
        appNewsService.updateBatchById(newsList);
        log.info("<==新闻浏览量数据库与redis同步成功");
    }
}

redis操作工具类

@Component
public class RedisCache {

    @Resource
    public RedisTemplate redisTemplate;

    /**
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key   缓存的键值
     * @param value 缓存的值
     */
    public <T> void setCacheObject(final String key, final T value) {
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key      缓存的键值
     * @param value    缓存的值
     * @param timeout  时间
     * @param timeUnit 时间颗粒度
     */
    public <T> void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit) {
        redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
    }

    /**
     * 设置有效时间
     *
     * @param key     Redis键
     * @param timeout 超时时间，默认秒为单位
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout) {
        return expire(key, timeout, TimeUnit.SECONDS);
    }

    /**
     * 设置有效时间
     *
     * @param key     Redis键
     * @param timeout 超时时间
     * @param unit    时间单位
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout, final TimeUnit unit) {
        return redisTemplate.expire(key, timeout, unit);
    }

    /**
     * 获取有效时间
     *
     * @param key Redis键
     * @return 有效时间
     */
    public long getExpire(final String key) {
        return redisTemplate.getExpire(key);
    }

    /**
     * 判断 key是否存在
     *
     * @param key 键
     * @return true 存在 false不存在
     */
    public Boolean hasKey(String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 获得缓存的基本对象。
     *
     * @param key 缓存键值
     * @return 缓存键值对应的数据
     */
    public <T> T getCacheObject(final String key) {
        ValueOperations<String, T> operation = redisTemplate.opsForValue();
        return operation.get(key);
    }

    /**
     * 删除单个对象
     *
     * @param key
     */
    public boolean deleteObject(final String key) {
        return redisTemplate.delete(key);
    }

    /**
     * 删除集合对象
     *
     * @param collection 多个对象
     * @return
     */
    public boolean deleteObject(final Collection collection) {
        return redisTemplate.delete(collection) > 0;
    }

    /**
     * 缓存List数据
     *
     * @param key      缓存的键值
     * @param dataList 待缓存的List数据
     * @return 缓存的对象
     */
    public <T> long setCacheList(final String key, final List<T> dataList) {
        Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
        return count == null ? 0 : count;
    }

    /**
     * 获得缓存的list对象
     *
     * @param key 缓存的键值
     * @return 缓存键值对应的数据
     */
    public <T> List<T> getCacheList(final String key) {
        return redisTemplate.opsForList().range(key, 0, -1);
    }

    /**
     * 缓存Set
     *
     * @param key     缓存键值
     * @param dataSet 缓存的数据
     * @return 缓存数据的对象
     */
    public <T> BoundSetOperations<String, T> setCacheSet(final String key, final Set<T> dataSet) {
        BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);
        Iterator<T> it = dataSet.iterator();
        while (it.hasNext()) {
            setOperation.add(it.next());
        }
        return setOperation;
    }

    /**
     * 获得缓存的set
     *
     * @param key
     * @return
     */
    public <T> Set<T> getCacheSet(final String key) {
        return redisTemplate.opsForSet().members(key);
    }

    /**
     * 缓存Map
     *
     * @param key
     * @param dataMap
     */
    public <T> void setCacheMap(final String key, final Map<String, T> dataMap) {
        if (dataMap != null) {
            redisTemplate.opsForHash().putAll(key, dataMap);
        }
    }

    /**
     * 获得缓存的Map
     *
     * @param key
     * @return
     */
    public <T> Map<String, T> getCacheMap(final String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * 往Hash中存入数据
     *
     * @param key   Redis键
     * @param hKey  Hash键
     * @param value 值
     */
    public <T> void setCacheMapValue(final String key, final String hKey, final T value) {
        redisTemplate.opsForHash().put(key, hKey, value);
    }

    /**
     * 获取Hash中的数据
     *
     * @param key  Redis键
     * @param hKey Hash键
     * @return Hash中的对象
     */
    public <T> T getCacheMapValue(final String key, final String hKey) {
        HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();
        return opsForHash.get(key, hKey);
    }

    /**
     * 获取多个Hash中的数据
     *
     * @param key   Redis键
     * @param hKeys Hash键集合
     * @return Hash对象集合
     */
    public <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys) {
        return redisTemplate.opsForHash().multiGet(key, hKeys);
    }

    /**
     * 删除Hash中的某条数据
     *
     * @param key  Redis键
     * @param hKey Hash键
     * @return 是否成功
     */
    public boolean deleteCacheMapValue(final String key, final String hKey) {
        return redisTemplate.opsForHash().delete(key, hKey) > 0;
    }

    /**
     * 获得缓存的基本对象列表
     *
     * @param pattern 字符串前缀
     * @return 对象列表
     */
    public Collection<String> keys(final String pattern) {
        return redisTemplate.keys(pattern);
    }

    /**
     * map自增
     *
     * @param key
     * @param hKey
     * @param v
     */
    public void incrementCacheMapValue(String key, String hKey, long v) {
        redisTemplate.boundHashOps(key).increment(hKey, v);
    }
}