6.Spring security中的rememberMe

RememberMe

6.1RememberMe简介

RememberMe具体的实现思路就是通过cookie来记录当前用户身份。当用户登录成功之后，会通过一定的算法，将用户信息、时间戳等进行加密，加密完成后，通过响应头带回前端存储在cookie中，当浏览器关闭之后重新打开，如果再次访问该网站，会自动将cookie中的信息发送给服务器，服务器对cookie中的信息进行校验分析，进而确定出用户的身份，cookie中所保存的用户信息也是有时效的，例如三天、一周等。
由于相关信息存放在前端，因此存在着一定的安全隐患，不过可以通过持久化令牌以及二次校验来降低使用rememberMe所带来的安全风险。

6.2RememberMe基本用法

/**
 * 浏览器关闭或者服务器重启不需要重新登录。第一次进行表单登录时，多了一个请求参数remember-me: on，用来告诉服务端是否开启
 * RememberMe功能。
 * 如果自定义登录页面，那么默认情况下，是否开启RememberMe的参数就是remember-me。当请求成功后，在响应头中会多出一个
 * Set-Cookie，并携带remember-me字符串。以后所有请求的请求头Cookie字段，都会自动携带上这个令牌，服务端利用该令牌
 * 可以校验用户身份是否合法。
 */
@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Bean
    PasswordEncoder passwordEncoder() {
        return NoOpPasswordEncoder.getInstance();
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
                .withUser("javaboy")
                .password("123")
                .roles("admin");
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                .anyRequest().authenticated()
                .and()
                .formLogin()
                .and()
                // 最终会向过滤器链中添加RememberMeAuthenticationFilter过滤器
                .rememberMe()
                .key("javaboy")
                .and()
                .csrf().disable();
    }
}

不过需要注意的是，这种方式隐患很大，一旦remember-me令牌泄露，恶意用户就可以拿着这个令牌去随意访问系统资源，持久化令牌和二次校验可以在一定程度上降低该问题带来的风险。

6.3持久化令牌

持久化令牌在普通令牌的基础上，新增了series和token两个校验参数，当使用用户名/密码的方式登录时，series才会自动更新；而一旦有了新的会话，token就会重新生成。
所以，如果令牌被人盗用，一旦对方基于remember-me登录成功后，就会生成新的token，自己的登录令牌就会失效，这样就能及时发现账户泄露并作出处理，比如清除自动登录令牌、通知用户账号泄露等。
Spring security中对于持久化令牌提供了两种实现：JdbcTokenRepositoryImpl和InMemoryTokenRepositoryImpl，前者是基于JdbcTemplate来操作数据库，后者则是操作存储在内存中的数据，不过后者的使用场景很少，因此主要介绍前者的相关配置。
首先需要一张表来记录令牌信息，创建表的SQL脚本在JdbcTokenRepositoryImpl类中的CREATE_TABLE_SQL变量上已经定义好了：

public static final String CREATE_TABLE_SQL = "create table persistent_logins (username varchar(64) not null, series varchar(64) primary key, "
			+ "token varchar(64) not null, last_used timestamp not null)";

接下来，引入JdbcTemplate和mysql依赖：

<dependency>
	<groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

之后配置好数据库信息即可。

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    DataSource dataSource;

    /**
     * 提供JdbcTokenRepositoryImpl实例，并配置数据源
     */
    @Bean
    JdbcTokenRepositoryImpl jdbcTokenRepository() {
        JdbcTokenRepositoryImpl jdbcTokenRepository = new JdbcTokenRepositoryImpl();
        jdbcTokenRepository.setDataSource(dataSource);
        return jdbcTokenRepository;
    }

    @Bean
    PasswordEncoder passwordEncoder() {
        return NoOpPasswordEncoder.getInstance();
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
                .withUser("javaboy")
                .password("123")
                .roles("admin");
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                .anyRequest().authenticated()
                .and()
                .formLogin()
                .and()
                .rememberMe()
                // 通过tokenRepository方法指定JdbcTokenRepositoryImpl实例
                .tokenRepository(jdbcTokenRepository())
                .and()
                .csrf().disable();
    }
}

