Springboot 限制IP访问指定的网址实现

来自:网络
时间:2024-06-09
阅读:

IP黑白名单是网络安全管理中常见的策略工具,用于控制网络访问权限,根据业务场景的不同,其应用范围广泛

Springboot 限制IP访问指定的网址实现

方式一:

添加一个简单的白名单,然后只有白名单上面的 IP 才能访问网站,否则不能访问这是只是一个很简单的实现方法
首先:在 application.yml 配置 IP 白名单

my:
  ipList:
    - 192.168.3.3
    - 192.168.2.12
    - 192.168.5.24
    - 152.63.54.26

想要引用到配置文件里面的 String 数组,如果使用普通的 @Value 是不行的,必须使用其他方法

步骤一:创建一个实体类

@Component
@ConfigurationProperties(prefix = "my") // 这里是对应的配置文件里面自定义的 my
public class My {

    private String[] ipList;

    public My(String[] ipList) {
        this.ipList = ipList;
    }

    public String[] getIpList() {
        return ipList;
    }

    public void setIpList(String[] ipList) {
        this.ipList = ipList;
    }
}

这样配置文件的信息就保存在了这个实体类里面
在 Controller 里面比对 IP

@Controller
public class LoginController {

    @Autowired
    private My myIpList;

    @PostMapping("/login")
    @ResponseBody
    public String login(@RequestBody LoginForm loginForm, HttpServletRequest request) {
        String [] ipList = myIpList.getIpList();

        String IPAddress = loginForm.getIpAddress();
    	// 如果前端传递过来的 IP 在白名单里面,就返回 OK,如果不在,就返回 error
        for (String s : ipList) {
            if (s.equals(IPAddress)) {
                return "OK";
            }
        }
        return "error";
    }

}

方式二:限制 IP 访问的次数

这个是利用了 aop 的切面编程,如果同一个 IP 访问一个地址一分钟之内超过10次,就会把这个 IP 拉入黑名单,在自定义的时间内是不能再次访问这个网站的。

第一步,在 application.yml 中配置 Redis 相关设置

spring:
  redis:
    # 超时时间
    timeout: 10000ms
    # 服务器地址
    host: 192.168.1.1
    # 服务器端口
    port: 6379
    # 数据库
    database: 0
    # 密码
    password: xxxxxxx
    lettuce:
      pool:
        # 最大连接数,默认为 8
        max-active: 1024
        # 最大连接阻塞等待时间,默认 -1
        max-wait: 10000ms
        # 最大空闲连接
        max-idle: 200
        # 最小空闲连接
        min-idle: 5

第一步,自定义一个注解

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Documented
@Order(Ordered.HIGHEST_PRECEDENCE)
public @interface RequestLimit {

    /**
     * 允许访问的最大次数
     */
    int count() default Integer.MAX_VALUE;

    /**
     * 时间段,单位为毫秒,默认值一分钟
     */
    long time() default 60000;
}

第二步:序列化 redis 类

@Configuration
@Slf4j
public class RedisConfiguration {

    @Bean
    @ConditionalOnMissingBean
    public RedisTemplate redisTemplate(RedisConnectionFactory connectionFactory) {
        System.err.println("调用了 Redis 配置类");
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        // String 类型 key 序列器
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        // String 类型 value 序列器
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        // Hash 类型 value 序列器
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        // Hash 类型 value 序列器
        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setConnectionFactory(connectionFactory);
        return redisTemplate;
    }
}

第三步:创建一个切面类

@Aspect
@Component
@Slf4j
public class RequestLimitContract {


    private static final Logger logger = LoggerFactory.getLogger("requestLimitLogger");

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    @Autowired
    private ObjectMapper objectMapper;

