针对 SpringSecurity 鉴权流程做了一个详细分析，让你明白它是如何执行的！

@PreAuthorize("hasRole('ROLE_ADMIN')")
@RequestMapping("/role/admin1")
String admin() {
    return "role: ROLE_ADMIN";
}

//过滤器链实际调用的方法。 简单地委托给invoke(FilterInvocation)方法。
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
    throws IOException, ServletException {
    invoke(new FilterInvocation(request, response, chain));
}

public void invoke(FilterInvocation filterInvocation) throws IOException, ServletException {
    if (isApplied(filterInvocation) && this.observeOncePerRequest) {
    //过滤器已应用于此请求，用户希望我们观察每个请求处理一次，因此不要重新进行安全检查
        filterInvocation.getChain().doFilter(filterInvocation.getRequest(), filterInvocation.getResponse());
        return;
    }
    // 第一次调用这个请求，所以执行安全检查
    if (filterInvocation.getRequest() != null && this.observeOncePerRequest) {
        filterInvocation.getRequest().setAttribute(FILTER_APPLIED, Boolean.TRUE);
    }
    //调用 beforeInvocation(filterInvocation) 方法 跟着这个方法往下看
    InterceptorStatusToken token = super.beforeInvocation(filterInvocation) ;
    try {
        //每个过滤器都有这么一步 
        filterInvocation.getChain().doFilter(filterInvocation.getRequest(), filterInvocation.getResponse());
    }
    finally {
        //在安全对象调用完成后清理AbstractSecurityInterceptor的工作。
        //无论安全对象调用是否成功返回，都应该在安全对象调用之后和 afterInvocation 之前调用此方法（即它应该在 finally 块中完成）。
        super.finallyInvocation(token);
    }
    //当调用afterInvocation（InterceptorStatusToken，Object）时，AbstractSecurityInterceptor不会采取进一步的操作。
    super.afterInvocation(token, null);
}

protected InterceptorStatusToken beforeInvocation(Object object) {
      //检查操作
    Assert.notNull(object, "Object was null");
    if (!getSecureObjectClass().isAssignableFrom(object.getClass())) {
      //....
    }
      //这里获取的信息看下图示1 ：
      //object 就是调用处传过来的参数 FilterInvocation filterInvocation，它本身其实就是 HttpServletRequest 和 HttpServletResponse 的增强
      //object :filter invocation [GET /role/admin1] "
      //然后我们获取到的就是受保护调用的列表  
    Collection<ConfigAttribute> attributes = this.obtainSecurityMetadataSource().getAttributes(object);
    if (CollectionUtils.isEmpty(attributes)) {
            //...
      return null; // no further work post-invocation
    }
      //在 SecurityContext 中未找到身份验证对象，会发事件抛异常
    if (SecurityContextHolder.getContext().getAuthentication() == null) {
      credentialsNotFound(this.messages.getMessage("AbstractSecurityInterceptor.authenticationNotFound",
          "An Authentication object was not found in the SecurityContext"), object, attributes);
    }
      //在这里拿到了  Authentication 对象登录的信息 ,后文会简单说是如何拿到的
    Authentication authenticated = authenticateIfRequired();
    if (this.logger.isTraceEnabled()) {
      this.logger.trace(LogMessage.format("Authorizing %s with attributes %s", object, attributes));
    }
    // Attempt authorization ： 尝试授权 这步本文重点，用我的话来说，这就是鉴权的入口  重点关注，下文继续
    attemptAuthorization(object, attributes, authenticated);
    //...
    // Attempt to run as a different user
    Authentication runAs = this.runAsManager.buildRunAs(authenticated, object, attributes);
    if (runAs != null) {
      //...
    }
    // 无后续动作
    return new InterceptorStatusToken(SecurityContextHolder.getContext(), false, attributes, object);
  }

