前言
刚写代码不就，还不能做深层次安全措施，今天研究了一下基本的防止接口多次恶意请求的方法。
思路
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这里就不讲了。。。
以上为个人经验，希望能给大家一个参考，也希望大家多多支持www.887551.com。如有错误或未考虑完全的地方，望不吝赐教。
黄山市民网：https://www.huangshanshimin.com/
