SpringSecurity--权限配置

分手后的思念是犯贱 2024-02-19 17:33 61阅读 0赞

权限相关API和流程:

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU0OTU3OA_size_16_color_FFFFFF_t_70][]

关键点在：

1.FilterSecurityInterceptor 所有的SpringSecurity拦截器都会进入这个安全处理器中。只有通过才能处理业务逻辑。

2.AccessDecisionManager：认证投票处理。

3.AccessDecisionVoter：选举者。

4. AbstractAccessDecisionManager：选择选举方式。

在请求过来的时候不同的业务走不同的拦截器。如用户名密码登陆：UsernamePasswordAuthenticationFilter 社交登陆：

SocialAuthenticationFilter等等。

在整个服务过程中SpringSecurity永远有一个处理认证请求的拦截器：AnonymousAuthenticationFilter。

AnonymousAuthenticationFilter：

//这个拦截器是在SpringSecurity拦截器链最后一个 程序会将其传递给FilterSecurityInterceptor
    public class AnonymousAuthenticationFilter extends GenericFilterBean implements
    		InitializingBean {
    
    	
    	private AuthenticationDetailsSource<HttpServletRequest, ?> authenticationDetailsSource = new WebAuthenticationDetailsSource();
    	private String key;
    	private Object principal;
    	private List<GrantedAuthority> authorities;
    
    	。。。。。。。。。。。。。。。。。。。。。。。。
    	public AnonymousAuthenticationFilter(String key) {
    		this(key, "anonymousUser", AuthorityUtils.createAuthorityList("ROLE_ANONYMOUS"));
    	}
    
        。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
    	//拦截逻辑
    	public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)
    			throws IOException, ServletException {
            //判断之前的拦截器是否已经进行了权限验证 如UsernamePasswordAuthenticationFilter，BasicAuthenticationFilter等拦截器
    		if (SecurityContextHolder.getContext().getAuthentication() == null) {
    			//如果没有进行权限验证 则创建一个匿名的权限验证拦截器
    			//说明 SpringSecurity中一定会有一个权限验证的拦截器
    			SecurityContextHolder.getContext().setAuthentication(
    					createAuthentication((HttpServletRequest) req));
    
    			if (logger.isDebugEnabled()) {
    				logger.debug("Populated SecurityContextHolder with anonymous token: '"
    						+ SecurityContextHolder.getContext().getAuthentication() + "'");
    			}
    		}
    		else {
    			if (logger.isDebugEnabled()) {
    				logger.debug("SecurityContextHolder not populated with anonymous token, as it already contained: '"
    						+ SecurityContextHolder.getContext().getAuthentication() + "'");
    			}
    		}
    
    		chain.doFilter(req, res);
    	}
        //创建匿名的权限验证拦截器
    	protected Authentication createAuthentication(HttpServletRequest request) {
    	    //new 一个匿名的权限验证拦截器 principal="anonymousUser" 表明用户信息是一个字符串
    		AnonymousAuthenticationToken auth = new AnonymousAuthenticationToken(key,
    				principal, authorities);
    		auth.setDetails(authenticationDetailsSource.buildDetails(request));
    
    		return auth;
    	}
        。。。。。。。。。。。。。。。。。。。。。。。。
    }

接着程序会进入FilterSecurityInterceptor中。

整个流程解析：

