一文看懂Spring Security，附视频教程！

最新推荐文章于 2024-08-08 23:55:21 发布

业余草

最新推荐文章于 2024-08-08 23:55:21 发布

阅读量520

点赞数 1

原文链接：https://www.bilibili.com/video/BV1af4y1i7n1

版权

你知道的越多，不知道的就越多，业余的像一棵小草！

你来，我们一起精进！你不来，我和你的竞争对手一起精进！

编辑：业余草

http://dwz.date/dR2e

权限相关概念

权限管理一般是值根据系统设置的安全规则或者安全策略，用户只能访问被授权的资源。权限管理的前置条件是用户和密码的认证系统。其中认证是通过用户名和密码成功登陆系统后，让系统得到当前用户的角色身份；授权则是系统根据当前用户的角色，给其授予可以操作的的权限资源。

主要有三个对象：

用户：用户名，密码和当前用户的角色信息，可以实现认证操作
角色：角色名称，描述和当前角色拥有的权限信息，可以实现授权操作。
权限：权限也可以成为菜单，主要包含当前权限的名称，URL 地址等信息，可以动态展示菜单。

Spring Security 基本概念

Spring Security 是 Spring 采用 AOP 思想，基于 Servlet 过滤器实现的安全框架，其提供了完善的认证机制和方法级授权。其主要是通过过滤器实现认证和授权的，可以简单看一下 Spring Security 中的过滤器。

Spring 主要的 Filters

SecurityContextPersistenceFilter

SecurityContextPersistenceFilter 主要是使用 SecurityContextRepository 在 Session 中保存或更新一个 SecurityContext，并将 SecurityContext 给后续的过滤器中使用，来为后续 filter 建立所需的上下文，SecurityContext 中存储了当前用户认证及授权信息。

WebAsyncManagerIntegrationFilter

用于集成 SecurityContext 到 Spring 异步执行的 WebAsyncManager

HeaderWriterFilter

向请求头 Header 中添加相应的信息。

CsrfFilter

Spring Security 会对所有 POST 请求验证是否包含系统生成的 CSRF 的 Token 信息，如果不包含则报错，起到防止 CSRF 共计的效果。

LogoutFilter

匹配 URL 为 /logout 的请求，实现用户退出清除认证信息。

UsernamePasswordAuthenticationFilter

认证操作，默认匹配 URL 为 /login 且必须为 POST 请求

DefaultLoginPageGeneratingFilter

默认的登录页面，该过滤器会生成一个默认的认证页面

DefaultLogoutPageGeneratingFilter

默认的登出页面，该过滤器会生成一个默认的登出页面。

BasicAuthenticationFilter

过滤器会自动解析 HTTP 请求头中名字为 Authentication，且以 BASIC 开头的头部信息

Authorization: Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==

RequestCacheAwareFilter

通过 HttpSessionRequestCache 内部维护一个 RequestCache，用于缓存 HttpServletRequest

SecurityContextHolderAwareRequestFilter

针对于 ServletRequest 进行一次包装，使 Request 具有更多的 API。

AnonymousAuthenticationFilter

在 SecurityContextHolder 中认证信息为空的时候，会创建一个匿名的用户存入到 SecurityContextHolder 中，Spring Security 为了兼容未登录的访问，使用匿名的身份走了一套认证的流程。

SessionManagementFilter

SecurityContextRepository 限制一个用户开启多个会话的数量。

ExceptionTranslationFilter

转换过滤器链中出现的异常，在过滤器链的最后。

FilterSecurityInterceptor

获取所配置资源的访问授权信息，根据 SecurityContextHolder 中存储的用户信息决定是否有权限访问。

几个基本概念

其中 FilterSecurityInterceptor 中会根据 config 配置的内容，判断是否可以访问对应的资源，如果不可以则会抛出异常。然后在 ExceptionTranslationFilter 中会捕获异常并作出响应的处理。

Spring Security 几个重要的概念如下：

SecurityContextHolder

Spring Security 提供的 SecurityContextHolder 类让程序可以方便访问 SecurityContext。其采用的是 ThreadLocal 方式存储，保证获取到的永远是当前用户的 SecurityContext。

SecurityContext

SecurityContext 保存用户的信息，用户是谁，权限有哪些，是否被认证等。可以通过 SecurityContextHolder.getContext() 获取。

Authentication

Authentication 包含 sessionId, IP, 用户的 UserDetail 信息，用户的角色。其有很多实现类，每种类都对应着一个认证方式。可以通过 SecurityContextHolder.getContext().getAuthentication(); 获取。

