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

这篇文章将为大家详细讲解有关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<String, Long[]> ipMap = new HashMap<String, Long[]>();
  context.setAttribute("ipMap", ipMap);
  // 限制IP存储器：存储被限制的IP信息
  Map<String, Long> limitedIpMap = new HashMap<String, Long>();
  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<String, Long> limitedIpMap = (Map<String, Long>) 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<String, Long[]> ipMap = (Map<String, Long[]>) 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<String, Long> limitedIpMap) {
  if (limitedIpMap == null) {
   return;
  }
  Set<String> keys = limitedIpMap.keySet();
  Iterator<String> 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<String, Long> limitedIpMap, String ip) {
  if (limitedIpMap == null || ip == null) {
   // 没有被限制
   return false;
  }
  Set<String> keys = limitedIpMap.keySet();
  Iterator<String> 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<String, Long[]> 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字节码文件中存在，但运行时无法获得，
 * @Retention(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<String, String> 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怎么防止接口恶意多次请求的操作”这篇文章就分享到这里了，希望以上内容可以对大家有一定的帮助，使各位可以学到更多知识，如果觉得文章不错，请把它分享出去让更多的人看到。