Spring Security实现禁止用户重复登陆（配置及原理）

/**
     * In addition to the steps from the superclass, the sessionRegistry will be updated
     * with the new session information.
     */
    public void onAuthentication(Authentication authentication,
            HttpServletRequest request, HttpServletResponse response) {

        //根据所登录的用户信息，查询相对应的现存session列表
        final List<SessionInformation> sessions = sessionRegistry.getAllSessions(
                authentication.getPrincipal(), false);

        int sessionCount = sessions.size();
        //获取session并发数量，对于XML中的maximumSessions
        int allowedSessions = getMaximumSessionsForThisUser(authentication);

        //判断现有session列表数量和并发控制数间的关系
        //如果是首次登录，根据xml配置，这里应该是0<1，程序将会继续向下执行，
        //最终执行到SessionRegistryImpl的registerNewSession进行新session的保存
        if (sessionCount < allowedSessions) {
            // They haven't got too many login sessions running at present
            return;
        }

        if (allowedSessions == -1) {
            // We permit unlimited logins
            return;
        }

        if (sessionCount == allowedSessions) {
            //获取本次http请求的session
            HttpSession session = request.getSession(false);

            if (session != null) {
                // Only permit it though if this request is associated with one of the
                // already registered sessions
                for (SessionInformation si : sessions) {
                    //循环已保存的session列表，判断本次http请求session是否已经保存
                    if (si.getSessionId().equals(session.getId())) {
                        //本次http请求是有效请求，返回执行下一个filter
                        return;
                    }
                }
            }
            // If the session is null, a new one will be created by the parent class,
            // exceeding the allowed number
        }

        //本次http请求为新请求，进入具体判断
        allowableSessionsExceeded(sessions, allowedSessions, sessionRegistry);
    }

/**
     * Allows subclasses to customise behaviour when too many sessions are detected.
     *
     * @param sessions either <code>null</code> or all unexpired sessions associated with
     * the principal
     * @param allowableSessions the number of concurrent sessions the user is allowed to
     * have
     * @param registry an instance of the <code>SessionRegistry</code> for subclass use
     *
     */
    protected void allowableSessionsExceeded(List<SessionInformation> sessions,
            int allowableSessions, SessionRegistry registry)
            throws SessionAuthenticationException {
        //根据exceptionIfMaximumExceeded判断是否要将新http请求拒绝
        //exceptionIfMaximumExceeded也可以在XML中配置
        if (exceptionIfMaximumExceeded || (sessions == null)) {
            throw new SessionAuthenticationException(messages.getMessage(
                    "ConcurrentSessionControlAuthenticationStrategy.exceededAllowed",
                    new Object[] { Integer.valueOf(allowableSessions) },
                    "Maximum sessions of {0} for this principal exceeded"));
        }

        // Determine least recently used session, and mark it for invalidation
        SessionInformation leastRecentlyUsed = null;

        //若不拒绝新请求，遍历现存seesion列表
        for (SessionInformation session : sessions) {
            //获取上一次/已存的session信息
            if ((leastRecentlyUsed == null)
                    || session.getLastRequest()
                            .before(leastRecentlyUsed.getLastRequest())) {
                leastRecentlyUsed = session;
            }
        }

        //将上次session信息写为无效（欺骗）
        leastRecentlyUsed.expireNow();
    }

public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)
            throws IOException, ServletException {
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) res;

    //获取本次http请求的session
        HttpSession session = request.getSession(false);
    
        if (session != null) {
            //从本地session关系表中取出本次http访问的具体session信息
            SessionInformation info = sessionRegistry.getSessionInformation(session
                    .getId());
           //如果存在信息，则继续执行
            if (info != null) {
                //判断session是否已经失效（这一步在本文4.2中被执行）
                if (info.isExpired()) {
                    // Expired - abort processing
                    if (logger.isDebugEnabled()) {
                        logger.debug("Requested session ID "
                                + request.getRequestedSessionId() + " has expired.");
                    }
                    //执行登出操作
                    doLogout(request, response);

                    //从XML配置中的redirectSessionInformationExpiredStrategy获取URL重定向信息，页面跳转到登录页面
                    this.sessionInformationExpiredStrategy.onExpiredSessionDetected(new SessionInformationExpiredEvent(info, request, response));
                    return;
                }
                else {
                    // Non-expired - update last request date/time
                    sessionRegistry.refreshLastRequest(info.getSessionId());
                }
            }
        }

        chain.doFilter(request, response);
    }