Come differenziare le sessioni nelle schede del browser?


135

In un'applicazione web implementata in Java usando JSP e Servlet; se conservo informazioni nella sessione utente, queste informazioni sono condivise da tutte le schede dallo stesso browser. Come differenziare le sessioni nelle schede del browser? In questo esempio:

<%@page language="java"%>
<%
String user = request.getParameter("user");
user = (user == null ? (String)session.getAttribute("SESSIONS_USER") : user);
session.setAttribute("SESSIONS_USER",user);
%>
<html><head></head><body>
<%=user %>
<form method="post">
User:<input name="user" value="">
<input type="submit" value="send">
</form>
</body></html>

Copia questo codice in una pagina jsp ( testpage.jsp), distribuisci questo file in un contesto esistente di un'applicazione web sul server (utilizzo Apache Tomcat), quindi apri un browser (FF, IE7 o Opera) utilizzando l'URL corretto ( localhost/context1/testpage.jsp), digita il tuo nome nell'input e invia il modulo. Quindi apri una nuova scheda nello stesso browser, quindi puoi vedere il tuo nome (ottenere dalla sessione) nella nuova scheda. Fai attenzione con la cache del browser, a volte sembra che non accada, ma è nella cache, aggiorna la seconda scheda.

Grazie.



1
Questa è una cosa che l'utente deve fare: Apri IE, fai clic su "File-> Nuova sessione"
Stefan Steiger,

3
@Quandary, la tua soluzione non è una soluzione generica (in altri browser non funziona) e, soprattutto, non è user friendly (gli utenti non conoscono le sessioni).
Oriol Terradas,

2
Alcune persone sembrano incapaci di immaginare quale sia lo scopo di questo. Il dominio problematico è la maggior parte delle situazioni in cui si desidera consentire diverse "visualizzazioni" del proprio sito Web. Una volta che l'utente può avere più di una vista del tuo sito Web, inevitabilmente desiderano (o tentano accidentalmente) di accedere a due diverse viste contemporaneamente. Gli esempi includono: controllo delle versioni temporali (passare alla visualizzazione del sito Web come esisteva ad un certo punto in passato); sandboxing (apportare modifiche al sito Web che gli altri non possono ancora vedere); viste basate sul ruolo (vedere come il sito Web appare all'utente meno privilegiato); ecc.
Ron Burk,

Risposte:


92

È possibile utilizzare HTML5 SessionStorage (window.sessionStorage). Genererai un ID casuale e salvi in ​​sessione Archiviazione per scheda Browser. Quindi ogni scheda del browser ha il suo ID.

I dati archiviati utilizzando sessionStorage non persistono tra le schede del browser, anche se due schede contengono entrambe pagine Web della stessa origine di dominio. In altre parole, i dati all'interno di sessionStorage sono limitati non solo al dominio e alla directory della pagina invocante, ma alla scheda del browser in cui è contenuta la pagina.


7
Dai documenti: "I dati memorizzati utilizzando sessionStorage non persistono tra le schede del browser, anche se due schede contengono entrambe pagine Web della stessa origine di dominio. In altre parole, i dati all'interno di sessionStorage sono limitati non solo al dominio e alla directory della pagina richiamante, ma la scheda del browser in cui è contenuta la pagina. Confrontala con i cookie di sessione, che mantengono i dati da una scheda all'altra. " Test semplici confermano questo comportamento in Chrome e FF.
jswanson,

21
Nota, l'ID verrà duplicato quando si utilizza la funzione "Scheda duplicata" di Chrome. Questo in genere non è un problema, ma dovrebbe essere meditato.
JosiahDaniels,

Tranne quando si "duplica" una scheda in Chrome o Firefox. In questo caso, SessionStorage viene copiato.
Tiago Freitas Leal,

@Gonzalo Gallotti: E come mi aiuterà se la sessione è lato server? )))
Stefan Steiger,

@StefanSteiger. Quindi puoi inviare l'ID BrowserTab (salvato nella memoria di sessione) con la tua chiamata Ajax. Sul lato server sarà necessaria una logica personalizzata, poiché la sessione Web è la stessa. Ma puoi creare una HashMap con oggetti Session per tab.
Gonzalo Gallotti,

