Session管理

Tomcat中的session管理，首先的明白一点 ： 不是你客户端一个请求传过去，服务器就会为创建一个会话，

不是的，如果后台没有对应的session操作，就是你的servlet中没有session操作(getSession(boolean))，那么就不会给你创建会话；

 

在开发JEE应用中，通常我们都是对会话进行处理，而对于会话的创建，维护，删除，则是服务器替我们完成！

而在Tomcat中，与会话有关的两个重要的类 ： StandardSession , StandardManager(这个manager就像一个组件一样，在tomcat启动的时候就会start) ;

而standardsession 则是实现了HttpSession ; session 只是一个简单的对象就像一个POJO，对session 进行的操作则是通过StandardManger 实现，它继承自

ManagerBase ;在ManagerBase中定义了成员变量：session池：

Map<String, Session> sessions = new ConcurrentHashMap<String, Session>();

 

StandardSession中的属性：

  

/**
     * The collection of user data attributes associated with this Session.
     */
 protected Map attributes = new ConcurrentHashMap();

/**
     * The time this session was created, in milliseconds since midnight,
     * January 1, 1970 GMT.
     */
    protected long creationTime = 0L;

/**
     * The last accessed time for this Session.
     */
    protected volatile long lastAccessedTime = creationTime;


    /**
     * The session event listeners for this Session.
     */
    protected transient ArrayList listeners = new ArrayList();


    /**
     * The Manager with which this Session is associated.
     */
    protected transient Manager manager = null;

    * The maximum time interval, in seconds, between client requests before
     * the servlet container may invalidate this session.  A negative time
     * indicates that the session should never time out.
     */
    protected int maxInactiveInterval = -1;


    /**
     * Flag indicating whether this session is new or not.
     */
    protected boolean isNew = false;


    /**
     * Flag indicating whether this session is valid or not.
     */
    protected volatile boolean isValid = false;

    
    /**
     * Internal notes associated with this session by Catalina components
     * and event listeners.  <b>IMPLEMENTATION NOTE:</b> This object is
     * <em>not</em> saved and restored across session serializations!
     */
    protected transient Map notes = new Hashtable();


    /**
     * The authenticated Principal associated with this session, if any.
     * <b>IMPLEMENTATION NOTE:</b>  This object is <i>not</i> saved and
     * restored across session serializations!
     */
    protected transient Principal principal = null;

    /**
     * The access count for this session.
     */
    protected transient AtomicInteger accessCount = null;

 

 

session的创建过程 ：

   调用getSession(boolean create)   // 取得会话对象，如果没有session， create = true时 ，则会创建一个，create=false ， 返回null

  

public HttpSession getSession(boolean create) {
        Session session = doGetSession(create);
        if (session != null) {
            return session.getSession();
        } else {
            return null;
        }
    }

 

doGetSession(create) :

  

protected Session doGetSession(boolean create) {  
  
        ……  
        // 先获取所在context的manager对象  
        Manager manager = null;  
        if (context != null)  
            manager = context.getManager();  
        if (manager == null)  
            return (null);      // Sessions are not supported  
          
        //这个requestedSessionId就是从Http request中解析出来的  
        if (requestedSessionId != null) {  // 如果之前存在session
            try {  
                //manager管理的session池中找相应的session对象  
                session = manager.findSession(requestedSessionId);  
            } catch (IOException e) {  
                session = null;  
            }  
            //判断session是否为空及是否过期超时  
            if ((session != null) && !session.isValid())  
                session = null;  
            if (session != null) {  
                //session对象有效，记录此次访问时间  
                session.access();  
                return (session);  
            }  
        }  
  
        // 如果参数是false，则不创建新session对象了，直接退出了  
        if (!create)  
            return (null);  
        if ((context != null) && (response != null) &&  
            context.getCookies() &&  
            response.getResponse().isCommitted()) {  
            throw new IllegalStateException  
              (sm.getString("coyoteRequest.sessionCreateCommitted"));  
        }  
  
        // 开始创建新session对象  
        if (connector.getEmptySessionPath()   
                && isRequestedSessionIdFromCookie()) {  
            session = manager.createSession(getRequestedSessionId());  // 调用manager中方法创建session
        } else {  
            session = manager.createSession(null);  
        }  
  
        // 将新session的jsessionid写入cookie，传给browser  
        if ((session != null) && (getContext() != null)  
               && getContext().getCookies()) {  
            Cookie cookie = new Cookie(Globals.SESSION_COOKIE_NAME,  
                                       session.getIdInternal());  
            configureSessionCookie(cookie);  
            response.addCookieInternal(cookie);  // response中的cookies就是在这里写入的
        }  
        //记录session最新访问时间  
        if (session != null) {  
            session.access();  
            return (session);  
        } else {  
            return (null);  
        }  
    }  

 接下来进入StandardManager的createSession方法：

  

public Session createSession(String sessionId) {  
//是个session数量控制逻辑，超过上限则抛异常退出  
    if ((maxActiveSessions >= 0) &&  
        (sessions.size() >= maxActiveSessions)) {  
        rejectedSessions++;  
        throw new IllegalStateException  
            (sm.getString("standardManager.createSession.ise"));  
    }  
    return (super.createSession(sessionId));  // 调用ManagerBase中的
}  

 

