tomcat之Session的管理

Session是由服务器端的应用服务器容器（如Tomcat、Jetty）存储的。下面分析一下Tomcat是如何管理Session的。

转自：tomcat架构分析 (Session管理)

Tomcat中主要由每个context容器内的一个Manager对象来管理session。对于这个manager对象的实现，可以根据tomcat提供的接口或基类来自己定制，同时，tomcat也提供了标准实现。 
在每个context对象，即web app都具有一个独立的manager对象。通过server.xml可以配置定制化的manager，也可以不配置。不管怎样，在生成context对象时，都会生成一个manager对象。缺省的是StandardManager类，其类路径为：

引用org.apache.catalina.session.StandardManager

Session对象也可以定制化实现，其主要实现标准servlet的session接口：

引用javax.servlet.http.HttpSession

Tomcat也提供了标准的session实现：

引用org.apache.catalina.session.StandardSession

Session管理主要涉及到这几个方面：

• 创建session
• 注销session
• 持久化及启动加载session

创建session 
在具体说明session的创建过程之前，先看一下BS访问模型吧，这样理解直观一点。 

1. browser发送Http request；
2. tomcat内核Http11Processor会从HTTP request中解析出“jsessionid”(具体的解析过程为先从request的URL中解析，这是为了有的浏览器把cookie功能禁止后，将URL重写考虑的，如果解析不出来，再从cookie中解析相应的jsessionid)，解析完后封装成一个request对象(当然还有其他的http header)；
3. servlet中获取session，其过程是根据刚才解析得到的jsessionid(如果有的话)，从session池(session maps)中获取相应的session对象；这个地方有个逻辑，就是如果jsessionid为空的话(或者没有其对应的session对象，或者有session对象，但此对象已经过期超时)，可以选择创建一个session，或者不创建；
4. 如果创建新session，则将session放入session池中，同时将与其相对应的jsessionid写入cookie通过Http response header的方式发送给browser，然后重复第一步。

以上是session的获取及创建过程。在servlet中获取session，通常是调用request的getSession方法。这个方法需要传入一个boolean参数，这个参数就是实现刚才说的，当jsessionid为空或从session池中获取不到相应的session对象时，选择创建一个新的session还是不创建。 
看一下核心代码逻辑；

1. protected Session doGetSession(boolean create) {
2. ……
3. // 先获取所在context的manager对象
4. Manager manager = null;
5. if (context != null)
6. manager = context.getManager();
7. if (manager == null)
8. return (null);      // Sessions are not supported
9. //这个requestedSessionId就是从Http request中解析出来的
10. if (requestedSessionId != null) {
11. try {
12. //manager管理的session池中找相应的session对象
13. session = manager.findSession(requestedSessionId);
14. } catch (IOException e) {
15. session = null;
16. }
17. //判断session是否为空及是否过期超时
18. if ((session != null) && !session.isValid())
19. session = null;
20. if (session != null) {
21. //session对象有效，记录此次访问时间
22. session.access();
23. return (session);
24. }
25. }
26. // 如果参数是false，则不创建新session对象了，直接退出了
27. if (!create)
28. return (null);
29. if ((context != null) && (response != null) &&
30. context.getCookies() &&
31. response.getResponse().isCommitted()) {
32. throw new IllegalStateException
33. (sm.getString(“coyoteRequest.sessionCreateCommitted”));
34. }
35. // 开始创建新session对象
36. if (connector.getEmptySessionPath()
37. && isRequestedSessionIdFromCookie()) {
38. session = manager.createSession(getRequestedSessionId());
39. } else {
40. session = manager.createSession(null);
41. }
42. // 将新session的jsessionid写入cookie，传给browser
43. if ((session != null) && (getContext() != null)
44. && getContext().getCookies()) {
45. Cookie cookie = new Cookie(Globals.SESSION_COOKIE_NAME,
46. session.getIdInternal());
47. configureSessionCookie(cookie);
48. response.addCookieInternal(cookie);
49. }
50. //记录session最新访问时间
51. if (session != null) {
52. session.access();
53. return (session);
54. } else {
55. return (null);
56. }
57. }

尽管不能贴出所有代码，但是上述的核心逻辑还是很清晰的。从中也可以看出，我们经常在servlet中这两种调用方式的不同； 
新创建session

引用request.getSession(); 或者request.getSession(true);

不创建session

引用request.getSession(false);

接下来，看一下StandardManager的createSession方法，了解一下session的创建过程；

1. public Session createSession(String sessionId) {
2. 是个session数量控制逻辑，超过上限则抛异常退出
3. ) &&
4. (sessions.size() >= maxActiveSessions)) {
5. rejectedSessions++;
6. throw new IllegalStateException
7. (sm.getString(“standardManager.createSession.ise”));
8. }
9. return (super.createSession(sessionId));
10. }

这个最大支持session数量maxActiveSessions是可以配置的，先不管这个安全控制逻辑，看其主逻辑，即调用其基类的createSession方法；

1. public Session createSession(String sessionId) {
2. // 创建一个新的StandardSession对象
3. Session session = createEmptySession();
4. // Initialize the properties of the new session and return it
5. session.setNew(true);
6. session.setValid(true);
7. session.setCreationTime(System.currentTimeMillis());
8. session.setMaxInactiveInterval(this.maxInactiveInterval);
9. if (sessionId == null) {
10. //设置jsessionid
11. sessionId = generateSessionId();
12. }
13. session.setId(sessionId);
14. sessionCounter++;
15. return (session);
16. }