    @Before("within(@org.springframework.stereotype.Controller *) && @annotation(limit)")
    public void requestLimit(final JoinPoint joinPoint , RequestLimit limit) throws RequestLimitException {
        try {
            LoginForm loginForm = new LoginForm();
            Object[] args = joinPoint.getArgs();
            HttpServletRequest request = null;
            for (int i = 0; i < args.length; i++) {
                if (args[i] instanceof HttpServletRequest) {
                    request = (HttpServletRequest) args[i];
                    break;
                } else if (args[i] instanceof LoginForm) {
                    loginForm = (LoginForm) args[i];
                }

            }
            if (request == null) {
                throw new RequestLimitException("方法中缺失HttpServletRequest参数");
            }

            //获取请求中的ip与url链接参数 用于拼接key存放redis中
            String ip = loginForm.getIpAddress();
            String url = request.getRequestURL().toString();
            Long  interview_time = new Date().getTime();
            String key = "req_limit_".concat(url).concat("---").concat(ip);
            System.err.println("准备保存在redis中的数据为-->");
            Map<String, Long> form = new HashMap<>();
            form.put("size", 1L);
            form.put("saveRedisTime", interview_time);

            if (redisTemplate.opsForValue().get(key) == null) {
                System.err.println(form);
                redisTemplate.opsForValue().set(key, form);
            } else {
                //用于进行ip访问的计数
                Map<String, Long> result = (Map<String, Long>) redisTemplate.opsForValue().get(key);
                System.err.println("从redis取到的数据(内部)");
                System.out.println(result);

                assert result != null;
                result.put("size", result.get("size") + 1);
                redisTemplate.opsForValue().set(key, result);


                if (result.get("size") > 10) {
                    logger.info("用户IP[" + ip + "]访问地址[" + url + "]超过了限定的次数[" + limit.count() + "]");
                    throw new RequestLimitException();
                }

                // 如果访问次数小于 10 次,那么一分钟过后就直接删除这个节点
                if (result.get("size") <= limit.count()) {
                    //创建一个定时器
                    Timer timer = new Timer();
                    TimerTask timerTask = new TimerTask() {
                        @Override
                        public void run() {
                            redisTemplate.delete(key);
                        }
                    };
                    //这个定时器设定在time规定的时间之后会执行上面的remove方法,也就是说在这个时间后它可以重新访问
                    timer.schedule(timerTask, limit.time());
                }
            }
        }catch (RequestLimitException e){
            throw e;
        }catch (Exception e){
            logger.error("发生异常",e);
        }
    }
}

第四步,创建一个定时器

记住要在启动类上面开启启动定时器注解

@Component
public class ScheduledTask {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

//    @Value("${properties.continueTime}")
    private final long continueTime = 120;  // 这是是黑名单的保存时间,在这个时间内,同一个IP将不能继续访问
    //    @Scheduled(cron = "0 0 0 * * ?") // 每天凌晨触发一次
    @Scheduled(fixedRate = 1000000) // 每 30s 执行一次
    public void deleteDataScheduled() {
        Set<String> keys = redisTemplate.keys("*");
        if (keys == null || keys.size() == 0) {
            return;
        }
        System.out.println("redis里面所有的key为:" + keys.toString());

        long now_time = new Date().getTime();

        for (String key : keys) {
            Map<String, Long> result = (Map<String, Long>) redisTemplate.opsForValue().get(key);
            assert result != null;
            System.err.println(result);
            // 计算出时间差
            long createTime = result.get("saveRedisTime");
            System.err.println("创建时间为:" + createTime);
            long l = (now_time - createTime) / 1000L;
            System.err.println("时间差为:" + l);
            if (l > continueTime) {
                System.out.println("禁止时间结束,解除时间限制!!!");
                redisTemplate.delete(key);
                return;
            }
            int s = Math.toIntExact(result.get("size"));
            System.out.println("s===>" + s + "   l===>" + l);
            if (s <= 10) {
                if (l > 60) {
                    System.out.println("一分钟结束,删除节点,重新计时");
                    redisTemplate.delete(key);
                }
            }
        }
    }
}

第五步:在需要的类上使用自己自定义的注解

@PostMapping("/login")
    @RequestLimit(count=10,time=60000)   // 这个注解就是开启IP限制的注解,这个注解的业务都是自己写的
    @ResponseBody
    public String login(@RequestBody LoginForm loginForm, HttpServletRequest request) {

        System.out.println("执行登录代码");

        String name = loginForm.getUsername();
        String IPAddress = loginForm.getIpAddress();
        String timestamp = String.valueOf(new Date().getTime());
        String info = Arrays.toString(ipList);

        request.setAttribute("userName", name);
        request.setAttribute("ipAddress", IPAddress);

        return "OK1";
    }

总结:在这里针对 IP 的限制就结束了,总而言之还是比较简单的,没有什么特别难的点

返回顶部
顶部