public class FilterSecurityInterceptor extends AbstractSecurityInterceptor implements
    		Filter {
    	。。。。。。。。。。。。。。。。。。。。。。。
    	private static final String FILTER_APPLIED = "__spring_security_filterSecurityInterceptor_filterApplied";
    
    	// ~ Instance fields
    	// ================================================================================================
    
    	private FilterInvocationSecurityMetadataSource securityMetadataSource;
    	private boolean observeOncePerRequest = true;
    
    	。。。。。。。。。。。。。。。。。。。。。。。
    	public void doFilter(ServletRequest request, ServletResponse response,
    			FilterChain chain) throws IOException, ServletException {
    		FilterInvocation fi = new FilterInvocation(request, response, chain);
    		invoke(fi);
    	}
    
         。。。。。。。。。。。。。。。。。。。。。。。
    
    	public void invoke(FilterInvocation fi) throws IOException, ServletException {
    	    //判断之前的请求有没有经过这个过滤器 fi.getRequest().getAttribute(FILTER_APPLIED)
    		if ((fi.getRequest() != null)
    				&& (fi.getRequest().getAttribute(FILTER_APPLIED) != null)
    				&& observeOncePerRequest) {
    			//经过不用在进行判断
    			fi.getChain().doFilter(fi.getRequest(), fi.getResponse());
    		}
    		else {
    			// first time this request being called, so perform security checking
    			if (fi.getRequest() != null) {
    			//用于设置请求是否是第一次标识
    				fi.getRequest().setAttribute(FILTER_APPLIED, Boolean.TRUE);
    			}
                //授权判断逻辑
    			InterceptorStatusToken token = super.beforeInvocation(fi);
    
    			try {
    			//进入服务
    				fi.getChain().doFilter(fi.getRequest(), fi.getResponse());
    			}
    			finally {
    				super.finallyInvocation(token);
    			}
    
    			super.afterInvocation(token, null);
    		}
    	}
        。。。。。。。。。。。。。。。。。。
    }
    // AbstractSecurityInterceptor
    protected InterceptorStatusToken beforeInvocation(Object object) {
    		Assert.notNull(object, "Object was null");
    	。。。。。。。。。。。。。。。。。。
    	//从系统配置获取所需信息封装成ConfigAttribute
    	//DefaultFilterInvocationSecurityMetadataSource getAttributes
    	//获取权限结果
    	Collection<ConfigAttribute> attributes = this.obtainSecurityMetadataSource()
    			.getAttributes(object);
    
    	。。。。。。。。。。。。。。。。。。。。。。。。。。
        // SecurityContextHolder.getContext().getAuthentication()一定不会为空 应为有匿名验证拦截器 AnonymousAuthenticationFilter
    	if (SecurityContextHolder.getContext().getAuthentication() == null) {
    		credentialsNotFound(messages.getMessage(
    				"AbstractSecurityInterceptor.authenticationNotFound",
    				"An Authentication object was not found in the SecurityContext"),
    				object, attributes);
    	}
        //获取认证信息 AbstractSecurityInterceptor authenticateIfRequired()
    	Authentication authenticated = authenticateIfRequired();
    
    	// Attempt authorization
    	try {
    	   //authenticated 认证拦截器 
    	   //object请求的信息 如请求路径 
    	   //attributes 认证权限标识：authenticed,permitAll
    	   //decide 决定是否可以通过 有三种实现方式
    	   //AffirmativeBased（默认的 只要有一个投票器没有投过，则都不通过）  ConsensusBased（更具没有通过的权限和通过的权限的比数取最大的一方）
            //UnanimousBased
    		//投票器 在Spring3以后只有一个投票器 
    		this.accessDecisionManager.decide(authenticated, object, attributes);
    	}
    	。。。。。。。。。。。。。。。。。。。。。。。。
    	// Attempt to run as a different user
    	Authentication runAs = this.runAsManager.buildRunAs(authenticated, object,
    			attributes);
        。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
    }
    //DefaultFilterInvocationSecurityMetadataSource
    public Collection<ConfigAttribute> getAttributes(Object object) {
    		final HttpServletRequest request = ((FilterInvocation) object).getRequest();
    		//RequestMatcher 封装了在项目中定义的配置信息
    		//config.antMatchers("/session/invalid").permitAll().anyRequest().authenticated()；
    	for (Map.Entry<RequestMatcher, Collection<ConfigAttribute>> entry : requestMap
    			.entrySet()) {
    		if (entry.getKey().matches(request)) {
    			return entry.getValue();
    		}
    	}
    	return null;
    }
    // AbstractSecurityInterceptor
    private Authentication authenticateIfRequired() {
       //获取用户设置的权限信息
       //new SocialUser(userId, password,true, true, true, true,AuthorityUtils.commaSeparatedStringToAuthorityList("ROLE_USER"));
    	Authentication authentication = SecurityContextHolder.getContext()
    			.getAuthentication();
    
    	if (authentication.isAuthenticated() && !alwaysReauthenticate) {
    		。。。。。。。。。。。。。。。。。。。。。
    		return authentication;
    	}
    
    	authentication = authenticationManager.authenticate(authentication);
    
    	。。。。。。。。。。。。。。。。。。。。。
    	SecurityContextHolder.getContext().setAuthentication(authentication);
    
    	return authentication;
    }
    //投票决定
    public void decide(Authentication authentication, Object object,
    			Collection<ConfigAttribute> configAttributes) throws AccessDeniedException {
    	int deny = 0;
       //AccessDecisionVoter 投票器  在Spring3以后只有一个投票器 WebExpressionVoter spring表达式投票器
    	for (AccessDecisionVoter voter : getDecisionVoters()) {
    	   //表达式解析
    		int result = voter.vote(authentication, object, configAttributes);
    
    		if (logger.isDebugEnabled()) {
    			logger.debug("Voter: " + voter + ", returned: " + result);
    		}
    
    		switch (result) {
    		case AccessDecisionVoter.ACCESS_GRANTED:
    			return;
    
    		case AccessDecisionVoter.ACCESS_DENIED:
    			deny++;
    
    			break;
    
    		default:
    			break;
    		}
    	}
        //只要有一个拒绝 就立马抛出异常 ExceptionTranslationFilter拦截处理
    	if (deny > 0) {
    		throw new AccessDeniedException(messages.getMessage(
    				"AbstractAccessDecisionManager.accessDenied", "Access is denied"));
    	}
    
    	// To get this far, every AccessDecisionVoter abstained
    	checkAllowIfAllAbstainDecisions();
    }