登录成功后，可以发现数据库表中多了一条记录。此时，如果关闭浏览器重新打开，再去访问/hello接口，访问时并不需要登录，但是访问成功之后，数据库中的token字段会发生变化。同时，如果服务端重启之后，浏览器再去访问/hello接口，依然不需要登录，但是token字段也会更新，因为这两种情况中都有新会话的建立，而series则不会更新。当然，如果用户注销登录，则数据库中和该用户相关的登录记录会自动清除。

6.4二次校验

二次校验就是将系统中的资源分为敏感的和不敏感的，如果用户使用了remember-me的方式登录，则访问敏感资源时会自动跳转到登录页面，要求用户重新登录；如果使用了用户名/密码的方式登录，则可以访问所有资源。

@RestController
public class HelloController {
    // 认证后可以访问，无论通过何种认证方式
    @GetMapping("/hello")
    public String hello() {
        return "hello";
    }

    // 必须通过用户名/密码方式认证后才可以访问
    @GetMapping("/admin")
    public String admin() {
        return "admin";
    }

    // 必须通过remember-me方式认证后才可以访问
    @GetMapping("/rememberme")
    public String rememberme() {
        return "rememberme";
    }
}

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    // 省略其他配置，同上
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                // 必须通过用户名/密码的方式认证后才可以访问
                .antMatchers("/admin").fullyAuthenticated()
                // 必须通过RememberMe的方式认证后才可以访问，至于/hello接口，认证后即可访问，无论通过何种认证方式
                .antMatchers("/rememberme").rememberMe()
                .anyRequest().authenticated()
                .and()
                .formLogin()
                .and()
                .rememberMe()
                .key("javaboy")
                .tokenRepository(jdbcTokenRepository())
                .and()
                .csrf().disable();
    }
}

6.5原理分析

从RememberMeServices接口开始介绍：

public interface RememberMeServices {
    // 从请求中提取出需要的参数，完成自动登录功能
    Authentication autoLogin(HttpServletRequest request, HttpServletResponse response);

    // 自动登录失败的回调
    void loginFail(HttpServletRequest request, HttpServletResponse response);

    // 自动登录成功的回调
    void loginSuccess(HttpServletRequest request, HttpServletResponse response,
			Authentication successfulAuthentication);
}

NullRememberMeServices是一个空的实现，不做讨论。

AbstractRememberMeServices

AbstractRememberMeServices对于RememberMeServices接口中定义的方法提供了基本的实现。
首先来看autoLogin及其相关方法：

@Override
public final Authentication autoLogin(HttpServletRequest request, HttpServletResponse response) {
	// 从cookie中提取出remember-me对应的值
    String rememberMeCookie = extractRememberMeCookie(request);
    if (rememberMeCookie == null) {
        return null;
    }

    // 如果remember-me对应的值长度为0，则在返回null之前，执行cancelCookie，将remember-me值置为null
    if (rememberMeCookie.length() == 0) {
        cancelCookie(request, response);
        return null;
    }
    try {
    	// 对获取到的令牌进行解析，还原之后的字符串分为三部分，彼此之间用":"隔开，第一部分是当前登录用户名，
    	// 第二部分是时间戳，第三部分是一个签名，而浏览器看到的是一个Base64编码后的字符串
        String[] cookieTokens = decodeCookie(rememberMeCookie);
        // 对cookie进行验证，如果验证通过，则返回登录用户对象，然后对用户状态进行校验(账户是否可用、是否锁定等)
        UserDetails user = processAutoLoginCookie(cookieTokens, request, response);
        this.userDetailsChecker.check(user);
        // 创建登录成功的用户对象，其类型是RememberMeAuthenticationToken
        return createSuccessfulAuthentication(request, user);
    }
    catch (CookieTheftException ex) {
        cancelCookie(request, response);
        throw ex;
    }
    catch (UsernameNotFoundException ex) {
        this.logger.debug("Remember-me login was valid but corresponding user not found.", ex);
    }
    catch (InvalidCookieException ex) {
        this.logger.debug("Invalid remember-me cookie: " + ex.getMessage());
    }
    catch (AccountStatusException ex) {
        this.logger.debug("Invalid UserDetails: " + ex.getMessage());
    }
    catch (RememberMeAuthenticationException ex) {
        this.logger.debug(ex.getMessage());
    }
    cancelCookie(request, response);
    return null;
}

