SpringMVC使用过滤器处理登陆跳转问题

问题描述：

        如果一个页面的功能需要登陆后才能使用，比如用户的个人中心，此时，点到个人中心，系统判断用户是否登陆，如果没有登陆，则跳转到登陆页面，登陆完后自动跳转到个人中心，如果用户已经登陆了，则直接跳转到个人中心。

思路：

      使用过滤器对请求进行过滤，判断session中是否有用户，如果有用户则直接放行，如果session中没有用户，判断请求是否是需要过滤的请求，如果是不是需要过滤的请求则放行，如果是需要过滤的请求，则进行过滤。在请求中把目标url作为变量放在请求中，在第二次请求中即可跳转到该页面。

实现：

       本人表达能力有限，如果看不懂描述的话可以看代码，首先是在web.xml中进行配置过滤器

<!-- Session 过滤器 -->
<!-- 检查用户是否登录了系统的过滤器配置  开始 -->
<filter>
    <filter-name>SessionFilter</filter-name>
    <filter-class>cn.xaut.filter.SessionFilter</filter-class>
    <init-param>
        <description>将当前登录的用户的信息保存在 session 中时使用的key，如果没有配置此参数，则该过滤器不起作用</description>
        <param-name>sessionKey</param-name>
        <param-value>user</param-value>
    </init-param>
    <init-param>
        <description>
	    如果用户未登录（即在 session 中 key 为 sessionKey 的属性不存在或为空），则将请求重定向到该 url。
	    该 url 不包含web应用的 ContextPath。
	    如果不配置此参数，则在用户未登录系统的情况下，直接重定向到web应用的根路径（/）
        </description>
        <param-name>forwardUrl</param-name>
        <param-value>/toLogin</param-value>
    </init-param>
    <init-param>
        <description>
	    不需要进行拦截的 url 的正则表达式，即：如果当前请求的 url 的 servletPath 能匹配该正则表达式，则直接放行（即使未登录系统）。
	    此参数的值一般为 loginServlet 和 registServlet 等。
	    另外，参数 redirectUrl 的值不用包含在该正则表达式中，因为 redirectUrl 对应的 url 会被自动放行。
	    还有一点需要说明的是，该参数的值不包含web应用的 ContextPath。
	    不拦截 /servlets/loginServlet 和 /servlets/registServlet 
        </description>
        <param-name>excepUrlRegex</param-name>
        <param-value>toLogin|toRegist</param-value>
    </init-param>
    <init-param>
        <description>首页地址</description>
	<param-name>indexPage</param-name>
	<param-value>userActioin_goPortals.do</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name>SessionFilter</filter-name>
    <url-pattern>/*</url-pattern>
    </filter-mapping>

接下来新建一个SessionFilter.java类，该类实现Filter接口，所以要重写init()，doFilter()，destroy()三个方法

package cn.xaut.filter;

import java.io.IOException;
import java.net.URLEncoder;
import java.util.Enumeration;
import java.util.regex.Pattern;
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 org.apache.commons.lang.StringUtils;

public class SessionFilter implements Filter {
/**
* 用于检查用户是否登录了系统的过滤器<br>
* @author wft
*/

//自定义Session超时状态为 timeout
public static final String Session_Time_Out = "timeout";
/** 自定义response状态值**/
public static final int ReponseState = 911; 

/** 要检查的 session 的名称 */
private String sessionKey;

/** 需要排除（不拦截）的URL的正则表达式 */
private Pattern excepUrlPattern;

/** 检查不通过时，转发的URL */
private String forwardUrl;

/** 网站首页地址 */
private String indexPage;

@Override
public void init(FilterConfig cfg) throws ServletException {
sessionKey = cfg.getInitParameter("sessionKey");
indexPage = cfg.getInitParameter("indexPage");

String excepUrlRegex = cfg.getInitParameter("excepUrlRegex");

if (!StringUtils.isBlank(excepUrlRegex)) {
excepUrlPattern = Pattern.compile(excepUrlRegex);
}

forwardUrl = cfg.getInitParameter("forwardUrl");
}

