会话Session处理

介绍：

Session，又被称为会话。是指有始有终的一系列动作/消息。

用户请求访问某个网站域名时，如果该用户还没有会话，则 Web 服务器将自动创建一个 Session 对象，存放在服务端，此对象的唯一标识放入cookie中。这样，当用户在应用程序的 Web 页之间跳转时，存储在 Session 对象中的变量将不会丢失，而是在整个用户会话中一直存在下去。但是session对象是有生命周期的，当会话过期或被放弃后，服务器将终止该会话。

Session 对象存储特定用户会话所需的属性及配置信息。最常见的一个用法就是存储用户的首选项。例如，用户登录之后的登录信息，就可以将该信息存储在 Session 对象中。

在开发工程中，常用到的是javax.servlet.http.HttpSession。

cookie与session：

我们都知道，HTTP协议本身是无状态的，客户端只需要简单的向服务器发送请求，无论是客户端还是服务器都没有必要纪录彼此过去的行为，每一次请求之间都是独立的。

但是在后来发展应用中，需要客户端和服务端保持状态。这样cookie就产生了，其中cookie的作用就是为了解决HTTP协议无状态的缺陷所作出的努力。至于后来出现的session机制则是又一种在客户端与服务器之间保持状态的解决方案。cookie就是在客户端保持状态，session是在服务端保持状态，但是又是借助客户端的，所以在使用过程中，session的唯一标识常保持在cookie中的。一般取名JSESSIONID=唯一标识（可以动过UUID方式产生）。考虑到实际情况中，cookie在客户端被禁用了，这时候可以直接通过请求参数方式传入。

因为session的唯一标识在cookie当中，跟随着cookie的生命周期。一般cookie的默认生命周期是浏览器关闭结束，所以session在浏览器关闭时也当做结束。但是，只要服务端session还在，通过相同的session唯一标示依然可以保持状态。

前面说过，session保持在服务端，当大量请求时，session就会占用大量内存，所以在会给session设置个过期时间，释放空间。

httpsession:

httpSession是java提供的一个接口。提供了一些对session的操作方法：

• public String getId(); //获取session的唯一标识
• public long getLastAccessedTime(); //获取最后的请求过来的时间（毫秒）
• public ServletContext getServletContext();//获取session所属的上下文
• public void setMaxInactiveInterval(int interval);//设置有效期（秒）
• public Object getAttribute(String name); //获取session中存放的对象
• public Enumeration getAttributeNames(); //获取所有存放对象
• public void setAttribute(String name, Object value); //存放对象到session中。如果放入的对象为null，效果跟removeAttribute()一致。
• public void removeAttribute(String name);//移出session中的对象
• public void invalidate(); //无效session

• public boolean isNew(); //判断客户端是不是支持session的。如果客户端不支持cookie，每次请求都会创建个新的session。

  一般情况下，session都是存储在内存里，当服务器进程被停止或者重启的时候，内存里的session也会被清空，如果设置了session的持久化特性，服务器就会把session保存到硬盘上，当服务器进程重新启动或这些信息将能够被再次使用。

文章开头，当请求过来时，没有就创建。其实严格的来说，并非这样的，实际上是调用了HttpServletRequest中的public HttpSession getSession(boolean create);实现时才获取出来session。
我们先来看下源码中这个方法的说明：

*返回此请求的关联当前httpSession,如果没有，当create设置为true时，就会创建个新的session；
如果create为false，同时请求request没有有效的httpSession，则就会返回null；*
我们可以这样测试：创建两个页面，一个是jsp，一个是html。jsp本质上就是一个servlet，参与服务交互，SP文件在编译成Servlet时将会自动加上这样一条语句HttpSession session = HttpServletRequest.getSession(true);这也是JSP中隐含的session对象的来历。html是个静态页面，与服务器没有啥交互。

http://localhost/web_01/testSession.html 请求后，可以看出返回response中没有session。

http://localhost/web_01/welcome.jsp 请求后，可以看出有session了。

