源头
最近在翻阅Springboot Security板块中的会话管理器过滤器SessionManagementFilter源码的时候，发现其会对单用户的多会话进行校验控制，比如其下的某个策略ConcurrentSessionControlAuthenticationStrategy，节选部分代码
public void onAuthentication(Authentication authentication,
HttpServletRequest request, HttpServletResponse response) {
// 获取单用户的多会话
final List<SessionInformation> sessions = sessionRegistry.getAllSessions(
authentication.getPrincipal(), false);
// 一系列判断
int sessionCount = sessions.size();
int allowedSessions = getMaximumSessionsForThisUser(authentication);
....
....
// session超出后的操作,一般是抛异常结束filter的过滤
allowableSessionsExceeded(sessions, allowedSessions, sessionRegistry);
}笔者一般的思维是认为单个校验通过的用户有单一的会话，为何会有多个会话呢？那多个会话其又是如何管理的呢？带着疑问探究下HttpSession的概念
何为HttpSession
通俗的理解应该是基于HTTP协议而产生的服务器级别的对象。其独立于客户端发的请求，并不是客户端每一次的请求便会创建此对象，也不是客户端关闭了就会被注销。
故其依赖于HTTP服务器的运行，是独立于客户端的一种会话。目的也是保存公共的属性供页面间跳转的参数传递。
如何使用HttpSession
HttpSession主要是通过HttpServletRequest#getSession()方法来创建，且只依赖于此方法的创建。一般都是用户校验通过后，应用才会调用此方法保存一些公共的属性，方便页面间传递。
HttpSession的实现机制
为了理解清楚上述的疑问，那么HttpSession的实现机制必须深入的了解一下。因为其依赖于相应的HTTP服务器，就以Springboot内置的Tomcat服务器作为分析的入口吧。
代码层
笔者以唯一入口HttpServletRequest#getSession()方法为源头，倒推其代码实现逻辑，大致梳理了下Tomcat服务器的HTTP请求步骤
AbstractEndpoint作为服务的创建入口，其子类NioEndpoint则采用NIO思想创建TCP服务并运行多个Poller线程用于接收客户端(浏览器)的请求-->
通过Poller#processSocket()方法调用内部类SocketProcessor来间接引用AbstractProtocol内部类ConnectionHandler处理具体的请求-->
HTTP相关的请求则交由AbstractHttp11Protocol#createProcessor()方法创建Http11Processor对象处理---->
Http11Processor引用CoyoteAdapter对象来包装成org.apache.catalina.connector.Request对象来最终处理创建HttpSession-->
优先解析URL中的JSESSIONID参数，如果没有则尝试获取客户端Cookie中的JSESSIONID键值，最终存入至相应Session对象属性sessionId中，避免对来自同一来源的客户端重复创建HttpSession基于上述的步骤用户在获取HttpSession对象时，会调用Request#doGetSession()方法来创建，具体的笔者不分析了。
总而言之，HttpSession的关键之处在于其对应的sessionId，每个HttpSession都会有独一无二的sessionId与之对应，至于sessionId的创建读者可自行分析，只需要知道其在应用服务期间会对每个HttpSession创建唯一的sessionId即可。
保存方式
上述讲解了HttpSession的获取方式是基于sessionId的，那么肯定有一个出口去保存相应的键值对，仔细一看发现其是基于cookie去实现的，附上Request#doGetSession()方法关键源码
protected Session doGetSession(boolean create) {
.....
.....
// session不为空且支持cookie机制
if (session != null
&& context.getServletContext()
.getEffectiveSessionTrackingModes()
.contains(SessionTrackingMode.COOKIE)) {
// 默认创建Key为JSESSIONID的Cookie对象，并设置maxAge=-1
Cookie cookie =
ApplicationSessionCookieConfig.createSessionCookie(
context, session.getIdInternal(), isSecure());
response.addSessionCookieInternal(cookie);
}
if (session == null) {
return null;
}
session.access();
return session;
}很明显，由上述的代码可知，HttpSession的流通还需要依赖Cookie机制的使用。此处谈及一下Cookie对象中的maxAge，可以看下其API说明
/**
* Sets the maximum age of the cookie in seconds.
* <p>
* A positive value indicates that the cookie will expire after that many
* seconds have passed. Note that the value is the <i>maximum</i> age when
* the cookie will expire, not the cookie's current age.
* <p>
* A negative value means that the cookie is not stored persistently and
* will be deleted when the Web browser exits. A zero value causes the
* cookie to be deleted.
*
* @param expiry
* an integer specifying the maximum age of the cookie in
* seconds; if negative, means the cookie is not stored; if zero,
* deletes the cookie
* @see #getMaxAge
*/
public void setMaxAge(int expiry) {
maxAge = expiry;
}默认maxAge值为-1，即当浏览器进程重开之前，此对应的JSESSIONID的cookie值都会在访问服务应用的时候被带上。
由此处其实可以理解，如果多次重开浏览器进程并登录应用，则会出现单用户有多个session的情况。所以才有了限制Session最大可拥有量
HttpSession的管理
这里浅谈下Springboot Security中对Session的管理，主要是针对单个用户多session的情况。由HttpSecurity#sessionManagement()来进行相应的配置
@Override
protected void configure(HttpSecurity http) throws Exception {
// 单用户最大session数为2
http.sessionManagement().maximumSessions(2);
}经过上述的配置，便会引入两个关于session管理的过滤链，笔者按照过滤顺序分开浅析
ConcurrentSessionFilter
主要是针对过期的session进行相应的注销以及退出操作，看下关键的处理代码
public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)
throws IOException, ServletException {
HttpServletRequest request = (HttpServletRequest) req;
HttpServletResponse response = (HttpServletResponse) res;
// 获取HttpSession
HttpSession session = request.getSession(false);
if (session != null) {
SessionInformation info = sessionRegistry.getSessionInformation(session
.getId());
if (info != null) {
// 如果设置为过期标志，则开始清理操作
if (info.isExpired()) {
// 默认使用SecurityContextLogoutHandler处理退出操作，内含session注销
doLogout(request, response);
// 事件推送，默认是直接输出session数过多的信息
this.sessionInformationExpiredStrategy.onExpiredSessionDetected(new SessionInformationExpiredEvent(info, request, response));
return;
}
else {
// Non-expired - update last request date/time
sessionRegistry.refreshLastRequest(info.getSessionId());
}
}
}
chain.doFilter(request, response);
}前文也提及，如果服务应用期间，要注销session，只能调用相应的session.invalid()方法。直接看下SecurityContextLogoutHandler#logout()源码
public void logout(HttpServletRequest request, HttpServletResponse response,
Authentication authentication) {
Assert.notNull(request, "HttpServletRequest required");
if (invalidateHttpSession) {
HttpSession session = request.getSession(false);
if (session != null) {
// 注销
session.invalidate();
}
}
if (clearAuthentication) {
SecurityContext context = SecurityContextHolder.getContext();
context.setAuthentication(null);
}
// 清理上下文
SecurityContextHolder.clearContext();
}SessionManagementFilter
笔者只展示ConcurrentSessionControlAuthenticationStrategy策略类用于展示session的最大值校验
public void onAuthentication(Authentication authentication,
HttpServletRequest request, HttpServletResponse response) {
// 获取当前校验通过的用户所关联的session数量
final List<SessionInformation> sessions = sessionRegistry.getAllSessions(
authentication.getPrincipal(), false);
int sessionCount = sessions.size();
// 最大session支持，可配置
int allowedSessions = getMaximumSessionsForThisUser(authentication);
if (sessionCount < allowedSessions) {
// They haven't got too many login sessions running at present
return;
}
if (allowedSessions == -1) {
// We permit unlimited logins
return;
}
if (sessionCount == allowedSessions) {
HttpSession session = request.getSession(false);
if (session != null) {
// Only permit it though if this request is associated with one of the
// already registered sessions
for (SessionInformation si : sessions) {
if (si.getSessionId().equals(session.getId())) {
return;
}
}
}
// If the session is null, a new one will be created by the parent class,
// exceeding the allowed number
}
// 超出对应数的处理
allowableSessionsExceeded(sessions, allowedSessions, sessionRegistry);
}继续跟踪allowableSessionsExceeded()方法
protected void allowableSessionsExceeded(List<SessionInformation> sessions,
int allowableSessions, SessionRegistry registry)
throws SessionAuthenticationException {
// 1.要么抛异常
if (exceptionIfMaximumExceeded || (sessions == null)) {
throw new SessionAuthenticationException(messages.getMessage(
"ConcurrentSessionControlAuthenticationStrategy.exceededAllowed",
new Object[] { Integer.valueOf(allowableSessions) },
"Maximum sessions of {0} for this principal exceeded"));
}
// Determine least recently used session, and mark it for invalidation
SessionInformation leastRecentlyUsed = null;
for (SessionInformation session : sessions) {
if ((leastRecentlyUsed == null)
|| session.getLastRequest()
.before(leastRecentlyUsed.getLastRequest())) {
leastRecentlyUsed = session;
}
}
// 2.要么设置对应的expired为true，最后交由上述的ConcurrentSessionFilter来处理
leastRecentlyUsed.expireNow();
}关于session的保存，大家可以关注RegisterSessionAuthenticationStrategy注册策略，其是排在上述的策略之后的，就是先判断再注册，很顺畅的逻辑。笔者此处就不分析了，读者可自行分析
小结
HttpSession是HTTP服务中比较常用的对象，理解它的含义以及应用逻辑可以帮助我们更好的使用它。以苏格拉底的话来说就是我唯一知道的，就是自己一无所知