jeecg限制用户访问次数

jeecg限制用户访问次数

**防止客户恶意点击或者爬虫不断访问接口对接口进行次数限制**
*版本1 超过一定时间内次数不到指定次数返回不可访问，会产生一定时间内连续点击，只要不超过100次*

	public class RedisCountUtils {
    private static final Logger logger = LoggerFactory.getLogger(RedisCountUtils.class);

    // 30分钟
    public static final long MORE_TIME = 30 * 60 * 1000; // 30分钟
    public static final long EXPIRE_TIME = 60 * 60 * 1000; // 1个小时
    public static final int VISITS_TIME = 100; // 次数
    // 5分钟
    public static final long SAVE_TIME = 5 * 60 * 1000; // 30分钟

    /**
     * 每个人一个小时内最多访问100次接口 【版本1】
     *
     * @param message 判断缓存的KEy值
     * @param redisUtil redis工具类
     * @return
     */
    public static boolean CheckVisitsCount(RedisUtil redisUtil,String message) {
        if (oConvertUtils.isEmpty(message)) {
            return false;
        }
        // 访问次数
        int limitCount = 0;
        // 获取保存得时间戳
        Object obj = redisUtil.hget(CommonConstant.CSOM_CHECK + message, message);
        // 保存次数得key值 Item项
        String limitCountKey = "LIMIT_COUNT"+message;
        String limitCountItem = message+"_limitCount";
        // 获取保存得key值
        if (redisUtil.hget(limitCountKey,limitCountItem) == null) {
            limitCount = 1; //记录第一次
        } else {
        	// 获取缓存保存的次数
            limitCount = (int)redisUtil.hget(limitCountKey,limitCountItem);
        }

        if (obj instanceof Long) {
            long time = (Long)obj;
            if (System.currentTimeMillis() - time < EXPIRE_TIME*2) {
                // 在规定得时间内 判断访问次数
                limitCount ++;
                // 修改次数
                redisUtil.hset(limitCountKey,limitCountItem,limitCount);
                if (limitCount > VISITS_TIME) {
                    return true;
                } else {
                    return false;
                }
            } else {
                // 超过一个小时
                limitCount = 1;
                redisUtil.hset(CommonConstant.CSOM_CHECK + message, message,System.currentTimeMillis());
                redisUtil.hset(limitCountKey,limitCountItem,limitCount);
                return false;
            }
        } else {
            // 没有保存访问时间 访问次数
            redisUtil.hset(CommonConstant.CSOM_CHECK + message, message,System.currentTimeMillis());
            redisUtil.hset(limitCountKey,limitCountItem,limitCount);
            return false;
        }
    }


    /**
     * 每个人一个小时内最多访问100次接口 【比较完美版】
     *
     * @param message 判断缓存的KEy值
     * @param redisUtil redis工具类
     * @param visits_time 访问限制次数
     * @param more_time 间隔时间
     * @param expire_time 缓存保存时间
     * @return
     */
    public static boolean CheckStackCount(RedisUtil redisUtil,String message,String visits_time,
    										String more_time,String expire_time) {
        if (oConvertUtils.isEmpty(message)) {
            return false;
        }
        // 次数
        if (oConvertUtils.isEmpty(visits_time)) {
            visits_time = String.valueOf(VISITS_TIME);
        }
        if (oConvertUtils.isEmpty(more_time)) {
            more_time = String.valueOf(MORE_TIME);
        }
        if (oConvertUtils.isEmpty(expire_time)) {
            expire_time = String.valueOf(EXPIRE_TIME*24);
        }
        // key值
        String csomKey = CommonConstant.CSOM_CHECK + message;
        // 判断是否存在
        if (!redisUtil.hasKey(csomKey)) {
        	// list 保存时间戳 大小表示访问的次数
            ArrayList<Object> list = new ArrayList<>();
            list.add(System.currentTimeMillis());
            redisUtil.lSet(csomKey,list,Long.valueOf(expire_time));
            return false;
        }
        long lsize = redisUtil.lGetListSize(csomKey);
        if (lsize < Long.valueOf(visits_time)) {
            redisUtil.lSet(csomKey,System.currentTimeMillis(),Long.valueOf(expire_time));
            return false;
        } else {
        	// 获取第一个保存值
            Object obj = redisUtil.lGetIndex(csomKey, 0);
            if (obj instanceof Long) {
                long time = (Long)obj;
                System.out.println(time);
                // 时间限制
                if (System.currentTimeMillis() - time < Long.valueOf(more_time)) {
                    // 超过次数
                    return true;
                } else {
                    // 超过次数 但是时间超过时限
                    redisUtil.lSet(csomKey,System.currentTimeMillis(),Long.valueOf(expire_time));
                    redisUtil.ltrim(csomKey,1,Long.valueOf(visits_time));
                    System.out.println(redisUtil.lGet(csomKey, 0,-1).toString());
                }
            }
            return false;
        }
    }
    /**
     * 保存在redis里
     * @param prefix 前缀
     * @param message 保存的值
     * @param redisUtil redis工具类
     * @param saveTime 保存时间
     * @return
     */
    public static boolean saveRedisData(RedisUtil redisUtil, String prefix, String item,Object message,String saveTime) {
        if (oConvertUtils.isEmpty(message)) {
            return false;
        }
         if (oConvertUtils.isEmpty(saveTime)) {
             saveTime = String.valueOf(SAVE_TIME);
         }
         long time = Long.valueOf(saveTime);
        // 保存key值 前缀 + item
        String key = prefix + item;
        if (redisUtil.hHasKey(key,item)) {
            if (redisUtil.hget(key,item) == null) {
                return redisUtil.hset(key, item, message, time);
            }
            return redisUtil.hset(key, item, message, time);
        } else {
            return redisUtil.hset(key, item, message, time);
        }
    }

     /**
     * 删除redis里的值
     * @param prefix 前缀
     * @param message 保存的值
     * @param redisUtil redis工具类
     * @param item 指定的key
     * @return
     */
    public static void delRedis(RedisUtil redisUtil, String prefix, String item) {
        String key = prefix + item;
        if (redisUtil.hasKey(key)) {
             //redisUtil.hdel(key, item);
            redisUtil.del(key);
        }
    }