Quando è scaduta la sessione HttpSession (inizia ad essere idonea per la distruzione - non necessariamente ancora distrutta)?

Question

Mi piacerebbe sapere quando esattamente un HttpSession sarebbe scaduto (non è lo stesso di quello distrutto)?

Sto cercando di capire se session.getLastAccessedTime() + (session.getMaxInactiveInterval() * 1000) mi darà l'esatto tempo in millisecondi di scadenza della sessione ogni volta che una richiesta arriva con lo stesso ID di sessione!

Dalle javadocs:

lungo getLastAccessedTime()

Returns the last time the client sent a request associated with this session, as the number of milliseconds since midnight January 1, 1970 GMT, and marked by the time the container received the request.  

int getMaxInactiveInterval()

Returns the maximum time interval, in seconds, that the servlet container will keep this session open between client accesses. 

Consente di dire che abbiamo la seguente:
Treq1 - the time the container received the 1st request (HttpSession.lastAccessedTime)
Tresp1 - the time the container sends the 1st response
Preq1 - the time period between Treq1 and Tresp1 (the time period that the server processes the 1st request
Treq2 - the time the container received the 2nd request (HttpSession.lastAccessedTime)
Preq1req2 - the time period between Treq1 and Treq2 (the time between requests entering the container)
Presp1req2 - the time period between Tresp1 and Treq2 (the time between the 1st response exiting the container and the 2nd request entering the container)

Così ora, quando si fa il server calcolare il sessione scaduta? Quando:
1. Treq1 + maxInactiveInterval < Treq1 + Preq1req2 =>maxInactiveInterval < Preq1req2
2. Tresp1 + maxInactiveInterval < Tresp1 + Presp1req2 =>maxInactiveInterval < Presp1req2

Questa parte, è un the servlet container will keep this session open between client accesses un po 'di confusione. Significa tra le richieste che entrano nel contenitore o tra la risposta che esce e le richieste che entrano?

Su un lato nota, so che la sessione non può essere distrutto al momento esatto in cui scade, ma non so ancora se è distrutto prima che si verifichi qualsiasi logica di elaborazione delle richieste in Il container. Mi riferisco alla richiesta che contiene un id della sessione scaduta.

Cordiali saluti,
despota

Answer 1

meccanismo La sessione è parte del Servlet specification, che mandati:

Nel protocollo HTTP, non v'è alcun segnale di terminazione esplicita quando un cliente non è più attiva. Ciò significa che l'unico meccanismo che può essere utilizzato per indicare quando un client non è più attivo è un periodo di timeout.

Il periodo di timeout predefinito per le sessioni è definito dal contenitore servlet e può essere ottenuto tramite il metodo getMaxInactiveInterval dell'interfaccia HttpSession. Questo timeout può essere modificato dallo sviluppatore utilizzando il metodo setMaxInactiveInterval dell'interfaccia HttpSession. I periodi di timeout utilizzati da questi metodi sono definiti in secondi. Per definizione, se il periodo di timeout per una sessione è impostato su -1, , la sessione non scadrà mai. L'invalidazione della sessione non avrà effetto fino a quando tutti i servlet che utilizzano quella sessione sono usciti dal metodo di servizio. Una volta avviata l'invalidazione della sessione , una nuova richiesta non deve essere in grado di vedere quella sessione.

Il metodo getLastAccessedTime dell'interfaccia HttpSession consente a un servlet di di determinare l'ultima volta che è stata eseguita l'accesso alla sessione prima della richiesta corrente. Si considera che la sessione sia accessibile quando una richiesta che fa parte della sessione è la prima gestita dal contenitore della servlet.

Probabilmente si può presumere che "l'intervallo inattivo" inizi con "lastAccessedTime".

Answer 2

Sto cercando di capire se session.getLastAccessedTime() + (session.getMaxInactiveInterval() * 1000) mi darà l'ora esatta in millisecondi di scadenza sessione ogni tempo in cui una richiesta arriva con lo stesso ID di sessione!

dato che è possibile accedere oggetto sessione solo in un thread di richiesta Io parto dal presupposto che si stanno avendo sopra il codice in un servlet per informare client (browser) di quello che ora si può prendere prima della sua prossima click, può essere un contatore del timeout .

Presumo che System.currentTimeMillis() + (session.getMaxInactiveInterval() * 1000) sarà più preciso in tal caso.

Answer 3

origine?

ho tracciato le richieste due volte con "org.springframework.boot: primavera-boot-starter-web: 1.5.6.RELEASE" spring e ha concluso:

nel gestore del servizio (doGet, Doxx, o metodi di controller), il tempo di scadenza sarà session.getLastAccessedTime() + (session.getMaxInactiveInterval() * 1000) (2. caso)

Duration:  |<---------- Preq1req2 ---------->| 
Duration:  |   |<---- Presp1req2 --->| 
Time :  Treq1  Tresp1    Treq2  Tresp2 
Action : req1-->|--service--|-->resp1 ... req2-->|--service--|-->resp2 
Duration:  |<- Preq1 ->|      |<- Preq2 ->| 
       |   |         | 
Set :  creationTime  |         | 
      lastAccessedTime |         |    
         lastAccessedTime     lastAccessedTime 

Quando lastAccessedTime viene aggiornato dopo il servizio:

snippet di codice C:/Us ERS/ssfang/.m2/repository/org/apache/tomcat/embed/tomcat-incorporare processori/8.5.16/tomcat-incorporare-core-8.5.16-sources.jar

package org.apache.catalina.session; 
public class StandardSession implements HttpSession, Session, Serializable { 
    /** The time this session was created, in milliseconds since midnight, January 1, 1970 GMT. */ 
    protected long creationTime = 0L; 

    /** 
    * We are currently processing a session expiration, so bypass 
    * certain IllegalStateException tests. NOTE: This value is not 
    * included in the serialized version of this object. 
    */ 
    protected transient volatile boolean expiring = false; 

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

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

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

    /** The current accessed time for this session. */ 
    protected volatile long thisAccessedTime = creationTime; 


    /** The access count for this session. */ 
    protected transient AtomicInteger accessCount = 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 volatile int maxInactiveInterval = -1; 

    /** 
    * Return the idle time from last client access time without invalidation check 
    * @see #getIdleTime() 
    */ 
    @Override 
    public long getIdleTimeInternal() { 
     long timeNow = System.currentTimeMillis(); 
     long timeIdle; 
     if (LAST_ACCESS_AT_START) { 
      timeIdle = timeNow - lastAccessedTime; 
     } else { 
      timeIdle = timeNow - thisAccessedTime; 
     } 
     return timeIdle; 
    } 

    /** 
    * Set the creation time for this session. This method is called by the 
    * Manager when an existing Session instance is reused. 
    * 
    * @param time The new creation time 
    */ 
    @Override 
    public void setCreationTime(long time) { 
     this.creationTime = time; 
     this.lastAccessedTime = time; 
     this.thisAccessedTime = time; 
    } 

    /** Return the <code>isValid</code> flag for this session. */ 
    @Override 
    public boolean isValid() { 
     if (!this.isValid) { 
      return false; 
     } 
     if (this.expiring) { 
      return true; 
     } 
     if (ACTIVITY_CHECK && accessCount.get() > 0) { 
      return true; 
     } 
     if (maxInactiveInterval > 0) { 
      int timeIdle = (int) (getIdleTimeInternal()/1000L); 
      if (timeIdle >= maxInactiveInterval) { 
       expire(true); 
      } 
     } 
     return this.isValid; 
    } 
} 

Verificare se il sessione è valida prima di ottenere la sessione

un thread in background per la scansione di tutte le sessioni se sono scaduti.