案例：

在SpringSecurity权限配置中：整个权限都配置在

ExpressionUrlAuthorizationConfigurer<HttpSecurity>.ExpressionInterceptUrlRegistry

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU0OTU3OA_size_16_color_FFFFFF_t_70 1][]

这样我们可以自定义加入权限配置逻辑。

/**
     * 授权信息管理器
     *
     * 用于收集系统中所有 AuthorizeConfigProvider 并加载其配置
     */
    public interface AuthorizeConfigManager {
    
    	/**
    	 * @param config
    	 */
    	void config(ExpressionUrlAuthorizationConfigurer<HttpSecurity>.ExpressionInterceptUrlRegistry config);
    
    }

/**
     * 授权配置提供器，各个模块和业务系统可以通过实现此接口向系统添加授权配置。
     */
    public interface AuthorizeConfigProvider {
    
    	/**
    	 * @param config
    	 * @return 返回的boolean表示配置中是否有针对anyRequest的配置。在整个授权配置中，
    	 * 应该有且仅有一个针对anyRequest的配置，如果所有的实现都没有针对anyRequest的配置，
    	 * 系统会自动增加一个anyRequest().authenticated()的配置。如果有多个针对anyRequest
    	 * 的配置，则会抛出异常。
    	 */
    	boolean config(ExpressionUrlAuthorizationConfigurer<HttpSecurity>.ExpressionInterceptUrlRegistry config);
    
    }