public Session createSession(String sessionId) {  
        // 创建一个新的StandardSession对象  
        Session session = createEmptySession();    
        // Initialize the properties of the new session and return it  
        session.setNew(true);  
        session.setValid(true);  
        session.setCreationTime(System.currentTimeMillis());  
        session.setMaxInactiveInterval(this.maxInactiveInterval);  
        if (sessionId == null) {  
            //设置jsessionid  
            sessionId = generateSessionId();  
        }
// 就是这里顺便把session加入session池中  
        session.setId(sessionId);  
        sessionCounter++;  
        return (session);  
    }  

    setId() 方法 ：把session对象加入session池中！

    中间省略set(String id) ;

public void setId(String id, boolean notify) {

        if ((this.id != null) && (manager != null))
            manager.remove(this);

        this.id = id;

        if (manager != null)
            manager.add(this); // 添加session到session池好隐蔽啊！！！
        
        if (notify) {
            tellNew();
        }
    }

 

   

generateSessionId() 生成sessionId：

   

protected synchronized String generateSessionId() {  
  
        byte random[] = new byte[16];  
        String jvmRoute = getJvmRoute();  
        String result = null;    
        // Render the result as a String of hexadecimal digits  
        StringBuffer buffer = new StringBuffer();  
        do {  
            int resultLenBytes = 0;  
            if (result != null) {  
                buffer = new StringBuffer();  
                duplicates++;  
            }    
            while (resultLenBytes < this.sessionIdLength) {  
                getRandomBytes(random);  
                random = getDigest().digest(random);  
                for (int j = 0;  
                j < random.length && resultLenBytes < this.sessionIdLength;  
                j++) {  
                    byte b1 = (byte) ((random[j] & 0xf0) >> 4);  
                    byte b2 = (byte) (random[j] & 0x0f);  
                    if (b1 < 10)  
                        buffer.append((char) ('0' + b1));  
                    else  
                        buffer.append((char) ('A' + (b1 - 10)));  
                    if (b2 < 10)  
                        buffer.append((char) ('0' + b2));  
                    else  
                        buffer.append((char) ('A' + (b2 - 10)));  
                    resultLenBytes++;  
                }  
            }  
            if (jvmRoute != null) {  
                buffer.append('.').append(jvmRoute);  
            }  
            result = buffer.toString();  
        //注意这个do…while结构  
        } while (sessions.containsKey(result));  // sessions就是那个session池，concurrentHashMap ， 检查池中是否包含该key
        return (result);  
    }  

 到此 一个session对象就创建了！

 

   Session注销：

 

    主动注销

     调用sesion的servlet接口方法：

 

session.invalidate();

  // StanardSession中的invalidate()

public void invalidate() {  
        if (!isValidInternal())  
            throw new IllegalStateException  
                (sm.getString("standardSession.invalidate.ise"));  
        // 明显的注销方法  
        expire();  // expire 终止
    }  

 

     超时注销

     我们可以在web.xml中配置session的超时时间，也就是过了这个时间点，session就失效了，

     如果要你来设计，你会怎么做，每一个会话接入时，就会去扫描map一次，找到那些超时的，然后剔除吗！ 

     这样，效率是不是降低了！

     那么，就是当你用这个会话的时候，再把它取出来，然后比较它是否过期，如果过期了，那么就重新创建一个会话！

     tomcat就是这么处理超时的！

     看源码 ：

    

public boolean isValid() {  
        ……  
        //这就是判断距离上次访问是否超时的过程  
        if (maxInactiveInterval >= 0) {   
            long timeNow = System.currentTimeMillis();  
            int timeIdle = (int) ((timeNow - thisAccessedTime) / 1000L);  
            if (timeIdle >= maxInactiveInterval) {  
                expire(true);  
            }  
        }  
        return (this.isValid);  
    }  

   expire() 方法：

  

public void expire(boolean notify) {   
  
        synchronized (this) {  
            ......  
            //设立标志位  
            setValid(false);  
  
            //计算一些统计值，例如此manager下所有session平均存活时间等  
            long timeNow = System.currentTimeMillis();  
            int timeAlive = (int) ((timeNow - creationTime)/1000);  
            synchronized (manager) {  
                if (timeAlive > manager.getSessionMaxAliveTime()) {  
                    manager.setSessionMaxAliveTime(timeAlive);  
                }  
                int numExpired = manager.getExpiredSessions();  
                numExpired++;  
                manager.setExpiredSessions(numExpired);  
                int average = manager.getSessionAverageAliveTime();  
                average = ((average * (numExpired-1)) + timeAlive)/numExpired;  
                manager.setSessionAverageAliveTime(average);  
            }  
  
            // 将此session从manager对象的session池中删除  
            manager.remove(this);  
            ......  
        }  
    }  

 

Session的持久化 和 启动初始化：

   tomcat执行安全退出时(通过执行shutdown脚本)，会将session持久化到本地文件，通常在tomcat的部署目录下有个session.ser文件。当启动tomcat时，会从这个文件读入session，并添加到manager的session池中    去。 这样，当tomcat正常重启时， session没有丢失，对于用户而言，体会不到重启，不影响用户体验。 

   可以把会话信息写入文件，也可以存入数据库中！