Spring Session源码解读

public interface ServletContainerInitializer {

	public void onStartup(Set<Class<?>> c, ServletContext ctx)
		throws ServletException;

}

@HandlesTypes(WebApplicationInitializer.class)
public class SpringServletContainerInitializer implements ServletContainerInitializer {
	@Override
	public void onStartup(Set<Class<?>> webAppInitializerClasses, ServletContext servletContext)
			throws ServletException {
        List<WebApplicationInitializer> initializers = new LinkedList<WebApplicationInitializer>();
		if (webAppInitializerClasses != null) {
			for (Class<?> waiClass : webAppInitializerClasses) {
				initializers.add((WebApplicationInitializer) waiClass.newInstance());
			}
		}
		for (WebApplicationInitializer initializer : initializers) {
			initializer.onStartup(servletContext);
		}
	}
}

public interface WebApplicationInitializer {
	void onStartup(ServletContext servletContext) throws ServletException;
}

public void onStartup(ServletContext servletContext)
		throws ServletException {
	beforeSessionRepositoryFilter(servletContext);
	if(configurationClasses != null) {
		AnnotationConfigWebApplicationContext rootAppContext = new AnnotationConfigWebApplicationContext();
		rootAppContext.register(configurationClasses);
		servletContext.addListener(new ContextLoaderListener(rootAppContext));
	}
	insertSessionRepositoryFilter(servletContext);
	afterSessionRepositoryFilter(servletContext);
}

private void insertSessionRepositoryFilter(ServletContext servletContext) {
	String filterName = DEFAULT_FILTER_NAME;
	DelegatingFilterProxy springSessionRepositoryFilter = new DelegatingFilterProxy(filterName);
	String contextAttribute = getWebApplicationContextAttribute();
	if(contextAttribute != null) {
		springSessionRepositoryFilter.setContextAttribute(contextAttribute);
	}
	registerFilter(servletContext, true, filterName, springSessionRepositoryFilter);
}

public final void init(FilterConfig filterConfig) throws ServletException {
	// 伪代码，利用filterConfig里的参数为filter做属性自动注入
	// Let subclasses do whatever initialization they like.
	initFilterBean();
}

protected void initFilterBean() throws ServletException {
	synchronized (this.delegateMonitor) {
		if (this.delegate == null) {
			// If no target bean name specified, use filter name.
			if (this.targetBeanName == null) {
				this.targetBeanName = getFilterName();
			}
			WebApplicationContext wac = findWebApplicationContext();
			if (wac != null) {
				this.delegate = initDelegate(wac);
			}
		}
	}
}
protected Filter initDelegate(WebApplicationContext wac) throws ServletException {
	Filter delegate = wac.getBean(getTargetBeanName(), Filter.class);
	if (isTargetFilterLifecycle()) {
		delegate.init(getFilterConfig());
	}
	return delegate;
}

@Import(RedisHttpSessionConfiguration.class)
@Configuration
public @interface EnableRedisHttpSession {
	int maxInactiveIntervalInSeconds() default 1800;
}

@Bean
public <S extends ExpiringSession> SessionRepositoryFilter<? extends ExpiringSession> springSessionRepositoryFilter(SessionRepository<S> sessionRepository, ServletContext servletContext) {
	SessionRepositoryFilter<S> sessionRepositoryFilter = new SessionRepositoryFilter<S>(sessionRepository);
	sessionRepositoryFilter.setServletContext(servletContext);
	if(httpSessionStrategy != null) {
		sessionRepositoryFilter.setHttpSessionStrategy(httpSessionStrategy);
	}
	return sessionRepositoryFilter;
}

@Override
public void contextInitialized(ServletContextEvent event) {
	initWebApplicationContext(event.getServletContext());
}

public WebApplicationContext initWebApplicationContext(ServletContext servletContext) {
	configureAndRefreshWebApplicationContext(cwac, servletContext);
	servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);
	return this.context;
}

protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
	beanFactory.addBeanPostProcessor(new ServletContextAwareProcessor(this.servletContext, this.servletConfig));
	beanFactory.ignoreDependencyInterface(ServletContextAware.class);
	beanFactory.ignoreDependencyInterface(ServletConfigAware.class);
	//在这里将ServletContext作为一个bean管理起来WebApplicationContextUtils.registerWebApplicationScopes(beanFactory, this.servletContext);
	WebApplicationContextUtils.registerEnvironmentBeans(beanFactory, this.servletContext, this.servletConfig);
}

public class ServletRequestWrapper implements ServletRequest {

	private ServletRequest request;
	public ServletRequestWrapper(ServletRequest request) {
	    if (request == null) {
	        throw new IllegalArgumentException("Request cannot be null");   
	    }
	    this.request = request;
	}

