import io.undertow.server.session.SessionListener; //导入依赖的package包/类
@Override
public void stop() {
    for (Map.Entry<String, SessionImpl> session : sessions.entrySet()) {
        session.getValue().destroy();
        sessionListeners.sessionDestroyed(session.getValue(), null, SessionListener.SessionDestroyedReason.UNDEPLOY);
    }
    sessions.clear();
    this.cacheManager.stop();
}
 

import io.undertow.server.session.SessionListener; //导入依赖的package包/类
@Override
public void run() {
    worker.execute(new Runnable() {
        @Override
        public void run() {
            long currentTime = System.currentTimeMillis();
            if(currentTime >= expireTime) {
                invalidate(null, SessionListener.SessionDestroyedReason.TIMEOUT);
            } else {
                timerCancelKey = executor.executeAfter(cancelTask, expireTime - currentTime, TimeUnit.MILLISECONDS);
            }
        }
    });
}
 

import io.undertow.server.session.SessionListener; //导入依赖的package包/类
@Override
public void invalidate(final HttpServerExchange exchange) {
    invalidate(exchange, SessionListener.SessionDestroyedReason.INVALIDATED);
    if(exchange != null) {
        exchange.removeAttachment(sessionManager.NEW_SESSION);
    }
}
 

import io.undertow.server.session.SessionListener; //导入依赖的package包/类
protected void configureSessionManager(SessionManager sessionManager , List<Class<?>> annotatedSessionListeners ){
  SessionListenerMounter mounter = new SessionListenerMounterImpl();
  for (Class<?> annotatedClass : annotatedSessionListeners) {
    SessionListener sl = mounter.mount(annotatedClass);
    if(sl != null){
      sessionManager.registerSessionListener( sl);
    }
  }
}
 

import io.undertow.server.session.SessionListener; //导入依赖的package包/类
@Test
public void doesCreateSessionListenerAndInvokeOnCreateAnnotatedMethodsOnSessionCreation(){
  SessionListener sl = mounter.mount(TestSessionListener.class);

  sl.sessionCreated( mock(Session.class) , NULL_EXCHANGE );

  assertSame( 1 , TestSessionListener.onCreateCallCounter );
  assertSame( 0 , TestSessionListener.onDestroyCallCounter );
}
 

import io.undertow.server.session.SessionListener; //导入依赖的package包/类
@Test
public void doesCreateSessionListenerAndInvokeOnDestroyAnnotatedMethodsOnSessionDestruction(){
  SessionListener sl = mounter.mount(TestSessionListener.class);

  sl.sessionDestroyed( mock(Session.class) , NULL_EXCHANGE , SessionDestroyedReason.TIMEOUT );

  assertSame( 1 , TestSessionListener.onDestroyCallCounter );
  assertSame( 0 , TestSessionListener.onCreateCallCounter );
}
 

import io.undertow.server.session.SessionListener; //导入依赖的package包/类
public DeploymentInfo addSessionListener(SessionListener sessionListener) {
    this.sessionListeners.add(sessionListener);
    return this;
}
 

import io.undertow.server.session.SessionListener; //导入依赖的package包/类
public List<SessionListener> getSessionListeners() {
    return Collections.unmodifiableList(sessionListeners);
}
 

import io.undertow.server.session.SessionListener; //导入依赖的package包/类
@Override
public Session createSession(final HttpServerExchange serverExchange, final SessionConfig config) {
    if (evictionQueue != null) {
        if(expireOldestUnusedSessionOnMax) {
            while (sessions.size() >= maxSize && !evictionQueue.isEmpty()) {

                String key = evictionQueue.poll();
                UndertowLogger.REQUEST_LOGGER.debugf("Removing session %s as max size has been hit", key);
                SessionImpl toRemove = sessions.get(key);
                if (toRemove != null) {
                    toRemove.invalidate(null, SessionListener.SessionDestroyedReason.TIMEOUT); //todo: better reason
                }
            }
        } else if(sessions.size() >= maxSize) {
            if(statisticsEnabled) {
                rejectedSessionCount.incrementAndGet();
            }
            throw UndertowMessages.MESSAGES.tooManySessions(maxSize);
        }
    }
    if (config == null) {
        throw UndertowMessages.MESSAGES.couldNotFindSessionCookieConfig();
    }
    String sessionID = config.findSessionId(serverExchange);
    int count = 0;
    while (sessionID == null) {
        sessionID = sessionIdGenerator.createSessionId();
        if(sessions.containsKey(sessionID)) {
            sessionID = null;
        }
        if(count++ == 100) {
            //this should never happen
            //but we guard against pathalogical session id generators to prevent an infinite loop
            throw UndertowMessages.MESSAGES.couldNotGenerateUniqueSessionId();
        }
    }
    Object evictionToken;
    if (evictionQueue != null) {
        evictionToken = evictionQueue.offerLastAndReturnToken(sessionID);
    } else {
        evictionToken = null;
    }
    if(statisticsEnabled) {
        createdSessionCount.incrementAndGet();
    }
    final SessionImpl session;
    if (sessions.containsKey(sessionID)) {
        SessionImpl session1 = sessions.get(sessionID);
        session = new SessionImpl(this, session1.sessionId, config, serverExchange.getIoThread(), serverExchange.getConnection().getWorker(), session1.evictionToken, defaultSessionTimeout, session1.attributes);
    } else {
        session = new SessionImpl(this, sessionID, config, serverExchange.getIoThread(), serverExchange.getConnection().getWorker(), evictionToken, defaultSessionTimeout);
    }
    sessions.put(sessionID, session);
    config.setSessionId(serverExchange, session.getId());
    session.lastAccessed = System.currentTimeMillis();
    session.bumpTimeout();
    sessionListeners.sessionCreated(session, serverExchange);
    serverExchange.putAttachment(NEW_SESSION, session);
    return session;
}
 

import io.undertow.server.session.SessionListener; //导入依赖的package包/类
@Override
public synchronized void registerSessionListener(final SessionListener listener) {
    sessionListeners.addSessionListener(listener);
}
 

import io.undertow.server.session.SessionListener; //导入依赖的package包/类
@Override
public synchronized void removeSessionListener(final SessionListener listener) {
    sessionListeners.removeSessionListener(listener);
}
 

import io.undertow.server.session.SessionListener; //导入依赖的package包/类
@Test
public void doesCreateASessionListenerFromAGenericClass(){
   SessionListener sl = mounter.mount(TestSessionListener.class);

   assertNotNull(sl);
}
 

import io.undertow.server.session.SessionListener; //导入依赖的package包/类
SessionListener mount(Class<?> annotatedClass);