Springboot做请求次数统计思路

这个功能，使用到了spring aop、redis来进行完成。具体思路是：使用aop对每个请求进行环绕通知，在每次请求的时候，都进行拦截，根据拦截的接口的方法名进行区分，在redis中创建不同的key，相同的key进行累加。然后可以定时将redis的请求统计写到数据库中。

具体代码实现：

aop代码：

@Aspect
@Component
public class CountOfTimesAop {

    @Autowired
    private RedisUtil redisUtil;

    @Pointcut("execution(* com.office.controller.synchronize.*.*(..)) || execution(* com.office.controller.*.*(..))")
    public void pointCut() {
    }

    @Around("pointCut()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        String key = RedisKeyPrefixConstants.TENANT_Call_LOGS + joinPoint.getSignature().getName() + "#" + DateUtil.format(new Date(), "yyyy/MM/dd");
        redisUtil.increment(key);
        redisUtil.expire(key,24, TimeUnit.HOURS);
        return joinPoint.proceed();
    }
}

redis工具类：

@Component
@RequiredArgsConstructor
public class RedisUtil {
    @NonNull
    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 long timeout, final TimeUnit timeUnit) {
        redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
    }
    /**
     * 单机redis 锁
     *
     * @param key setNX的key
     * @param value sexNX的值
     */
    public <T> boolean setCacheObjectNX(final String key, final T value) {
        return Boolean.TRUE.equals(redisTemplate.opsForValue().setIfAbsent(key, value));
    }
    /**
     * 单机redis 锁
     *
     * @param key setNX的key
     * @param value sexNX的值
     * @param timeout 时间
     * @param timeUnit 时间颗粒度
     */
    public <T> boolean setCacheObjectNX(final String key, final T value,final long timeout, final TimeUnit timeUnit) {
        return Boolean.TRUE.equals(redisTemplate.opsForValue().setIfAbsent(key, value,timeout,timeUnit));
    }

    /**
     *
     * @param buildLockKey ： 锁名称
     * @return
     */
    public boolean tryLock(String buildLockKey){
        String lockValue = IdUtil.simpleUUID()+ Thread.currentThread().getName();
        //尝试加锁,锁失效时间为 1 分钟,覆盖业务时间
        return this.setCacheObjectNX( buildLockKey, lockValue, RedisLockConstants.DEFAULT_EXPIRE_TIME, TimeUnit.SECONDS );
    }

    /**
     * 设置有效时间
     *
     * @param key Redis键
     * @param timeout 超时时间
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout) {
        return Boolean.TRUE.equals(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 Boolean.TRUE.equals(redisTemplate.expire(key, timeout, unit));
    }

    /**根据key获取过期时间*/
    public Long getExpire(final String key){
        return redisTemplate.getExpire(key);
    }

    /** 判断key是否存在*/
    public boolean hasKey(final String key){
        return  Boolean.TRUE.equals(redisTemplate.hasKey(key));
    }

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

//    /**
//     * keys *pattern*
//     *
//     * @param
//     * @return 缓存键值对应的数据
//     */
//    public Set<String> keys(String pattern) {
//
//        return redisTemplate.keys(pattern);
//
//    }


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

    /**
     * 删除集合对象
     *
     * @param collection 多个对象
     */
    public long deleteObject(final Collection collection) {
        Long delete = redisTemplate.delete(collection);
        return ObjectUtil.isNull(delete) ? 0 :delete;
    }

    /**
     * 删除指定前缀key
     *
     * @param
     */
    public long deleteObjectPrefix(final String pattern) {
        // 获取Redis中特定前缀
        Set<String> keys = redisTemplate.keys(pattern);
        // 删除
        Long delete = redisTemplate.delete(keys);
        return ObjectUtil.isNull(delete) ? 0 :delete;
    }


    /**
     * 缓存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 List 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);
        for (T t : dataSet) {
            setOperation.add(t);
        }
        return setOperation;
    }

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

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

    /**
     * 获得缓存的Map
     */
    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中的数据
     */
    public void delCacheMapValue(final String key, final String hKey) {
        HashOperations hashOperations = redisTemplate.opsForHash();
        hashOperations.delete(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);
    }

    /**
     * 返回指定指定的所有key
     * @param pattern 字符串前缀
     * @return 对象列表
     */
    public Collection<String> keys(final String pattern) {
        return redisTemplate.keys(pattern);
    }
    /**
     * 返回指定指定的所有key,使用全匹配
     * @param pattern 字符串前缀
     * @return 对象列表
     */
    public Collection<String> keysLike(final String pattern) {
        return redisTemplate.keys("*"+pattern+"*");
    }
    /**
     * 返回指定指定的所有key,使用右匹配
     * @param pattern 字符串前缀
     * @return 对象列表
     */
    public Collection<String> keysRightLike(final String pattern) {
        return redisTemplate.keys(pattern+"*");
    }
    /**
     * 返回指定指定的所有key,使用左匹配
     * @param pattern 字符串前缀
     * @return 对象列表
     */
    public Collection<String> keysLeftLike(final String pattern) {
        return redisTemplate.keys("*"+pattern);
    }


    /**
     * 根据键值对进行累加计数
     * @param key 键值
     */
    public void increment(String key) {
        redisTemplate.opsForValue().increment(key);
    }


    public String getIncrement(String key) {
        return redisTemplate.opsForValue().get(key).toString();
    }
}

定时任务将数据写到数据库中：

@Slf4j
@Component
public class ScheduleTask {

    @Autowired
    private ServiceLogsDao serviceLogsDao;

    @Autowired
    private RedisUtil redisUtil;


    @Scheduled(cron = "0 0/5 * * * ?")
    public void init() {
        Collection<String> keys = redisUtil.keysRightLike(RedisKeyPrefixConstants.TENANT_Call_LOGS);
        String countDate = DateUtil.format(new Date(), "yyyy/MM/dd");
        //拿到当天时间的
        List<String> list = keys.stream().filter(key -> key.contains(countDate)).toList();
        //缓存没有，结束
        if(CollUtil.isEmpty(list))return;
        List<ServiceCallLogs> serviceCallLogsArrayList = new ArrayList<>(list.size());
        for (String redisDate : list) {
            //组装对象，这里相关代码没有编写，看实际情况完成。
        }
        if(CollUtil.isEmpty(serviceCallLogsArrayList))return;
        //存入mysql 存在则更新
        serviceLogsDao.getBaseMapper().replaceInsert(serviceCallLogsArrayList);
    }
}