public class StandardSessionFacade implements HttpSession 

 private final HttpSession session;
 public StandardSessionFacade(HttpSession session) {
 this.session = session;
 }

 @GetMapping("/s")
 public String sessionTest(HttpSession httpSession) throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
 StandardSessionFacade session = (StandardSessionFacade) httpSession;
 Class targetClass = Class.forName(session.getClass().getName());

 //修改可见性
 Field standardSessionField = targetClass.getDeclaredField("session");
 standardSessionField.setAccessible(true);
 //获取
 StandardSession standardSession = (StandardSession) standardSessionField.get(session);
 
 return standardSession.getManager().toString();
 }

public class StandardSession implements 
HttpSession, Session, Serializable

 @GetMapping("/s")
 public void sessionTest(HttpSession httpSession, HttpServletResponse response) throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException, IOException {
 StandardSessionFacade session = (StandardSessionFacade) httpSession;
 Class targetClass = Class.forName(session.getClass().getName());

 //修改可见性
 Field standardSessionField = targetClass.getDeclaredField("session");
 standardSessionField.setAccessible(true);
 //获取
 StandardSession standardSession = (StandardSession) standardSessionField.get(session);
 
 //存点数据以便观察
 standardSession.setAttribute("msg","hello,world");
 standardSession.setAttribute("user","kesan");
 standardSession.setAttribute("password", "点赞");
 standardSession.setAttribute("tel", 10086L);
 //将序列化的结果直接写到Http的响应中
 ObjectOutputStream objectOutputStream = new ObjectOutputStream(response.getOutputStream());
 
 standardSession.writeObjectData(objectOutputStream);
 }

 public void setAttribute(String name, Object value, boolean notify) {
 //省略无关代码
  //获取上文中配置的事件监听器
 Object listeners[] = context.getApplicationEventListeners();
 if (listeners == null) {
  return;
 }
 for (int i = 0; i < listeners.length; i++) {
  //只有HttpSessionAttributeListener才可以执行
  if (!(listeners[i] instanceof HttpSessionAttributeListener)) {
  continue;
  }
  HttpSessionAttributeListener listener = (HttpSessionAttributeListener) listeners[i];
  try {
  //在当前线程调用监听器的处理方法
  if (unbound != null) {
   if (unbound != value || manager.getNotifyAttributeListenerOnUnchangedValue()) {
   //如果是某个键的值被修改则调用监听器的attributeReplaced方法
   context.fireContainerEvent("beforeSessionAttributeReplaced", listener);
   if (event == null) {
    event = new HttpSessionBindingEvent(getSession(), name, unbound);
   }
   listener.attributeReplaced(event);
   context.fireContainerEvent("afterSessionAttributeReplaced", listener);
   }
  } else {
   //如果是新添加某个键则执行attributeAdded方法
   context.fireContainerEvent("beforeSessionAttributeAdded", listener);
   if (event == null) {
   event = new HttpSessionBindingEvent(getSession(), name, value);
   }
   listener.attributeAdded(event);
   context.fireContainerEvent("afterSessionAttributeAdded", listener);
  }
  } catch (Throwable t) {
  //异常处理
  }
 }
 }

 public StandardSession(Manager manager) {
 //调用Object类的构造方法,默认已经调用了
 //此处再声明一次，不知其用意，或许之前此类有父类"text-align: center">

我们将目光转移到 ManagerBase中可以发现以下代码。


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


Session 是Tomcat自定义的接口, StandardSession 实现了 HttpSession 以及 Session 接口,此接口功能更加丰富，但并不向程序员提供。
查找此属性可以发现，与Session相关的操作都是通过操作 sessions 来实现的，因此我们可以明确保存Session的数据结构是 ConcurrentHashMap 。

如何创建Session
那么Session到底是如何创建的呢？我找到了以下方法 ManagerBase.creaeSession , 总结其流程如下。

  
检查session数是否超过限制，如果有就抛出异常
  
创建StandardSession对象
  
设置session各种必须的属性(合法性, 最大超时时间, sessionId)
  
生成SessionId, Tomcat支持不同的SessionId算法,本人调试过程其所使用的SessionId生成算法是LazySessionIdGenerator(此算法与其他算法不同之处就在于并不会在一开始就加载随机数数组，而是在用到的时候才加载,此处的随机数组并不是普通的随机数组而是SecureRandom,相关信息可以阅读大佬的文章)
  
增加session的计数，由于Tomcat的策略是只计算100个session的创建速率，因此sessionCreationTiming是固定大小为100的链表(一开始为100个值为null的元素)，因此在将新的数据添加到链表中时必须要将旧的数据移除链表以保证其固定的大小。session创建速率计算公式如下

(1000*60*counter)/(int)(now - oldest)

其中



  
now为获取统计数据时的时间System.currentTimeMillis()
  
oldest为队列中最早创建session的时间
  
counter为队列中值不为null的元素的数量
  
由于计算的是每分钟的速率因此在此处必须将1000乘以60（一分钟内有60000毫秒)



 public Session createSession(String sessionId) {
 //检查Session是否超过限制,如果是则抛出异常
 if ((maxActiveSessions >= 0) &&
  (getActiveSessions() >= maxActiveSessions)) {
  rejectedSessions++;
  throw new TooManyActiveSessionsException(
   sm.getString("managerBase.createSession.ise"),
   maxActiveSessions);
 }

 //该方法会创建StandardSession对象
 Session session = createEmptySession();

 //初始化Session中必要的属性
 session.setNew(true);
 //session是否可用
 session.setValid(true);
 //创建时间
 session.setCreationTime(System.currentTimeMillis());
 //设置session最大超时时间
 session.setMaxInactiveInterval(getContext().getSessionTimeout() * 60);
 String id = sessionId;
 if (id == null) {
  id = generateSessionId();
 }
 session.setId(id);
 sessionCounter++;
 //记录创建session的时间，用于统计数据session的创建速率
 //类似的还有ExpireRate即Session的过期速率
 //由于可能会有其他线程对sessionCreationTiming操作因此需要加锁
 SessionTiming timing = new SessionTiming(session.getCreationTime(), 0);
 synchronized (sessionCreationTiming) {
  //sessionCreationTiming是LinkedList
  //因此poll会移除链表头的数据，也就是最旧的数据
  sessionCreationTiming.add(timing);
  sessionCreationTiming.poll();
 }
 return session;
 }


