Redis实现计数器功能（接口最大访问次数检查）

1.前言

备注：不要全部粘贴代码，这个是我练习项目的代码（基于spring-boot），主要看2和3的逻辑
1.还是一个简单的redis使用Demo,包含setIfAbsent(不存在则插入)，setIfPresent（存在则更新），getExpire（获取剩余有效时间）
2.大体业务逻辑如下：检查用户请求系统的最大次数，每日最大请求次数为10.
3.也可以使用定时任务实现时效性配置（定时任务00:00执行，清空所有用户访问次数）

2.Redis配置

pom文件redis配置：

		<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

properties文件redis配置：

#redis 配置
spring.redis.host=127.0.0.1
spring.redis.port=6379
spring.redis.jedis.pool.max-active=8
spring.redis.timeout=2000

redis序列化配置：
配置序列化，防止插入redis乱码（默认二进制）

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisUtil  {
    /**
     * 因为序列化使用的jdkSerializeable ，redis存储数据默认为二进制，简单来说key和value是乱码
     * 所以自定义序列化类
     */
    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);

        // 使用Jackson2JsonRedisSerialize 替换默认序列化
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);

        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);

        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);

        // 设置value的序列化规则和 key的序列化规则
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

3.redis判断访问次数

RedisService代码：

public interface RedisService {
    /**
     * 更新时效性数据--String类型
     **/
    Boolean updateVaildValue(String key, String value);

    /**
     * 判断当前用户是否达到访问最大次数
     **/
    Boolean judgeMaxTimesByUserId(String key, String min, String max);
}

RedisServiceImpl代码：

import com.example.demo.util.redisUtil.RedisService.RedisService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;

import java.math.BigDecimal;
import java.util.concurrent.TimeUnit;

@Slf4j
@Service
public class RedisServiceImpl implements RedisService {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    /**
     * @Author longtao
     * @Date 2020/10/20
     * @Describe 更新失效性数据  保留剩余有效时间
     **/
    @Override
    public synchronized Boolean updateVaildValue(String key, String value) {
        //获取剩余时间 单位秒
        Long balanceSeconds = stringRedisTemplate.opsForValue().getOperations().getExpire(key);
        if (balanceSeconds > 0) {
            return stringRedisTemplate.opsForValue().setIfPresent(key, value, balanceSeconds, TimeUnit.SECONDS);
        }
        return false;
    }
    /**
     * @Author longtao
     * @Date   2020/10/20
     * @Describe 判断 最大访问次数 > userId当前访问次数
     **/
    @Override
    public synchronized Boolean judgeMaxTimesByUserId(String key, String min, String max) {
        //获取key的值，为null时则插入新的
        //不为null时，取出数据进行判断：是否达到最大值
        String value = stringRedisTemplate.opsForValue().get(key);
        if(StringUtils.isEmpty(value)){
        	//这里时间暂用的24小时，也可以计算得到当前时间到24:00点的毫秒时间。
            stringRedisTemplate.opsForValue().setIfAbsent(key,min,24,TimeUnit.HOURS);
            return true;
        }
        //最大次数 <= 当前访问次数
        if(new BigDecimal(max).compareTo(new BigDecimal(value)) <= 0 ){
            return false;
        }
        return updateVaildValue(key,new BigDecimal(value).add(new BigDecimal(1)).toString());
    }
}

4.切面调用检查逻辑

切面注解----CheckVisitTimesAroundAnnotation代码：

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface CheckVisitTimesAroundAnnotation {

}

切面注解----CheckVisitTimesAroundAspection代码：

//返回异常对象
return new BaseResponse<>(ResultEnum.CHECK_USER_ID_VISIT_TIMES);
这个可以换成日志输出，这里直接粘贴了我的Demo项目代码。

import com.alibaba.excel.util.StringUtils;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.example.demo.base.Enum.ResultEnum;
import com.example.demo.base.model.baseModel.BaseModel;
import com.example.demo.base.model.baseRequest.BaseRequest;
import com.example.demo.base.model.baseResponse.BaseResponse;
import com.example.demo.util.redisUtil.RedisService.RedisService;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

@Aspect
@Component
@Slf4j
@Order(2)
public class CheckVisitTimesAroundAspection {

    @Autowired
    private RedisService redisService;
    /**
     * 切入点
     */
    @Pointcut("@annotation(com.example.demo.base.annonation.CheckVisitTimesAroundAnnotation) ")
    public void entryPoint() {
    }