	public ServletRequest getRequest() {
	    return this.request;
	}

	public Object getAttribute(String name) {
	    return this.request.getAttribute(name);
	}
}

public class HttpServletRequestWrapper extends ServletRequestWrapper implements HttpServletRequest {

    public HttpServletRequestWrapper(HttpServletRequest request) {
        super(request);
    }

    private HttpServletRequest _getHttpServletRequest() {
        return (HttpServletRequest) super.getRequest();
    }

	......

}

protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {

	request.setAttribute(SESSION_REPOSITORY_ATTR, sessionRepository);

	SessionRepositoryRequestWrapper wrappedRequest = new SessionRepositoryRequestWrapper(request, response, servletContext);
	SessionRepositoryResponseWrapper wrappedResponse = new SessionRepositoryResponseWrapper(wrappedRequest,response);

	HttpServletRequest strategyRequest = httpSessionStrategy.wrapRequest(wrappedRequest, wrappedResponse);
	HttpServletResponse strategyResponse = httpSessionStrategy.wrapResponse(wrappedRequest, wrappedResponse);

	try {
	    filterChain.doFilter(strategyRequest, strategyResponse);
	} finally {
	    wrappedRequest.commitSession();
	}

}

abstract class OncePerRequestFilter implements Filter {

	public final void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain) throws ServletException, IOException {
		//alreadyFilteredAttributeName是个静态变量，由类名+.filtered构成
		//这样就能保证同一个类只被调用一次。
		boolean hasAlreadyFilteredAttribute = request.getAttribute(alreadyFilteredAttributeName) != null;

		if (hasAlreadyFilteredAttribute) {
		    filterChain.doFilter(request, response);
		} else {
			request.setAttribute(alreadyFilteredAttributeName, Boolean.TRUE);
			try {
				//通过模板方法，将处理交给子类
				doFilterInternal(httpRequest, httpResponse, filterChain);
			}
		}
	}

}

public HttpSession getSession(boolean create) {
	HttpSessionWrapper currentSession = getCurrentSession();
	if(currentSession != null) {
		return currentSession;
	}
	String requestedSessionId = getRequestedSessionId();
	if(requestedSessionId != null) {
		S session = sessionRepository.getSession(requestedSessionId);
		if(session != null) {
			this.requestedSessionIdValid = true;
			currentSession = new HttpSessionWrapper(session, getServletContext());
			//从数据仓库提取出来的session状态不为new
			currentSession.setNew(false);
			setCurrentSession(currentSession);
			return currentSession;
		}
	}
	if(!create) {
		return null;
	}
	S session = sessionRepository.createSession();
	currentSession = new HttpSessionWrapper(session, getServletContext());
	setCurrentSession(currentSession);
	return currentSession;
}

private final class HttpSessionWrapper implements HttpSession {

	public HttpSessionWrapper(S session, ServletContext servletContext) {
		this.session = session;
		this.servletContext = servletContext;
	}
	//省略了大部分方法，都是委托给被包装的Session处理的

	//对session坐invalidate时去数据仓库删掉对应的数据
	public void invalidate() {
		checkState();
		this.invalidated = true;
		requestedSessionInvalidated = true;
		setCurrentSession(null);
		sessionRepository.delete(getId());
	}

	public void setNew(boolean isNew) {
		this.old = !isNew;
	}

	public boolean isNew() {
		checkState();
		return !old;
	}

}

public interface ExpiringSession extends Session {

    //session的创建时间
    long getCreationTime();

    //session的上次访问时间
    long getLastAccessedTime();

    //设置最大访问间隔，超过这个间隔session会被invalidate
    void setMaxInactiveIntervalInSeconds(int interval);

    int getMaxInactiveIntervalInSeconds();

    //session是否失效
    boolean isExpired();

}

private void commitSession() {
    HttpSessionWrapper wrappedSession = getCurrentSession();
    if(wrappedSession == null) {
        if(isInvalidateClientSession()) {
            httpSessionStrategy.onInvalidateSession(this, response);
        }
    } else {
        S session = wrappedSession.session;
        sessionRepository.save(session);
        if(!isRequestedSessionIdValid() || !session.getId().equals(getRequestedSessionId())) {
            httpSessionStrategy.onNewSession(session, this, response);
        }
    }
}

public void onNewSession(Session session, HttpServletRequest request, HttpServletResponse response) {
	Set<String> sessionIdsWritten = getSessionIdsWritten(request);
	if(sessionIdsWritten.contains(session.getId())) {
	    return;
	}
	sessionIdsWritten.add(session.getId());
	Map<String,String> sessionIds = getSessionIds(request);
	String sessionAlias = getCurrentSessionAlias(request);
	sessionIds.put(sessionAlias, session.getId());
	Cookie sessionCookie = createSessionCookie(request, sessionIds);
	response.addCookie(sessionCookie);
}