AbstractAuthenticationToken

AbstractAuthenticationToken 和 AnonymousAuthenticationToken 及其很多子类都实现了 Authentication 接口，每一个子类代表一种认证方式。

GenericFilterBean

用来拦截认证的 filter，可以在这个 filter 注册认证成功和失败的 handler，子类主要有 OncePerRequestFilter, CasAuthenticationFilter, OpenIDAuthenticationFilter, UsernamePasswordAuthenticationFilter, LogoutFilter 等等。

AuthenticationManager 和 AuthenticationProvider

Spring Security 将通过 SecurityFilter 来调用 AuthenticationManager 进行验证，默认情况下 AuthenticationManager 将验证工作交给 ProviderManager 去做，而 ProviderManager 会通过一系列的 AuthenticationProvider 完成具体的验证。

UserDetails 和 UserDetailsService

UserDetail 包含 Authentication 需要的用户信息，这些信息往往从 JDBC 或其他数据源获取。UserDetailsService 是用来获取指定 username 对应 UserDetail 的接口。

Spring Security 加载及应用 Filter 流程

在 Spring Security 项目启动的时候会走到 WebSecurityConfigurerAdapter 的 getHttp 方法中，该方法中部分代码如下：

http
  .csrf().and()
  .addFilter(new WebAsyncManagerIntegrationFilter())
  .exceptionHandling().and()
  .headers().and()
  .sessionManagement().and()
  .securityContext().and()
  .requestCache().and()
  .anonymous().and()
  .servletApi().and()
  .apply(new DefaultLoginPageConfigurer<>()).and()
  .logout();

会将 SecurityConfigurer 的部分子类放到 AbstractConfiguredSecurityBuilder 的 configurers 中。例如 anonymous 就将 AnonymousConfigurer 放到了 configurers 中。然后

走到 AbstractConfiguredSecurityBuilder 的 configure 方法，简单来说就是调用所有 configurers 的 configure 的方法配置当前的 Builder ，还是拿 AnonymousConfigurer 为例，其就是在调用 AnonymousAuthenticationFilter 的 afterPropertiesSet 之后将其加入到 HttpSecurity 的 filters 中，然后封装成一个 DefaultSecurityFilterChain 过滤器链。然后将 SecurityFilterChain 封装到 FilterChainProxy 中。

在访问的时候首先会访问到 DelegatingFilterProxy 这个 Filter，在其 doFilter 方法中会调用 initDelegate 方法获取 ID 为 springSecurityFilterChain 类型为 FilterChainProxy 的 delegate 然后调用 doFilter 方法，然后调用其 doFilterInternal 方法，其中会获取上面所有的 Filters List<Filter> filters = getFilters(fwRequest);，然后然后将这些 Filters 封装成一个 VirtualFilterChain 逐个调用, 之后就是调用VirtualFilterChain 的 doFilter方法了。

Spring Security 的使用

在 pom 文件中引入相关的配置后就可以直接启动项目：

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
</dependency>

默认会有一个密码打印在控制台中，测试的时候也可以直接在代码中定义一个用户：

// 方式 1
@Bean
@Override
public UserDetailsService userDetailsService() {
  UserDetails userDetails = User.withDefaultPasswordEncoder().username("xinyue")
    .password("xinyue").roles("ADMIN").build();
  return new InMemoryUserDetailsManager(userDetails);
}
// 方式 2
@Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception {
  auth.inMemoryAuthentication().withUser("xinyue")
    .password("{noop}123")
    .roles("ADMIN")
    .authorities("admin", "demo");
}

然后再次启动就可以使用该用户名和密码登录了。如果要自定义登录页面可以使用在资源文件中添加出来相应的 page，并设置相应的 controller 简单的示例如下：

// Controller
@RequestMapping("/ilogin")
public String ilogin() {
  return "ilogin";
}

// Security 相关配置
@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests().anyRequest().authenticated()
                .and().formLogin(form ->
                 form.loginPage("/ilogin").permitAll()) 
                .csrf().disable(); // 禁用 CSRF
    }

    @Override
    public void configure(WebSecurity web) {
        web.ignoring().antMatchers("/static/**");
    }
}

❝
Spring Boot 项目中在 WebSecurityEnablerConfiguration 上的已经添加了 @EnableWebSecurity 所以在自己的配置类上可以不添加。
❞