/**
 * 提取出需要的cookie信息，即remember-me对应的值。如果这个值为null，表示本次请求携带的cookie中没有remember-me，
 * 这次不需要自动登录，直接返回null即可
 */
protected String extractRememberMeCookie(HttpServletRequest request) {
    Cookie[] cookies = request.getCookies();
    if ((cookies == null) || (cookies.length == 0)) {
        return null;
    }
    for (Cookie cookie : cookies) {
        if (this.cookieName.equals(cookie.getName())) {
            return cookie.getValue();
        }
    }
    return null;
}

protected void cancelCookie(HttpServletRequest request, HttpServletResponse response) {
    Cookie cookie = new Cookie(this.cookieName, null);
    cookie.setMaxAge(0);
    cookie.setPath(getCookiePath(request));
    if (this.cookieDomain != null) {
        cookie.setDomain(this.cookieDomain);
    }
    cookie.setSecure((this.useSecureCookie != null) ? this.useSecureCookie : request.isSecure());
    response.addCookie(cookie);
}

protected Authentication createSuccessfulAuthentication(HttpServletRequest request, UserDetails user) {
    RememberMeAuthenticationToken auth = new RememberMeAuthenticationToken(this.key, user,
            this.authoritiesMapper.mapAuthorities(user.getAuthorities()));
    auth.setDetails(this.authenticationDetailsSource.buildDetails(request));
    return auth;
}

再来看下自动登录成功和自动登录失败的回调：

@Override
public final void loginFail(HttpServletRequest request, HttpServletResponse response) {
	// 取消cookie的设置
    cancelCookie(request, response);
    // 调用onLoginFail方法(空方法)
    onLoginFail(request, response);
}

// 一般来说不需要重写
protected void onLoginFail(HttpServletRequest request, HttpServletResponse response) {
}

@Override
public final void loginSuccess(HttpServletRequest request, HttpServletResponse response,
        Authentication successfulAuthentication) {
    // 判断当前请求是否开启了自动登录
    if (!rememberMeRequested(request, this.parameter)) {
        return;
    }
    onLoginSuccess(request, response, successfulAuthentication);
}

protected abstract void onLoginSuccess(HttpServletRequest request, HttpServletResponse response,
        Authentication successfulAuthentication);

// 根据前端参数判断是否是remember-me请求，也可以在服务端配置，这样无论前端参数是什么，都会开启自动登录
protected boolean rememberMeRequested(HttpServletRequest request, String parameter) {
    if (this.alwaysRemember) {
        return true;
    }
    String paramValue = request.getParameter(parameter);
    if (paramValue != null) {
        if (paramValue.equalsIgnoreCase("true") || paramValue.equalsIgnoreCase("on")
                || paramValue.equalsIgnoreCase("yes") || paramValue.equals("1")) {
            return true;
        }
    }

    return false;
}

最后再来看看AbstractRememberMeServices中一个比较重要的方法setCookie，在自动登录成功后，将调用该方法把令牌信息放入响应头中并最终返回到前端：

protected void setCookie(String[] tokens, int maxAge, HttpServletRequest request, HttpServletResponse response) {
    String cookieValue = encodeCookie(tokens);
    // 配置cookie
    Cookie cookie = new Cookie(this.cookieName, cookieValue);
    cookie.setMaxAge(maxAge);
    cookie.setPath(getCookiePath(request));
    if (this.cookieDomain != null) {
        cookie.setDomain(this.cookieDomain);
    }
    if (maxAge < 1) {
        cookie.setVersion(1);
    }
    cookie.setSecure((this.useSecureCookie != null) ? this.useSecureCookie : request.isSecure());
    cookie.setHttpOnly(true);
    // 将cookie对象放入到响应头中
    response.addCookie(cookie);
}

// 将数组中的数据拼接成一个字符串并用":"隔开，然后对其进行Base64编码
protected String encodeCookie(String[] cookieTokens) {
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < cookieTokens.length; i++) {
        try {
            sb.append(URLEncoder.encode(cookieTokens[i], StandardCharsets.UTF_8.toString()));
        }
        catch (UnsupportedEncodingException ex) {
            this.logger.error(ex.getMessage(), ex);
        }
        if (i < cookieTokens.length - 1) {
            sb.append(DELIMITER);
        }
    }
    String value = sb.toString();
    sb = new StringBuilder(new String(Base64.getEncoder().encode(value.getBytes())));
    while (sb.charAt(sb.length() - 1) == '=') {
        sb.deleteCharAt(sb.length() - 1);
    }
    return sb.toString();
}