关键是jsessionid的产生过程，接着看generateSessionId方法；

1. protected synchronized String generateSessionId() {
2. ];
3. String jvmRoute = getJvmRoute();
4. String result = null;
5. // Render the result as a String of hexadecimal digits
6. StringBuffer buffer = new StringBuffer();
7. do {
8. ;
9. if (result != null) {
10. buffer = new StringBuffer();
11. duplicates++;
12. }
13. while (resultLenBytes < this.sessionIdLength) {
14. getRandomBytes(random);
15. random = getDigest().digest(random);
16. ;
17. j < random.length && resultLenBytes < this.sessionIdLength;
18. j++) {
19. );
20. byte b2 = (byte) (random[j] & 0x0f);
21. )
22. buffer.append((char) (‘0’ + b1));
23. else
24. )));
25. )
26. buffer.append((char) (‘0’ + b2));
27. else
28. )));
29. resultLenBytes++;
30. }
31. }
32. if (jvmRoute != null) {
33. buffer.append(‘.’).append(jvmRoute);
34. }
35. result = buffer.toString();
36. //注意这个do…while结构
37. } while (sessions.containsKey(result));
38. return (result);
39. }

这里主要说明的不是生成jsessionid的算法了，而是这个do…while结构。把这个逻辑抽象出来，可以看出； 
 
如图所示，创建jsessionid的方式是由tomcat内置的加密算法算出一个随机的jsessionid，如果此jsessionid已经存在，则重新计算一个新的，直到确保现在计算的jsessionid唯一。 
好了，至此一个session就这么创建了，像上面所说的，返回时是将jsessionid以HTTP response的header：“Set-cookie”发给客户端。 
注销session

• 主动注销
• 超时注销

Session创建完之后，不会一直存在，或是主动注销，或是超时清除。即是出于安全考虑也是为了节省内存空间等。例如，常见场景：用户登出系统时，会主动触发注销操作。 
主动注销 
主动注销时，是调用标准的servlet接口：

引用session.invalidate();

看一下tomcat提供的标准session实现(StandardSession)

1. public void invalidate() {
2. if (!isValidInternal())
3. throw new IllegalStateException
4. (sm.getString(“standardSession.invalidate.ise”));
5. // 明显的注销方法
6. expire();
7. }

Expire方法的逻辑稍后再说，先看看超时注销，因为它们调用的是同一个expire方法。 
超时注销 
Tomcat定义了一个最大空闲超时时间，也就是说当session没有被操作超过这个最大空闲时间时间时，再次操作这个session，这个session就会触发expire。 
这个方法封装在StandardSession中的isValid()方法内，这个方法在获取这个request请求对应的session对象时调用，可以参看上面说的创建session环节。也就是说，获取session的逻辑是，先从manager控制的session池中获取对应jsessionid的session对象，如果获取到，就再判断是否超时，如果超时，就expire这个session了。 
看一下tomcat提供的标准session实现(StandardSession)

1. public boolean isValid() {
2. ……
3. //这就是判断距离上次访问是否超时的过程
4. ) {
5. long timeNow = System.currentTimeMillis();
6. int timeIdle = (int) ((timeNow – thisAccessedTime) / 1000L);
7. if (timeIdle >= maxInactiveInterval) {
8. expire(true);
9. }
10. }
11. return (this.isValid);
12. }

Expire方法 
是时候来看看expire方法了。

1. public void expire(boolean notify) {
2. synchronized (this) {
3. ……
4. //设立标志位
5. setValid(false);
6. //计算一些统计值，例如此manager下所有session平均存活时间等
7. long timeNow = System.currentTimeMillis();
8. );
9. synchronized (manager) {
10. if (timeAlive > manager.getSessionMaxAliveTime()) {
11. manager.setSessionMaxAliveTime(timeAlive);
12. }
13. int numExpired = manager.getExpiredSessions();
14. numExpired++;
15. manager.setExpiredSessions(numExpired);
16. int average = manager.getSessionAverageAliveTime();
17. )) + timeAlive)/numExpired;
18. manager.setSessionAverageAliveTime(average);
19. }
20. // 将此session从manager对象的session池中删除
21. manager.remove(this);
22. ……
23. }
24. }

不需要解释，已经很清晰了。 
这个超时时间是可以配置的，缺省在tomcat的全局web.xml下配置，也可在各个app下的web.xml自行定义；

1. <session-config>
2. <session-timeout>30</session-timeout>
3. </session-config>

单位是分钟。 
Session持久化及启动初始化 
这个功能主要是，当tomcat执行安全退出时(通过执行shutdown脚本)，会将session持久化到本地文件，通常在tomcat的部署目录下有个session.ser文件。当启动tomcat时，会从这个文件读入session，并添加到manager的session池中去。 
这样，当tomcat正常重启时， session没有丢失，对于用户而言，体会不到重启，不影响用户体验。 
看一下概念图吧，觉得不是重要实现逻辑，代码就不说了。 
 
总结 
由此可以看出，session的管理是容器层做的事情，应用层一般不会参与session的管理，也就是说，如果在应用层获取到相应的session，已经是由tomcat提供的，因此如果过多的依赖session机制来进行一些操作，例如访问控制，安全登录等就不是十分的安全，因为如果有人能得到正在使用的jsessionid，则就可以侵入系统。

自己的个人博客：bingtel-木犹如此的博客