上面第一个方法自定义了登录页面的地址为 /ilogin 页面，默认情况处理登录请求的地址也是 /iloign 只是 Method 是 POST，当然也可以通过相关的属性配置，例如 loginProcessingUrl 处理登录请求的 URL，successForwardUrl 登录成功之后跳转的地址，defaultSuccessUrl 也登录成功之后跳转的地址，只是其有一个默认为 false 的参数 alwaysUse 用于控制默认会跳转到登录前访问的页面 URL， logoutSuccessUrl 登出跳转地址，failureForwardUrl 登录失败跳转的地址。

在第二个方法表示过滤掉 /static 下所有的请求，用于处理静态资源等。

CSRF

需要提示的一点是如果不想使用 csrf 一定要关闭 csrf 否则会被 Spring Security 认为是非法请求强制跳转到 /error 页面，如果要使用 csrf 需要在登录 form 中添加这样的隐藏字段，这里使用了 Thymeleaf 引擎，获取当前请求已经生成了一个 token 。

<input type="hidden" name="_csrf" th:value="${_csrf.token}"/>

生成这个 Token 也是在每个终端当前 session 中第一次访问的时候，在 CsrfFilter 中的 doFilterInternal 方法中生成的。该方法会首先会从 tokenRepository 中去查找有没有已经生成过 token，如果已经生成则直接使用，如果没有生成过则调用 this.tokenRepository.generateToken(request) 为当前请求的生成一个 token，即生成一个 DefaultCsrfToken 对象，主要使用请求的 Header Name ("X-CSRF-TOKEN")，Parameter Name （_csrf）和随机数生成。

// CsrfFilter
CsrfToken csrfToken = this.tokenRepository.loadToken(request);
final boolean missingToken = csrfToken == null;
if (missingToken) {
   csrfToken = this.tokenRepository.generateToken(request);
   this.tokenRepository.saveToken(csrfToken, request, response);
}
// HttpSessionCsrfTokenRepository
public CsrfToken generateToken(HttpServletRequest request) {
  return new DefaultCsrfToken(this.headerName, this.parameterName,
                              createNewToken());
}
private String createNewToken() {
  return UUID.randomUUID().toString();
}

因为默认使用的 LazyCsrfTokenRepository ，在生成完 session 紧随其后的 saveToken 方法中并不会真正的去保存 token 到 session 中，而是在 getToken 方法通过调用 saveTokenIfNecessary 方法最终调用 HttpSessionCsrfTokenRepository 的 saveToken 方法存到 session 中，因为如果没有使用 csrf 确实没有必要将这个 Token 放入的 Session 中。

另外就是在 CsrfFilter 中有一个 DEFAULT_CSRF_MATCHER 是 DefaultRequiresCsrfMatcher 其默认仅拦截除 "GET", "HEAD", "TRACE", "OPTIONS" 这些 Method 之外的请求。

if (!this.requireCsrfProtectionMatcher.matches(request)) {
  filterChain.doFilter(request, response);
  return;
}

在非以上的请求中会从请求 Header 中去获取 csrf token 的值，和 session 中的比较确保不是其他页面的非法请求。

String actualToken = request.getHeader(csrfToken.getHeaderName());
if (actualToken == null) {
  actualToken = request.getParameter(csrfToken.getParameterName());
}
if (!csrfToken.getToken().equals(actualToken)) {
  // token 不匹配的时候使用 accessDeniedHandler 跳转到
  if (missingToken) {
    this.accessDeniedHandler.handle(request, response,
                                    new MissingCsrfTokenException(actualToken));
  } else {
    this.accessDeniedHandler.handle(request, response,
                                    new InvalidCsrfTokenException(csrfToken, actualToken));
  }
  return;
}

Spring Security 认证流程

默认的主要认证逻辑在 UsernamePasswordAuthenticationFilter 中完成的，可以看一下该类：

public static final String SPRING_SECURITY_FORM_USERNAME_KEY = "username";
public static final String SPRING_SECURITY_FORM_PASSWORD_KEY = "password";

private String usernameParameter = SPRING_SECURITY_FORM_USERNAME_KEY;
private String passwordParameter = SPRING_SECURITY_FORM_PASSWORD_KEY;
private boolean postOnly = true;

public UsernamePasswordAuthenticationFilter() {
  super(new AntPathRequestMatcher("/login", "POST"));
}

