（三）Spring Security rememberMe实现自动登录

自动登录是将用户的登录信息保存在用户浏览器的 cookie 中，当用户下次访问时，自动实现校验并建立登录态的一种机制。
Spring Security 提供了两种非常好的令牌：

• 散列算法加密用户必要的登录信息并生成令牌
• 数据库等持久性数据存储机制用的持久化令牌
  
  

散列加密方案

在 Spring Security 中加入自动登录的功能非常简单：

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                .antMatchers("/api/user/**").hasRole("user")  //user 角色访问/api/user/开头的路由
                .antMatchers("/api/admin/**").hasRole("admin") //admin 角色访问/api/admin/开头的路由
                .antMatchers("/api/public/**").permitAll()                 //允许所有可以访问/api/public/开头的路由
                .and()
                .formLogin()
                .and()
                .rememberMe().userDetailsService(userDetailsService());      //记住密码
    }

重启服务后访问受限 API，这次在表单登录页中多了一个可选框:

勾选 “Remember me on this computer” 可选框（简写为 Remember-me），按照正常的流程登录，并在开发者工具中查看浏览器 cookie，可以看到除 JSESSIONID 外多了一个值：

这是 Spring Security 默认自动登录的 cookie 字段。在不配置的情况下，过期时间是两个星期:

Spring Security 会在每次表单登录成功之后更新此令牌，具体处理方式在源码中:

RememberConfigurer:

持久化令牌方案

在持久化令牌方案中，最核心的是 series 和 token 两个值，它们都是用 MD5 散列过的随机字符串。不同的是，series 仅在用户使用密码重新登录时更新，而 token 会在每一个新的 session 中都重新生成。
解决了散列加密方案中一个令牌可以同时在多端登录的问题。每个会话都会引发 token 的更
新，即每个 token 仅支持单实例登录。
自动登录不会导致 series 变更，而每次自动登录都需要同时验证 series 和 token 两个值，当该
令牌还未使用过自动登录就被盗取时，系统会在非法用户验证通过后刷新 token 值，此时在合法用户
的浏览器中，该 token 值已经失效。当合法用户使用自动登录时，由于该 series 对应的 token 不同，系统
可以推断该令牌可能已被盗用，从而做一些处理。例如，清理该用户的所有自动登录令牌，并通知该
用户可能已被盗号等
Spring Security 使用 PersistentRememberMeToken 来表明一个验证实体:

public class PersistentRememberMeToken {
    private final String username;
    private final String series;
    private final String tokenValue;
    private final Date date;
    public PersistentRememberMeToken(String username, String series, String tokenValue, Date date) {
        this.username = username;
        this.series = series;
        this.tokenValue = tokenValue;
        this.date = date;
    }
    public String getUsername() {
        return this.username;
    }
    public String getSeries() {
        return this.series;
    }
    public String getTokenValue() {
        return this.tokenValue;
    }
    public Date getDate() {
        return this.date;
    }
}

需要使用持久化令牌方案, 需要传入 PersistentTokenRepository 的实例：

PersistentTokenRepository 接口主要涉及 token 的增删查改四个接口：

MyPersistentTokenRepositoryImpl 使我们实现 PersistentTokenRepository 接口：

@Service
public class MyPersistentTokenRepositoryImpl implements PersistentTokenRepository {
    @Autowired
    private JPAPersistentTokenRepository  repository;
    @Override
    public void createNewToken(PersistentRememberMeToken persistentRememberMeToken) {
        MyPersistentToken myPersistentToken = new MyPersistentToken();
        myPersistentToken.setSeries(persistentRememberMeToken.getSeries());
        myPersistentToken.setUsername(persistentRememberMeToken.getUsername());
        myPersistentToken.setTokenValue(persistentRememberMeToken.getTokenValue());
        myPersistentToken.setUser_last(persistentRememberMeToken.getDate());
        repository.save(myPersistentToken);
    }
    @Override
    public void updateToken(String series, String tokenValue, Date lastUsed) {
        MyPersistentToken myPersistentToken = repository.findBySeries(series);
        myPersistentToken.setUser_last(lastUsed);
        myPersistentToken.setTokenValue(tokenValue);
        repository.save(myPersistentToken);
    }
    @Override
    public PersistentRememberMeToken getTokenForSeries(String series) {
        MyPersistentToken myPersistentToken = repository.findBySeries(series);
        PersistentRememberMeToken persistentRememberMeToken = new PersistentRememberMeToken(myPersistentToken.getUsername(), myPersistentToken.getSeries(), myPersistentToken.getTokenValue(), myPersistentToken.getUser_last());
        return persistentRememberMeToken;
    }
    @Override
    @Transactional
    public void removeUserTokens(String username) {
        repository.deleteByUsername(username);
    }
}

public interface JPAPersistentTokenRepository extends JpaRepository<MyPersistentToken,Long> {
    MyPersistentToken findBySeries(String series);
    void deleteByUsername(String username);
}

@Entity
@Table(name = "persistent_token")
public class MyPersistentToken {
    @Id
    @GeneratedValue(strategy = GenerationType.SEQUENCE)
    private Long id;
    private  String username;
    @Column(unique = true)
    private  String series;
    private  String tokenValue;
    private  Date user_last;
    public Long getId() {
        return id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getSeries() {
        return series;
    }
    public void setSeries(String series) {
        this.series = series;
    }
    public String getTokenValue() {
        return tokenValue;
    }
    public void setTokenValue(String tokenValue) {
        this.tokenValue = tokenValue;
    }
    public Date getUser_last() {
        return user_last;
    }
    public void setUser_last(Date user_last) {
        this.user_last = user_last;
    }
}

当自动登录认证时，Spring Security 通过 series 获取用户名、token 以及上一次自动登录时间三个信息，通过用户名确认该令牌的身份，通过对比 token 获知该令牌是否有效，通过上一次自动登录时间获知该令牌是否已过期，并在完整校验通过之后生成新的 token。