我们也是可以控制不创建session。在webcome.jsp页面上添加：
<%@ page session="false" %> 设置session为false时，关闭session。再次请求可以看到，没有看到session了。

我们可以深入源码中探查：
新创建个jsp页面error.jsp，这个session默认是打开的。请求welcome.jsp和error.jsp页面后，在tomcat中查看所生成的对应servlet文件。生成的servlet文件在tomcat下面的 work\Catalina\localhost\web_01\org\apache\jsp文件夹中。
首先看到error.jsp生成的servlet文件error_jsp.java:

package org.apache.jsp;import javax.servlet.*;import javax.servlet.http.*;import javax.servlet.jsp.*;public final class error_jsp extends org.apache.jasper.runtime.HttpJspBase    implements org.apache.jasper.runtime.JspSourceDependent {    private static final javax.servlet.jsp.JspFactory _jspxFactory =          javax.servlet.jsp.JspFactory.getDefaultFactory();    //其他代码省略    **********    public void _jspService(final javax.servlet.http.HttpServletRequest request, final javax.servlet.http.HttpServletResponse response)        throws java.io.IOException, javax.servlet.ServletException {    final javax.servlet.jsp.PageContext pageContext;    //注意：这里是HttpSession    javax.servlet.http.HttpSession session = null;    final javax.servlet.ServletContext application;    final javax.servlet.ServletConfig config;    javax.servlet.jsp.JspWriter out = null;    final java.lang.Object page = this;    javax.servlet.jsp.JspWriter _jspx_out = null;    javax.servlet.jsp.PageContext _jspx_page_context = null;    try {      response.setContentType("text/html; charset=UTF-8");      pageContext = _jspxFactory.getPageContext(this, request, response,                null, true, 8192, true);      _jspx_page_context = pageContext;      application = pageContext.getServletContext();      config = pageContext.getServletConfig();      //从页面上下文中获取session      session = pageContext.getSession();      out = pageContext.getOut();      _jspx_out = out;      //省略页面渲染代码    } catch (java.lang.Throwable t) {      //省略异常处理代码    } finally {      _jspxFactory.releasePageContext(_jspx_page_context);    }  }}

代码中可以看到HttpSession是从PageContext中获取。注意，这里的pageContext所属package为javax.servlet.jsp下面，此所属jar在tomcat本身的lib文件jsp-api.jar中。
这个pageContext是个抽象类，代码中pageContext = _jspxFactory.getPageContext(this, request, response, null, true, 8192, true);是个抽象类赋上具体的实现，再通过代码：
private static final javax.servlet.jsp.JspFactory _jspxFactory =
javax.servlet.jsp.JspFactory.getDefaultFactory();定位到JspFactory类。进入看下源代码：
//***********
先省略，后续补上。
//*********

当session关闭时，web.jsp的servlet文件中就没有看到HttpSession的相关内容。

当session被调用invalidate()方法时，或过期时就会终止。

分布式环境下的session：

因为session是存在服务器上，当应用集群时就成为一个问题。请求同一个网站，前一个请求到A服务器上，获取session，保持在A服务器上，但是下一个请求可能会分配到B服务器上，此时就识别不了session了。
一般来说有几种解决方法：

---

1：服务器直接同步session：集群中的服务器相互同步session，但是问题不少。首先实时性不好保证，其次同步的次数随着服务器的数量二指数级别增加，所以在实际中很少用到。
2：对请求进行筛选处理：判断请求的IP，给分配到固定的服务器上，达到同一个IP请求始终访问同一个服务器。但是依然问题不少：请求IP解析匹配的开销不少；如果某个服务器挂掉了，会导致访问这个请求失败；削弱了负载均衡的能力，会导致某些服务器负载很高，而某些却空闲；动态增减服务器需要修改ip的分配，这回增减很多难度。
3：使用缓存：让集群的session都放入同一个缓存中，与服务器脱离依赖。现实中常用这样的方式。不过这样缓存就会成为一个瓶颈，不过可以考虑对缓存进行集群来解决。

---

缓存session实例：

首先配置redis相关：

mvn包：

<dependency>    <groupId>org.springframework.data</groupId>    <artifactId>spring-data-redis</artifactId>    <version>1.7.1.RELEASE</version></dependency><dependency>    <groupId>redis.clients</groupId>    <artifactId>jedis</artifactId>    <version>2.8.1</version></dependency>

xml配置（使用的是spring-context-4.2.xsd）：

<context:property-placeholder location="config/redis.properties"/><bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">        <!-- 池中可借的最大数 -->        <property name="maxTotal" value="50" />        <!-- 允许池中空闲的最大连接数 -->        <property name="maxIdle" value="10" />        <!-- 允许池中空闲的最小连接数 -->        <property name="minIdle" value="2" />        <!-- 获取连接最大等待时间（毫秒） -->        <property name="maxWaitMillis" value="12000" />        <!-- 当maxActive到达最大数，获取连接时的操作  是否阻塞等待  -->        <property name="blockWhenExhausted" value="true" />        <!-- 在获取连接时，是否验证有效性 -->        <property name="testOnBorrow" value="true" />        <!-- 在归还连接时，是否验证有效性 -->        <property name="testOnReturn" value="true" />        <!-- 当连接空闲时，是否验证有效性 -->        <property name="testWhileIdle" value="true" />        <!-- 设定间隔没过多少毫秒进行一次后台连接清理的行动 -->        <property name="timeBetweenEvictionRunsMillis" value="1800000" />        <!-- 每次检查的连接数 -->        <property name="numTestsPerEvictionRun" value="5" />    </bean>    <bean id="redisFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">        <property name="poolConfig" ref="jedisPoolConfig"></property>        <property name="hostName" value="${redis.host}"></property>        <property name="port" value="${redis.port}"></property>        <property name="timeout" value="${redis.timeout}"></property>    </bean>    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">        <property name="connectionFactory" ref="redisFactory" />        <property name="keySerializer">              <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />          </property>     </bean>

自定义session类：

import java.io.Serializable;import java.util.HashMap;import java.util.Map;import java.util.Set;import com.zcl.session.util.SessionManager;/** * 自定义Session类 * */public class SystemSession implements Serializable {    /**     *      */    private static final long serialVersionUID = 3596476624020390228L;    /**     * session数据存储map     */    private Map<String,Object> sessionData = new HashMap<String,Object>();    /**     * sessionId  session标识     */    private String sessionId = null;    public String getSessionId() {        return sessionId;    }    public void setSessionId(String sessionId) {        this.sessionId = sessionId;    }    public Object getAttribute(String name){        Object value = sessionData.get(name);        return value;    }    public void setAttribute(String name,Object value){        sessionData.put(name, value);        SessionManager.updateSession(this.sessionId, this);    }    public void removeAttribute(String name){        sessionData.remove(name);        SessionManager.updateSession(this.sessionId, this);    }    public void removeAllAttribute(){        sessionData.clear();        SessionManager.updateSession(this.sessionId, this);    }    public void disable(){        SessionManager.deleteSession(this.sessionId);    }    public boolean hasAttributeName(String name){        return sessionData.containsKey(name);    }    public Set<String> getAttributeNames(){        return sessionData.keySet();    }    public Map<String, Object> getSessionData() {        return sessionData;    }    public void setSessionData(Map<String, Object> sessionData) {        this.sessionData = sessionData;    }}

session管理类:

import java.util.UUID;import java.util.concurrent.TimeUnit;import javax.servlet.http.Cookie;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import org.apache.commons.lang3.StringUtils;import org.apache.log4j.Logger;import org.springframework.data.redis.core.RedisTemplate;import com.zcl.constants.Constants;import com.zcl.session.bean.SystemSession;import com.zcl.util.CookieUtil;import com.zcl.util.SpringUtils;import com.zcl.util.UUIDUtils;/** * 自定义Session的工具类 *  *  */public class SessionManager {    private static Logger logger = Logger.getLogger(SessionManager.class);    /**     * 从request中获取sessionKey的值     *      * @Title: getSessionIdFromRequest     * @Description: TODO     * @param request     * @param sessionKey     * @return     */    public static String getSessionIdFromRequest(HttpServletRequest request, String sessionKey) {        String sessionId = null;        // 请求参数 中获取session_id        if (StringUtils.isBlank(sessionId)) {            sessionId = request.getParameter(sessionKey);        }        // 请求头 中获取session_id        if (StringUtils.isBlank(sessionId)) {            sessionId = request.getHeader(sessionKey);        }        // 从cookie中获取session_id        Cookie cookie = CookieUtil.getCookieByName(request, sessionKey);        if (cookie != null && StringUtils.isBlank(sessionId)) {            sessionId = cookie.getValue();        }        // 从request参数中获取        if (StringUtils.isBlank(sessionId))            sessionId = (String) request.getAttribute(sessionKey + "_attr");        return sessionId;    }    /**     * 获取一个session     *      * @param request     * @param response     * @return     */    public static SystemSession createSession(String sessionKey, String sessionId, HttpServletRequest request,            HttpServletResponse response) {        if (StringUtils.isBlank(sessionKey))            return null;        if (StringUtils.isBlank(sessionId))            sessionId = UUIDUtils.generateSessionKey();        /*         * sessionId保持入cookie中         */        response.setHeader("P3P","CP='CP=CAO PSA OUR'");        CookieUtil.addCookie(request, response, sessionKey, sessionId, null);        //现实中考虑到这里创建session后，后续就要立即使用，之后放在request的attribute中的。        request.setAttribute(sessionKey+"_attr", sessionId);        /*         * 新建session.保存入redis         */        SystemSession session = new SystemSession();        session.setSessionId(sessionId);        RedisTemplate<String, SystemSession> redisTemplate = getRedisTemplate();        redisTemplate.opsForValue().set(sessionId, session);        redisTemplate.expire(sessionId, Constants.APP_SESSION_TIMEOUT, TimeUnit.SECONDS);        return session;    }    /**     * 根据sessionId从redis中获取对应session信息     *      * @Title: getSession     * @Description: TODO     * @param sessionId     * @return     */    public static SystemSession getSessionFromRedis(String sessionId) {        SystemSession session = null;        if (StringUtils.isNotBlank(sessionId)) {            RedisTemplate<String, SystemSession> redisTemplate = getRedisTemplate();            session = (SystemSession) redisTemplate.opsForValue().get(sessionId);        }        return session;    }    /**     * 通过uuid生成sessionID     *      * @return     */    public static String generateSessionKey() {        String sessionKey = UUID.randomUUID().toString();        return sessionKey.replace("-", "");    }    /**     * 更新session数据内容     *      * @param sessionKey     * @param session     */    public static void updateSession(String sessionKey, SystemSession session) {        setSessionTimeout(sessionKey, session);    }    /**     * 删除session,使其失效     *      * @param sessionKey     */    public static void deleteSession(String sessionKey) {        RedisTemplate<String, SystemSession> redisTemplate = getRedisTemplate();        redisTemplate.delete(sessionKey);    }    public static RedisTemplate<String, SystemSession> getRedisTemplate() {        @SuppressWarnings("unchecked")        RedisTemplate<String, SystemSession> redisTemplate = (RedisTemplate<String, SystemSession>) SpringUtils                .getBeanByName("redisTemplate");        return redisTemplate;    }    /**     * 设置Session超时时间     *      * @return     */    private static void setSessionTimeout(String sessionKey, SystemSession session) {        long sessionTimeout = Constants.APP_SESSION_TIMEOUT;        RedisTemplate<String, SystemSession> redisTemplate = getRedisTemplate();        redisTemplate.opsForValue().set(sessionKey, session);        redisTemplate.expire(sessionKey, sessionTimeout, TimeUnit.SECONDS);    }}

在管理方法中获取redisTemplate对象是通过SpringUtils的公共方法
SpringUtils方法：

import org.springframework.web.context.ContextLoader;import org.springframework.web.context.WebApplicationContext;public class SpringUtils {    private static WebApplicationContext webAppContext = ContextLoader.getCurrentWebApplicationContext();    public static Object getBeanByName(String beanName) {        return webAppContext.getBean(beanName);    }    public static Object getBeanByClass(Class<?> className) {        return webAppContext.getBean(className);    }}

以上基本上搭建好了一个自定义的session。然后在模拟session的生产和使用情况。通过Filter或者Interceptor的方式：
SessionFilter方法：

import java.io.IOException;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.lang3.StringUtils;import com.zcl.constants.Constants;import com.zcl.session.bean.SystemSession;import com.zcl.session.util.SessionManager;public class SessionFilter implements Filter {    private boolean openFlag = false;    @Override    public void init(FilterConfig filterConfig) throws ServletException {        String openFlagStr = filterConfig.getInitParameter("openFlag");        openFlag = StringUtils.equals(openFlagStr, "true");    }    @Override    public void doFilter(ServletRequest request, ServletResponse response,            FilterChain chain) throws IOException, ServletException {        // TODO Auto-generated method stub        if(openFlag) {            SystemSession session = null;            //从请求从获取sessionId            String sessionId = SessionManager.getSessionIdFromRequest((HttpServletRequest)request, Constants.SESSION_KEY);            if(StringUtils.isNotBlank(sessionId)) {                //判断此sessionId在redis中是否还存在                session = SessionManager.getSessionFromRedis(sessionId);            }            //不存在，则创建新的            if(session == null) {                session = SessionManager.createSession(Constants.SESSION_KEY, sessionId,                        (HttpServletRequest)request, (HttpServletResponse)response);            }            request.setAttribute(Constants.SESSION_KEY, session);        }        chain.doFilter(request, response);    }    @Override    public void destroy() {        // TODO Auto-generated method stub    }}

然后在web.xml中配置：

<filter>    <filter-name>sessionFilter</filter-name>    <filter-class>com.zcl.filter.SessionFilter</filter-class>    <init-param>        <param-name>openFlag</param-name>        <param-value>true</param-value>    </init-param> </filter><filter-mapping>    <filter-name>sessionFilter</filter-name>    <url-pattern>*.htm</url-pattern></filter-mapping>

此个filter应放在最先的位置。
在使用的地方，直接从httpServletRequest中获取即可

public SystemSession getSystemSession(HttpServletRequest request) {        return (SystemSession)request.getAttribute(Constants.SESSION_KEY_USER);    }

上门是使用的filter过滤器方式，下面修改成拦截器Interceptor方式，同时加上登录之后才能访问的地址过滤处理：
SecurityInterceptor

import java.util.List;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import org.apache.commons.lang3.StringUtils;import org.springframework.web.bind.annotation.RequestMethod;import org.springframework.web.servlet.ModelAndView;import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;import com.zcl.constants.Constants;import com.zcl.session.bean.SystemSession;import com.zcl.session.util.SessionManager;import com.zcl.util.CookieUtil;import com.zcl.util.JSEscape;import com.zcl.util.PropertyUtils;/** * 判断用户权限，未登录用户跳转到登录页面 *  * @ClassName: SecurityInterceptor * @Description: TODO * @date May 5, 2016 2:53:34 PM  *  * */public class SecurityInterceptor extends HandlerInterceptorAdapter {    // 需要安全验证的 URL    private List<String> includedUrls;    // 不需要安全过滤的 URL    private List<String> excludedUrls;    @Override    public void postHandle(HttpServletRequest request,            HttpServletResponse response, Object handler,            ModelAndView modelAndView) throws Exception {        // TODO Auto-generated method stub        super.postHandle(request, response, handler, modelAndView);    }    @Override    public boolean preHandle(HttpServletRequest request,            HttpServletResponse response, Object handler) throws Exception {        request.setAttribute("mid", PropertyUtils.getProperty("MLTrackerz_MID"));        String requestUri = request.getRequestURI();        //获取session信息        SystemSession session = null;        String sessionId = SessionManager.getSessionIdFromRequest(request, Constants.SESSION_KEY);        if(sessionId != null){            session = SessionManager.getSessionFromRedis(sessionId);        }        if (session == null) {            session = SessionManager.createSession(Constants.SESSION_KEY, sessionId, request, response);        }        request.setAttribute(Constants.SESSION_KEY, session);        /*         * 需要登录才能访问url地址过滤         */        boolean mustLogin = false;        if (includedUrls != null && includedUrls.size() > 0) {            for (String url : includedUrls) {                // 请求地址匹配到 includedUrls里面的任何一个地址，就要求登录                if (requestUri.matches(url)) {                    mustLogin = true;                    break;                }            }            // 请求地址没有匹配到 includedUrls里面的任何一个地址            if (!mustLogin) {                return true;            }        } else if (excludedUrls != null && excludedUrls.size() > 0) {            for (String url : excludedUrls) {                // 请求地址匹配到 excludedUrls里面地址，可以通过拦截器，不需要登录                if (requestUri.matches(url)) {                    return true;                }            }        }        //未登录时，跳到登录界面        if (session == null                || session.getAttribute(Constants.LOGIN_USER_KEY) == null) {            // 记录登录前页面            StringBuffer beforeLoginPage = request.getRequestURL();            //参数            if(StringUtils.isNotBlank(request.getQueryString())){                beforeLoginPage.append("?").append(request.getQueryString());            }            // 只记录get请求            if (request.getMethod().equalsIgnoreCase(                    RequestMethod.GET.toString())                    && beforeLoginPage.toString().indexOf("logout") == -1) {                CookieUtil.addCookie(request, response,                         Constants.BEFORE_PAGE, JSEscape.escape(beforeLoginPage.toString()), null);            }            response.sendRedirect(request.getContextPath() + "/tologin");            return false;        }        return super.preHandle(request, response, handler);    }    public void setExcludedUrls(List<String> excludedUrls) {        this.excludedUrls = excludedUrls;    }    public void setIncludedUrls(List<String> includedUrls) {        this.includedUrls = includedUrls;    }}

这时候context.xml中的配置要变成interceptor的方式了：

<bean id="securityInterceptor" class="com.zcl.interceptor.SecurityInterceptor">        <property name="excludedUrls">            <list>                <value>/tologin.htm</value>                <value>/loginout.htm</value>            </list>        </property>        <property name="includedUrls">            <list>                <value>/myaddress.htm</value>                <value>/mycredit.htm</value>            </list>        </property>    </bean><mvc:interceptors>    <!-- session/登录访问地址过滤处理 -->    <mvc:interceptor>        <mvc:mapping path="/*"/>        <mvc:exclude-mapping path="/resource/**"/>        <ref bean="securityInterceptor"/>    </mvc:interceptor></mvc:interceptors>

然后我们在controller中使用：

@RequestMapping(value={"/","index.htm"})public ModelAndView index(HttpServletRequest request, ModelAndView mav) {        SystemSession session = (SystemSession)request.getAttribute(Constants.SESSION_KEY);        String userName = (String) session.getAttribute("userName");        if(StringUtils.isBlank(userName)) {            System.out.println("setUserName");            session.setAttribute("userName", "zcl");        }        System.out.println("getUserName:" + userName);        mav.setViewName("index");        return mav;    }

结果符合预期：
第一次请求时userName为NULL；第二次时为”zcl”。表示session唯一，同时放入session中的值也是跟随着用户的。

以上是我们单独构建的session处理，其实spring也提供了相关的封装，spring-session中已经封装了类似的处理。

springSession
观察上面我们的session处理过程，可以看出有两部分重点：
一是session怎样定义？session是个怎样的结果。
二是session怎样存放？因为在分布式环境下，session要采取啥方式存放；
三是session怎样与Request关联？因为每次请求中，都涉及到session的。
在上面的session构建中，通过redis方式存放session；通过cookie/header/参数方式与request/response关联。
知道了原理后，我们查看sping-session的源码，可以看出，实现的原理是一致的，只不过它提供了更好更多的扩展。
具体分析可以查看后面关于springSession学习的文章。