其定义了默认的用户名和密码参数，登录页面地址等信息。当然这些信息都可以通过上面的 config 方法修改，其实也就是通过 FormLoginConfigurer 进行修改的。其 doFilter 方法默认调用其父类的AbstractAuthenticationProcessingFilter 的方法，在其中完成了认证的操作。方法大概如下：

// AbstractAuthenticationProcessingFilter
public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)
  throws IOException, ServletException {
  HttpServletRequest request = (HttpServletRequest) req;
  HttpServletResponse response = (HttpServletResponse) res;
  // 首先判断是否需要认证，如果不需要认证则直接进行下一步
  if (!requiresAuthentication(request, response)) {
    chain.doFilter(request, response);
    return;
  }
  Authentication authResult;
  try {
    // 如果需要认证则调用 attemptAuthentication 方法尝试认证
    authResult = attemptAuthentication(request, response);
    if (authResult == null) {
      return;
    }
    sessionStrategy.onAuthentication(authResult, request, response);
  } catch (InternalAuthenticationServiceException failed) {
    unsuccessfulAuthentication(request, response, failed);
    return;
  } catch (AuthenticationException failed) {
    unsuccessfulAuthentication(request, response, failed);
    return;
  }
  
  if (continueChainBeforeSuccessfulAuthentication) {
    chain.doFilter(request, response);
  }
  // 登出成功后续操作
  successfulAuthentication(request, response, chain, authResult);
}

protected void successfulAuthentication(HttpServletRequest request,
                                        HttpServletResponse response, FilterChain chain, Authentication authResult)
  throws IOException, ServletException {
 // 将认证信息放到 SecurityContextHolder 中
  SecurityContextHolder.getContext().setAuthentication(authResult);
 // 记住我设置
  rememberMeServices.loginSuccess(request, response, authResult);

  // 发布成功登陆事件
  if (this.eventPublisher != null) {
    eventPublisher.publishEvent(new InteractiveAuthenticationSuccessEvent(
      authResult, this.getClass()));
  }
 
  successHandler.onAuthenticationSuccess(request, response, authResult);
}

下面看一下 UsernamePasswordAuthenticationFilter 的尝试认证的方法：

public Authentication attemptAuthentication(HttpServletRequest request,
   HttpServletResponse response) throws AuthenticationException {
  if (postOnly && !request.getMethod().equals("POST")) {
    throw new AuthenticationServiceException(
      "Authentication method not supported: " + request.getMethod());
  }
  // 获取请求中的用户名和密码
  String username = obtainUsername(request);
  String password = obtainPassword(request);
  if (username == null) {
    username = "";
  }
  if (password == null) {
    password = "";
  }
  username = username.trim();
  // 将用户名和密码封装成一个 UsernamePasswordAuthenticationToken 去认证
  UsernamePasswordAuthenticationToken authRequest = new UsernamePasswordAuthenticationToken(
    username, password);
  // Allow subclasses to set the "details" property
  setDetails(request, authRequest);
  return this.getAuthenticationManager().authenticate(authRequest);
}

使用 AuthenticationManager 的 authenticate 进行认证。

public Authentication authenticate(Authentication authentication)
   throws AuthenticationException {
  Class<? extends Authentication> toTest = authentication.getClass();
  AuthenticationException lastException = null;
  AuthenticationException parentException = null;
  Authentication result = null;
  Authentication parentResult = null;

  // 获取所有 AuthenticationProvider 逐个判断是否 Support 当前的认证
  for (AuthenticationProvider provider : getProviders()) {
    if (!provider.supports(toTest)) {
      continue;
    }

    try {
      // 如果支持则使用 AuthenticationProvider 进行认证
      result = provider.authenticate(authentication);
      if (result != null) {
        copyDetails(authentication, result);
        break;
      }
    } catch (AccountStatusException | InternalAuthenticationServiceException e) {
      prepareException(e, authentication);
      throw e;
    } catch (AuthenticationException e) {
      lastException = e;
    }
  }

  if (result == null && parent != null) {
    // 如果当前 Provider 没有认证成功则使用其 parent 进行认证
    try {
      result = parentResult = parent.authenticate(authentication);
    } catch (ProviderNotFoundException e) { } catch (AuthenticationException e) {
      lastException = parentException = e;
    }
  }

  if (result != null) {
    if (eraseCredentialsAfterAuthentication && (result instanceof CredentialsContainer)) {
      ((CredentialsContainer) result).eraseCredentials(); // 清除认证信息
    }
    if (parentResult == null) {
      eventPublisher.publishAuthenticationSuccess(result); // 发布认证成功的事件
    }
    return result;
  }

  // 如果没有认证成功则抛出异常
  if (lastException == null) {
    lastException = new ProviderNotFoundException(messages.getMessage(
      "ProviderManager.providerNotFound",
      new Object[] { toTest.getName() },
      "No AuthenticationProvider found for {0}"));
  }
  if (parentException == null) {
    prepareException(lastException, authentication);
  }

  throw lastException;
}