23

Devi capire che le sessioni lato server sono un componente aggiuntivo artificiale di HTTP. Poiché HTTP è senza stato, il server deve in qualche modo riconoscere che una richiesta appartiene a un determinato utente che conosce e per cui ha una sessione. Ci sono 2 modi per farlo:

  • Biscotti. Il metodo più pulito e più popolare, ma significa che tutte le schede del browser e le finestre di un utente condividono la sessione - IMO questo è in effetti desiderabile, e sarei molto infastidito in un sito che mi ha fatto accedere per ogni nuova scheda, poiché usare le schede molto intensamente
  • Riscrittura URL. Qualsiasi URL sul sito ha un ID sessione aggiunto ad esso. Questo è più lavoro (devi fare qualcosa ovunque tu abbia un link interno al sito), ma rende possibile avere sessioni separate in diverse schede, anche se le schede aperte tramite link condivideranno comunque la sessione. Significa anche che l'utente deve sempre accedere quando accede al tuo sito.

Cosa stai cercando di fare comunque? Perché vorresti che le schede avessero sessioni separate? Forse c'è un modo per raggiungere il tuo obiettivo senza usare le sessioni?

Modifica: per i test, è possibile trovare altre soluzioni (come l'esecuzione di più istanze del browser su macchine virtuali separate). Se un utente deve agire contemporaneamente in ruoli diversi, il concetto di "ruolo" deve essere gestito nell'app in modo che un accesso possa avere più ruoli. Dovrai decidere se questo, usando la riscrittura degli URL o semplicemente vivere con la situazione attuale è più accettabile, perché semplicemente non è possibile gestire le schede del browser separatamente con sessioni basate su cookie.


6
È per una grande applicazione che mantiene le informazioni dell'utente e l'ambiente. Quando qualcuno accede con utenti diversi in schede diverse, per test o per ruoli diversi, allora incrocia le informazioni dalle schede.
Oriol Terradas,

Solo un componente aggiuntivo molto tardi, sul perché: perché ho bisogno di sapere questo per sapere QUALE pagina del mio sito, ad esempio, un utente è concentrato e non solo che sono passati da una pagina all'altra ( invece sono passati da una scheda all'altra).
Oliver Williams,

16

La proprietà Javascript window.name è l'unica cosa che persiste nell'attività della scheda, ma può rimanere indipendente (anziché URL guff).


3
Anche window.sessionStorage fa
felickz il

3
attenzione quando l'archiviazione della sessione viene copiata in una nuova scheda quando l'utente sceglie "Apri in una nuova scheda" ... vorrei avere un link per i dettagli, ma vedi: bugzilla.mozilla.org/show_bug.cgi?id=818389
felickz

2
Tieni presente che la cosa salvata nell'impostazione window.name sarà ancora disponibile in altri domini, quando l'utente passa ad altre pagine nella stessa scheda.
nakib,

15

Non dovresti.Se vuoi fare una cosa del genere, devi forzare l'utente a usare una singola istanza della tua applicazione scrivendo gli URL al volo usando un ID sessionID simile (non sessionid non funzionerà) e passalo in ogni URL.

Non so perché ne abbiate bisogno, ma a meno che non sia necessario creare un'applicazione totalmente inutilizzabile, non farlo.


9
È per una grande applicazione che mantiene le informazioni dell'utente e l'ambiente. Quando qualcuno accede con utenti diversi in schede diverse, per test o per ruoli diversi, allora incrocia le informazioni dalle schede.
Oriol Terradas,

38
vecchia risposta lo so, ma google mail ti consente di avere account diversi per scheda e non è "un'applicazione totalmente inutilizzabile"
George

2
@George, La risposta è ancora corretta, e per il tuo esempio vedrai nel numero dell'URL che rappresenta l'indice degli account memorizzati nei cookie, Google Mail sta semplicemente memorizzando tutti i cookie e selezionane uno in base all'URL.
Mhmd,

