一、问题描述

某个系统的登录接口在被刷。现要建立一个防刷/限流机制，根据登录 IP，30 分钟之内，只能发起 30 次登录请求。如果超过该限制，则整个 IP 限制登录请求 30 分钟。

二、设计思路

这道题主要是设计两个 Map：

1️⃣第一个 Map，记录每个 IP 及其登录的时间。题目要求，30 分钟之内只能登录 30 次，所以 Map 的 key 为 IP，value 可以设计一个队列，队列长度 30，队列元素为每次的登录时间。

2️⃣第二个 Map，记录禁止登录的 IP 及禁止开始时间。Map 的 key 为 IP，value 为时间。

三、限流器实现代码

单例模式是为了保证一个 JVM 中只有一个限流器。

import java.time.LocalDateTime;
import java.util.HashMap;
import java.util.LinkedList;

public class LimitCache {
    private static volatile LimitCache instance;
    // 记录登录的ip地址及每次登录时间
    private static HashMap<String, LinkedList<LocalDateTime>> loginMap = new HashMap<>();
    // 记录禁止登录的ip地址及禁止开始时间
    private static HashMap<String, LocalDateTime> forbiddenMap = new HashMap<>();
    // 构造器私有化，不能在类的外部随意创建对象
    private LimitCache() {
    }
    // 提供一个全局的访问点来获得这个"唯一"的对象
    public static LimitCache getInstance() {
        if (instance == null) {
            synchronized (LimitCache.class) {
                if (instance == null) {
                    instance = new LimitCache();
                }
            }
        }
        return instance;
    }

    public static HashMap<String, LinkedList<LocalDateTime>> getLoginMap() {
        return loginMap;
    }
    public static HashMap<String, LocalDateTime> getForbiddenMap() {
        return forbiddenMap;
    }
}

四、限流实现逻辑

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;
import java.util.LinkedList;

/**
 * 模拟登录
 */
@RestController
public class LoginController {

    @GetMapping("/login")
    public String login(String ip) {
        String result = "";
        LimitCache limitCache = LimitCache.getInstance();
        LinkedList<LocalDateTime> queue = null;

        // 先判断ip地址是否禁止登录
        LocalDateTime forbiddenTime = limitCache.getForbiddenMap().get(ip);
        if (forbiddenTime != null) {
            Long after = ChronoUnit.MINUTES.between(forbiddenTime, LocalDateTime.now());
            if (after <= 30) {
                result = "当前时间=" + LocalDateTime.now() + " 上次禁止登录时间= " + forbiddenTime + " 距上次被禁时间没有超过30分钟";
                return result;
            } else {
                limitCache.getForbiddenMap().clear();
            }
        }

        // 如果是首次登录，则创建队列
        if (limitCache.getLoginMap().get(ip) == null) {
            queue = new LinkedList<>();
        } else {
            queue = limitCache.getLoginMap().get(ip);
        }

        // 登录次数达到登录次数上限
        if (queue.size() == 30) {
            // 当前时间和队列中最早的登录时间比较 是否小于30分钟
            LocalDateTime now = LocalDateTime.now();
            LocalDateTime firstLoginTime = queue.poll();
            Long duration = ChronoUnit.MINUTES.between(firstLoginTime, now);
            if (duration <= 30) {
                result = "30分钟内登录超过30次，不允许登录,30分钟后再登录";
                // 禁止该IP登录
                limitCache.getLoginMap().clear();
                limitCache.getForbiddenMap().put(ip, now);
                return result;
            }
        }
        queue.offer(LocalDateTime.now());
        limitCache.getLoginMap().put(ip, queue);

        result = ip + " 登录时间=" + queue.getLast() + "  队列长度=" + queue.size();
        return result;
    }
}