private Cookie createSessionCookie(HttpServletRequest request, Map<String, String> sessionIds) {

	//cookieName是"SESSION"，spring的session cookie都是
	//以"SESSION"命名的
	Cookie sessionCookie = new Cookie(cookieName,"");
	//省略部分非关键逻辑

	if(sessionIds.isEmpty()) {
	    sessionCookie.setMaxAge(0);
	    return sessionCookie;
	}

	if(sessionIds.size() == 1) {
	    String cookieValue = sessionIds.values().iterator().next();
	    sessionCookie.setValue(cookieValue);
	    return sessionCookie;
	}
	StringBuffer buffer = new StringBuffer();
	for(Map.Entry<String,String> entry : sessionIds.entrySet()) {
	    String alias = entry.getKey();
	    String id = entry.getValue();

	buffer.append(alias);
	buffer.append(" ");
	buffer.append(id);
	buffer.append(" ");
	}
	buffer.deleteCharAt(buffer.length()-1);

	sessionCookie.setValue(buffer.toString());
	return sessionCookie;

}

public Map<String,String> getSessionIds(HttpServletRequest request) {
    Cookie session = getCookie(request, cookieName);
    String sessionCookieValue = session == null ? "" : session.getValue();
    Map<String,String> result = new LinkedHashMap<String,String>();
    StringTokenizer tokens = new StringTokenizer(sessionCookieValue, " ");
    //单用户cookie的情况
    if(tokens.countTokens() == 1) {
        result.put(DEFAULT_ALIAS, tokens.nextToken());
        return result;
    }
    while(tokens.hasMoreTokens()) {
        String alias = tokens.nextToken();
        if(!tokens.hasMoreTokens()) {
            break;
        }
        String id = tokens.nextToken();
        result.put(alias, id);
    }
    return result;
}

public String getCurrentSessionAlias(HttpServletRequest request) {
    if(sessionParam == null) {
        return DEFAULT_ALIAS;
    }
    String u = request.getParameter(sessionParam);
    if(u == null) {
        return DEFAULT_ALIAS;
    }
    if(!ALIAS_PATTERN.matcher(u).matches()) {
        return DEFAULT_ALIAS;
    }
    return u;
}

abstract class OnCommittedResponseWrapper extends HttpServletResponseWrapper {
    public OnCommittedResponseWrapper(HttpServletResponse response) {
        super(response);
    }
    /**
     * Implement the logic for handling the {@link javax.servlet.http.HttpServletResponse} being committed
     */
    protected abstract void onResponseCommitted();

    @Override
    public final void sendError(int sc) throws IOException {
        doOnResponseCommitted();
        super.sendError(sc);
    }
    //sendRedirect处理类似sendError
    @Override
    public ServletOutputStream getOutputStream() throws IOException {
        return new SaveContextServletOutputStream(super.getOutputStream());
    }

    @Override
    public PrintWriter getWriter() throws IOException {
        return new SaveContextPrintWriter(super.getWriter());
    }

    private void doOnResponseCommitted() {
        if(!disableOnCommitted) {
            onResponseCommitted();
            disableOnResponseCommitted();
        } else if(logger.isDebugEnabled()){
            logger.debug("Skip invoking on");
        }
    }

    private class SaveContextPrintWriter extends PrintWriter {
        private final PrintWriter delegate;

        public SaveContextPrintWriter(PrintWriter delegate) {
            super(delegate);
            this.delegate = delegate;
        }

        public void flush() {
            doOnResponseCommitted();
            delegate.flush();
        }
	//close方法与flush方法类似
    }
	//SaveContextServletOutputStream处理同字符流
}

private final class SessionRepositoryResponseWrapper extends OnCommittedResponseWrapper {

    private final SessionRepositoryRequestWrapper request;
    /**
     * @param response the response to be wrapped
     */
    public SessionRepositoryResponseWrapper(SessionRepositoryRequestWrapper request, HttpServletResponse response) {
        super(response);
        if(request == null) {
            throw new IllegalArgumentException("request cannot be null");
        }
        this.request = request;
    }

    @Override
    protected void onResponseCommitted() {
        request.commitSession();
    }

}

protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
	try {
		//省略
		//filterChain会在所有filter都执行完毕后调用对应的servlet
	    filterChain.doFilter(strategyRequest, strategyResponse);
	} finally {
		//所有的处理都完成后提交session
		wrappedRequest.commitSession();
	}
}