5
Non sei sicuro che la risposta sia ancora corretta, puoi chiaramente farlo. Gmail lo fa. Per quanto riguarda il modo in cui lo fa, potrebbe non essere elegante ma funziona ed è questo che conta
George,

2
Vecchia risposta, ma potrei aggiungere che Whatsapp e Telegram non ti consentono di aprire due schede contemporaneamente. Questo non li rende inutilizzabili
Charlie

13

Ho escogitato una nuova soluzione, che ha un po 'di spese generali, ma sembra funzionare fino a un prototipo. Un presupposto è che ti trovi in ​​un ambiente di sistema d'onore per l'accesso, anche se questo potrebbe essere adattato richiedendo nuovamente una password ogni volta che cambi scheda.

Utilizzare localStorage (o equivalente) e l'evento di archiviazione HTML5 per rilevare quando una nuova scheda del browser ha cambiato l'utente attivo. Quando ciò accade, crea un overlay fantasma con un messaggio che dice che non puoi usare la finestra corrente (o altrimenti disabilita temporaneamente la finestra, potresti non volerlo essere così evidente.) Quando la finestra riprende lo stato attivo, invia una richiesta di registrazione AJAX l'utente rientra.

Un avvertimento a questo approccio: non è possibile effettuare chiamate AJAX normali (ovvero, che dipendono dalla sessione) in una finestra che non ha lo stato attivo (ad esempio se si è verificata una chiamata dopo un ritardo), a meno che prima fai una chiamata di re-login AJAX manualmente. Quindi davvero tutto ciò che devi fare è controllare prima la tua funzione AJAX per assicurarti che localStorage.currently_logged_in_user_id === window.yourAppNameSpace.user_id e, in caso contrario, accedi prima tramite AJAX.

Un altro è le condizioni di gara: se puoi cambiare finestra abbastanza velocemente da confonderlo, potresti finire con una sequenza relogin1-> relogin2-> ajax1-> ajax2, con ajax1 creato nella sessione sbagliata. Per ovviare a questo, invia le richieste di accesso AJAX su un array, quindi sul palco e prima di emettere una nuova richiesta di accesso, annulla tutte le richieste correnti.

L'ultimo gotcha a cui cercare è l'aggiornamento della finestra. Se qualcuno aggiorna la finestra mentre hai una richiesta di accesso AJAX attiva ma non completata, verrà aggiornata nel nome della persona sbagliata. In questo caso è possibile utilizzare l'evento beforeunload non standard per avvisare l'utente del potenziale mixup e chiedere loro di fare clic su Annulla, nel frattempo riemettendo una richiesta di accesso AJAX. Quindi l'unico modo in cui possono sbagliare è facendo clic su OK prima che la richiesta venga completata (o premendo accidentalmente enter / barra spaziatrice, perché OK è - purtroppo per questo caso - il valore predefinito.) Ci sono altri modi per gestire questo caso, come rilevamento delle pressioni F5 e Ctrl + R / Alt + R, che funzionerà nella maggior parte dei casi ma potrebbe essere vanificato dalla riconfigurazione delle scorciatoie da tastiera dell'utente o dall'uso di un sistema operativo alternativo. Tuttavia, questo è un po 'un caso limite nella realtà, e gli scenari peggiori non sono mai così male: in una configurazione del sistema d'onore, verrai effettuato l'accesso come persona sbagliata (ma puoi rendere ovvio che questo è il caso personalizzando le pagine con colori, stili, nomi ben visibili, eccetera.); in una configurazione di password, l'onere è sull'ultima persona che ha inserito la propria password per essersi disconnesso o condiviso la propria sessione, o se questa persona è effettivamente l'utente corrente, allora non c'è violazione.

Ma alla fine hai un'applicazione per un utente per scheda che (si spera) agisce come dovrebbe, senza dover necessariamente impostare i profili, usare IE o riscrivere gli URL. Assicurati di renderlo ovvio in ogni scheda che è connesso a quella particolare scheda, sebbene ...