//如果Authentication.isAuthenticated()返回 false 或属性alwaysReauthenticate已设置为 true，
//则检查当前的身份验证令牌并将其传递给 AuthenticationManager进行身份验证
private Authentication authenticateIfRequired() {
    Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
    if (authentication.isAuthenticated() && !this.alwaysReauthenticate) {
        return authentication;
    }
    authentication = this.authenticationManager.authenticate(authentication);
    SecurityContextHolder.getContext().setAuthentication(authentication);
    return authentication;
}

private void attemptAuthorization(Object object, Collection<ConfigAttribute> attributes,
                                  Authentication authenticated) {
    try {
        //接着套娃 我们去看 AccessDecisionManager 下的 decide() 方法
        this.accessDecisionManager.decide(authenticated, object, attributes);
    }
    catch (AccessDeniedException ex) {
        if (this.logger.isTraceEnabled()) {
            this.logger.trace(LogMessage.format("Failed to authorize %s with attributes %s using %s", object,
                                                attributes, this.accessDecisionManager));
        }
        else if (this.logger.isDebugEnabled()) {
            this.logger.debug(LogMessage.format("Failed to authorize %s with attributes %s", object, attributes));
        }
        publishEvent(new AuthorizationFailureEvent(object, attributes, authenticated, ex));
        throw ex;
    }
}

public interface AccessDecisionManager {
  /**
为传递的参数解析访问控制决策。
参数：
身份验证 - 调用方法的调用者（非空）
object – 被调用的安全对象
configAttributes – 与被调用的安全对象关联的配置属性
   */
  void decide(Authentication authentication, Object object, Collection<ConfigAttribute> configAttributes)
      throws AccessDeniedException, InsufficientAuthenticationException;
    // 下面这两个方法主要起辅助作用的。大都执行检查操作
  boolean supports(ConfigAttribute attribute);
  boolean supports(Class<?> clazz);
}

public class AffirmativeBased extends AbstractAccessDecisionManager {
  public AffirmativeBased(List<AccessDecisionVoter<?>> decisionVoters) {
    super(decisionVoters);
  }
  /**
  这个具体的实现只是轮询所有配置的AccessDecisionVoter并在任何AccessDecisionVoter投赞成票时授予访问权限。 仅当存在拒绝投票且没有赞成票时才拒绝访问。
如果每个AccessDecisionVoter放弃投票，则决策将基于isAllowIfAllAbstainDecisions()属性（默认为 false）。
   */
  @Override
  @SuppressWarnings({ "rawtypes", "unchecked" })
  public void decide(Authentication authentication, Object object, Collection<ConfigAttribute> configAttributes)
      throws AccessDeniedException {
    int deny = 0;
    for (AccessDecisionVoter voter : getDecisionVoters()) {
      int result = voter.vote(authentication, object, configAttributes);
      switch (result) {
      case AccessDecisionVoter.ACCESS_GRANTED:
        return;
      case AccessDecisionVoter.ACCESS_DENIED:
        deny++;
        break;
      default:
        break;
      }
    }
    if (deny > 0) {
      throw new AccessDeniedException(
          this.messages.getMessage("AbstractAccessDecisionManager.accessDenied", "Access is denied"));
    }
    // To get this far, every AccessDecisionVoter abstained
    checkAllowIfAllAbstainDecisions();
  }
}

//表示一个类负责对授权决定进行投票。
//投票的协调（即轮询AccessDecisionVoter ，统计他们的响应，并做出最终授权决定）由AccessDecisionManager执行。
public interface AccessDecisionVoter<S> {
    int ACCESS_GRANTED = 1;
    int ACCESS_ABSTAIN = 0;
    int ACCESS_DENIED = -1;
    //这两个用来执行check操作，判断参数是否合法等等
    boolean supports(ConfigAttribute attribute);
    boolean supports(Class<?> clazz);
    /**
指示是否授予访问权限。
决定必须是肯定的 ( ACCESS_GRANTED )、否定的 ( ACCESS_DENIED ) 或者 AccessDecisionVoter可以弃权 ( ACCESS_ABSTAIN ) 投票。 
在任何情况下，实现类都不应返回任何其他值。 如果需要对结果进行加权，则应改为在自定义AccessDecisionManager处理。
除非AccessDecisionVoter由于传递的方法调用或配置属性参数而专门用于对访问控制决策进行投票，否则它必须返回ACCESS_ABSTAIN 。 
这可以防止协调AccessDecisionManager计算来自那些AccessDecisionVoter的选票，而这些AccessDecisionVoter对访问控制决策没有合法利益。
虽然安全对象（例如MethodInvocation ）作为参数传递以最大限度地提高访问控制决策的灵活性，但实现类不应修改它或导致所表示的调用发生（例如，通过调用MethodInvocation.proceed() ） .
   */
  int vote(Authentication authentication, S object, Collection<ConfigAttribute> attributes);
}

