tomcat容器通过一个称为Session管理器的组件来管理建立的Session对象，该组件由org.apache.catalina.Manager接口表示；Session管理器必须与一个Context容器相关联（需要用到Context容器的相关上下文或方法）。
默认情况下，Session管理器会将其所管理的 Session对象存放在内存中，不过在tomcat中，Session管理器也库将Session对象持久化，存储到文件存储器或通过JDBC写入到数据库中。
下面我们来分析具体实现，在servlet编程方面中，Session对象由javax.servlet.http.HttpSession接口表示；在tomcat中该接口的标准实现是org.apache.catalina.session包下的StandardSession类，该类同时实现了org.apache.catalina.Session接口，在tomcat内部供Session管理器使用;而实际交给servlet实例使用的是Session接口的外观类StandardSessionFacade
下面是Session管理器内部使用的Session接口
public interface Session { public static final String SESSION_CREATED_EVENT = "createSession"; public static final String SESSION_DESTROYED_EVENT = "destroySession"; public String getAuthType(); public void setAuthType(String authType); public long getCreationTime(); public void setCreationTime(long time); public String getId(); public void setId(String id); public String getInfo(); public long getLastAccessedTime(); public Manager getManager(); public void setManager(Manager manager); public int getMaxInactiveInterval(); public void setMaxInactiveInterval(int interval); public void setNew(boolean isNew); public Principal getPrincipal(); public void setPrincipal(Principal principal); public HttpSession getSession(); public void setValid(boolean isValid); public boolean isValid(); public void access(); public void addSessionListener(SessionListener listener); public void expire(); public Object getNote(String name); public Iterator getNoteNames(); public void recycle(); public void removeNote(String name); public void removeSessionListener(SessionListener listener); public void setNote(String name, Object value); }
Session对象总是存在于Session管理器中，可以通过setManager()方法将Session实例 与某个Session管理器相关联；Session管理器可以通过setId()方法设置Session标识符；同时会调用getLastAccessedTime()方法判断一个Session对象的有效性；setValid()方法用于重置该Session对象的有效性；每当访问一个Session实例时，会调用access()方法来修改Session对象的最后访问时间；最后，Session管理器会调用Session对象的expire()方法使其过期，通过getSession()方法获取一个经过外观类StandardSessionFacade包装的HttpSession对象
StandardSession类是Session接口的标准实现，同时实现了javax.servlet.http.HttpSession接口和java.lang.Serializable接口
（注：StandardSession类实现HttpSession接口方法的实现基本上都依赖于实现Session接口的方法对StandardSession实例的填充，因此我们可以想象，StandardSession类基本上类似与适配器模式中的Adapter角色，实现了原类型（Session接口类型）到目标接口的转换（HttpSession接口））
其构造函数接受一个Manager接口的实例，迫使Session对象必须拥有一个Session管理器实例
public StandardSession(Manager manager) { super(); this.manager = manager; if (manager instanceof ManagerBase) this.debug = ((ManagerBase) manager).getDebug(); }
下面是StandardSession实例的一些比较重要的私有成员变量
//存储session的键值对 private HashMap attributes = new HashMap(); private transient String authType = null; //创建时间 private long creationTime = 0L; //是否过期 private transient boolean expiring = false; //外观类 private transient StandardSessionFacade facade = null; //session标识 private String id = null; //最后访问时间 private long lastAccessedTime = creationTime; //监听器聚集 private transient ArrayList listeners = new ArrayList(); //session管理器 private Manager manager = null; //清理session过期时间 private int maxInactiveInterval = -1; private boolean isNew = false; private boolean isValid = false; //当前访问时间 private long thisAccessedTime = creationTime;
其中getSession()方法通过传入自身实例来创建外观类StandardSessionFacade实例
public HttpSession getSession() { if (facade == null) facade = new StandardSessionFacade(this); return (facade); }
如果session管理器中的某个Session对象在某个时间长度内都没有被访问的话，会被Session管理器设置为过期，这个时间长度是由变量maxInactiveInterval的值来指定
public void expire(boolean notify) { // Mark this session as "being expired" if needed if (expiring) return; expiring = true; setValid(false); // Remove this session from our manager's active sessions if (manager != null) manager.remove(this); // Unbind any objects associated with this session String keys[] = keys(); for (int i = 0; i < keys.length; i++) removeAttribute(keys[i], notify); // Notify interested session event listeners if (notify) { fireSessionEvent(Session.SESSION_DESTROYED_EVENT, null); } // Notify interested application event listeners // FIXME - Assumes we call listeners in reverse order Context context = (Context) manager.getContainer(); Object listeners[] = context.getApplicationListeners(); if (notify && (listeners != null)) { HttpSessionEvent event = new HttpSessionEvent(getSession()); for (int i = 0; i < listeners.length; i++) { int j = (listeners.length - 1) - i; if (!(listeners[j] instanceof HttpSessionListener)) continue; HttpSessionListener listener = (HttpSessionListener) listeners[j]; try { fireContainerEvent(context, "beforeSessionDestroyed", listener); listener.sessionDestroyed(event); fireContainerEvent(context, "afterSessionDestroyed", listener); } catch (Throwable t) { try { fireContainerEvent(context, "afterSessionDestroyed", listener); } catch (Exception e) { ; } // FIXME - should we do anything besides log these? log(sm.getString("standardSession.sessionEvent"), t); } } } // We have completed expire of this session expiring = false; if ((manager != null) && (manager instanceof ManagerBase)) { recycle(); } }
上面方法中从Session管理器移除该session实例并触发一些事件，同时设置一些内部变量的值。
为了传递一个session对象给servlet实例，tomcat的session管理器会实例化StandardSession类，并填充该session对象；不过，为了阻止servlet程序员访问StandardSession实例中的一些敏感方法，tomcat容器将StandardSession实例封装为StandardSessionFacade类型的实例（实现HttpRequest接口的HttpRequestBase类的doGetSession方法里面调用session管理器的createSession()方法返回StandardSession类的实例，然后调用StandardSession实例 的getSession()方法返回StandardSessionFacade类型实例），该类仅仅实现了javax.servlet.http.HttpSession接口中的方法，这样servlet程序员就不能将HttpSession对象向下转型为StandardSession类型
下面接下来描述session管理器，session管理器是org.apache.catalina.Manager接口的实例，抽象类ManagerBase实现了Manager接口,提供了常见功能的实现；ManagerBase类有两个直接子类，分别为StandardManager类和PersistentManagerBase类
当tomcat运行时，StandardManager实例将session对象存储在内存中；当tomcat关闭时，它会将当前内存中所有的session对象序列化存储到文件中；当在此运行tomcat时，又会将这些session对象重新载入内存。
另外，继承自PersistentManagerBase类的session管理器会将session对象存储到辅助存储器中，包括PersistentManager类和DistributedManager类（tomcat4中）
下面是Manager接口的方法声明：
public interface Manager { public Container getContainer(); public void setContainer(Container container); public DefaultContext getDefaultContext(); public void setDefaultContext(DefaultContext defaultContext); public boolean getDistributable(); public void setDistributable(boolean distributable); public String getInfo(); public int getMaxInactiveInterval(); public void setMaxInactiveInterval(int interval); public void add(Session session); public void addPropertyChangeListener(PropertyChangeListener listener); public Session createSession(); public Session findSession(String id) throws IOException; public Session[] findSessions(); public void load() throws ClassNotFoundException, IOException; public void remove(Session session); public void removePropertyChangeListener(PropertyChangeListener listener); public void unload() throws IOException; }
提供了setContainer()方法使用session管理器与Context容器相关联；一起一下添加、移除session实例的方法；设置session对象的最长存活时间；最后， load()方法与unload()方法用于从辅助存储器加载session对象到内存和序列化session对象并持久化到辅助存储器中。
ManagerBase类为一个抽象类，提供了一些公共方法的实现，包括创建session对象、移除session对象等；这些活动的session对象都存储在一个名为sessions的HashMap变量中
protected HashMap sessions = new HashMap();
下面是创建session实例的方法
public Session createSession() { // Recycle or create a Session instance Session session = null; synchronized (recycled) { int size = recycled.size(); if (size > 0) { session = (Session) recycled.get(size - 1); recycled.remove(size - 1); } } if (session != null) session.setManager(this); else session = new StandardSession(this); // Initialize the properties of the new session and return it session.setNew(true); session.setValid(true); session.setCreationTime(System.currentTimeMillis()); session.setMaxInactiveInterval(this.maxInactiveInterval); String sessionId = generateSessionId(); String jvmRoute = getJvmRoute(); // @todo Move appending of jvmRoute generateSessionId()??? if (jvmRoute != null) { sessionId += '.' + jvmRoute; session.setId(sessionId); } /* synchronized (sessions) { while (sessions.get(sessionId) != null) // Guarantee uniqueness sessionId = generateSessionId(); } */ session.setId(sessionId); return (session); }
上面创建的是StandardSession类型实例，在实现HttpRequest接口的HttpRequestBase类的相关方法中，调用getSession()方法返回StandardSessionFacade类型实例
创建session对象需要调用受保护的方法返回session对象的唯一标识符
/** * Generate and return a new session identifier. */ protected synchronized String generateSessionId() { // Generate a byte array containing a session identifier Random random = getRandom(); byte bytes[] = new byte[SESSION_ID_BYTES]; getRandom().nextBytes(bytes); bytes = getDigest().digest(bytes); // Render the result as a String of hexadecimal digits StringBuffer result = new StringBuffer(); for (int i = 0; i < bytes.length; i++) { byte b1 = (byte) ((bytes[i] & 0xf0) >> 4); byte b2 = (byte) (bytes[i] & 0x0f); if (b1 < 10) result.append((char) ('0' + b1)); else result.append((char) ('A' + (b1 - 10))); if (b2 < 10) result.append((char) ('0' + b2)); else result.append((char) ('A' + (b2 - 10))); } return (result.toString()); }
该标识符生成之后，会发送到客户端cookies里面，使客户端cookies里面的JSESSIONID值与之一致
其他相关操作session对象方法如下，容易理解
public void add(Session session) { synchronized (sessions) { sessions.put(session.getId(), session); } } public Session findSession(String id) throws IOException { if (id == null) return (null); synchronized (sessions) { Session session = (Session) sessions.get(id); return (session); } } public Session[] findSessions() { Session results[] = null; synchronized (sessions) { results = new Session[sessions.size()]; results = (Session[]) sessions.values().toArray(results); } return (results); } public void remove(Session session) { synchronized (sessions) { sessions.remove(session.getId()); } }
StandardManager类是Manager接口的标准实现，继承自上面的ManagerBase抽象类，同时实现了Lifecycle接口，这有可以由其相关联的Context容器来启动和关闭，在Context容器调用它的start()方法和stop()方法时，会调用load()从辅助存储器加载session对象到内存和调用unload()方法从内存持久化session对象到辅助存储器
同时session管理器还负责销毁那些失效的session对象，这是由一个专门的线程来实现的，StandardManager类实现了Runnable接口
/** * The background thread that checks for session timeouts and shutdown. */ public void run() { // Loop until the termination semaphore is set while (!threadDone) { threadSleep(); processExpires(); } }
在线程休眠指定时间间隔后，调用processExpires()方法清理过期session对象
/** * Invalidate all sessions that have expired. */ private void processExpires() { long timeNow = System.currentTimeMillis(); Session sessions[] = findSessions(); for (int i = 0; i < sessions.length; i++) { StandardSession session = (StandardSession) sessions[i]; if (!session.isValid()) continue; int maxInactiveInterval = session.getMaxInactiveInterval(); if (maxInactiveInterval < 0) continue; int timeIdle = // Truncate, do not round up (int) ((timeNow - session.getLastAccessedTime()) / 1000L); if (timeIdle >= maxInactiveInterval) { try { session.expire(); } catch (Throwable t) { log(sm.getString("standardManager.expireException"), t); } } } }
我们可以看到，session对象的过期时间实际是session对象本身的成员变量的值
int maxInactiveInterval = session.getMaxInactiveInterval()
最后，servlet程序员需要调用javax.servlet.http.HttpSerletRequest接口的getSession()方法获取Session对象，当调用getSession()方法时，request对象必须调用与Context容器相关联的session管理器（创建session对象或返回一个已存在色session对象）；request对象为了能够访问Session管理器，它必须能够访问Context容器。因此在SimpleWrapperValve类的invoke()方法中，需要调用org.apache.catalina.Request接口的setContext()方法传入Context容器实例
public void invoke(Request request, Response response, ValveContext valveContext) throws IOException, ServletException { SimpleWrapper wrapper = (SimpleWrapper) getContainer(); ServletRequest sreq = request.getRequest(); ServletResponse sres = response.getResponse(); Servlet servlet = null; HttpServletRequest hreq = null; if (sreq instanceof HttpServletRequest) hreq = (HttpServletRequest) sreq; HttpServletResponse hres = null; if (sres instanceof HttpServletResponse) hres = (HttpServletResponse) sres; //-- new addition ----------------------------------- Context context = (Context) wrapper.getParent(); request.setContext(context); //------------------------------------- // Allocate a servlet instance to process this request try { servlet = wrapper.allocate(); if (hres!=null && hreq!=null) { servlet.service(hreq, hres); } else { servlet.service(sreq, sres); } } catch (ServletException e) { } }
同时在org.apache.catalina.connector.HttpRequestBase类的私有方法diGetSession()里面会调用Context接口的getManager()方法来获取session管理器对象
private HttpSession doGetSession(boolean create) { // There cannot be a session if no context has been assigned yet if (context == null) return (null); // Return the current session if it exists and is valid if ((session != null) && !session.isValid()) session = null; if (session != null) return (session.getSession()); // Return the requested session if it exists and is valid Manager manager = null; if (context != null) manager = context.getManager(); if (manager == null) return (null); // Sessions are not supported if (requestedSessionId != null) { try { session = manager.findSession(requestedSessionId); } catch (IOException e) { session = null; } if ((session != null) && !session.isValid()) session = null; if (session != null) { return (session.getSession()); } } // Create a new session if requested and the response is not committed if (!create) return (null); if ((context != null) && (response != null) && context.getCookies() && response.getResponse().isCommitted()) { throw new IllegalStateException (sm.getString("httpRequestBase.createCommitted")); } session = manager.createSession(); if (session != null) return (session.getSession()); else return (null); }
注意里面实质是通过StandardSession实例的getSession()方法获取一个经过外观类StandardSessionFacade包装的HttpSession对象
---------------------------------------------------------------------------
本系列How Tomcat Works系本人原创
转载请注明出处 博客园 刺猬的温驯
本人邮箱： chenying998179#163.com （#改为@）
