java中过滤器的使用

public final class EntranceFilter implements Filter {

	private static final String JSONP_CALLBACK = "callback";
	private static final String JSONP_UPLOAD_CALLBACK = "uploadcallback";
	private static final String HTTP_AJAX_TYPE = "ajax";

	@SuppressWarnings("unchecked")
	public void doFilter(ServletRequest req, ServletResponse respon, FilterChain chain) throws IOException, ServletException {
		HttpServletRequest request = (HttpServletRequest) req;
		HttpServletResponse response = (HttpServletResponse) respon;
		
		//请求类型  如果是ajax请求响应头会有，x-requested-with；
		if (request.getHeader("x-requested-with") != null
				&& request.getHeader("x-requested-with").equalsIgnoreCase("XMLHttpRequest")) {
			TempleConfigContext.setCurrentRequestType(TempleConfigContext.AJAX_REQUEST_TYPE);
		}
		
		//跨域请求
		if(request.getParameter(JSONP_CALLBACK) != null || request.getParameter(JSONP_UPLOAD_CALLBACK) != null){
			TempleConfigContext.setCurrentRequestType(TempleConfigContext.AJAX_REQUEST_TYPE);
		}
		
		if(request.getParameter(HTTP_AJAX_TYPE) != null){
			TempleConfigContext.setCurrentRequestType(TempleConfigContext.AJAX_REQUEST_TYPE);
		}
		
		//请求是ajax请求
		if(TempleConfigContext.getCurrentRequestType() == TempleConfigContext.AJAX_REQUEST_TYPE){
			ByteResponseWrapper brw = new ByteResponseWrapper(response);
			chain.doFilter(request, brw);
			String out = new String(brw.getBytes());
			
			//ajax矫正
			if(TempleConfigContext.getCurrentRequestType() == TempleConfigContext.AJAX_REQUEST_TYPE){
				Map<String, Object> map = null;
				try {
					map = JsonTool.getMap4Json(out);
				} catch (JSONException ex) {
					map = new HashMap<String, Object>();
					map.put(Constant.MESSAGE, out);
				}
				
				int status = brw.getStatus();
				response.setStatus(HttpStatus.OK.value());
				if (status >= 200 && status < 300 || status == 304) {
					if (status == 304) {
						response.setStatus(HttpStatus.NOT_MODIFIED.value());
					}
					map.put(Constant.STATUS, Constant.SUCCESS);
				} else {
					map.put(Constant.STATUS, Constant.FAILURE);
				}
				out = JSONObject.fromObject(map).toString();
			}
			
//			System.out.println(out);
			if (request.getParameter(JSONP_CALLBACK) != null) {
				out = request.getParameter(JSONP_CALLBACK) + "(" + out + ");";
				response.setCharacterEncoding("utf8");
				response.setContentType("application/json;charset=" + Constant.ENCODING);
				response.setContentLength(out.getBytes().length);
				response.getOutputStream().write(out.getBytes());
				response.getOutputStream().flush();
			}else if(request.getParameter(JSONP_UPLOAD_CALLBACK) != null){
				out = URLEncoder.encode(out, Constant.ENCODING); 
				response.setCharacterEncoding(Constant.ENCODING);
				response.setContentType("text/html;charset=" + Constant.ENCODING);
				response.setHeader("Cache-Control", "no-cache");
				response.addHeader("Access-Control-Allow-Origin", "*");
				response.addHeader("Access-Control-Allow-Headers", "x-requested-with");
				response.addHeader("Location", Constant.FRONT_DOMAIN_NAME + "/deal_callback.html?" + request.getParameter(JSONP_UPLOAD_CALLBACK) + "(" + out + ")");
				response.sendRedirect(Constant.FRONT_DOMAIN_NAME + "/deal_callback.html?" + request.getParameter(JSONP_UPLOAD_CALLBACK) + "(" + out + ")");
			}else {
				response.getOutputStream().write(out.getBytes());
				response.getOutputStream().flush();
			}
		}else {
			chain.doFilter(request, respon);
		}
		
		TempleConfigContext.removeContext();
	}

	public void destroy() {
		
	}

	public void init(FilterConfig filterConfig) {

	}

	static class ByteResponseWrapper extends HttpServletResponseWrapper {
		private PrintWriter writer;
		private ByteOutputStream output;
		private int code = 200;

		public byte[] getBytes() {
			writer.flush();
			return output.getBytes();
		}

		public ByteResponseWrapper(HttpServletResponse response) {
			super(response);
			output = new ByteOutputStream();
			writer = new PrintWriter(output);
		}

		@Override
		public PrintWriter getWriter() {
			return writer;
		}

		@Override
		public ServletOutputStream getOutputStream() throws IOException {
			return output;
		}

		public int getStatus() {
			return code;
		}

		public void sendRedirect(String location) throws IOException {
			code = HttpStatus.MOVED_TEMPORARILY.value();
			super.sendRedirect(location);
		}

		@Override
		public void setStatus(int sc) {
			this.code = sc;
		}

		@Override
		public void setStatus(int sc, String message) {
			this.code = sc;
		}

		@Override
		public void sendError(int sc) throws IOException {
			this.code = sc;
		}

		@Override
		public void sendError(int sc, String msg) throws IOException {
			this.code = sc;
		}
	}

	static class ByteOutputStream extends ServletOutputStream {
		private ByteArrayOutputStream bos = new ByteArrayOutputStream();

		@Override
		public void write(int b) throws IOException {
			bos.write(b);
		}

		public byte[] getBytes() {
			return bos.toByteArray();
		}
	}

	private static class JsonTool {
		@SuppressWarnings({ "unchecked", "rawtypes" })
		public static Map getMap4Json(String jsonString) {
			JSONObject jsonObject = JSONObject.fromObject(jsonString);
			Iterator keyIter = jsonObject.keys();
			String key;
			Object value;
			Map valueMap = new HashMap();

			while (keyIter.hasNext()) {
				key = (String) keyIter.next();
				value = jsonObject.get(key);
				valueMap.put(key, value);
			}

			return valueMap;
		}
	}
}

如果请求是跨域的则请求会带一个callback的参数 进入过滤器并设置请求类型是AJAX_REQUEST_TYPE

当准备响应给浏览器时 再次进入过滤器将返回的字符串转化为JSON对象 这里controller的返回类型必须是对象类型 比如Map<String, Object>或者bean 不能是JSONArray对象或者直接是List对象 因为JsonTool.getMap4Json转化json的时候JSONObject.fromObject()这句的限制只能转化Object