    /**
     * @return
     * @Describe 前置切面
     */
    @Around("entryPoint()")
    public Object aroundMethod(ProceedingJoinPoint proceedingJoinPoint) {
        log.info("------检查userId访问次数限制------start");
        Object[] args = proceedingJoinPoint.getArgs();
        //打印入口方法以及入参
        try {
            for (Object arg : args) {
                Boolean flag = judgeVisitTimesByUserId(arg);
                if(!flag){
                    //返回异常对象
                    return new BaseResponse<>(ResultEnum.CHECK_USER_ID_VISIT_TIMES);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            log.debug("不能打印请求参数");
        }
        //执行请求方法
        Object o = null;
        try {
            o = proceedingJoinPoint.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        log.info("------检查userId访问次数限制------end");
        return o;

    }

    //检查userId请求接口限制
    public Boolean judgeVisitTimesByUserId(Object object){
        BaseModel baseModel = JSONObject.parseObject(JSONObject.toJSONString(object),BaseModel.class);
        String userId = baseModel.getUserId();
        if(!StringUtils.isEmpty(userId)){
            return redisService.judgeMaxTimesByUserId(userId,"1","10");
        }
        return true;
    }
}

在controller层方法上增加注解代码：
增加@CheckVisitTimesAroundAnnotation注解

    @BaseBeforeAnnotation
    @CheckVisitTimesAroundAnnotation
    @RequestMapping("selectOne")
    public BaseResponse selectReaderInfo(@RequestBody ReaderInfoModel model) {
        ReaderInfoModel bookInfoModel = readerInfoService.selectOne(model.getId());
        return new BaseResponse(ResultEnum.SUCCESS,bookInfoModel);
    }

4.执行结果

redis中：userId 的值：

postman收到的返回值：

最后：本次写的比较仓促，我要接我老婆了。有不足的地方望大家指正和包涵！

使用redis 作为计数器

我们公司的业务 需要生成订单号大致格式是

kd01 0001 20220701 拼接的订单号 中间的0001是用作计数的

用来判断这是今天第几个单

工具类：

package com.plz.manager.util;

import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;

import java.time.LocalDate;
import java.util.Calendar;
import java.util.Date;
import java.util.concurrent.TimeUnit;

/**
 * @Author HappyLiu
 * @Description //封装redis计数器方法
 * @Date 9:15 2022/7/1
 **/
public class KdOrderIdUtil {

    public KdOrderIdUtil() {
    }
    
    /**
    * 这个方法 是返回一个 000120220701的字符串
	* 我们公司的业务 需要生成订单号大致格式是
	* kd01 0001 20220701 拼接的订单号 中间的0001是用作计数的
	* 用来判断这是今天第几个单
    */
    public static String getOrderId(RedisTemplate redisTemplate) {
        String key = "plz_num";
        String code = "";
        // 判断key是否存在 如果存在将value递增1
        if (redisTemplate.hasKey(key)) {
            int value = redisTemplate.boundValueOps(key).increment(1).intValue();
            code = String.format("%04d", value);//变成0001，如果想变成001---“%03d”
        } else {
            // 根据当前时间 距离凌晨还剩多少秒 用来给Key设置过期时间
            Integer second = getRemainSecondsOneDay(new Date());
            redisTemplate.opsForValue().set(key, "1", second, TimeUnit.SECONDS);
            code = String.format("%04d", 1);
        }
        LocalDate today = LocalDate.now();
        String YMD = today.toString().replaceAll("-", "");
        return code + YMD;
    }
    
     /**
    * 这个方法是用来获取当前时间距离凌晨00:00 还有多少毫秒(秒)
	* 用来给redis设置过期时间
    */
    public static Integer getRemainSecondsOneDay(Date currentDate) {
        Calendar midnight = Calendar.getInstance();
        midnight.setTime(currentDate);
        midnight.add(midnight.DAY_OF_MONTH, 1);//将日加1
        midnight.set(midnight.HOUR_OF_DAY, 0);//控制时
        midnight.set(midnight.MINUTE, 0);//控制分
        midnight.set(midnight.SECOND, 0);//控制秒
        midnight.set(midnight.MILLISECOND, 0);//毫秒
        //通过以上操作就得到了一个currentDate明天的0时0分0秒的Calendar对象，然后相减即可得到到明天0时0点0分0秒的时间差
        // 返回以秒为单位的秒数
        Integer second = (int) (midnight.getTime().getTime() - currentDate.getTime()) / 1000;
        // 返回以毫秒为单位的毫秒数
//        Long millisecond = (midnight.getTimeInMillis() - currentDate.getTime());
        return second;
    }
}

controller:

先把RedisTemplate 注册到容器中

然后使用工具类调用 传入即可

  @Autowired
    private RedisTemplate redisTemplate
    
    
  @RequestMapping("/test")
    public R getOrderid() {
            String orderId1 = KdOrderIdUtil.getOrderId(redisTemplate);
            String orderId2 = KdOrderIdUtil.getOrderId(redisTemplate);
            String orderId3 = KdOrderIdUtil.getOrderId(redisTemplate);
            String kd = "kd";
            String kdOrderId1 = kd+"01"+ orderId1;
            String kdOrderId2 = kd+"01"+ orderId2;
            String kdOrderId3 = kd+"01"+ orderId3;
        List<String> list = new ArrayList<>();
        list.add(kdOrderId1);
        list.add(kdOrderId2);
        list.add(kdOrderId3);
        return R.ok().put("list",list);
    }

测试结果

{
	"msg": "success",
	"code": 0,
	"list": [
		"kd01000120220701",
		"kd01000220220701",
		"kd01000320220701"
	]
}

• 当遇到需求，在规定时间，用户的访问量不能超过规定次数的时候就可以用redis中的计数器来实现了
• 又可以使用这个技术用来做限流（使用用户的ip作为key，用户访问一次，就加1，如果超过次数就返回false）
• 可以处理业务上面的的一些访问次数之类的，例如：文章的点赞数，阅读量，允许有一点的延迟效果，先保存到redis中，然后在同步到数据库当中
• 首先我们先初始化一下RedisTemplate，这个是操作redis的第三方库，我们先要对他初始化一下（重新序列化）
• 先把StringRedisTemplate注入进来,这里有人会用RedisTemplate可能会报错，可能是序列化的问题，私下百度一下就行了

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(connectionFactory);
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        // 这个地方不可使用 json 序列化，如果使用的是ObjectRecord传输对象时，可能会有问题，会出现一个 java.lang.IllegalArgumentException: Value must not be null! 错误
        redisTemplate.setHashValueSerializer(RedisSerializer.string());
        return redisTemplate;
    }
}

• 然后我们就可以用@Autowired进行注入到spring容器中使用了，这里我将方法都放在一个类中，用作与测试的

