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集成redis这里就不讲了。。。

以上为个人经验，希望能给大家一个参考，也希望大家多多支持。如有错误或未考虑完全的地方，望不吝赐教。