TokenBasedRememberMeServices

TokenBasedRememberMeServices对AbstractRememberMeServices中所定义的两个抽象方法processAutoLoginCookie和onLoginSuccess做出了相应的实现。

// 验证cookie中的令牌信息是否合法
@Override
protected UserDetails processAutoLoginCookie(String[] cookieTokens, HttpServletRequest request,
        HttpServletResponse response) {
    // 判断cookieTokens长度是否为3，不为3说明格式不对，则直接抛出异常
    if (cookieTokens.length != 3) {
        throw new InvalidCookieException(
                "Cookie token did not contain 3" + " tokens, but contained '" + Arrays.asList(cookieTokens) + "'");
    }
    
    // 提取出过期时间，判断令牌是否过期，如果已经过期，则抛出异常
    long tokenExpiryTime = getTokenExpiryTime(cookieTokens);
    
    if (isTokenExpired(tokenExpiryTime)) {
        throw new InvalidCookieException("Cookie token[1] has expired (expired on '" + new Date(tokenExpiryTime)
                + "'; current time is '" + new Date() + "')");
    }
    
    // 检查用户是否存在。将查找推迟到过期时间检查之后，从而可能避免昂贵的数据库调用
    UserDetails userDetails = getUserDetailsService().loadUserByUsername(cookieTokens[0]);
    // 生成一个签名，将用户名、令牌过期时间、用户密码以及key组成一个字符串，中间用":"隔开，然后通过MD5消息摘要算法
    // 对该字符串进行加密
    String expectedTokenSignature = makeTokenSignature(tokenExpiryTime, userDetails.getUsername(),
            userDetails.getPassword());
    // 判断生成的签名和通过cookie传来的签名是否相等，如果不相等则抛出异常
    if (!equals(expectedTokenSignature, cookieTokens[2])) {
        throw new InvalidCookieException("Cookie token[2] contained signature '" + cookieTokens[2]
                + "' but expected '" + expectedTokenSignature + "'");
    }
    return userDetails;
}

@Override
public void onLoginSuccess(HttpServletRequest request, HttpServletResponse response,
        Authentication successfulAuthentication) {
    // 获取用户名和密码
    String username = retrieveUserName(successfulAuthentication);
    String password = retrievePassword(successfulAuthentication);

    // 如果找不到用户名和密码，只需中止，因为在这种情况下，TokenBasedMemberMeservices无法构造有效的令牌
    if (!StringUtils.hasLength(username)) {
        return;
    }
    if (!StringUtils.hasLength(password)) {
        UserDetails user = getUserDetailsService().loadUserByUsername(username);
        password = user.getPassword();
        if (!StringUtils.hasLength(password)) {
            return;
        }
    }
    // 计算令牌的过期时间，默认有效期是两周
    int tokenLifetime = calculateLoginLifetime(request, successfulAuthentication);
    long expiryTime = System.currentTimeMillis();
    // SEC-949
    expiryTime += 1000L * ((tokenLifetime < 0) ? TWO_WEEKS_S : tokenLifetime);
    // 根据令牌的过期时间、用户名、密码计算出一个签名
    String signatureValue = makeTokenSignature(expiryTime, username, password);
    // 设置cookie
    setCookie(new String[] { username, Long.toString(expiryTime), signatureValue }, tokenLifetime, request,
            response);
}

• 当用户通过用户名/密码的形式登录成功后，系统会根据用户的用户名、密码以及令牌的过期时间计算出一个签名，这个签名使用MD5消息摘要算法生成，是不可逆的。
• 然后再将用户名、令牌过期时间以及签名拼接成一个字符串，中间用":"隔开，对拼接好的字符串进行Base64编码，然后将编码后的结果返回到前端，也就是在浏览器中看到的令牌。
• 当用户关闭浏览器再次打开，访问系统资源时会自动携带上cookie中的令牌，服务端拿到cookie中的令牌后，先进行Base64解码，解码后分别提取出令牌中的三项数据。
• 接着根据令牌中的数据判断令牌是否已经过期，如果没有过期，则根据令牌中的用户名查询出用户信息。
• 接着再计算出一个签名和令牌中的签名进行对比，如果一致，表示令牌是合法令牌，自动登录成功，否则自动登录失败。