默认情况下会使用 DaoAuthenticationProvider 进行认证，首先使用 AbstractUserDetailsAuthenticationProvider 的 authenticate 主要方法如下：

// AbstractUserDetailsAuthenticationProvider
public Authentication authenticate(Authentication authentication)
  throws AuthenticationException {
  // Determine username
  String username = (authentication.getPrincipal() == null) ? "NONE_PROVIDED"
    : authentication.getName();

  boolean cacheWasUsed = true;
  // 先尝试从 Cache 中获取用户
  UserDetails user = this.userCache.getUserFromCache(username);
  if (user == null) {
    cacheWasUsed = false;
    try {
      // 如果 Cache 中没有则根据用户名查找用户
      user = retrieveUser(username, (UsernamePasswordAuthenticationToken) authentication);
    } catch (UsernameNotFoundException notFound) {
      // 没有找到用户
      if (hideUserNotFoundExceptions) {
        throw new BadCredentialsException(messages.getMessage(
          "AbstractUserDetailsAuthenticationProvider.badCredentials",
          "Bad credentials"));
      } else {
        throw notFound;
      }
    }
  }

  try {
    // 先检查账户是否过期，禁用，被锁等状态
    preAuthenticationChecks.check(user);
    // 后续认证，密码匹配等
    additionalAuthenticationChecks(user, (UsernamePasswordAuthenticationToken) authentication);
  } catch (AuthenticationException exception) {
    if (cacheWasUsed) {
      // There was a problem, so try again after checking
      // we're using latest data (i.e. not from the cache)
      cacheWasUsed = false;
      user = retrieveUser(username, (UsernamePasswordAuthenticationToken) authentication);
      preAuthenticationChecks.check(user);
      additionalAuthenticationChecks(user, (UsernamePasswordAuthenticationToken) authentication);
    } else {
      throw exception;
    }
  }

  postAuthenticationChecks.check(user);
  if (!cacheWasUsed) {
    // 将用户放到 Cache 中
    this.userCache.putUserInCache(user);
  }
  Object principalToReturn = user;
  if (forcePrincipalAsString) {
    principalToReturn = user.getUsername();
  }
  // 生成成功登录的凭证
  return createSuccessAuthentication(principalToReturn, authentication, user);
}

protected Authentication createSuccessAuthentication(Object principal,
                                                     Authentication authentication, UserDetails user) {
  // Ensure we return the original credentials the user supplied,
  // so subsequent attempts are successful even with encoded passwords.
  // Also ensure we return the original getDetails(), so that future
  // authentication events after cache expiry contain the details
  UsernamePasswordAuthenticationToken result = new UsernamePasswordAuthenticationToken(
    principal, authentication.getCredentials(),
    authoritiesMapper.mapAuthorities(user.getAuthorities()));
  result.setDetails(authentication.getDetails());
  return result;
}

// DaoAuthenticationProvider
protected final UserDetails retrieveUser(String username,
                                         UsernamePasswordAuthenticationToken authentication)
  throws AuthenticationException {
  prepareTimingAttackProtection();
  try {
    // 通过 UserDetailsService 根据用户名去查询 User信息
    // 我们在配置中定义了一个 UserDetailsService Bean 并将一个 User 传给了他
    // 所以这里能拿到配置用户的信息。
    UserDetails loadedUser = this.getUserDetailsService().loadUserByUsername(username);
    if (loadedUser == null) {
      throw new InternalAuthenticationServiceException("UserDetailsService returned null, which is an interface contract violation");
    }
    return loadedUser;
  } catch (UsernameNotFoundException ex) {
    mitigateAgainstTimingAttack(authentication);
    throw ex;
  } catch (InternalAuthenticationServiceException ex) {
    throw ex;
  } catch (Exception ex) {
    throw new InternalAuthenticationServiceException(ex.getMessage(), ex);
  }
}

