java redis expire 1_运用redis键的expire时间，控制1一分钟内的访问量

客户端频繁的访问网站，会对网站资源造成很大的压力，所以，需要限制时间段内的访问次数，如果访问过于频繁，应该禁止访问，采用redis实现这一需要，redis中，可以使用expire设置key的生存时间，这一特性很好的满足我们的需求，解决代码如下：

工具类：

package cn.sniper.tjfxpt.utils;

import redis.clients.jedis.Jedis;

import redis.clients.jedis.JedisPool;

import redis.clients.jedis.JedisPoolConfig;

import redis.clients.jedis.exceptions.JedisDataException;

public class RedisUtil {

private static JedisPool jedisPool;

//每分钟允许最大访问次数

private static int MAX_ALLOWED_TIMES = 60;

static {

String host = "192.168.31.231";

int port = 6379;

JedisPoolConfig poolConfig = new JedisPoolConfig();

poolConfig.setMaxIdle(100);

poolConfig.setMaxTotal(500);

poolConfig.setMaxWaitMillis(20000);

poolConfig.setTestOnBorrow(true);

jedisPool = new JedisPool(poolConfig, host, port);

}

/**

* 如果key不存在，设置值，如果key存在，覆盖值

* @param key

* @param value

*/

public static void set(String key, String value) {

Jedis jedis = jedisPool.getResource();

jedis.set(key, value);

//用完后放回连接池

jedisPool.returnResourceObject(jedis);

}

/**

* 如果key不存在，设置值，如果key存在，不做任何操作

* @param key

* @param value

*/

public static void setIfNotExists(String key, String value) {

Jedis jedis = jedisPool.getResource();

jedis.setnx(key, value);

//用完后放回连接池

jedisPool.returnResourceObject(jedis);

}

/**

* 自加1

* @param key

* @param value

*/

public static void incrByOne(String key) {

Jedis jedis = jedisPool.getResource();

try {

//如果key对应的值不是数值型，会报异常

jedis.incr(key);

} catch(JedisDataException e) {

e.printStackTrace();

}

//用完后放回连接池

jedisPool.returnResourceObject(jedis);

}

/**

* 判断键是否存在

* @param key

* @return

*/

public static boolean exists(String key) {

Jedis jedis = jedisPool.getResource();

return jedis.exists(key);

}

/**

* 是否允许访问

* @param key

* @return

*/

public static boolean ifAllowed(String key) {

boolean flag = true;

Jedis jedis = jedisPool.getResource();

if(exists(key)) {

//key对应的value自加1

jedis.incr(key);

//取得key对应的value

String value = jedis.get(key);

try {

//如果在60秒的生存周期内的访问次数大于MAX_ALLOWED_TIMES，则不允许访问

if(Integer.parseInt(value) > MAX_ALLOWED_TIMES) {

flag = false;

}

} catch(RuntimeException e) {

e.printStackTrace();

}

} else {

//第一次访问，设置初始值1

jedis.set(key, "1");

//设置生存时间60秒

jedis.expire(key, 60);

}

//用完记得放回，否则池很快就用完

jedisPool.returnResourceObject(jedis);

return flag;

}

public static void main(String[] args) {

//setIfNotExists("sniper", "ccc");

//set("sniper", "ccc");

//incrByOne("sniper");

//System.out.println(exists("sniper"));

for(int i=0; i<70; i++) {

System.out.println(i + "" + ifAllowed("sniper"));

}

}

}

filter拦截器：

package cn.sniper.webkit.filter;

import java.io.IOException;

import javax.servlet.Filter;

import javax.servlet.FilterChain;

import javax.servlet.FilterConfig;

import javax.servlet.ServletException;

import javax.servlet.ServletRequest;

import javax.servlet.ServletResponse;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import cn.sniper.tjfxpt.utils.RedisUtil;

public class SecureFilter implements Filter {

@Override

public void init(FilterConfig filterConfig) throws ServletException {

}

@Override

public void doFilter(ServletRequest request, ServletResponse response,

FilterChain chain) throws IOException, ServletException {

boolean ifAllowed = true;

try {

HttpServletRequest req = (HttpServletRequest)request;

HttpServletResponse resp = (HttpServletResponse)response;

String uri = req.getRequestURI();

//ip地址

String ip = "";

if (req.getHeader("x-forwarded-for") == null) {

ip = req.getRemoteAddr();

} else {

ip = req.getHeader("x-forwarded-for");

}

ip = "0:0:0:0:0:0:0:1".equals(ip)?"127.0.0.1":ip;

String key = ip + "-" + uri;

ifAllowed = RedisUtil.ifAllowed(key);

if(!ifAllowed) {

req.getSession().invalidate();

resp.sendRedirect(req.getContextPath() + "/gotoError.xhtml");

} else {

chain.doFilter(request, response);

}

//防止因为redis异常导致服务不可用

} catch(Throwable e) {

chain.doFilter(request, response);

}

}

@Override

public void destroy() {

}

}