Spring Security授权源码分析

授权是在用户认证通过后，对访问资源的权限进行检查的过程。
Spring Security使用标准 Filter建立了对 web请求的拦截，最终实现对资源的授权访问。

• Spring Security过滤器链加载执行流程源码分析请查看：https://blog.csdn.net/qq_42402854/article/details/122205790

关于授权，这里查看几个重要的 Filter 的处理逻辑。

一、SecurityContextPersistenceFilter

针对 ServletRequest进行了一次包装，使得 request具有更加丰富的 API。

查看 doFilter方法：

• 通过repo.loadContext从请求中获取session，然后将 session信息保存在context中，方便后面 filter直接获取当前的用户信息。
• 通过 SecurityContextHolder.setContext(contextBeforeChainExecution); 设置 context信息到contextHolder中（将context信息放在了ThreadLocal中，线程安全的）。

1）repo.loadContext方法

2）setContext方法

二、AnonymousAuthenticationFilter

Spring Security为了兼容未登录的访问，也走了一套认证流程，只不过是一个匿名的身份。

AnonymousAuthenticationFilter过滤器是在 UsernamePasswordAuthenticationFilter等过滤器之后，如果它前面的过滤器都没有认证成功，即认证信息为空，AnonymousAuthenticationFilter会创建一个匿名用户（一个 Authenticaiton 的匿名实现类 AnonymousAuthenticationToken）存入到当前 SecurityContextHolder中。

查看 doFilter方法：

• 判断 SecurityContextHolder中Authentication为否为空；
• 如果空则为当前的 SecurityContextHolder中添加一个匿名的 AnonymousAuthenticationToken（用户名为 anonymousUser的 AnonymousAuthenticationToken）

三、ExceptionTranslationFilter

ExceptionTranslationFilter异常处理过滤器，用来处理在系统认证授权过程中抛出的异常（也就是下一个 FilterSecurityInterceptor过滤器）。

ExceptionTranslationFilter过滤器主要是拦截处理 AuthenticationException 和 AccessDeniedException异常并添加到HTTP响应中。其他异常它会捕获 Filter处理的异常，抛给下一个 Filter去处理。

查看 doFilter方法：

四、FilterSecurityInterceptor

FilterSecurityInterceptor过滤器是认证授权过滤器链中最后一个过滤器，获取所配置资源访问的授权信息，根据 SecurityContextHolder中存储的用户信息来决定其是否有权限。

该过滤器之后就交由 Spring MVC，访问到我们的controller方法。

查看 doFilter方法：

    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        FilterInvocation fi = new FilterInvocation(request, response, chain);
        this.invoke(fi);
    }

	/**
	 *  doFilter实际执行的方法
	 * @param filterInvocation 封装了request response 过滤器链的对象
	 */
	public void invoke(FilterInvocation filterInvocation) throws IOException, ServletException {
		// 1. 如果已经执行过该过滤器，直接放行
		if (isApplied(filterInvocation) && this.observeOncePerRequest) {
			// filter already applied to this request and user wants us to observe
			// once-per-request handling, so don't re-do security checking
			filterInvocation.getChain().doFilter(filterInvocation.getRequest(), filterInvocation.getResponse());
			return;
		}
		// first time this request being called, so perform security checking
		// 2. 第一次调用这个请求，所以执行安全检查
		if (filterInvocation.getRequest() != null && this.observeOncePerRequest) {
			// 3. 在request中添加__spring_security_filterSecurityInterceptor_filterApplied = true,表示执行了该过滤器
			filterInvocation.getRequest().setAttribute(FILTER_APPLIED, Boolean.TRUE);
		}
		// 4. 前置访问控制处理
		InterceptorStatusToken token = super.beforeInvocation(filterInvocation);
		try {
			// 5. 放行
            filterInvocation.getChain().doFilter(filterInvocation.getRequest(), filterInvocation.getResponse());
		} finally {
			super.finallyInvocation(token);
		}
		// 6. 后置处理
		super.afterInvocation(token, null);
	}

比较重要的方法

• beforeInvocation
• finallyInvocation
• afterInvocation

1、查看 beforeInvocation方法