protected void additionalAuthenticationChecks(UserDetails userDetails,
                                              UsernamePasswordAuthenticationToken authentication)
  throws AuthenticationException {
  // 从 authentication 获取认证信息
  if (authentication.getCredentials() == null) {
    logger.debug("Authentication failed: no credentials provided");
    throw new BadCredentialsException(messages.getMessage(
      "AbstractUserDetailsAuthenticationProvider.badCredentials",
      "Bad credentials"));
  }
  // 获取登录密码
  String presentedPassword = authentication.getCredentials().toString();
 // 使用 passwordEncoder 系统中的密码和请求提交的密码是否一致
  if (!passwordEncoder.matches(presentedPassword, userDetails.getPassword())) {
    logger.debug("Authentication failed: password does not match stored value");
    throw new BadCredentialsException(messages.getMessage("AbstractUserDetailsAuthenticationProvider.badCredentials", "Bad credentials"));
  }
}

以上涉及到类关系图如下：

从数据库中读取数据认证

通过上面的分析知道，如果要实现从数据库中获取认证内容。只要提供一个 UserDetailService 的实现即可，简单如下：

// User 类
public class SysUser implements UserDetails {
    private int id;
    private String password;
    private String username;

// Service 方法
@Service
public class SysUserService implements UserDetailsService {
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        SysUser user = new SysUser(); // retrieve from db
        return user;
    }
}

显然如果明文存储密码是不安全的，所以创建用户的时候需要对用户的密码加密后存储。Spring Security 提供了一个 PasswordEncoder 并提供了很多的实现，这里介绍一下 BCryptPasswordEncoder 这个加密类。其提供了一下默认的构造方法，例如空，加密强度，加密版本，加密随机算法等。例如下面就是向容器中添加一个加密强度为 12 的 BCryptPasswordEncoder。

@Bean
public PasswordEncoder passwordEncoder() {
  return new BCryptPasswordEncoder(12);
}

因为使用的是随机数作为盐，所以同一个字符串每次 encode 出来加密结果并不一致，其提供了 matches 方法，可以判断两个加密过的字符串的原本字符串是否相同。

Remember Me 功能

如何没有配置 rememberMe, 则使用 NullRememberMeServices 表示不进行处理。如果配置了之后为容器增加一个 RememberMeAuthenticationFilter ，第一次登陆成功之后会记录 remeberMe，先是在 AbstractRememberMeServices 中：

public final void loginSuccess(HttpServletRequest request,
                               HttpServletResponse response, Authentication successfulAuthentication) {
 // 在请求中找 rememberme 的标记
  if (!rememberMeRequested(request, parameter)) {
    logger.debug("Remember-me login not requested.");
    return;
  }
  onLoginSuccess(request, response, successfulAuthentication);
}

然后在 TokenBasedRememberMeServices 中处理：

// TokenBasedRememberMeServices
public void onLoginSuccess(HttpServletRequest request, HttpServletResponse response,
                           Authentication successfulAuthentication) {
 // 获取用户名和密码
  String username = retrieveUserName(successfulAuthentication);
  String password = retrievePassword(successfulAuthentication);
 
  //省略部分 Check 逻辑...

  // 计算 Token 声明周期默认为：1209600秒
  int tokenLifetime = calculateLoginLifetime(request, successfulAuthentication);
  // 计算过期日期
  long expiryTime = System.currentTimeMillis();
  expiryTime += 1000L * (tokenLifetime < 0 ? TWO_WEEKS_S : tokenLifetime);

  // 生成数字签名并放到 Token 中
  String signatureValue = makeTokenSignature(expiryTime, username, password);
  setCookie(new String[] { username, Long.toString(expiryTime), signatureValue },
            tokenLifetime, request, response);
}
// 计算数字签名
protected String makeTokenSignature(long tokenExpiryTime, String username,
                                    String password) {
  String data = username + ":" + tokenExpiryTime + ":" + password + ":" + getKey();
  MessageDigest digest;
  try {
    digest = MessageDigest.getInstance("MD5");
  }
  catch (NoSuchAlgorithmException e) {
    throw new IllegalStateException("No MD5 algorithm available!");
  }

  return new String(Hex.encode(digest.digest(data.getBytes())));
}

第二次访问的时候在 RememberMeAuthenticationFilter 的 doFilter 中首先尝试从 SecurityContextHolder 获取认证信息，如果认证信息没有了则尝试自动登录。