**
     * 核心模块的授权配置提供器，安全模块涉及的url的授权配置在这里。
     */
    @Component
    @Order(Integer.MIN_VALUE)
    public class SpringAuthorizeConfigProvider implements AuthorizeConfigProvider {
    
    	@Autowired
    	private SecurityProperties securityProperties;
    
    	@Override
    	public boolean config(ExpressionUrlAuthorizationConfigurer<HttpSecurity>.ExpressionInterceptUrlRegistry config) {
    		//项目总不需要进行登陆的访问url配置
    		config.antMatchers(SecurityConstants.DEFAULT_UNAUTHENTICATION_URL,
    				SecurityConstants.DEFAULT_SIGN_IN_PROCESSING_URL_MOBILE,
    				SecurityConstants.DEFAULT_SIGN_IN_PROCESSING_URL_OPENID,
    				SecurityConstants.DEFAULT_VALIDATE_CODE_URL_PREFIX + "/*",
    				securityProperties.getBrowser().getSignInPage(),
    				securityProperties.getBrowser().getSignUpUrl(),
    				securityProperties.getBrowser().getSession().getSessionInvalidUrl(),
    				"/user/regist","/session/invalid").permitAll();
    
    		if (StringUtils.isNotBlank(securityProperties.getBrowser().getSignOutUrl())) {
    			config.antMatchers(securityProperties.getBrowser().getSignOutUrl()).permitAll();
    		}
    		return false;
    	}
    
    }

/**
     * 默认的授权配置管理器
     */
    @Component
    public class SpringAuthorizeConfigManager implements AuthorizeConfigManager {
    
        //将所有的AuthorizeConfigProvider实现类放置到集合中
    	@Autowired
    	private List<AuthorizeConfigProvider> authorizeConfigProviders;
    
    	/* (non-Javadoc)
    	 * @see AuthorizeConfigManager#config(org.springframework.security.config.annotation.web.configurers.ExpressionUrlAuthorizationConfigurer.ExpressionInterceptUrlRegistry)
    	 */
    	@Override
    	public void config(ExpressionUrlAuthorizationConfigurer<HttpSecurity>.ExpressionInterceptUrlRegistry config) {
    		boolean existAnyRequestConfig = false;
    		String existAnyRequestConfigName = null;
    
    		for (AuthorizeConfigProvider authorizeConfigProvider : authorizeConfigProviders) {
    			//通过currentIsAnyRequestConfig 权限判断 如果返回false则需要进行登陆，否则不需要
    			boolean currentIsAnyRequestConfig = authorizeConfigProvider.config(config);
    			if (existAnyRequestConfig && currentIsAnyRequestConfig) {
    				throw new RuntimeException("重复的anyRequest配置:" + existAnyRequestConfigName + ","
    						+ authorizeConfigProvider.getClass().getSimpleName());
    			} else if (currentIsAnyRequestConfig) {
    				existAnyRequestConfig = true;
    				existAnyRequestConfigName = authorizeConfigProvider.getClass().getSimpleName();
    			}
    		}
    
    		if(!existAnyRequestConfig){
    			//其他路径需要进行登陆才可以访问
    			config.anyRequest().authenticated();
    		}
    	}
    
    }

在不同的模块，使用的是不同的权限，这样只需要实现AuthorizeConfigProvider接口就行。

如浏览器：

/**
     * 浏览器环境默认的授权配置，对常见的静态资源，如js,css，图片等不验证身份
     */
    @Component
    @Order(Integer.MIN_VALUE)
    public class BrowserAuthorizeConfigProvider implements AuthorizeConfigProvider {
    
    	/* (non-Javadoc)
    	 * @see com.imooc.security.core.authorize.AuthorizeConfigProvider#config(org.springframework.security.config.annotation.web.configurers.ExpressionUrlAuthorizationConfigurer.ExpressionInterceptUrlRegistry)
    	 */
    	@Override
    	public boolean config(ExpressionUrlAuthorizationConfigurer<HttpSecurity>.ExpressionInterceptUrlRegistry config) {
    		config.antMatchers(HttpMethod.GET,
    			"/**/*.js",
    			"/**/*.css",
    			"/**/*.jpg",
    			"/**/*.png",
    			"/**/*.gif"
    				).permitAll();
    
    		return false;
    	}
    
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU0OTU3OA_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/2c3eccf71569470498c2514b4c947f75.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU0OTU3OA_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/29/576d4fd573ee4597abe2a5a039b6d9c1.png