springmvc实现网站限流

辅助类，用于存储每个请求的访问数

public class AccessCounts {

	public static final String CALLPATH = "AccessCounts.CALLPATH";
	
	private ConcurrentHashMap<Object, AtomicInteger> map = new ConcurrentHashMap<Object, AtomicInteger>();
	private AccessCounts() {
	}
	
	private static class Instance {
		static AccessCounts counts = new AccessCounts();
	}
	
	public static AccessCounts getInstance() {
		return Instance.counts;
	}
	
	public int get(Object key) {
		AtomicInteger counter = map.get(key);
		if (counter == null) {
			counter = new AtomicInteger(0);
			map.put(key, counter);
		}
		return counter.intValue();
	}
	
	public int incrementAndGet(Object key) {
		AtomicInteger counter = map.get(key);
		if (counter == null) {
			counter = new AtomicInteger(0);
			map.put(key, counter);
		}
		return counter.incrementAndGet();
	}
	
	public int decrementAndGet(Object key) {
		AtomicInteger counter = map.get(key);
		if (counter == null) {
			return 0;
		}
		return counter.decrementAndGet();
	}
	
	public String status(){
		return map.toString();
	}
}

拦截器

/**
 *限流拦截器
 **/
public class InServiceAccessInterceptor extends HandlerInterceptorAdapter {

	private static final Logger logger = Logger.getLogger(InServiceAccessInterceptor.class);

	private ConcurrentHashMap<String, Integer> config = new ConcurrentHashMap<String, Integer>();
	
	// setting
	private int defaultLimit = 100;
	
	private String configUrl = null;
	private int loadInterval = 1, loadDelay=5;
	private boolean valid;
	
	public InServiceAccessInterceptor(int defaultLimit, String configUrl, int loadInterval, int loadDelay, boolean valid) {
		this.defaultLimit = defaultLimit;
		this.configUrl = configUrl;
		this.loadInterval = loadInterval;
		this.loadDelay = loadDelay;
		this.valid = valid;
		if(valid){
			task();
		}
	}
	
	//before the actual handler will be executed
	@Override
	public boolean preHandle(HttpServletRequest request,
			HttpServletResponse response, Object handler) throws Exception {
		if(valid){
			if(handler instanceof HandlerMethod){
				HandlerMethod handlerMethod = (HandlerMethod) handler;
			    String callpath = handlerMethod.getMethod().getDeclaringClass().getSimpleName()+"."+handlerMethod.getMethod().getName();
				System.out.println(callpath);
			    int counter = AccessCounts.getInstance().get(callpath);
				boolean limit = limit(callpath, counter);
				if (limit) {
					throw new IllegalAccessException("Flowing Limit." + callpath + "=" +counter );
				}
				MDC.put(AccessCounts.CALLPATH, callpath);
				AccessCounts.getInstance().incrementAndGet(callpath);
			}
		}
		return true;
	}
	
	//after the handler is executed
	@Override
	public void postHandle(HttpServletRequest request,
			HttpServletResponse response, Object handler,
			ModelAndView modelAndView) throws Exception {
		if(valid){
			Object callpath = MDC.get(AccessCounts.CALLPATH);
			if (null != callpath) {
				AccessCounts.getInstance().decrementAndGet( callpath);
			}
			MDC.remove(AccessCounts.CALLPATH);
		}
    }
	
	@Override
	public void afterCompletion(HttpServletRequest request,
			HttpServletResponse response, Object handler, Exception ex)
			throws Exception {
		// TODO Auto-generated method stub
		
	}
	
	private boolean limit(String callpath, int counter) {

		Integer obj = config.get(callpath);
		int limit = defaultLimit;
		if (obj != null) {
			limit = obj.intValue();
		}
		if (logger.isDebugEnabled() ) {
			logger.debug("check callpath:" + callpath + " limit:" + limit);
		}
		if (counter >= limit) {
			logger.warn("the call[" + callpath + "] is over limit:" + limit + " counter:" + counter);
			return true;
		}
		return false;
	}

	public static String sendGet(String url, String param) {
		String result = "";
		BufferedReader in = null;
		try {
			String urlNameString = url + (param == null ? "" : "?" + param);
			URL realUrl = new URL(urlNameString);
			// 打开和URL之间的连接
			URLConnection connection = realUrl.openConnection();
			// 设置通用的请求属性
			connection.setRequestProperty("accept", "*/*");
			connection.setRequestProperty("connection", "Keep-Alive");
			connection.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
			// 建立实际的连接
			connection.connect();
			// 获取所有响应头字段
			/*Map<String, List<String>> map = connection.getHeaderFields();
			for (String key : map.keySet()) {
				System.out.println(key + "--->" + map.get(key));
			}*/
			// 定义 BufferedReader输入流来读取URL的响应
			in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
			String line;
			while ((line = in.readLine()) != null) {
				result += line;
			}
		} catch (Exception e) {
			logger.error("request url fail="+url, e);
		}
		// 使用finally块来关闭输入流
		finally {
			try {
				if (in != null) {
					in.close();
				}
			} catch (Exception e) {
			}
		}
		return result;
	}
	
	public void task() {
		TimerTask task = new TimerTask() {  
            @Override  
            public void run() { 
            	if (null == configUrl ) return;
            	String text = sendGet(configUrl, null);
            	logger.info("load config:" + text );
            	if ( null == text || "".equals(text.trim())) return;
            	
            	text = text.replaceAll("[\\{\\}\"\n]", "");
            	config.clear();
            	for (String line : text.split(",")) {
            		String fields[] = line.split(":");
            		if ( fields.length < 2) continue;
            		try {
            			config.put(fields[0].trim(), Integer.valueOf(fields[1].trim()));
            		} catch (Exception e) {
            			logger.error("load config fail.", e);
            		}
            	}
            }
        };
        Timer timer = new Timer();  
        long delay = 1000 * loadDelay;  
        long intevalPeriod = 1000 * loadInterval;  
        // schedules the task to be run in an interval  
        logger.info("Task setting  delay:" + delay + "  intevalPeriod:" + intevalPeriod);
        timer.scheduleAtFixedRate(task, delay, intevalPeriod); 
        
        new Thread(new Runnable() {
			@Override
			public void run() {
				while (true) {
					try {
						Thread.sleep(60*1000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println("AccessCounts status:" + AccessCounts.getInstance().status());
				}
			}
		}).start();

	}
	

}

xml配置

<mvc:interceptors>
		<mvc:interceptor>
			<mvc:mapping path="/**" />
			<beans:bean class="xxx.xxx.xxx.intercept.InServiceAccessInterceptor">
				<beans:constructor-arg index="0" value="1000" /> <!-- defaultLimit 默认设置 -->
				<beans:constructor-arg index="1" value="http://localhost/web.limit" /> <!--　configUrl    -->
		        <beans:constructor-arg index="2" value="60" /> <!-- loadInterval unit : second -->
		        <beans:constructor-arg index="3" value="5" /> <!-- loadDelay unit : second -->
		        <beans:constructor-arg index="4" value="false" /> <!-- valid  true: used -->
			</beans:bean>
		</mvc:interceptor>
</mvc:interceptors>

http://localhost/web.limit文件

{"IndexController.index":500,
"ProductController.searchProducts":500
}