 /**
     * 利用redis做计数器
     * 可以处理业务上面的的一些访问次数之类的
     * 例如：文章的点赞数，阅读量，允许有一点的延迟效果，先保存到redis中，然后在同步到数据库当中
     */
    @RequestMapping("hello")
    public void count() {
        /**
         * 判断是否到达次数
         */
        Boolean aBoolean = invokeExceededTimes("time_key2",1,3);
        if (aBoolean) {
            LOGGER.info("可以访问");
        }else {
            LOGGER.info("请求次数达标了");
        }
    }

    /**
     * 判断同一个key在规定时间内访问次数是否到达了最高值
     * @param key   键
     * @param days  时间
     * @param count 一定时间内的访问次数
     * @return
     */
    public Boolean invokeExceededTimes(String key, int days, int count) {

        LOGGER.info("key值:{}",key);
        // 判断在redis中是否有key值
        Boolean redisKey = stringRedisTemplate.hasKey(key);
        if (redisKey) {
            // 获取key所对应的value
            Integer hasKey =Integer.parseInt((String)stringRedisTemplate.opsForValue().get(key));
            if (hasKey >= count) {
                return false;
            }
            // 对value进行加1操作
            stringRedisTemplate.opsForValue().increment(key,1);
            return true;
        }else {
            // 如果没有key值，对他进行添加到redis中
            stringRedisTemplate.opsForValue().set(key,"1",days,TimeUnit.DAYS);
        }
        return true;
    }

• 这里面有用到这两个方法，关注一下

   // 对value进行加1操作
            stringRedisTemplate.opsForValue().increment(key,1);

     // 判断在redis中是否有key值
        Boolean redisKey = stringRedisTemplate.hasKey(key);

• 最后我测试的是同一个key只能访问三次，当然根据业务需求来就行了，我这里只是一个测试
  
• 就到这里了，后面会分享更多的关于redis的操作