大聪明教你学Java | Spring Boot 整合 Redis 实现访问量统计

大聪明教你学Java | Spring Boot 整合 Redis 实现访问量统计 前言

之前开发系统的时候客户提到了一个需求：需要统计某些页面的访问量，记得当时还纠结了一阵子，不知道怎么去实现这个功能，后来还是在大佬的带领下借助 Redis 实现了这个功能。今天又回想起了这件事，正好和大家分享一下 Spring Boot 整合 Redis 实现访问量统计的全过程。

首先先解释一下为什么需要借助 Redis，其实原因也很简单，就是因为它非常快（每秒可执行大约110000次的 SET *** 作，每秒大约可执行81000次的 GET *** 作），我们就可以把访问量暂存在 Redis 中，当有人访问页面的时候，就直接在 Redis 中执行 +1 的 *** 作，然后再每隔一段时间把 Redis 中的访问量的数值写入到数据库中就搞定了~

肯定有小伙伴会想：如果我们不借助 Redis 而是直接 *** 作数据库的话会怎么样呢？

访问量的统计是需要频繁读写的，如果不用 Redis 做缓存而是直接 *** 作数据库的话，就会对数据库带来巨大的压力，试想一下如果此时有成千上万个人同时访问页面的话，数据库很可能在这一瞬间造成数据库的崩溃。对于这种高读写的场景，就需要直接在 Redis 上读写，等到合适的时间，再将数据批量写到数据库中。所以通常来说，在必要的时候引入Redis，可以减少MySQL（或其他）数据库的压力。

Spring Boot 整合 Redis

怎么创建 Spring Boot 项目这里就不提了，直接上重点——整合 Redis

引入依赖、增加配置

首先还是需要引入 Redis 依赖

	org.springframework.boot
	spring-boot-starter-data-redis

接下来就在配置文件中增加 Redis 的相关配置

# spring配置
spring:
  # redis配置
  redis:
    host: 127.0.0.1
    port: 6379
    database: 0
    jedis:
      pool:
        max-active: 200
        max-idle: 500
        min-idle: 8
        max-wait: 10000
    timeout: 5000

P.S. 如果 Redis 设置了密码，别忘了增加 password 配置哦 ~

翠花！上代码

首先在 Utils 包内新增一个 RedisUtil

package com.media.common.utils;

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import javax.annotation.Resource;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;


@Component
public final class RedisUtil {

    @Resource
    private RedisTemplate redisTemplate;

    // =============================common============================
    
    public boolean expire(String key, long time) {
        try {
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    
    public long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }


    
    public boolean hasKey(String key) {
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    
    @SuppressWarnings("unchecked")
    public void del(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete(CollectionUtils.arrayToList(key));
            }
        }
    }


    // ============================String=============================

    
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    

    public boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    

    public boolean set(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    
    public long incr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }


    
    public long decr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }


    // ================================Map=================================

    
    public Object hget(String key, String item) {
        return redisTemplate.opsForHash().get(key, item);
    }

    
    public Map hmget(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    
    public boolean hmset(String key, Map map) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    
    public boolean hmset(String key, Map map, long time) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    
    public boolean hset(String key, String item, Object value) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    
    public boolean hset(String key, String item, Object value, long time) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    
    public void hdel(String key, Object... item) {
        redisTemplate.opsForHash().delete(key, item);
    }


    
    public boolean hHasKey(String key, String item) {
        return redisTemplate.opsForHash().hasKey(key, item);
    }


    
    public double hincr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, by);
    }


    
    public double hdecr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, -by);
    }


    // ============================set=============================

    
    public Set