En el proyecto web actual, muchas situaciones son que la misma información de la cuenta se puede registrar en diferentes portales de inicio de sesión esta vez, por lo que no será tan hermosa.
Lectura recomendada:
Implementación de las restricciones de inicio de sesión de Java MultiSer
Ahora hay dos soluciones:
1. Guarde la información de inicio de sesión del usuario con un campo en una bandera. Cada vez que el inicio de sesión es exitoso, está marcado 1 y el inicio de sesión está marcado 0. Cuando está marcado 1, no está permitido iniciar sesión.
2. Guarde la información de inicio de sesión del usuario en el alcance incorporado de la aplicación y luego use el oyente de la sesión para monitorear el estado de inicio de sesión de cada usuario iniciado.
Obviamente, el primer método requiere operar la base de datos cada vez que inicia sesión, lo que agrega algunas sobrecargas de rendimiento innecesarias. Además, si la computadora se apaga de repente durante el estado de inicio de sesión, nunca podrá iniciar sesión, y la usabilidad es relativamente baja.
Pero el segundo método es diferente, es altamente operable y conveniente mantener la información de todos los usuarios en línea.
A continuación, presentaremos principalmente la implementación específica del segundo método:
1. En el método de inicio de sesión para procesar el inicio de sesión, primero consulte la base de datos para verificar si el usuario existe. Si lo hay, determine si la cuenta de inicio de sesión ha sido bloqueada. Luego, elimine toda la información de inicio de sesión del objeto de alcance incorporado de la aplicación para verificar si la cuenta de nombre de usuario ha sido iniciada. Si ha iniciado sesión, será un aviso amistoso. De lo contrario, significa que puede iniciar sesión y guardar la información de inicio de sesión en la aplicación en forma de un par de valores clave.
El código es el siguiente:
// La acción debe agregarse a cada método de acceso antes de la configuración cero, de lo contrario 404 @Action (value = "Login", resultados = {@Result (name = "index", ubicación = "index.jsp"),}) public String login () lanza excepción {try {user resultado = userservice.login (user.getFuusername (), user.getFupassWord ()); if (resultado! = null) {if (resultado.getFustatus ()! = null && result.getFustatus () == 0) {super.setRequestattr (constant.message, "¡Lo sentimos, este usuario ha sido bloqueado!"); devolver "error"; } Map <string, string> loginUsermap = (map <string, string>) super.getApplicationAttr (constant.login_user_map); boolean isExist = false; Cadena sessionId = super.getSessionId (falso); if (loginusermap == null) {loginusermap = new Hashmap <String, String> (); } for (String UserName: LogInUsermap.KeySet ()) {// Juzgue si la información del usuario conectado se ha guardado o si el mismo usuario ha iniciado sesión repetidamente, entonces el inicio de sesión está permitido si (! username.equals (result.getFuUsername ()) || loginusermap.containsvalue (sessionId)) {continúe; } isExist = true; romper; } if (isExist) {super.setRequestatTR (constant.message, "¡Lo sentimos, el usuario está conectado!"); devolver "error"; } else {loginusermap.put (resultado.getFuUsername (), sessionId); } // Iniciar sesión con éxito super.setsessionAttr (constant.login_user, resultado); super.setApplicationAttr (constant.login_user_map, loginusermap); logger.info (result.getFuUsername () + "¡Iniciar sesión con éxito!"); // Si fromurl tiene un valor en la sesión, salte a la cadena de página fromurl = (string) super.getSessionAttr (constant.from_url); if (fromurl! = null) {super.setsessionAttr (constant.from_url, null); super.getResponse (). Sendedirect (fromurl.ToString ()); regresar nulo; } return "índice"; }} catch (Exception e) {E.PrintStackTrace (); logger.info ("Iniciar fallido:"+E.getMessage ()); } super.setRequestatTR ("Mensaje", "Error"); devolver "error"; }2. Después de procesar el portal de inicio de sesión, teniendo en cuenta que finaliza la sesión, el usuario de inicio de sesión correspondiente también debe iniciar sesión en el inicio de sesión en consecuencia. Podemos escribir un oyente de sesión. Cuando se destruye la sesión, registramos al usuario iniciado, es decir, eliminarla de la aplicación. Significa que el usuario ha estado fuera de línea.
El código es el siguiente:
paquete com.facelook.util; import java.util.map; import javax.servlet.http.httpsessionEvent; import javax.servlet.http.httpsessionListener; importar org.apache.log4j.logger; import com.facelook.entity.user; Public Class SessionListener implementa httpsessionListener {private logger logger = logger.getLogger (this.getClass ()); @Override public void sessionCreated (httpSessionEvent Event) {} @Override public void sessionDestrOyed (httpSessionEvent Event) {// Borrar los pares de valor clave guardados en LoginUsermap cuando la sesión se destruye usuarios de usuario = (usuario) Event.getSession (). GetTribute ("loginuser"); if (user! = null) {map <string, string> loginusermap = (map <string, string>) event.getSession (). getServletContext (). getAttribute ("loginusermap"); LoginUsermap.remove (user.getFuUsername ()); event.getSession (). }}}La configuración en Web.xml es la siguiente:
<!-Session Listener-> <Oyerer> <Oyerer-class> com.facelook.util.sessionListener </oyente-class> </oyente>
3. Además, hay otro problema. Si el usuario iniciado de sesión cierra repentinamente el navegador o la página sin hacer clic en el botón de cierre de sesión. Luego, puede usar el evento BeforeSload para disparar cuando el navegador se actualiza o se cierra.
// Eventos $ (Window) .bind ('BeforeUnload', function () {$ .AJAX ({URL: "$ {CTX} /System/user/user!Logout.action", type: "post", éxito: function () {alert ("ha registrado");}}););Sin embargo, si algunas razones objetivas, como la computadora, de repente se apagan, se reinician automáticamente, etc., no se pueden evitar, por lo que solo puede esperar a que la sesión del lado del servidor se reinicie antes de poder iniciar sesión nuevamente.
A menos que sea un módulo que cuenta con todo el personal en línea, el administrador gestiona el estado de inicio de sesión e inicio de sesión del personal en línea, y destruye directamente a los que registran los usuarios con problemas.
A continuación, presentemos brevemente la gestión de los módulos de personal en línea:
1. Primero, se necesita un oyente de sesión para monitorear todas las situaciones de creación de respuesta. En este momento, cada vez que se crea una sesión, se puede contar el recuento+1 y luego se destruye el recuento-1. Además, se necesita un oyente de ServletContext para monitorear el ciclo de vida de la aplicación web, obtener el objeto ServletContext y luego contar el número total de personal en línea y almacenarlo;
El código específico es el siguiente:
paquete com.facelook.util; import java.util.map; import javax.servlet.servletContext; import javax.servlet.servletContextEvent; import javax.servlet.servletContextListener; import javax.servlet.http.httpsessionEvent; import javax.servlet.http.httpsessionListener; import javax.servlet.http.httpsessionListener; importar org.apache.log4j.logger; import com.facelook.entity.user; Public Class SessionSistener implementa httpsessionListener, servletContextListener {private int count; ServletContext privado ServletContext = NULL; public sessionSistener () {count = 0; } private logger logger = logger.getLogger (this.getClass ()); @Override public void sessionCreated (httpsessionEvent event) {count ++; setContext (evento); logger.info ("************ La sesión http se crea ... ******************"); } @Override public void sessionDestroyed (httpsessionEvent event) {// Borrar los pares de valor clave guardados en LoginUsermap cuando la sesión se destruye user user = (usuario) 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 (). } contar--; setContext (evento); logger.info ("************ La sesión http está destruida ... *********************"); } public void setContext (httpsessionEvent httpsessionEvent) {httpsessionEvent.getSession (). } @Override public void contextDestroyed (servletContextEvent ServletContextEvent) {this.servletContext = null; logger.info ("************ El contexto de servlet está destruido ... *********************"); } @Override public void contextInitialized (servletContextEvent ServletContextEvent) {this.servletContext = servletContextEvent.getServletContext (); logger.info ("************ El contexto de servlet se inicializa ... ******************"); }}2. Cree un módulo para administrar a los usuarios en línea en Useraction y admitir la función de salida forzada;
/ ** * logrout * @return * @throws servletException * @throws ioexception */ public string logrout () lanza ServletException, ioException {try {map <string, string> loginusermap = (map <string, string>) super.getApplicationAttr (constant.login_user_map); Usuario user = (usuario) super.getSessionAttr (constant.login_user); super.removeattribute (constant.login_user_map); LoginUsermap.remove (user.getFuUsername ()); super.setApplicationAttr (constant.login_user_map, loginusermap); logger.info ("¡Iniciar sesión Iniciar éxito!"); } catch (Exception e) {E.PrintStackTrace (); logger.error ("Iniciar fallido:"+e.getMessage ()); } entrada de retorno; } / *** administración de usuarios en línea* @return* / public string LoginManager () {return éxito; } / *** Force Salida de otros usuarios* @return* / public String logOutother () {try {string username = servletactionContext.getRequest (). GetParameter ("username"); MAP <String, String> LoginUsermap = (MAP <String, String>) Super.getApplicationAttr (constant.login_user_map); if (username! = null && loginusermap.containskey (nombre de usuario)) {loginusermap.remove (nombre de usuario); super.setApplicationAttr (constant.login_user_map, loginusermap); }} catch (Exception e) {E.PrintStackTrace (); logger.info ("Falling Fory Falling:"+E.getMessage ()); } return null; }3. Cargue la lista de usuarios en línea en la página de administración;
Después de definir el método correspondiente, agregue una lista en línea a la página de administración correspondiente, de la siguiente manera:
<%@page import = "java.util.map"%> <%@page import = "java.util.map.entry"%> <%@page lenguaje = "java" pageEncoding = "utf-8"%> <%@include file = "/común/taglib.jsp"%> < Transitional // en "" http://www.w3.org/tr/xhtml1/dtd/xhtml1-transitionalal.dtd "> <html xmlns =" http://www.w3.org/1999/xhtml "> <foad> content="text/html; charset=utf-8" /> <title>Welcome to Facelook</title> <%@ include file="/common/resource.jsp" %> <script type="text/javascript"> <!-- // Events $(window).bind('beforeunload',function(){ $.ajax({ URL: "$ {CTX} /System/user/user!Logout.action", type: "Post", Success: Function () {Alert ("Ha desconectado") Function logrout (username) {if (username == "$ {sessionscope.loginuser.fuusername}") {alerta ("¡Cerrar sesión de su cuenta!"); devolver; } $ .AJAX ({url: "$ {ctx} /System/user/user!Logoutother.action?username ="+username, type: "post", éxito: function () {$ ("#tr"+username) .hide (); var count = parseint ($ ("#count"). html ()); $ ("#count"). Html (count-1); } //-> </script> </head> <body> <%@ include file = "/común/header.jsp"%> <div id = "main"> <%@ include file = "/común/lefter.jsp"%> <div> <div> <h2> Login list </h2> <string <string <string> map = (map <tred, cadena>) aplicación out.println ("Actualmente hay <font id = 'count'>"+map.size ()+"</font> usuarios en línea !!"); %> <topla> <%for (Entry <String, String> M: Map.EntrySet ()) {%> <tr id = "tr <%= m.getKey ()%>"> <td> <%= m.getkey ()%> </td> <td> <a href = "javascript: logOut ('<%= m.getkey ()%>')" <%}%> </table> </div> </div> </div> <%@ include file = "/común/footer.jsp"%> <%@ include file = "/común/message.jsp"%> </body> </html>Ok, inicie el proyecto de implementación, luego inicie el servicio e ingrese el módulo de administración de usuarios en línea. El efecto simple es el siguiente:
Cabe señalar que el usuario de inicio de sesión actual no puede forzar el inicio de sesión de su información de inicio de sesión.
De esta manera, los casos de evitar que múltiples usuarios inicien sesión se pueden realizar básicamente.
La anterior es la solución perfecta para el desarrollo web de Java para evitar que múltiples usuarios se inicien repetidamente. Espero que sea útil para todos. Si tiene alguna pregunta, déjame un mensaje y el editor responderá a todos a tiempo. ¡Muchas gracias por su apoyo al sitio web de Wulin.com!