@Override
public void doFilter(ServletRequest req, ServletResponse res,
FilterChain chain) throws IOException, ServletException {

// 如果 sessionKey 为空，则直接放行
if (StringUtils.isBlank(sessionKey)) {
chain.doFilter(req, res);
return;
}

HttpServletRequest request = (HttpServletRequest) req;
HttpServletResponse response = (HttpServletResponse) res;

// 要请求的地址
String servletPath = request.getServletPath();
// 工程项目地址
String contextPath = request.getContextPath(); 

Object sessionObj = request.getSession().getAttribute(sessionKey);

if(sessionObj == null && servletPath.equals("/")){
chain.doFilter(req, res);
return;
}
	        //对静态资源进行处理
		if (servletPath.endsWith(".css") || servletPath.endsWith(".js") 
                || servletPath.endsWith(".png") || servletPath.endsWith(".jpg")||servletPath.endsWith(".jpeg")
                || servletPath.endsWith(".gif") || servletPath.endsWith(".jsp")||servletPath.endsWith("/GoSport/")
                || servletPath.endsWith(".html")) {
			chain.doFilter(req, res);
			return;
        }
		// 如果请求的路径与forwardUrl相同，或请求的路径是排除的URL时，则直接放行
		if (sessionObj !=null || servletPath.equals(forwardUrl)|| excepUrlPattern.matcher(servletPath).matches()) {
			chain.doFilter(req, res);
			return;
		}

		
		// 如果Session为空，则跳转到指定页面
		if (sessionObj == null) {
			
			System.out.println("Session Filter Catched");
			System.out.println("ServletPath -> " + servletPath);
			
			//登录后返回的页面
			String redirect = "";
			
			//判断发起请求的类型 : http 或者 ajax
			String type = request.getHeader("X-Requested-With");  
			
			if ("XMLHttpRequest".equalsIgnoreCase(type)) {
				System.out.println("Ajax 请求");
                                redirect = request.getHeader("referer");
                                if(redirect == null)
                	        redirect = contextPath + indexPage;
                        //获取到的url进行截取，等号后面的内容为目标url
                if(redirect.indexOf("=")!=-1){
                      String url[] = redirect.split("=");
                    String goUrl = url[1];
                    request.getSession().setAttribute("goUrl",goUrl);
                }
			chain.doFilter(req, res);
                return;
            } else {
            	// NORMAL REQUEST PROCESS
            	System.out.println("Http 请求");
            	redirect = getHttpGoUrl(request);
            } 
			
			
			System.out.println("redirect --> " + redirect);
			
			// 抓住后要前往的地址
			String forword = StringUtils.defaultIfEmpty(forwardUrl, "/");
			
			// 编码重定向地址
			redirect = URLEncoder.encode(redirect,"UTF-8");
			request.getSession().setAttribute("goUrl",redirect);
			
			System.out.println("跳回登录页");
			response.sendRedirect(contextPath + forword+ "?redirect=" +redirect);
			/*response.sendRedirect(contextPath + forword);*/
		}
	}
	
	/**
	 * http请求action,直接跳去这个action
	 * */
	private String getHttpGoUrl(HttpServletRequest request){
		
		StringBuffer buffer = new StringBuffer();
		String url = request.getServletPath();
		buffer.append(url);
		
		String param = request.getQueryString();//获取get的请求参数
		Enumeration<String> emParams = request.getParameterNames();//获取post的请求参数
		if (param != null) {
			buffer.append("?");
			buffer.append(param);
		}
		else
		{
			//post提交参数
			boolean first = true;
			do {
				if (!emParams.hasMoreElements()) {
					break;
				}
				String sParam = (String) emParams.nextElement();
				String[] sValues = request.getParameterValues(sParam);

				String sValue = "";
				for (int i = 0; i < sValues.length; i++) {
					sValue = sValues[i];
					//if (sValue != null && sValue.trim().length() != 0 && first == true)
					if (sValue != null && first == true) {
						// 第一个参数
						first = false;
						buffer.append("?");
						buffer.append(sParam).append("=").append(sValue);
								
					//} else if (sValue != null && sValue.trim().length() != 0 && first == false) {
					} else if (sValue != null && first == false) {
						buffer.append("&").append(sParam).append("=").append(sValue);
					}
				}
			} while (true);
		}
		return buffer.toString();
		
	}
	

	@Override
	public void destroy() {
	}
}

过滤器添加完了之后还需要在LoginController中添加重定向的代码

if (session.getAttribute("goUrl") != null)
	//如果需要重定向
    {
        goUrl = URLDecoder.decode(session.getAttribute("goUrl").toString(),"UTF-8");
        session.removeAttribute("goUrl");// 这里移除掉，免得又跳转
        errorInfo = goUrl;
    }

因为我的登陆是用ajax方式提交的，所以在ajax的代码中也需要添加跳转的代码

success : function(json) {
    if(json.result == 'error'){
        alert('用户名或密码错误！');
        return;
    }else if(json.result == 'validateFalse'){
    	alert('验证码错误！');
    	return;
    }else if(json.result == 'success'){
 	window.location.href=getRootPath();
    	return;
    }else{
        //跳转到目标url
    	window.location.href= getRootPath()+json.result;
    	return;
    }
},

至此登陆过滤器就算完成了，要过滤的action只需要在web.xml中的excepUrlRegex中添加即可