Springboot 限制IP访问指定的网址实现
作者：NLD_GOD
本文主要介绍了Springboot 限制IP访问指定的网址实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
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 的限制就结束了，总而言之还是比较简单的，没有什么特别难的点
到此这篇关于Springboot 限制IP访问指定的网址实现的文章就介绍到这了,更多相关Springboot 限制IP访问指定网址内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！