// RememberMeAuthenticationFilter
if (SecurityContextHolder.getContext().getAuthentication() == null) {
  // 尝试自动登录
  Authentication rememberMeAuth = rememberMeServices.autoLogin(request, response);
  if (rememberMeAuth != null) {
    try {
      // 使用 authenticationManager 再次认证
      rememberMeAuth = authenticationManager.authenticate(rememberMeAuth);
      // 将认证信息保存的 SecurityContextHolder 中
      SecurityContextHolder.getContext().setAuthentication(rememberMeAuth);
      onSuccessfulAuthentication(request, response, rememberMeAuth);
      // 触发发布事件
      if (this.eventPublisher != null) {
        eventPublisher.publishEvent(new InteractiveAuthenticationSuccessEvent(
            SecurityContextHolder.getContext().getAuthentication(), this.getClass()));
      }
      if (successHandler != null) {
        successHandler.onAuthenticationSuccess(request, response, rememberMeAuth);
        return;
      }
    } catch (AuthenticationException authenticationException) {
      rememberMeServices.loginFail(request, response);
      onUnsuccessfulAuthentication(request, response, authenticationException);
    }
  }
  chain.doFilter(request, response);
}

// AbstractRememberMeServices
public final Authentication autoLogin(HttpServletRequest request,
                                      HttpServletResponse response) {
 // 从请求中获取 Cookie
  String rememberMeCookie = extractRememberMeCookie(request);
  // Cookie 为 null 或者为空
  if (rememberMeCookie == null) {
    return null;
  }
  if (rememberMeCookie.length() == 0) {
    cancelCookie(request, response);
    return null;
  }

  UserDetails user = null;
  try {
    // 解码 cookie 信息
    String[] cookieTokens = decodeCookie(rememberMeCookie);
    // 根据 cookie 自动登录
    user = processAutoLoginCookie(cookieTokens, request, response);
    // 检查用户的信息过期等。
    userDetailsChecker.check(user);
  // 生成登录成功的凭据
    return createSuccessfulAuthentication(request, user);
  }
  //...
 // 删除 cookie
  cancelCookie(request, response);
  return null;
}
// 解码 Cookie
protected String[] decodeCookie(String cookieValue) throws InvalidCookieException {
  for (int j = 0; j < cookieValue.length() % 4; j++) {
    cookieValue = cookieValue + "=";
  }
  try {
    Base64.getDecoder().decode(cookieValue.getBytes());
  } catch (IllegalArgumentException e) {
    throw new InvalidCookieException(
      "Cookie token was not Base64 encoded; value was '" + cookieValue
      + "'");
  }

  String cookieAsPlainText = new String(Base64.getDecoder().decode(cookieValue.getBytes()));
  String[] tokens = StringUtils.delimitedListToStringArray(cookieAsPlainText, DELIMITER);

  for (int i = 0; i < tokens.length; i++) {
    try {
      tokens[i] = URLDecoder.decode(tokens[i], StandardCharsets.UTF_8.toString());
    } catch (UnsupportedEncodingException e) {
      logger.error(e.getMessage(), e);
    }
  }
  return tokens;
}

// TokenBasedRememberMeServices
protected UserDetails processAutoLoginCookie(String[] cookieTokens,
                                             HttpServletRequest request, HttpServletResponse response) {
 // 获取过期时间
  long tokenExpiryTime;
  try {
    tokenExpiryTime = new Long(cookieTokens[1]);
  } catch (NumberFormatException nfe) {
    throw new InvalidCookieException(
      "Cookie token[1] did not contain a valid number (contained '"
      + cookieTokens[1] + "')");
  }
 // 判断 Token 是否过期
  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]);
  // 根据查到的用户名和密码构造 token
  String expectedTokenSignature = makeTokenSignature(tokenExpiryTime, userDetails.getUsername(), userDetails.getPassword());
 // 判断请求中 Token 和 实际的需要的 Token 是否相同，不同就抛出异常
  if (!equals(expectedTokenSignature, cookieTokens[2])) {
    throw new InvalidCookieException("Cookie token[2] contained signature '"
                                     + cookieTokens[2] + "' but expected '" + expectedTokenSignature + "'");
  }
 // 相同就返回用户信息
  return userDetails;
}

上面主要是默认的使用 TokenBasedRememberMeServices 也可以指定使用 Spring 提供的另外一种方式 PersistentTokenRepository。

可以通过以下方式启用：

@Bean
public PersistentTokenRepository persistentTokenRepository() {
  JdbcTokenRepositoryImpl persistentTokenRepository = new JdbcTokenRepositoryImpl();
  persistentTokenRepository.setDataSource(dataSource);
  return persistentTokenRepository;
}