PersistentTokenBasedRememberMeServices

在持久化令牌中，存储在数据库中的数据被封装成了一个对象PersistentRememberMeToken：

public class PersistentRememberMeToken {
    // 登录用户名
    private final String username;

    // 自动生成
	private final String series;

    // 自动生成
	private final String tokenValue;

    // 上次使用时间
	private final Date date;
    // 省略getter/setter
}

PersistentTokenBasedRememberMeServices里边重要的方法也是processAutoLoginCookie和onLoginSuccess：

@Override
protected UserDetails processAutoLoginCookie(String[] cookieTokens, HttpServletRequest request,
        HttpServletResponse response) {
    // 第一项是series，第二项是token
    if (cookieTokens.length != 2) {
        throw new InvalidCookieException("Cookie token did not contain " + 2 + " tokens, but contained '"
                + Arrays.asList(cookieTokens) + "'");
    }
    String presentedSeries = cookieTokens[0];
    String presentedToken = cookieTokens[1];
    // 根据series去数据库中查询出一个PersistentRememberMeToken对象
    PersistentRememberMeToken token = this.tokenRepository.getTokenForSeries(presentedSeries);
    if (token == null) {
        // 没有series匹配，所以我们无法使用此cookie进行身份验证
        throw new RememberMeAuthenticationException("No persistent token found for series id: " + presentedSeries);
    }

    // 如果token不相同，说明自动登录令牌已经泄露(恶意用户利用令牌登录后，数据库中的token发生变化了)
    if (!presentedToken.equals(token.getTokenValue())) {
        // 令牌和series值不匹配。删除该用户的所有登录信息，并抛出一个异常来警告他们
        this.tokenRepository.removeUserTokens(token.getUsername());
        throw new CookieTheftException(this.messages.getMessage(
                "PersistentTokenBasedRememberMeServices.cookieStolen",
                "Invalid remember-me token (Series/token) mismatch. Implies previous cookie theft attack."));
    }
    // 判断token是否过期
    if (token.getDate().getTime() + getTokenValiditySeconds() * 1000L < System.currentTimeMillis()) {
        throw new RememberMeAuthenticationException("Remember-me login has expired");
    }

	// token也匹配，所以登录是有效的。更新token值，保持相同的series
    PersistentRememberMeToken newToken = new PersistentRememberMeToken(token.getUsername(), token.getSeries(),
            generateTokenData(), new Date());
    try {
        // 根据series去修改数据库中的token和date
        this.tokenRepository.updateToken(newToken.getSeries(), newToken.getTokenValue(), newToken.getDate());
        addCookie(newToken, request, response);
    }
    catch (Exception ex) {
        throw new RememberMeAuthenticationException("Autologin failed due to data access problem");
    }
    return getUserDetailsService().loadUserByUsername(token.getUsername());
}

private void addCookie(PersistentRememberMeToken token, HttpServletRequest request, HttpServletResponse response) {
    setCookie(new String[] { token.getSeries(), token.getTokenValue() }, getTokenValiditySeconds(), request,
            response);
}

@Override
protected void onLoginSuccess(HttpServletRequest request, HttpServletResponse response,
        Authentication successfulAuthentication) {
    String username = successfulAuthentication.getName();
    this.logger.debug(LogMessage.format("Creating new persistent login for user %s", username));
    PersistentRememberMeToken persistentToken = new PersistentRememberMeToken(username, generateSeriesData(),
            generateTokenData(), new Date());
    try {
        this.tokenRepository.createNewToken(persistentToken);
        addCookie(persistentToken, request, response);
    }
    catch (Exception ex) {
        this.logger.error("Failed to save persistent token ", ex);
    }
}

PersistentTokenBasedRememberMeServices和TokenBasedRememberMeServices还是有一些明显的区别的：前者返回给前端的令牌是将series和token组成的字符串进行base64编码后返回给前端；后者返回给前端的令牌则是将用户名、过期时间以及签名组成的字符串进行base64编码后返回给前端。
那么，RememberMeServices是在何时被调用的呢？
当开发者配置.rememberMe().key("javaboy")时，实际上是引入了配置类RememberMeConfigurer，其中最重要的就是init和configure方法：