6
+1 perché hai impiegato del tempo per pensarci davvero! :-) Guardando tutti gli avvertimenti, sai solo che è una cattiva idea. Le mie lezioni apprese da queste cose sono di capire veramente quali dati dovrebbero andare nelle sessioni e quali dati non dovrebbero.
Peter,

10

Abbiamo avuto questo problema e l'abbiamo risolto molto facilmente. Intendo facile perché nessuna programmazione coinvolta. Quello che volevamo fare era consentire a un utente di accedere a più account all'interno della stessa finestra del browser senza mettere in conflitto le sessioni.

Quindi la soluzione era sottodomini casuali.

23423.abc.com
242234.abc.com
235643.abc.com

Quindi abbiamo chiesto al nostro amministratore di sistema di configurare i certificati SSL per * .abc.com piuttosto che abc.com Quindi, con una piccola modifica del codice, ogni volta che un utente tenta di accedere, viene registrato in una scheda con un numero di sottodominio casuale. così ogni scheda potrebbe avere la propria sessione in modo indipendente. Inoltre, per evitare qualsiasi conflitto, abbiamo sviluppato il numero casuale usando un hash o md5 di id utente.


3
Sembra un'alternativa intelligente alla riscrittura degli URL. Si finisce con la variabile desiderata (ID sessione) in un luogo conforme HTTP che è visibile ma non invadente. Nits che mi vengono in mente: 1) hanno bisogno di caratteri jolly su DNS, ovviamente, 2) l'intero sito Web deve evitare qualsiasi URL assoluto che reindirizzerebbe l'utente al (sotto) dominio "www", 3) probabilmente vorrebbe tenere fuori i crawler web , ma questa è probabilmente una situazione web privata, quindi potrebbe essere già stato fatto. Grazie per averlo condiviso!
Ron Burk,

@ user3534653: mi piace l'approccio. Ma hai detto "nessuna programmazione in questione". Quindi prosegui dicendo "con un piccolo cambio di codice". Quindi davvero, un piccolo cambio di codice non sta programmando? ;) Inoltre, questo approccio potrebbe non funzionare se si dispone di più applicazioni con collegamenti canonici in cui il dominio è codificato / configurato (canonicamente).
Stefan Steiger,

5

Sarò onesto qui. . . tutto quanto sopra può o non può essere vero, ma tutto sembra MODO troppo complicato, o non affronta sapere cosa scheda è essere lato server utilizzato.

A volte dobbiamo applicare il rasoio di Occam.

Ecco l'approccio di Occam: (no, non sono Occam, è morto nel 1347)

1) assegnare un ID univoco del browser alla pagina caricata. . . se e solo se la finestra non ha ancora un ID (quindi utilizzare un prefisso e un rilevamento)

2) su ogni pagina che hai (usa un file globale o qualcosa del genere) metti semplicemente il codice in atto per rilevare l'evento focus e / o l'evento del mouseover. (Userò jquery per questa parte, per facilitare la scrittura del codice)

3) nella funzione focus (e / o passaggio del mouse), imposta un cookie con il nome della finestra

4) leggi quel valore del cookie dal tuo lato server quando devi leggere / scrivere dati specifici sulla scheda.

Dalla parte del cliente:

//Events 
$(window).ready(function() {generateWindowID()});
$(window).focus(function() {setAppId()});
$(window).mouseover(function() {setAppId()});


function generateWindowID()
{
    //first see if the name is already set, if not, set it.
    if (se_appframe().name.indexOf("SEAppId") == -1){
            "window.name = 'SEAppId' + (new Date()).getTime()
    }
    setAppId()
}

function setAppId()
{
    //generate the cookie
    strCookie = 'seAppId=' + se_appframe().name + ';';
    strCookie += ' path=/';

    if (window.location.protocol.toLowerCase() == 'https:'){
        strCookie += ' secure;';
    }

    document.cookie = strCookie;
}