Session的销毁
要销毁Session，必然要将Session从 ConcurrentHashMap 中移除，顺藤摸瓜我们可以发现其移除session的代码如下所示。


 @Override
 public void remove(Session session, boolean update) {
 //检查是否需要将统计过期的session的信息
 if (update) {
  long timeNow = System.currentTimeMillis();
  int timeAlive =
  (int) (timeNow - session.getCreationTimeInternal())/1000;
  updateSessionMaxAliveTime(timeAlive);
  expiredSessions.incrementAndGet();
  SessionTiming timing = new SessionTiming(timeNow, timeAlive);
  synchronized (sessionExpirationTiming) {
  sessionExpirationTiming.add(timing);
  sessionExpirationTiming.poll();
  }
 }
 //将session从Map中移除
 if (session.getIdInternal() != null) {
  sessions.remove(session.getIdInternal());
 }
 }


被销毁的时机
主动销毁
我们可以通过调用 HttpSession.invalidate() 方法来执行session销毁操作。此方法最终调用的是 StandardSession.invalidate() 方法，其代码如下,可以看出使 session 销毁的关键方法是 StandardSession.expire()


 public void invalidate() {

 if (!isValidInternal())
  throw new IllegalStateException
  (sm.getString("standardSession.invalidate.ise"));

 // Cause this session to expire
 expire();
 }


expire 方法的代码如下


 @Override
 public void expire() {

 expire(true);

 }
 public void expire(boolean notify) {
  //省略代码
  //将session从ConcurrentHashMap中移除
  manager.remove(this, true);
  //被省略的代码主要是将session被销毁的消息通知
  //到各个监听器上
 }


超时销毁
除了主动销毁之外，我们可以为session设置一个过期时间，当时间到达之后session会被后台线程主动销毁。我们可以为session设置一个比较短的过期时间，然后通过 JConsole 来追踪其调用栈，其是哪个对象哪个线程执行了销毁操作。
如下图所示，我们为session设置了一个30秒的超时时间。

然后我们在 ManagerBase.remove
方法上打上断点，等待30秒之后，如下图所示

Tomcat会开启一个后台线程，来定期执行子组件的 backgroundProcess 方法(前提是子组件被Tomcat管理且实现了 Manager接口)


 @Override
 public void backgroundProcess() {
 count = (count + 1) % processExpiresFrequency;
 if (count == 0)
  processExpires();
 }

 public void processExpires() {

 long timeNow = System.currentTimeMillis();
 Session sessions[] = findSessions();
 int expireHere = 0 ;

 if(log.isDebugEnabled())
  log.debug("Start expire sessions " + getName() + " at " + timeNow + " sessioncount " + sessions.length);
 //从JConsole的图中可以看出isValid可能导致expire方法被调用
 for (int i = 0; i < sessions.length; i++) {
  if (sessions[i]!=null && !sessions[i].isValid()) {
  expireHere++;
  }
 }
 long timeEnd = System.currentTimeMillis();
 if(log.isDebugEnabled())
  log.debug("End expire sessions " + getName() + " processingTime " + (timeEnd - timeNow) + " expired sessions: " + expireHere);
 processingTime += ( timeEnd - timeNow );

 }


我们可以来看看接口中 Manager.backgroundProcess 中注释,简略翻译一下就是 backgroundProcess 会被容器定期的执行，可以用来执行session清理任务等。


 /**
 * This method will be invoked by the context/container on a periodic
 * basis and allows the manager to implement
 * a method that executes periodic tasks, such as expiring sessions etc.
 */
 public void backgroundProcess();


总结 
Session的数据结构如下图所示，简单来说就是用 ConcurrentHashMap 来保存 Session ，而 Session 则用 ConcurrentHashMap 来保存键值对，其结构如下图所示。 .jpg

这意味着，不要拼命的往Session里面添加离散的数据, 把离散的数据封装成一个对象性能会更加好 如下所示


//bad
httpSession.setAttribute("user","kesan");
httpSession.setAttribute("nickname","点赞");
httpSession.setAttribute("sex","男");
....




//good
User kesan = userDao.getUser()
httpSession.setAttribute("user", kesan);


如果你为Session配置了监听器，那么对Session执行任何变更都将直接在当前线程执行监听器的方法， 因此最好不要在监听器中执行可能会发生阻塞的方法 。
Tomcat会开启一个后台线程来定期执行 ManagerBase.backgroundProcess 方法用来检测过期的Session并将其销毁。
思想迁移
对象生成速率算法此算法设计比较有趣，并且也可以应用到其他项目中，因此做如下总结。
首先生成一个固定大小的链表(比如说100)，然后以null元素填充。 当创建新的对象时，将创建时间加入链表末尾中(当然是封装后的对象)，然后将链表头节点移除，此时被移除的对象要么是null节点要么是最早加入链表的节点 当要计算对象生成速率时，统计链表中不为null的元素的数量除以当前的时间与最早创建对象的时间的差，便可以得出其速率。（注意时间单位的转换)
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。