Dans le projet Web actuel, de nombreuses situations sont que les mêmes informations de compte peuvent être connectées à différents portails de connexion cette fois, donc ce ne sera pas si beau.
Lecture recommandée:
Implémentation des restrictions de connexion multi-utilisateurs Java
Il y a maintenant deux solutions:
1. Enregistrez les informations de connexion de l'utilisateur avec un champ dans un drapeau. Chaque fois que la connexion est réussie, elle est marquée 1 et la connexion est marquée 0. Lorsqu'il est marqué 1, il n'est pas autorisé à se connecter.
2. Enregistrez les informations de connexion de l'utilisateur dans la portée intégrée de l'application, puis utilisez l'écouteur de session pour surveiller l'état de connexion de chaque utilisateur connecté.
De toute évidence, la première méthode nécessite l'exploitation de la base de données chaque fois que vous vous connectez, ce qui ajoute une surcharge de performances inutile. De plus, si l'ordinateur s'arrête soudainement pendant l'état de connexion, vous ne pourrez jamais vous connecter et que la convivialité est relativement faible.
Mais la deuxième méthode est différente, il est très opérable et pratique de maintenir les informations de tous les utilisateurs en ligne.
Ensuite, nous présenterons principalement la mise en œuvre spécifique de la deuxième méthode:
1. Dans la méthode de connexion pour le traitement de la connexion, interrogez d'abord la base de données pour vérifier si l'utilisateur existe. S'il y a, déterminez si le compte de connexion a été verrouillé. Ensuite, supprimez toutes les informations de connexion de l'objet de portée intégré de l'application pour vérifier si le compte d'utilisateur a été connecté. S'il est connecté, ce sera une invite amicale. Sinon, cela signifie que vous pouvez vous connecter et enregistrer les informations de connexion dans l'application sous la forme d'une paire de valeurs clés.
Le code est le suivant:
// Action doit être ajoutée à chaque méthode d'accès avant la configuration zéro, sinon 404 @Action (value = "login", résultats = {@result (name = "index", location = "index.jsp"),}) public String Login () lève exception {try {user result = uservcece.login (user.getfuuserName (), user.getFupassword ()); if (result! = null) {if (result.getfustatus ()! = null && result.getfustatus () == 0) {super.setRequestattr (constant.message, "désolé, cet utilisateur a été verrouillé!"); return "erreur"; } Map <string, string> LoginUserMap = (map <string, string>) super.getApplicationAtTr (constante.login_user_map); Boolean isExist = false; String sessionId = super.getSessionId (false); if (LoginUserMap == NULL) {LoginUserMap = new HashMap <String, String> (); } pour (String username: LoginUserMap.KeySet ()) {// jugez si les informations de l'utilisateur connectées ont été enregistrées ou si le même utilisateur s'est connecté à plusieurs reprises, alors la connexion est autorisée si (! userName.equals (resing.getFuUsername ()) || Loginusermap.containvalue (sessionId)) {continue; } isExist = true; casser; } if (isExist) {super.setRequestattr (constant.message, "Désolé, l'utilisateur est connecté!"); return "erreur"; } else {LoginUserMap.put (result.getFuUserName (), sessionId); } // Connexion avec succès super.setsessionAttr (constante.login_user, résultat); super.setApplicationAtTr (constante.login_user_map, LoginUserMap); Logger.info (result.getFuUsername () + "Connexion avec succès!"); // Si FromUrl a une valeur dans la session, passez à la chaîne de page fromUrl = (String) super.getSessionAttr (constante.from_url); if (fromUrl! = null) {super.setsessionAttr (constant.from_url, null); super.getResponse (). SenDredirect (FromUrl.ToString ()); retourner null; } return "index"; }} catch (exception e) {e.printStackTrace (); Logger.info ("Login a échoué:" + e.getMessage ()); } super.setRequestattr ("message", "erreur"); return "erreur"; }2. Une fois le portail de connexion traité, étant donné que la session se termine, l'utilisateur de connexion correspondant doit également se déconnecter de la connexion en conséquence. Nous pouvons écrire un écouteur de session. Lorsque la session est détruite, nous avons enregistré l'utilisateur connecté, c'est-à-dire le supprimer de l'application. Cela signifie que l'utilisateur a été hors ligne.
Le code est le suivant:
package com.facelook.util; importation java.util.map; Importer javax.servlet.http.httpSessionEvent; Importer javax.servlet.http.httpSessionListener; import org.apache.log4j.logger; import com.facelook.entity.user; La classe publique SessionListener implémente httSessionListener {private logger logger = logger.getLogger (this.getClass ()); @Override public void SessionCreated (événement httpSessionEvent) {} @Override public void sessionDestRoyed (événement httpSessionEvent) {// effacer les paires de valeurs clés enregistrées dans LoginUserMap lorsque la session est destruction user user = (user) event.getSession (). GetTrribute ("LoginUser"); if (user! = null) {map <string, string> LoginUserMap = (map <string, string>) event.getSession (). getServletContext (). getAttribute ("LoginUserMap"); LoginUserMap.Remove (user.getFuUserName ()); event.getSession (). getServletContext (). SetAttribute ("LoginUserMap", LoginUserMap); }}}La configuration dans web.xml est la suivante:
<! - Session auditeur -> <ouvoiteur> <écouteur-classe> com.facelook.util.ssesionListener </ auteur-classe> </diner>
3. De plus, il y a un autre problème. Si l'utilisateur enregistré ferme soudainement le navigateur ou la page sans cliquer sur le bouton déconnecté. Ensuite, vous pouvez utiliser l'événement avant-charge pour tirer lorsque le navigateur se rafraîchit ou se ferme.
// Events $ (fenêtre) .bind ('avant en charge', function () {$ .ajax ({url: "$ {ctx} /System/user/user!logout.action", type: "post", Success: function () {alert ("vous avez enregistré");}}););Cependant, si certaines raisons objectives, telles que l'ordinateur s'arrêtent soudainement, le redémarrage automatique, etc., ceux-ci ne peuvent pas être évités, vous ne pouvez donc attendre que la session de la session côté serveur se réinitialise avant de pouvoir vous connecter.
À moins qu'il ne s'agisse d'un module qui compte tout le personnel en ligne, l'administrateur gère le statut de connexion et de déconnexion du personnel en ligne et détruit directement les utilisateurs connectés aux problèmes.
Ensuite, présentons brièvement la gestion des modules de personnel en ligne:
1. Premièrement, un écouteur de session est nécessaire pour surveiller toutes les situations de création de réponses. Pour le moment, chaque fois qu'une session est créée, le compte + 1 peut être compté, puis le compte-1 est détruit. De plus, un auditeur ServletContext est nécessaire pour surveiller le cycle de vie de l'application Web, obtenir l'objet ServletContext, puis compter le nombre total de personnel en ligne et le stocker;
Le code spécifique est le suivant:
package com.facelook.util; importation java.util.map; import javax.servlet.servletContext; Importer javax.servlet.servletContexTevent; import javax.servlet.servletContextListener; Importer javax.servlet.http.httpSessionEvent; Importer javax.servlet.http.httpSessionListener; Importer javax.servlet.http.httpSessionListener; import org.apache.log4j.logger; import com.facelook.entity.user; La classe publique SessionListener implémente HTTPSessionListener, ServletContextListener {private int count; ServletContext privé ServletContext = null; public SessionListener () {count = 0; } Logger Private Logger = Logger.getLogger (this.getClass ()); @Override public void sessionCreated (événement httpSessionEvent) {count ++; setContext (événement); Logger.info ("************ La session HTTP est créée ... ******************"); } @Override public void SessionDestRoyed (événement httpSessionEvent) {// Effacer les paires de valeurs de clé enregistrées dans LoginUserMap lorsque la session est détruite utilisateur utilisateur = (utilisateur) event.getSession (). GetAttribute ("Loginuser"); if (user! = null) {map <string, string> LoginUserMap = (map <string, string>) event.getSession (). getServletContext (). getAttribute ("LoginUserMap"); LoginUserMap.Remove (user.getFuUserName ()); event.getSession (). getServletContext (). SetAttribute ("LoginUserMap", LoginUserMap); } compter--; setContext (événement); Logger.info ("************ La session http est détruite ... *********************"); } public void setContext (httpSessionEvent httpSessionEvent) {httpSessionEvent.getSession (). getServletContext (). setAttribute ("Online", count); } @Override public void contextDestRoyed (servletContexTevent servletContexTevent) {this.servletContext = null; Logger.info ("************ Le contexte du servlet est détruit ... *********************"); } @Override public void contextinitialialized (servletContextevent servletContexTevent) {this.servletContext = servletContextevent.getServletContext (); Logger.info ("************ Le contexte du servlet est initialisé ... ******************"); }}2. Créez un module pour gérer les utilisateurs en ligne dans UserAction et prendre en charge la fonction de sortie forcée;
/ ** * Logout * @return * @throws servlexception * @throws ioException * / public String Logout () lève Servlexception, ioException {try {map <string, string> Loginusermap = (map <string, string>) super.getApplicationAtAt (constant.login_user_map); User user = (user) super.getSessionAttr (constante.login_user); super.reMoveAttribute (constant.login_user_map); LoginUserMap.Remove (user.getFuUserName ()); super.setApplicationAtTr (constante.login_user_map, LoginUserMap); Logger.info ("Login Login réussi!"); } catch (exception e) {e.printStackTrace (); Logger.Error ("Login a échoué:" + e.getMessage ()); } retour d'entrée; } / ** * Gestion des utilisateurs en ligne * @return * / public String LoginManager () {return Success; } / ** * Force Exit des autres utilisateurs * @return * / public String LogOutother () {try {String username = servletActionContext.getRequest (). GetParameter ("username"); Map <string, string> LoginUserMap = (map <string, string>) super.getApplicationAtTr (constante.login_user_map); if (username! = null && LoginUserMap.containsKey (nom d'utilisateur)) {LoginUserMap.Remove (nom d'utilisateur); super.setApplicationAtTr (constante.login_user_map, LoginUserMap); }} catch (exception e) {e.printStackTrace (); Logger.info ("La sortie de force a échoué:" + e.getMessage ()); } return null; }3. Chargez la liste des utilisateurs en ligne sur la page de gestion;
Une fois la méthode correspondante définie, ajoutez une liste en ligne à la page de gestion correspondante, comme suit:
<% @ page import = "java.util.map"%> <% @ page import = "java.util.map.entry"%> <% @ page linguisse = "java" pageencoding = "utf-8"%> <% @ include file = "/ commun / taglib.jsp"%> <! doctype html public "- // w3c // dtd xh" doctype html public "- // w3c // dtd xh "0 Transitional // en "" http://www.w3.org/tr/xhtml1/dtd/xhtml1-transitional.dtd "> <html xmlns =" http://www.w3.org/1999/xhtml "> <read> <méta http-équieur =" content = "text / html; charset = utf-8" /> <itle> bienvenue sur facelook </ title> <% @ include file = "/ commun / ressource.jsp"%> <script type = "text / javascrip URL: "$ {ctx} /System/User/User!Logout.Action", Type: "Post", Success: Function () {alert ("Vous avez enregistré");}}); Fonction Logout (nom d'utilisateur) {if (username == "$ {sessionscope.loginuser.fuusername}") {alert ("Logout de votre compte!"); retour; } $ .ajax ({url: "$ {ctx} /system/user/user!logoutother.action?userName =" + username, type: "post", succès: function () {$ ("# tr" + username) .hide (); var count = parseInt ($ ("# count"). html ()); $ ("# count"). html (count-1); } // -> </ script> </ head> <body> <% @ include file = "/ commun / headr.jsp"%> <div id = "main"> <% @ include file = "/ Common / Lefter.jsp"%> <v> <div> <h2> Liste de connexion </ h2> <% map <string, string> map = (map <string, string>) application.get.get. out.println ("Actuellement, il y a <font id = 'count'>" + map.size () + "</font> utilisateurs en ligne !!"); %> <table <%}%> </ table> </ div> </ div> </div> <% @ include file = "/ commun / footer.jsp"%> <% @ include file = "/ commun / message.jsp"%> </ body> </html>OK, démarrez le projet de déploiement, puis démarrez le service et entrez le module de gestion des utilisateurs en ligne. L'effet simple est le suivant:
Il convient de noter que l'utilisateur de connexion actuel n'est pas autorisé à forcer la déconnexion de ses informations de connexion.
De cette façon, les cas d'empêcher plusieurs utilisateurs de se connecter peuvent être essentiellement réalisés!
Ce qui précède est la solution parfaite pour le développement Web de Java afin d'empêcher plusieurs utilisateurs de se connecter à plusieurs reprises. J'espère que ce sera utile à tout le monde. Si vous avez des questions, veuillez me laisser un message et l'éditeur répondra à tout le monde à temps. Merci beaucoup pour votre soutien au site Web Wulin.com!