lato server (C # - ad esempio)

//variable name 
string varname = "";
HttpCookie aCookie = Request.Cookies["seAppId"];
if(aCookie != null) {
     varname  = Request.Cookies["seAppId"].Value + "_";
}
varname += "_mySessionVariable";

//write session data 
Session[varname] = "ABC123";

//readsession data 
String myVariable = Session[varname];

Fatto.


1
Mi piace molto la tua risposta semplificata e il riferimento al rasoio di Occam. Volevo solo ricontrollare che questa soluzione funzioni ancora per te.
Jeff Marino,

1
Vale la pena notare che se l'aggiornamento della pagina dovesse mantenere la sua sessione questo approccio non funzionerebbe. L'altro approccio suggerito in un'altra risposta sull'uso di window.sessionStorage mi sembra più ragionevole.
rosenfeld,

@quijibo Funziona ancora perfettamente nella mia applicazione, sì. Per quanto riguarda l'aggiornamento della pagina, potrebbe essere vero per alcuni browser, l'utilizzo di window.sessionStorage potrebbe risolvere il problema, non l'ho provato
Mike A.

3
Qual è la funzione "se_appframe ()"?
AndreMiranda,

Che cos'è se_appframe ?
Kiquenet,

2

Puoi usare la riscrittura dei link per aggiungere un identificatore univoco a tutti i tuoi URL quando inizi da una singola pagina (es. Index.html / jsp / qualunque). Il browser utilizzerà gli stessi cookie per tutte le schede in modo che tutto ciò che viene inserito nei cookie non sia unico.


2
Penso che riscrivere i collegamenti per codificare le sessioni sia noioso e soggetto a errori. Ho una grande applicazione, con molti collegamenti, ho bisogno di una soluzione trasparente o facile da implementare.
Oriol Terradas,

2

Penso che ciò che probabilmente desideri è mantenere lo stato di navigazione tra le schede e non creare specificamente una singola sessione per scheda. Questo è esattamente ciò che il framework Seam raggiunge con il loro ambito / contesto di conversazione. La loro implementazione si basa sul fatto che un ID di conversazione viene propagato con ogni richiesta e crea l'idea di una conversazione sul lato server, che è qualcosa che si trova tra una sessione e una richiesta. Consente il controllo del flusso di navigazione e la gestione dello stato.

Sebbene sia principalmente rivolto a JSF, dai un'occhiata e controlla se è qualcosa da cui puoi prendere alcune idee da: http://docs.jboss.org/seam/latest/reference/en-US/html_single/#d0e3620



1

Un altro approccio che funziona è quello di creare un ID finestra univoco e archiviare questo valore insieme all'ID sessione in una tabella del database. L'id della finestra che uso spesso è intero (ora). Questo valore viene creato quando una finestra viene aperta e riassegnata alla stessa finestra se la finestra viene aggiornata, ricaricata o inviata a se stessa. I valori della finestra (input) vengono salvati nella tabella locale utilizzando il collegamento. Quando è richiesto un valore, viene ottenuto dalla tabella del database in base al collegamento ID finestra / ID sessione. Sebbene questo approccio richieda un database locale, è praticamente infallibile. L'uso di una tabella di database è stato facile per me, ma non vedo alcun motivo per cui gli array locali non funzionino altrettanto bene.




1

Nota: la soluzione qui deve essere eseguita in fase di progettazione dell'applicazione. Sarebbe difficile progettarlo più tardi.

Utilizzare un campo nascosto per aggirare l'identificatore di sessione .

Perché questo funzioni ogni pagina deve includere un modulo:

<form method="post" action="/handler">

  <input type="hidden" name="sessionId" value="123456890123456890ABCDEF01" />
  <input type="hidden" name="action" value="" />

</form>

Ogni azione dalla tua parte, inclusa la navigazione, invia il modulo indietro (impostando il modo actionappropriato). Per richieste "non sicure" , è possibile includere un altro parametro, ad esempio contenente un valore JSON dei dati da inviare:

<input type="hidden" name="action" value="completeCheckout" />
<input type="hidden" name="data" value='{ "cardNumber" : "4111111111111111", ... ' />

Poiché non sono presenti cookie, ciascuna scheda sarà indipendente e non avrà alcuna conoscenza di altre sessioni nello stesso browser.

Molti vantaggi, in particolare per quanto riguarda la sicurezza:

  • Nessun affidamento su JavaScript o HTML5.
  • Inerentemente protegge dal CSRF .
  • Non fare affidamento sui cookie, quindi protegge da POODLE .
  • Non vulnerabile alla fissazione della sessione .
  • Può impedire l'uso del pulsante Indietro, che è desiderabile quando si desidera che gli utenti seguano un percorso prestabilito attraverso il sito (il che significa che è possibile prevenire bug logici che a volte possono essere attaccati da richieste fuori ordine).

Alcuni svantaggi:

  • È possibile che si desideri la funzionalità del pulsante Indietro.
  • Non molto efficace con la memorizzazione nella cache in quanto ogni azione è un POST.

Ulteriori informazioni qui .


1

Ho risolto questo nel modo seguente:

  • Ho assegnato un nome alla finestra, questo nome è lo stesso della risorsa di connessione.
  • più 1 per eliminare i cookie memorizzati per collegare la connessione.
  • Ho creato una funzione per catturare tutta la risposta xmloutput e assegnare sid e liberare i cookie in formato json. Lo faccio per ogni window.name.

qui il codice:

var deferred = $q.defer(),
        self = this,
        onConnect = function(status){
          if (status === Strophe.Status.CONNECTING) {
            deferred.notify({status: 'connecting'});
          } else if (status === Strophe.Status.CONNFAIL) {
            self.connected = false;
            deferred.notify({status: 'fail'});
          } else if (status === Strophe.Status.DISCONNECTING) {
            deferred.notify({status: 'disconnecting'});
          } else if (status === Strophe.Status.DISCONNECTED) {
            self.connected = false;
            deferred.notify({status: 'disconnected'});
          } else if (status === Strophe.Status.CONNECTED) {
            self.connection.send($pres().tree());
            self.connected = true;
            deferred.resolve({status: 'connected'});
          } else if (status === Strophe.Status.ATTACHED) {
            deferred.resolve({status: 'attached'});
            self.connected = true;
          }
        },
        output = function(data){
          if (self.connected){
            var rid = $(data).attr('rid'),
                sid = $(data).attr('sid'),
                storage = {};

            if (localStorageService.cookie.get('day_bind')){
              storage = localStorageService.cookie.get('day_bind');
            }else{
              storage = {};
            }
            storage[$window.name] = sid + '-' + rid;
            localStorageService.cookie.set('day_bind', angular.toJson(storage));
          }
        };
    if ($window.name){
      var storage = localStorageService.cookie.get('day_bind'),
          value = storage[$window.name].split('-')
          sid = value[0],
          rid = value[1];
      self.connection = new Strophe.Connection(BoshService);
      self.connection.xmlOutput = output;
      self.connection.attach('bosh@' + BoshDomain + '/' + $window.name, sid, parseInt(rid, 10) + 1, onConnect);
    }else{
      $window.name = 'web_' + (new Date()).getTime();
      self.connection = new Strophe.Connection(BoshService);
      self.connection.xmlOutput = output;
      self.connection.connect('bosh@' + BoshDomain + '/' + $window.name, '123456', onConnect);
    }

Spero di aiutarti


0

Ho letto questo post perché pensavo di voler fare la stessa cosa. Ho una situazione simile per un'applicazione a cui sto lavorando. E davvero si tratta di testare più della praticità.

Dopo aver letto queste risposte, in particolare quella data da Michael Borgwardt, ho realizzato il flusso di lavoro che deve esistere:

  1. Se l'utente accede alla schermata di accesso, verifica la presenza di una sessione esistente. Se ne esiste uno, ignorare la schermata di accesso e inviarli alla schermata di benvenuto.
  2. Se l'utente (nel mio caso) passa alla schermata di iscrizione, controlla se è presente una sessione. Se ne esiste uno, fai sapere all'utente che disconnetterai quella sessione. Se sono d'accordo, disconnettersi e iniziare la registrazione.

Ciò risolverà il problema della visualizzazione da parte dell'utente dei dati "di un altro utente" nella loro sessione. Non stanno davvero vedendo i dati di "un altro utente" nella loro sessione, stanno davvero vedendo i dati dall'unica sessione che hanno aperto. Chiaramente questo provoca alcuni dati interessanti poiché alcune operazioni sovrascrivono alcuni dati di sessione e non altri, quindi hai una combinazione di dati in quella singola sessione.

Ora, per risolvere il problema del test. L'unico approccio praticabile sarebbe quello di sfruttare le direttive del preprocessore per determinare se utilizzare sessioni senza cookie. Vedi, costruendo in una configurazione specifica per un ambiente specifico sono in grado di fare alcune ipotesi sull'ambiente e su cosa viene utilizzato. Ciò mi consentirebbe tecnicamente di avere due utenti connessi contemporaneamente e il tester potrebbe testare più scenari dalla stessa sessione del browser senza mai disconnettersi da nessuna di quelle sessioni del server.

Tuttavia, questo approccio presenta alcune avvertenze serie. Non da ultimo il fatto che ciò che il tester sta testando non è ciò che verrà eseguito in produzione.

Quindi penso di dover dire che alla fine questa è una cattiva idea.


0

Memorizzare timeStamp in window.sessionStorage se non è già impostato. Ciò fornirà un valore univoco per ciascuna scheda (anche se gli URL sono uguali)

http://www.javascriptkit.com/javatutors/domstorage.shtml

https://developer.mozilla.org/en-US/docs/Web/Guide/API/DOM/Storage

Spero che questo ti aiuti.


1
Questo probabilmente va bene, ma teoricamente non è sicuro. Alcuni sistemi operativi (ad esempio Windows) hanno una granularità di data / ora molto grossolana, il che significa che è possibile cercare più volte la marca temporale e ottenere lo stesso valore. Inoltre, se si riapre un browser dopo un arresto anomalo e si riaprono contemporaneamente tutte le schede, è possibile ottenere lo stesso timestamp.
Gili,

0
How to differ sessions in browser-tabs?

Il modo più semplice per differenziare le sessioni nelle schede del browser è impedire al tuo dominio specifico di impostare i cookie. In questo modo, puoi avere sessioni separate da schede separate. Supponi di non consentire i cookie da questo dominio: www.xyz.com. Apri la scheda 1, accedi e inizia la navigazione. Quindi apri Tab 2 e puoi accedere come uno stesso utente o come uno diverso; in entrambi i casi, avrai una sessione separata dalla scheda 1. E così via.

Ma ovviamente questo è possibile quando si ha il controllo sul lato client. Altrimenti, dovrebbero applicarsi le soluzioni prescritte dalla gente qui.


0

dovrai farlo

1- memorizza un cookie per l'elenco degli account

2- opzionale memorizza un cookie per quello predefinito

3- store per ogni account con il suo indice come acc1, acc2

4- inserisci nell'URL qualcosa rappresenta l'indice degli account e in caso contrario selezionerai quello predefinito come google mail domain.com/0/some-url >> 0 qui rappresenta l'indice dell'account e potresti dover sapere come usa urlwrite

5- quando si seleziona un cookie, selezionarlo in base al proprio percorso URL rappresenta l'indice dell'account

Saluti


0

Vedo molte implementazioni che presentano modifiche sul lato client per manipolare i cookie dell'ID sessione. Ma in generale i cookie ID sessione dovrebbero essere HttpOnly quindi java-script non può accedere altrimenti potrebbe portare a Session Hijack tramite XSS


0

Se è perché ogni scheda eseguirà un flusso diverso nell'applicazione e la miscelazione di entrambi i flussi causa problemi, è meglio "Regionalizzare" gli oggetti della sessione, in modo che ciascun flusso utilizzi una regione diversa della sessione

Questa regione può essere implementata semplicemente come avere prefissi diversi per ciascun flusso, oppure l'oggetto sessione conterrà più mappe (una per ciascun flusso) e si useranno quelle mappe invece degli attributi di sessione, la cosa migliore sarebbe estendere la classe di sessione e usalo invece.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.