public class WebExpressionVoter implements AccessDecisionVoter<FilterInvocation> {
  private SecurityExpressionHandler<FilterInvocation> expressionHandler = new DefaultWebSecurityExpressionHandler();
  @Override
  public int vote(Authentication authentication, FilterInvocation filterInvocation,
      Collection<ConfigAttribute> attributes) {
        //...执行的一些检查
        //
    WebExpressionConfigAttribute webExpressionConfigAttribute = findConfigAttribute(attributes);
    if (webExpressionConfigAttribute == null) {
      return ACCESS_ABSTAIN;
    }
        //允许对EvaluationContext进行后处理。 实现可能会返回一个新的EvaluationContext实例或修改传入的EvaluationContext 。
        EvaluationContext ctx = webExpressionConfigAttribute.postProcess(
            //调用内部模板方法来创建StandardEvaluationContext和SecurityExpressionRoot对象。
            this.expressionHandler.createEvaluationContext(authentication, filterInvocation), filterInvocation);
        //针对指定的根对象评估默认上下文中的表达式。 如果评估结果与预期结果类型不匹配（并且无法转换为），则将返回异常。
        boolean granted = ExpressionUtils.evaluateAsBoolean(webExpressionConfigAttribute.getAuthorizeExpression(), ctx);
    // 投赞同票，返回
        if (granted) {
      return ACCESS_GRANTED;
    }
    return ACCESS_DENIED;
  }
    //循环判断
  private WebExpressionConfigAttribute findConfigAttribute(Collection<ConfigAttribute> attributes) {
    for (ConfigAttribute attribute : attributes) {
      if (attribute instanceof WebExpressionConfigAttribute) {
        return (WebExpressionConfigAttribute) attribute;
      }
    }
    return null;
  }
    //...
}

for (AccessDecisionVoter voter : getDecisionVoters()) {
    int result = voter.vote(authentication, object, configAttributes);
    switch (result) {
        case AccessDecisionVoter.ACCESS_GRANTED:
            return;
        case AccessDecisionVoter.ACCESS_DENIED:
            deny++;
            break;
        default:
            break;
    }
}

private void attemptAuthorization(Object object, Collection<ConfigAttribute> attributes,
                                  Authentication authenticated) {
    try {
        this.accessDecisionManager.decide(authenticated, object, attributes);
    }
}

protected InterceptorStatusToken beforeInvocation(Object object) {
    // 返回到这里，我们再顺着往下看，看如何执行 
    attemptAuthorization(object, attributes, authenticated);
    // Attempt to run as a different user ：尝试以其他用户身份运行
    Authentication runAs = this.runAsManager.buildRunAs(authenticated, object, attributes);
    if (runAs != null) {
        SecurityContext origCtx = SecurityContextHolder.getContext();
        SecurityContextHolder.setContext(SecurityContextHolder.createEmptyContext());
        SecurityContextHolder.getContext().setAuthentication(runAs);
        // 需要恢复到 token.Authenticated 调用后 true的意思是：如果能以其他用户运行 就执行刷新
        return new InterceptorStatusToken(origCtx, true, attributes, object);
    }
    return new InterceptorStatusToken(SecurityContextHolder.getContext(), false, attributes, object);
}