进入父类 AbstractSecurityInterceptor的 beforeInvocation方法进行处理，最终返回一个 InterceptorStatusToken对象，它就是 Spring Security处理鉴权的入口。

    protected InterceptorStatusToken beforeInvocation(Object object) {
		// 1. 判断object是不是FilterInvocation
        if (!this.getSecureObjectClass().isAssignableFrom(object.getClass())) {
            throw new IllegalArgumentException(...);
        } else {
            // 2. 获取配置的访问控制规则 any request => authenticated ，没有配置，return null
            Collection<ConfigAttribute> attributes = this.obtainSecurityMetadataSource().getAttributes(object);

            ...

                // 3. 获取Authentication对象
                Authentication authenticated = this.authenticateIfRequired();

                try {
                    // 4. 进行授权判断(重点)
                    this.accessDecisionManager.decide(authenticated, object, attributes);
                } catch (AccessDeniedException var7) {
                    this.publishEvent(new AuthorizationFailureEvent(object, attributes, authenticated, var7));
                    throw var7;
                }

                if (debug) {
                    this.logger.debug("Authorization successful");
                }
				// 5. 发布授权成功
                if (this.publishAuthorizationSuccess) {
                    this.publishEvent(new AuthorizedEvent(object, attributes, authenticated));
                }
				// 6. 对Authentication进行再处理，这里没有处理，直接返回null
                Authentication runAs = this.runAsManager.buildRunAs(authenticated, object, attributes);
                if (runAs == null) {
                    if (debug) {
						this.logger.debug("RunAsManager did not change Authentication object");
                    }
				// 7. 返回 InterceptorStatusToken
                    return new InterceptorStatusToken(SecurityContextHolder.getContext(), false, attributes, object);
                } else {
                    if (debug) {
                        this.logger.debug("Switching to RunAs Authentication: " + runAs);
                    }

                    SecurityContext origCtx = SecurityContextHolder.getContext();
                    SecurityContextHolder.setContext(SecurityContextHolder.createEmptyContext());
                    SecurityContextHolder.getContext().setAuthentication(runAs);
                    // 7. 返回 InterceptorStatusToken
                    return new InterceptorStatusToken(origCtx, true, attributes, object);
                }
            } else if (this.rejectPublicInvocations) {
                throw new IllegalArgumentException(...);
            } else {
                if (debug) {
                    this.logger.debug("Public object - authentication not attempted");
                }

                this.publishEvent(new PublicInvocationEvent(object));
                return null;
            }
        }
    }

1.1 AffirmativeBased授权处理器

AccessDecisionManager 是如何授权的？
Spring Security默认使用 AffirmativeBased实现 AccessDecisionManager 的 decide 方法来实现授权。它会调用授权管理器进行决策，当失败发生异常时，会爆出异常。

调用 AccessDecisionVoter 进行vote(投票)

• 只要有投通过（ACCESS_GRANTED）票，则直接判为通过。
• 如果没有投通过则 ++deny ,
• 最后判断if（deny>0 抛出AccessDeniedException（未授权）

1.2 WebExpressionVoter.vote()

这里简单查看 WebExpressionVoter.vote()方法：

    public int vote(Authentication authentication, FilterInvocation fi, Collection<ConfigAttribute> attributes) {
        assert authentication != null;

        assert fi != null;

        assert attributes != null;

        // 1. 获取http配置项
        WebExpressionConfigAttribute weca = this.findConfigAttribute(attributes);
        // 2. 没有配置规则，弃权
        if (weca == null) {
            return 0;
        } else {
            // 3. 对EL表达式进行处理
            EvaluationContext ctx = this.expressionHandler.createEvaluationContext(authentication, fi);
            ctx = weca.postProcess(ctx, fi);
            // 5. 符合条件，则投赞成票，否则反对票
            return ExpressionUtils.evaluateAsBoolean(weca.getAuthorizeExpression(), ctx) ? 1 : -1;
        }
    }

投票完成，回到 beforeInvocation方法，最后返回 InterceptorStatusToken对象。

2、查看 finallyInvocation方法

授权成功处理：没有抛出异常，则认为授权通过，FilterSecurityInterceptor会进入 finallyInvocation方法。
这个方法主要是判断需不需要重新设置 SecurityContext内容，这里没有配置，直接跳过。

3、查看 afterInvocation方法

接下来进入 afterInvocation方法，再次调用了 finallyInvocation方法，然后查询是否还有决策后置处理器，如果有，再次进行决策。
最后的最后，才代表授权成功，就交由 Spring MVC，访问到我们的 controller方法了。

    protected Object afterInvocation(InterceptorStatusToken token, Object returnedObject) {
        if (token == null) {
            return returnedObject;
        } else {
            this.finallyInvocation(token);
            if (this.afterInvocationManager != null) {
                try {
                    returnedObject = this.afterInvocationManager.decide(token.getSecurityContext().getAuthentication(), token.getSecureObject(), token.getAttributes(), returnedObject);
                } catch (AccessDeniedException var5) {
                    AuthorizationFailureEvent event = new AuthorizationFailureEvent(token.getSecureObject(), token.getAttributes(), token.getSecurityContext().getAuthentication(), var5);
                    this.publishEvent(event);
                    throw var5;
                }
            }

            return returnedObject;
        }
    }

– 求知若饥，虚心若愚。