@Override
public void init(H http) throws Exception {
    // 验证rememberMeServices和rememberMeCookieName没有同时设置
    validateInput();
    // 获取配置的key，如果没有配置，则会自动生成一个UUID字符串。如果开发者使用普通的remember-me，
    // 即没有使用持久化令牌，则建议自行配置该key，因为使用默认的UUID字符串，系统每次重启都会生成新的key，
    // 会导致之前下发的remember-me失效
    String key = getKey();
    // 如果开发者配置了tokenRepository，则获取到的实例是PersistentTokenBasedRememberMeServices，
    // 否则获取到TokenBasedRememberMeServices
    RememberMeServices rememberMeServices = getRememberMeServices(http, key);
    http.setSharedObject(RememberMeServices.class, rememberMeServices);
    LogoutConfigurer<H> logoutConfigurer = http.getConfigurer(LogoutConfigurer.class);
    if (logoutConfigurer != null && this.logoutHandler != null) {
        logoutConfigurer.addLogoutHandler(this.logoutHandler);
    }
    // 配置RememberMeAuthenticationProvider实例，其主要用来校验key
    RememberMeAuthenticationProvider authenticationProvider = new RememberMeAuthenticationProvider(key);
    authenticationProvider = postProcess(authenticationProvider);
    http.authenticationProvider(authenticationProvider);
    initDefaultLoginFilter(http);
}

@Override
public void configure(H http) {
    // 创建RememberMeAuthenticationFilter，同时传入RememberMeServices实例
    RememberMeAuthenticationFilter rememberMeFilter = new RememberMeAuthenticationFilter(
            http.getSharedObject(AuthenticationManager.class), this.rememberMeServices);
    if (this.authenticationSuccessHandler != null) {
        rememberMeFilter.setAuthenticationSuccessHandler(this.authenticationSuccessHandler);
    }
    // 加入到spring容器中
    rememberMeFilter = postProcess(rememberMeFilter);
    // 加入到过滤器链中
    http.addFilter(rememberMeFilter);
}

再来看一下RememberMeAuthenticationFilter的doFilter方法是如何运作的：

private void doFilter(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
        throws IOException, ServletException {
    // 判断SecurityContextHolder中是否有值，没值的话表示用户尚未登录，此时调用autoLogin方法进行自动登录
    if (SecurityContextHolder.getContext().getAuthentication() != null) {
        chain.doFilter(request, response);
        return;
    }

    Authentication rememberMeAuth = this.rememberMeServices.autoLogin(request, response);

	// 不为空表示自动登录成功
    if (rememberMeAuth != null) {
        // 尝试通过AuthenticationManager进行身份验证
        try {
        	// 调用RememberMeAuthenticationProvider的authenticate方法对key进行校验
            rememberMeAuth = this.authenticationManager.authenticate(rememberMeAuth);
            // 存储到SecurityContextHolder对象中
            SecurityContextHolder.getContext().setAuthentication(rememberMeAuth);
            // 调用登录成功回调(空方法)
            onSuccessfulAuthentication(request, response, rememberMeAuth);

            if (this.eventPublisher != null) {
            	// 发布登录成功事件
                this.eventPublisher.publishEvent(new InteractiveAuthenticationSuccessEvent(
                        SecurityContextHolder.getContext().getAuthentication(), this.getClass()));
            }
            if (this.successHandler != null) {
                this.successHandler.onAuthenticationSuccess(request, response, rememberMeAuth);
                return;
            }
        } catch (AuthenticationException ex) {
        	// 如果自动登录失败，则调用rememberMeServices.loginFail处理登录失败回调
            this.rememberMeServices.loginFail(request, response);
            // 空方法
            onUnsuccessfulAuthentication(request, response, ex);
        }
    }
    chain.doFilter(request, response);
}

这就是RememberMeAuthenticationFilter过滤器所做的事情，成功将RememberMeServices的服务集成进来。
需要注意的是，RememberMeServices#loginSuccess方法的调用位置，是在AbstractAuthenticationProcessingFilter#successfulAuthentication中触发的，也就是说，无论是否开启了remember-me功能，该方法都会被调用。只不过在RememberMeServices#loginSuccess方法的具体实现中，会去判断是否开启了remember-me，进而决定是否在响应中添加对应的cookie。