public void invoke(FilterInvocation filterInvocation) throws IOException, ServletException {
    if (isApplied(filterInvocation) && this.observeOncePerRequest) {
      // 过滤器已应用于此请求，用户希望我们观察每个请求处理一次，因此不要重新进行安全检查
      filterInvocation.getChain().doFilter(filterInvocation.getRequest(), filterInvocation.getResponse());
      return;
    }
    // 第一次调用这个请求，所以执行安全检查
    if (filterInvocation.getRequest() != null && this.observeOncePerRequest) {
      filterInvocation.getRequest().setAttribute(FILTER_APPLIED, Boolean.TRUE);
    }
    //返回至此处  
        //InterceptorStatusToken类上的doc注释说：
        //AbstractSecurityInterceptor子类接收的返回对象。
    //这个类反映了安全拦截的状态，以便最终调用AbstractSecurityInterceptor.afterInvocation(InterceptorStatusToken, Object)可以正确整理。
        InterceptorStatusToken token = super.beforeInvocation(filterInvocation);
    try {
            //每个过滤器的必备代码
      filterInvocation.getChain().doFilter(filterInvocation.getRequest(), filterInvocation.getResponse());
    }
    finally {
      super.finallyInvocation(token);
    }
    super.afterInvocation(token, null);
  }

//提供对基于 AOP 联盟的方法调用的安全拦截。
//此安全拦截器所需的SecurityMetadataSource是MethodSecurityMetadataSource类型。 这与基于 AspectJ 的安全拦截器 ( AspectJSecurityInterceptor ) 共享，因为两者都与 Java Method 。
public class MethodSecurityInterceptor extends AbstractSecurityInterceptor implements MethodInterceptor {
  private MethodSecurityMetadataSource securityMetadataSource;
  //此方法应用于对MethodInvocation强制实施安全性。
  @Override
  public Object invoke(MethodInvocation mi) throws Throwable {
        //beforeInvocation 这个有没有似曾相识 ，莫错哈  就是我们之前在 FilterSecurityInterceptor 看到的那个 
        //需要注意到的是 之前我们传的参是一个  FilterInvocation ，这里则是一个  MethodInvocation 。
    InterceptorStatusToken token = super.beforeInvocation(mi);
    Object result;
    try {
      result = mi.proceed();
    }
    finally {
      super.finallyInvocation(token);
    }
    return super.afterInvocation(token, result);
  }
    //...
}

protected void configure(HttpSecurity http) throws Exception {
    http.csrf().disable()
        .authorizeRequests()
        .antMatchers("/r/r1").hasAuthority("r1")
        .antMatchers("/r/r2").hasAuthority("r2")
        ....
}

attemptAuthorization(object, attributes, authenticated);
this.accessDecisionManager.decide(authenticated, object, attributes);

public class PreInvocationAuthorizationAdviceVoter implements AccessDecisionVoter<MethodInvocation> {
  private final PreInvocationAuthorizationAdvice preAdvice;
  public PreInvocationAuthorizationAdviceVoter(PreInvocationAuthorizationAdvice pre) {
    this.preAdvice = pre;
  }
    //...一些检查方法
  @Override
  public int vote(Authentication authentication, MethodInvocation method, Collection<ConfigAttribute> attributes) {
    // 查找 prefilter 和 preauth（或组合）属性，如果两者都为 null，则弃权使用它们调用建议
    PreInvocationAttribute preAttr = findPreInvocationAttribute(attributes);
    if (preAttr == null) {
      // 没有基于表达式的元数据，所以弃权
      return ACCESS_ABSTAIN;
    }
        //在这里又委托给 PreInvocationAuthorizationAdvice接口的before方法来做判断
    return this.preAdvice.before(authentication, method, preAttr) ? ACCESS_GRANTED : ACCESS_DENIED;
  }
  private PreInvocationAttribute findPreInvocationAttribute(Collection<ConfigAttribute> config) {
    for (ConfigAttribute attribute : config) {
      if (attribute instanceof PreInvocationAttribute) {
        return (PreInvocationAttribute) attribute;
      }
    }
    return null;
  }
}