// config Method
.rememberMe().tokenRepository(persistentTokenRepository())

其主要方法如下：

// PersistentTokenRepository
protected void onLoginSuccess(HttpServletRequest request,
                              HttpServletResponse response, Authentication successfulAuthentication) {
  String username = successfulAuthentication.getName();

 // 根据用户名等信息, series 加密后的随机值等生成一个 Token
  PersistentRememberMeToken persistentToken = new PersistentRememberMeToken(
    username, generateSeriesData(), generateTokenData(), new Date());
  try {
    // 将 Token 存储起来：默认有两种实现
    // 1. InMemoryTokenRepositoryImpl 默认实现放到内存中
    // 2. JdbcTokenRepositoryImpl 放到数据库中
    tokenRepository.createNewToken(persistentToken);
    // 然后将 Token 添加到 Cookie 中
    addCookie(persistentToken, request, response);
  }
  catch (Exception e) {
    logger.error("Failed to save persistent token ", e);
  }
}
// 添加到 Cookie 中
private void addCookie(PersistentRememberMeToken token, HttpServletRequest request,
   HttpServletResponse response) {
  setCookie(new String[] { token.getSeries(), token.getTokenValue() },
            getTokenValiditySeconds(), request, response);
}
// 基于 Token 自动登录
protected UserDetails processAutoLoginCookie(String[] cookieTokens,
   HttpServletRequest request, HttpServletResponse response) {

  final String presentedSeries = cookieTokens[0];
  final String presentedToken = cookieTokens[1];

  PersistentRememberMeToken token = tokenRepository.getTokenForSeries(presentedSeries);

  // 没有 Token 抛出异常
  if (token == null) {
    throw new RememberMeAuthenticationException(
      "No persistent token found for series id: " + presentedSeries);
  }
 // 比较服务器中 Token 和 请求中的 Token 是否相同，不相同则情况 Token
  if (!presentedToken.equals(token.getTokenValue())) {
    tokenRepository.removeUserTokens(token.getUsername());
    throw new CookieTheftException(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
  PersistentRememberMeToken newToken = new PersistentRememberMeToken(
    token.getUsername(), token.getSeries(), generateTokenData(), new Date());

  try {
    // 更新 Token
    tokenRepository.updateToken(newToken.getSeries(), newToken.getTokenValue(), newToken.getDate());
    addCookie(newToken, request, response);
  } catch (Exception e) {
    logger.error("Failed to update token: ", e);
    throw new RememberMeAuthenticationException( "Autologin failed due to data access problem");
  }
 // 返回用户信息
  return getUserDetailsService().loadUserByUsername(token.getUsername());
}

Spring Security 权限控制

如果要使用注解控制不同请求的权限需要在 config 加上相关的注解开启，例如：

@EnableGlobalMethodSecurity(prePostEnabled = true,  // Spring 指定的权限控制注解开关
                            securedEnabled = true,  // Spring Security 内部权限控制注解开关
                            jsr250Enabled = true)  // 开启 Java 250 注解支持
public class SecurityConfig extends WebSecurityConfigurerAdapter {

// @PreAuthorize("hasAnyAuthority('ROLE_ADMIN', 'ROLE_DEMO') and hasAnyRole('MAINTAIN_PRODUCT')")  // Spring
@Secured({"ROLE_ADMIN", "ROLE_DEMO"}) // Spring Security
// @RolesAllowed({"ROLE_ADMIN", "ROLE_DEMO"})  // JSR 250
@RequestMapping("/maintain")
public String demo1() {
  return "maintain";
}

异常处理

一种是通过实现 HandlerExceptionResolver 的方式实现，示例如下：

@Component
public class HandlerExceptionController implements HandlerExceptionResolver {
    @Override
    public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        ModelAndView mv = new ModelAndView();
        if (ex instanceof AccessDeniedException) {
            mv.setViewName("redirect:/403");
        } else {
            mv.setViewName("redirect:/error");
        }
        return mv;
    }
}

一种是直接通过 @ControllerAdvice 注解，示例如下：

public class HandlerExceptionAdvice {
    @ExceptionHandler(AccessDeniedException.class)
    public String accessDeniedException() {
        return "redirect:/403”";
    }
    @ExceptionHandler(Exception.class)
    public String exceptionHandler() {
        return "redirect:/error”";
    }
}

最后，如果没看懂此文，送给大家一套宇宙最强的 Spring Security 的视频教程：https://www.bilibili.com/video/BV1af4y1i7n1