SpringBoot 防止接口恶意多次请求的操作-FinClip官网

SpringBoot 防止接口恶意多次请求的操作

网友投稿 877 2023-02-15

SpringBoot 防止接口恶意多次请求的操作

前言

刚写代码不就，还不能做深层次安全措施，今天研究了一下基本的防止接口多次恶意请求的方法。

思路

1：设置同一IP，一个时间段内允许访问的最大次数

2：记录所有IP单位时间内访问的次数

3：将所有被限制IP存到存储器

4：通过IP过滤访问请求

该demo只有后台java代码，没有前端

代码

首先是获取IP的工具类

public class Ipsettings {

public static String getRemoteHost(HttpServletRequest request) {

String ipAddress = null;

//ipAddress = request.getRemoteAddr();

ipAddress = request.getHeader("x-forwarded-for");

if(ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {

ipAddress = request.getHeader("Proxy-Client-IP");

}

if(ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {

ipAddress = request.getHeader("WL-Proxy-Client-IP");

}

if(ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {

ipAddress = request.getRemoteAddr();

if(ipAddress.equals("127.0.0.1")){

//根据网卡取本机配置的IP

InetAddress inet=null;

try {

inet = InetAddress.getLocalHost();

} catch (UnknownHostException e) {

e.printStackTrace();

}

ipAddress= inet.getHostAddress();

}

//对于通过多个代理的情况，第一个IP为客户端真实IP,多个IP按照','分割

if(ipAddress!=null && ipAddress.length()>15){ //"***.***.***.***".length() = 15

if(ipAddress.indexOf(",")>0){

ipAddress = ipAddress.substring(0,ipAddress.indexOf(","));

}

return ipAddress;

}

其次是-以及IP存储器

import java.util.HashMap;

import java.util.Map;

import javax.servlet.ServletContext;

import javax.servlet.ServletContextEvent;

import javax.servlet.ServletContextListener;

import javax.servlet.annotation.WebListener;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

@WebListener

public class MyApplicationListener implements ServletContextListener {

private Logger logger = LoggerFactory.getLogger(MyApplicationListener.class);

@Override

public void contextInitialized(ServletContextEvent sce) {

logger.info("liting: contextInitialized");

System.err.println("初始化成功");

ServletContext context = sce.getServletContext();

// IP存储器

Map ipMap = new HashMap();

context.setAttribute("ipMap", ipMap);

// 限制IP存储器：存储被限制的IP信息

Map limitedIpMap = new HashMap();

context.setAttribute("limitedIpMap", limitedIpMap);

logger.info("ipmap："+ipMap.toString()+";limitedIpMap:"+limitedIpMap.toString()+"初始化成功。。。。。");

}

@Override

public void contextDestroyed(ServletContextEvent sce) {

// TODO Auto-generated method stub

}

最后是具体规则设置

import java.io.IOException;

import java.util.Iterator;

import java.util.Map;

import java.util.Set;

import javax.servlet.Filter;

import javax.servlet.FilterChain;

import javax.servlet.FilterConfig;

import javax.servlet.ServletContext;

import javax.servlet.ServletException;

import javax.servlet.ServletRequest;

import javax.servlet.ServletResponse;

import javax.servlet.annotation.WebFilter;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

@WebFilter(urlPatterns="/*")

public class IpFilter implements Filter{

/**

* 默认限制时间（单位：ms）

private static final long LIMITED_TIME_MILLIS = 5 * 2 * 1000;

/**

* 用户连续访问最高阀值，超过该值则认定为恶意操作的IP，进行限制

private static final int LIMIT_NUMBER = 2;

/**

* 用户访问最小安全时间，在该时间内如果访问次数大于阀值，则记录为恶意IP，否则视为正常访问

private static final int MIN_SAFE_TIME = 5000;

private FilterConfig config;

@Override

public void init(FilterConfig filterConfig) throws ServletException {

this.config = filterConfig; //设置属性filterConfig

}

/* (non-Javadoc)

* @see javax.servlet.Filter#doFilter(javax.servlet.ServletRequest, javax.servlet.ServletResponse, javax.servlet.FilterChain)

@SuppressWarnings("unchecked")

@Override

public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain chain)

throws IOException, ServletException {

HttpServletRequest request = (HttpServletRequest) servletRequest;

HttpServletResponse response = (HttpServletResponse) servletResponse;

ServletContext context = config.getServletContext();

// 获取限制IP存储器：存储被限制的IP信息

Map limitedIpMap = (Map) context.getAttribute("limitedIpMap");

// 过滤受限的IP

filterLimitedIpMap(limitedIpMap);

// 获取用户IP

String ip = Ipsettings.getRemoteHost(request);

System.err.println("ip:"+ip);

//以下是处理限制IP的规则，可以自己写

// 判断是否是被限制的IP，如果是则跳到异常页面

if (isLimitedIP(limitedIpMap, ip)) {

long limitedTime = limitedIpMap.get(ip) - System.currentTimeMillis();

// 剩余限制时间(用为从毫秒到秒转化的一定会存在些许误差，但基本可以忽略不计)

request.setAttribute("remainingTime", ((limitedTime / 1000) + (limitedTime % 1000 > 0 ? 1 : 0)));

//request.getRequestDispatcher("/error/overLimitIP").forward(request, response);

System.err.println("ip访问过于频繁："+ip);

return;

}

// 获取IP存储器

Map ipMap = (Map) context.getAttribute("ipMap");

// 判断存储器中是否存在当前IP，如果没有则为初次访问，初始化该ip

// 如果存在当前ip，则验证当前ip的访问次数

// 如果大于限制阀值，判断达到阀值的时间，如果不大于[用户访问最小安全时间]则视为恶意访问，跳转到异常页面

if (ipMap.containsKey(ip)) {

Long[] ipInfo = ipMap.get(ip);

ipInfo[0] = ipInfo[0] + 1;

System.out.println("当前第[" + (ipInfo[0]) + "]次访问");

if (ipInfo[0] > LIMIT_NUMBER) {

Long ipAccessTime = ipInfo[1];

Long currentTimeMillis = System.currentTimeMillis();

if (currentTimeMillis - ipAccessTime <= MIN_SAFE_TIME) {

limitedIpMap.put(ip, currentTimeMillis + LIMITED_TIME_MILLIS);

request.setAttribute("remainingTime", LIMITED_TIME_MILLIS);

System.err.println("ip访问过于频繁："+ip);

request.getRequestDispatcher("/error/overLimitIP").forward(request, response);

return;

} else {

initIpVisitsNumber(ipMap, ip);

}

} else {

initIpVisitsNumber(ipMap, ip);

System.out.println("您首次访问该网站");

}

context.setAttribute("ipMap", ipMap);

chain.doFilter(request, response);

}

@Override

public void destroy() {

// TODO Auto-generated method stub

}

/**

* @Description 过滤受限的IP，剔除已经到期的限制IP

* @param limitedIpMap

private void filterLimitedIpMap(Map limitedIpMap) {

if (limitedIpMap == null) {

return;

}

Set keys = limitedIpMap.keySet();

Iterator keyIt = keys.iterator();

long currentTimeMillis = System.currentTimeMillis();

while (keyIt.hasNext()) {

long expireTimeMillis = limitedIpMap.get(keyIt.next());

if (expireTimeMillis <= currentTimeMillis) {

keyIt.remove();

}

/**

* @Description 是否是被限制的IP

* @param limitedIpMap

* @param ip

* @return true : 被限制 | false : 正常

private boolean isLimitedIP(Map limitedIpMap, String ip) {

if (limitedIpMap == null || ip == null) {

// 没有被限制

return false;

}

Set keys = limitedIpMap.keySet();

Iterator keyIt = keys.iterator();

while (keyIt.hasNext()) {

String key = keyIt.next();

if (key.equals(ip)) {

// 被限制的IP

return true;

}

return false;

}

/**

* 初始化用户访问次数和访问时间

* @param ipMap

* @param ip

private void initIpVisitsNumber(Map ipMap, String ip) {

Long[] ipInfo = new Long[2];

ipInfo[0] = 0L;// 访问次数

ipInfo[1] = System.currentTimeMillis();// 初次访问时间

ipMap.put(ip, ipInfo);

}

然后再在启动类上加上注解扫描配置包

@ServletComponentScan(basePackages="扫描刚才的MyApplicationListener")

补充：springboot和redis控制单位时间内同个ip访问同个接口的次数

第一步：自定义一个注解

注：其实完全没必要（这样做的唯一好处就是每个接口与的访问限制次数都可以不一样）。。但是注解这个东西自从培训结束后没有在用到过，决定还是再复习下

package com.mzd.redis_springboot_mybatis_mysql.limit;

import org.springframework.core.Ordered;

import org.springframework.core.annotation.Order;

import java.lang.annotation.*;

/**

* @Retention：注解的保留位置

* @Retention(RetentionPolicy.SOURCE) //注解仅存在于源码中，在class字节码文件中不包含

* @Retention(RetentionPolicy.CLASS) // 默认的保留策略，注解会在class字节码文件中存在，但运行时无法获得，

* @Retentihttp://on(RetentionPolicy.RUNTIME) // 注解会在class字节码文件中存在，在运行时可以通过反射获取到

@Retention(RetentionPolicy.RUNTIME)

/**

* @Target:注解的作用目标

* @Target(ElementType.TYPE) //接口、类、枚举、注解

* @Target(ElementType.FIELD) //字段、枚举的常量

* @Target(ElementType.METHOD) //方法

* @Target(ElementType.PARAMETER) //方法参数

* @Target(ElementType.CONSTRUCTOR) //构造函数

* @Target(ElementType.LOCAL_VARIABLE) //局部变量

* @Target(ElementType.ANNOTATION_TYPE) //注解

* @Target(ElementType.PACKAGE) ///包

@Target(ElementType.METHOD)

/**

* @Document 说明该注解将被包含在javadoc中

@Documented

/**

* Ordered接口是由spring提供的，为了解决相同接口实现类的优先级问题

//最高优先级- - - 个人觉得这个在这里没必要加

//@order，使用注解方式使类的加载顺序得到控制

@Order(Ordered.HIGHEST_PRECEDENCE)

public @interface RequestTimes {

//单位时间允许访问次数 - - -默认值是2

int count() default 2;

//设置单位时间为1分钟 - - - 默认值是1分钟

long time() default 60 * 1000;

}

Ordered:

1、接口内容：我们可以打开这个接口查看它的源码

我们可以看到这个接口中只有一个方法两个属性，一个是int的最小值，另一个是int的最大值

2、OrderComparator接口： PriorityOrdered是个接口，是Ordered接口的子类，并没有实现任何方法

这个Comparator方法的逻辑大致是：

PriorityOrdered的优先级高于Ordered

如果两个都是Ordered或者PriorityOrdered就比较他们的order值，order值越大，优先级越小

第二步：定义一个aop

package com.mzd.redis_springboot_mybatis_mysql.limit;

import com.mzd.redis_springboot_mybatis_mysql.bean.generator.Student;

import org.aspectj.lang.JoinPoint;

import org.aspectj.lang.annotation.Aspect;

import org.aspectj.lang.annotation.Before;

import org.aspectj.lang.annotation.Pointcut;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.data.redis.core.RedisTemplate;

import org.springframework.stereotype.Component;

import org.springframework.web.context.request.RequestContextHolder;

import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;

import java.util.concurrent.TimeUnit;

//使用@Aspect注解将一个java类定义为切面类

@Aspect

@Component

public class RequestTimesAop {

@Autowired

private RedisTemplate redisTemplate;

//切面范围

@Pointcut("execution(public * com.mzd.redis_springboot_mybatis_mysql.controller.*.*(..))")

public void WebPointCut() {

}

@Before("WebPointCut() && @annotation(times)")

/**

* JoinPoint对象封装了SpringAop中切面方法的信息,在切面方法中添加JoinPoint参数,就可以获取到封装了该方法信息的JoinPoint对象.

public void ifovertimes(final JoinPoint joinPoint, RequestTimes times) {

try {

//java.lang.Object[] getArgs()：获取连接点方法运行时的入参列表；

//Signature getSignature() ：获取连接点的方法签名对象；

//java.lang.Object getTarget() ：获取连接点所在的目标对象；

//java.lang.Object getThis() ：获取代理对象本身；

//####################################################################

/**

* 比如：获取连接点方法运行时的入参列表

* 不足：如果连接点方法中没有request参数的话，就没法获取request，如果不做处理的话，会报空指针异常的

* 但是所有请求怎么可能没有request

// Object[] objects = joinPoint.getArgs();

// HttpServletRequest request = null;

// for (int i = 0; i < objects.length; i++) {

// if (objects[i] instanceof HttpServletRequest) {

// request = (HttpServletRequest) objects[i];

// break;

// }

//####################################################################

/**

* 另一种获取request

ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();

HttpServletRequest request = attributes.getRequest();

String ip = request.getRemoteAddr();

String url = request.getRequestURL().toString();

String key = "ifovertimes".concat(url).concat(ip);

//访问次数加一

long count = redisTemplate.opsForValue().increment(key, 1);

//如果是第一次，则设置过期时间

if (count == 1) {

redisTemplate.expire(key, times.time(), TimeUnit.MILLISECONDS);

}

if (count > times.count()) {

request.setAttribute("ifovertimes", "true");

} else {

request.setAttribute("ifovertimes", "false");

}

} catch (Exception e) {

e.printStackTrace();

}

提问：就是在aop方法中返回的值在controller层值如何才能获得，比如：ifovertimes这个方法返回的String类型的值，那我在controller层如何获得这个值。我现在是将这个值放在了request域里面，不知道有没有别的更好的值。。。求大神帮助啊。。。

第三步：写一个测试接口

@RequestTimes(count = 3, time = 60000)

@RequestMapping("hello.do")

public String hello(String username, HttpServletRequest request) {

System.out.println(request.getAttribute("ifovertimes"));

if (request.getAttribute("ifovertimes").equals("false")) {

System.out.println(username);

return "hello redis_springboot_mybatis_mysql";

}

return "HTTP请求超出设定的限制";

}

总结：

这是一个完全可以跑的例子，当然，springboot集成redis这里就不讲了。。。

微信小程序实现对接七牛云存储的具体实例讲解

877 2023-02-15

SpringBoot 防止接口恶意多次请求的操作

开发微信公众平台配置接口程序详细步骤

微信小程序实现对接七牛云存储的具体实例讲解

微信小程序实例讲解倒计时功能的实现途径

最近发表

更多内容

小程序SDK

Finclip技术文档

小程序开发

小程序容器

小程序框架

Finclip小程序平台

Finclip用户投稿

车联网

推荐文章

小程序SDK是什么意思？小程序sdk和插件有什么区别？

小程序支付功能怎么实现？

企业app开发流程是什么？

app运营模式有哪些？

小程序多端引流怎么做？

小程序生态分析的机会和威胁

Flutter入门这一篇效率文章就够了

原生与跨平台解决方案分析,跨平台软件开发技术方案

热更新技术：让软件更新变得更加轻松快速

解决方案

银行解决方案

证券解决方案

互联网解决方案

政企OA解决方案

科技解决方案

loT解决方案

信任解决方案

热评文章

AppCan:基于混合模式的移动应用开发,移动混合模

Hybrid App混合模式开发的了解

小程序容器技术助力券商数字营销突围，小程序容器化的意

用mpvue开发微信小程序基础知识（vue.js开发

小程序多端框架全面测评对比，强烈推荐！

开放银行银行案例，迎接金融创新的未来