SpringSecurity源码解析

最新推荐文章于 2024-04-15 16:55:44 发布
最新推荐文章于 2024-04-15 16:55:44 发布
阅读量462 收藏 3
点赞数 1
分类专栏： java 文章标签： servlet spring java spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zheyangyebuxingaaa/article/details/128605672
版权

SpringSecurity源码解析

SpringSecurity是独立于SpringMVC的，SpringSecurity是直接与Servlet容器整合在一起的。它通过Filter整合到Servlet中。本篇分如下几个方面介绍SpringSecurity：

  1. 通过DelegatingFilterProxy向应用注册BeanFilter
  2. 通过SecurityConfigurer配置SecurityFilterChain
  3. 常见认证和授权过程

1. 通过DelegatingFilterProxy注册过滤器链

在介绍DelegatingFilterProxy前，先回顾一下Servlet容器的FilterChain。下面是Servlet容器处理Http请求的流程：

在这里插入图片描述

Servlet容器的请求过程如下：

  • 浏览器发送HTTPServletRequest
  • 容器创建FilterChain（包含Filter和Servlet，在SpringMVC中这里的Servlet是DispatcherServlet）
  • HTTPServletRequest 依次经过 Filter 和 Servlet 处理。

下面就是FilterChain的工作代码示意：

public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) {
	// 在激活后续过滤器前做一些处理
    chain.doFilter(request, response); // 激活后续过滤器
    // 在激活后续过滤器后做一些处理
}

由于FilterChain中的Filter可以影响后续Filter，比如直接返回而不激活后续过滤器，又比如修改请求等，因此Filter的执行顺序很重要。

为了整合Spring和Servlet容器，Spring提供了DelegatingFilterProxy。它是一个Servlet容器的Filter；它的工作则是拦截请求到Spring Bean中，这样Spring容器中的Bean就无需注册成Servlet容器的Filter即可拦截请求。

下图是DelegatingFilterProxy整合到Servlet FilterChain中的示意图：

在这里插入图片描述

DelegatingFilterProxy拦截请求到Bean的工作示意代码如下：

public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) {
	// 获取 BeanFilter，例子中是 BeanFilter0
	Filter delegate = getFilterBean(someBeanName);
	// 代理工作到 BeanFilter
	delegate.doFilter(request, response);
}

DelegatingFilterProxy 是Spring提供的，如果你要自己整合Spring和Servlet容器，则需要自己注册DelegatingFilterProxy。但如果使用SpringWeb，则它已经帮我们注册好了，我们只需要实现Filter接口。（并且可以通过DelegatingFilterProxyRegistrationBean指定Filter对应的URL或servlet）

有了DelegatingFilterProxy之后，SpringSecurity就可以通过提供BeanFilter整合到Servlet容器的Filter了。SpringSecurity提供了一个叫FilterChainProxy的BeanFilter。FilterChainProxy的工作是将请求拦截到SecurityFilterChain中。而SecurityFilterChain中的一个个过滤器就是SpringSecurity用来进行认证和授权用的过滤器。

SpringSecurity提供的FilterChainProxy整合到DelegatingFilterProxy的示意图如下：

在这里插入图片描述

右边的SecurityFilterChain中的过滤器，即SpringSecurity实现功能的各种过滤器。

下面是SpringSecurity借助DelegatingFilterProxy注册FilterChainProxy的源码：（通过DelegatingFilterProxyRegistrationBean 来向 Servlet3.0+ 容器注册DelegatingFilterProxy）

public DelegatingFilterProxyRegistrationBean securityFilterChainRegistration(
		SecurityProperties securityProperties) {
   	// 通过 RegistrationBean 注册 DelegatingFilterProxy
   	// 这个 Proxy 对应的 FilterBean 名字为 DEFAULT_FILTER_NAME 常量
   	// DEFAULT_FILTER_NAME 常量的值为 springSecurityFilterChain
	DelegatingFilterProxyRegistrationBean registration = new DelegatingFilterProxyRegistrationBean(
			DEFAULT_FILTER_NAME);
	registration.setOrder(securityProperties.getFilter().getOrder());
	registration.setDispatcherTypes(getDispatcherTypes(securityProperties));
	return registration;
}

下面是上面被代理的 springSecurityFilterChain Bean 的定义，即SpringSecurity提供的默认SecurityFilterChain：

@Bean(name = AbstractSecurityWebApplicationInitializer.DEFAULT_FILTER_NAME)
public Filter springSecurityFilterChain() throws Exception {
    // SpringSecurity 的两种配置方式
    // 老版本使用 Adapter，新版本可以直接创建 SecurityFilterChain Bean
	boolean hasConfigurers = this.webSecurityConfigurers != null && !this.webSecurityConfigurers.isEmpty();
	boolean hasFilterChain = !this.securityFilterChains.isEmpty();
	Assert.state(!(hasConfigurers && hasFilterChain),
			"Found WebSecurityConfigurerAdapter as well as SecurityFilterChain. Please select just one.");
	if (!hasConfigurers && !hasFilterChain) {
		WebSecurityConfigurerAdapter adapter = this.objectObjectPostProcessor
				.postProcess(new WebSecurityConfigurerAdapter() {
				});
		this.webSecurity.apply(adapter);
	}
    // 新版使用这个过滤器链，它通过 bean 自动注入
	for (SecurityFilterChain securityFilterChain : this.securityFilterChains) {
		this.webSecurity.addSecurityFilterChainBuilder(() -> securityFilterChain);
		for (Filter filter : securityFilterChain.getFilters()) {
			if (filter instanceof FilterSecurityInterceptor) {
				this.webSecurity.securityInterceptor((FilterSecurityInterceptor) filter);
				break;
			}
		}
	}
	for (WebSecurityCustomizer customizer : this.webSecurityCustomizers) {
		customizer.customize(this.webSecurity);
	}
    // 最后通过 SecurityFilterChain 构造出一个名字为 springSecurityFilterChain 的 Filter 
    // 这个 Filter 最终会被 DelegatingFilterProxy 代理到 Servlet 容器中
	return this.webSecurity.build();
}

上面的this.webSecurity.build()方法最终会回到WebSecurity的performBuild()方法中，就是在这个方法构造了这个Filter具体如下：

protected Filter performBuild() throws Exception {
	Assert.state(!this.securityFilterChainBuilders.isEmpty(),
			() -> "At least one SecurityBuilder<? extends SecurityFilterChain> needs to be specified. "
					+ "Typically this is done by exposing a SecurityFilterChain bean. "
					+ "More advanced users can invoke " + WebSecurity.class.getSimpleName()
					+ ".addSecurityFilterChainBuilder directly");
	int chainSize = this.ignoredRequests.size() + this.securityFilterChainBuilders.size();
	List<SecurityFilterChain> securityFilterChains = new ArrayList<>(chainSize);
	List<RequestMatcherEntry<List<WebInvocationPrivilegeEvaluator>>> requestMatcherPrivilegeEvaluatorsEntries = new ArrayList<>();
   	// 添加一条由忽略url组成的 securityFilterChain
	for (RequestMatcher ignoredRequest : this.ignoredRequests) {
		WebSecurity.this.logger.warn("You are asking Spring Security to ignore " + ignoredRequest
				+ ". This is not recommended -- please use permitAll via HttpSecurity#authorizeHttpRequests instead.");
		SecurityFilterChain securityFilterChain = new DefaultSecurityFilterChain(ignoredRequest);
		securityFilterChains.add(securityFilterChain);
		requestMatcherPrivilegeEvaluatorsEntries
				.add(getRequestMatcherPrivilegeEvaluatorsEntry(securityFilterChain));
	}
   	// 1.添加自己配置的 SecurityFilterChain
   	// 2.即上面那段代码中自动注入的 SecurityFilterChain
	for (SecurityBuilder<? extends SecurityFilterChain> securityFilterChainBuilder : this.securityFilterChainBuilders) {
		SecurityFilterChain securityFilterChain = securityFilterChainBuilder.build();
		securityFilterChains.add(securityFilterChain);
		requestMatcherPrivilegeEvaluatorsEntries
				.add(getRequestMatcherPrivilegeEvaluatorsEntry(securityFilterChain));
	}
	if (this.privilegeEvaluator == null) {
		this.privilegeEvaluator = new RequestMatcherDelegatingWebInvocationPrivilegeEvaluator(
				requestMatcherPrivilegeEvaluatorsEntries);
	}
   	// 3.使用这多条链构造 FilterChainProxy (它就是一个Filter将会被DelegatingFilterProxy代理的)
	FilterChainProxy filterChainProxy = new FilterChainProxy(securityFilterChains);
	if (this.httpFirewall != null) {
		filterChainProxy.setFirewall(this.httpFirewall);
	}
	if (this.requestRejectedHandler != null) {
		filterChainProxy.setRequestRejectedHandler(this.requestRejectedHandler);
	}
	filterChainProxy.afterPropertiesSet();
	
	Filter result = filterChainProxy;
	if (this.debugEnabled) {
		this.logger.warn("\n\n" + "********************************************************************\n"
				+ "**********        Security debugging is enabled.       *************\n"
				+ "**********    This may include sensitive information.  *************\n"
				+ "**********      Do not use in a production system!     *************\n"
				+ "********************************************************************\n\n");
		result = new DebugFilter(filterChainProxy);
	}
	this.postBuildAction.run();
   	// 返回上面含有多条 SecurityFilterChain 的 FilterChainProxy
	return result;
}

这样Filter就借助DelegatingFilterProxy注册到Servlet容器中了。

2. 通过SecurityConfigurer配置过滤器链

从上面最后的代码的注释3可以看出来，SpringSecurity 的登录认证等操作都在 SecurityFilterProxy 的 SecurityFilterChain 中了。

下面是SpringSecurity默认提供的SecurityFilterChain

@Bean
@Order(SecurityProperties.BASIC_AUTH_ORDER)
SecurityFilterChain defaultSecurityFilterChain(HttpSecurity http) throws Exception {
    // 要求所有链接需要认证
	http.authorizeRequests().anyRequest().authenticated();
    // 启用表单登录
	http.formLogin();
	http.httpBasic();
    // 构造 SecurityFilterChain
	return http.build();
}

从上面代码可以看出SpringSecurity通过HttpSecurity的build()方法来构造SecurityFilterChain。它的build()方法先调用到doBuild()，然后最终调用到HttpSecurity的performBuild()方法，这两个方法如下：

@Override
protected final O doBuild() throws Exception {
	synchronized (this.configurers) {
		this.buildState = BuildState.INITIALIZING;
		beforeInit();
		init();
		this.buildState = BuildState.CONFIGURING;
		beforeConfigure();
		configure();
		this.buildState = BuildState.BUILDING;
		O result = performBuild();
		this.buildState = BuildState.BUILT;
		return result;
	}
}

这里面重要的configure()方法，它的代码如下：

private void configure() throws Exception {
	Collection<SecurityConfigurer<O, B>> configurers = getConfigurers();
	for (SecurityConfigurer<O, B> configurer : configurers) {
		configurer.configure((B) this);
	}
}

它所做的事情遍历调用 SecurityConfigurer 的configure()方法。而SecurityConfigure因为调用HttpSecurity的不同方法而配置了不同的SecurityConfigurer。比如上面http.formLogin()这个调用，就给HttpSecurity增加了一个FormLoginConfigurer如下所示：

public FormLoginConfigurer<HttpSecurity> formLogin() throws Exception {
	return getOrApply(new FormLoginConfigurer<>());
}

这个FormLoginConfigure的代码如下：

public final class FormLoginConfigurer<H extends HttpSecurityBuilder<H>> extends
		AbstractAuthenticationFilterConfigurer<H, FormLoginConfigurer<H>, UsernamePasswordAuthenticationFilter> {

	// 首先是构造函数默认创建了一个 UsernamePasswordAuthenticationFilter
	public FormLoginConfigurer() {
		super(new UsernamePasswordAuthenticationFilter(), null);
		usernameParameter("username");
		passwordParameter("password");
	}
    // ...
    // 然后是它的 configure 方法（这个方法在父类中）
    @Override
	public void configure(B http) throws Exception {
		PortMapper portMapper = http.getSharedObject(PortMapper.class);
		if (portMapper != null) {
			this.authenticationEntryPoint.setPortMapper(portMapper);
		}
		RequestCache requestCache = http.getSharedObject(RequestCache.class);
		if (requestCache != null) {
			this.defaultSuccessHandler.setRequestCache(requestCache);
		}
		this.authFilter.setAuthenticationManager(http.getSharedObject(AuthenticationManager.class));
		this.authFilter.setAuthenticationSuccessHandler(this.successHandler);
		this.authFilter.setAuthenticationFailureHandler(this.failureHandler);
		if (this.authenticationDetailsSource != null) {
			this.authFilter.setAuthenticationDetailsSource(this.authenticationDetailsSource);
		}
		SessionAuthenticationStrategy sessionAuthenticationStrategy = http
				.getSharedObject(SessionAuthenticationStrategy.class);
		if (sessionAuthenticationStrategy != null) {
			this.authFilter.setSessionAuthenticationStrategy(sessionAuthenticationStrategy);
		}
		RememberMeServices rememberMeServices = http.getSharedObject(RememberMeServices.class);
		if (rememberMeServices != null) {
			this.authFilter.setRememberMeServices(rememberMeServices);
		}
		SecurityContextConfigurer securityContextConfigurer = http.getConfigurer(SecurityContextConfigurer.class);
		if (securityContextConfigurer != null && securityContextConfigurer.isRequireExplicitSave()) {
			SecurityContextRepository securityContextRepository = securityContextConfigurer
					.getSecurityContextRepository();
			this.authFilter.setSecurityContextRepository(securityContextRepository);
		}
        // 重点是这里，前面都是配置那个 UsernamePasswordAuthenticationFilter
        // 这里将这个 Filter 添加到 HttpSecurity 的 filters 中
		F filter = postProcess(this.authFilter);
		http.addFilter(filter);
	}
}

最后，使用HttpSecurity的filters生成SecurityFilterChain，如下所示：

protected DefaultSecurityFilterChain performBuild() {
	ExpressionUrlAuthorizationConfigurer<?> expressionConfigurer = getConfigurer(
			ExpressionUrlAuthorizationConfigurer.class);
	AuthorizeHttpRequestsConfigurer<?> httpConfigurer = getConfigurer(AuthorizeHttpRequestsConfigurer.class);
	boolean oneConfigurerPresent = expressionConfigurer == null ^ httpConfigurer == null;
	Assert.state((expressionConfigurer == null && httpConfigurer == null) || oneConfigurerPresent,
				"authorizeHttpRequests cannot be used in conjunction with authorizeRequests. Please select just one.");
    // 1.主要代码在这里，排序 HttpSecurity 的 Filter
	this.filters.sort(OrderComparator.INSTANCE);
	List<Filter> sortedFilters = new ArrayList<>(this.filters.size());
	for (Filter filter : this.filters) {
		sortedFilters.add(((OrderedFilter) filter).filter);
	}
    // 2.用 filters 构造 SecurityFilterChain 返回
	return new DefaultSecurityFilterChain(this.requestMatcher, sortedFilters);
}

这样，一个 SecurityFilterChain 就构造好了。

3. 常见认证和授权流程

上面最后代码配置的 UsernamePasswordAuthenticationFilter 就是常用的认证和授权流程存在的地方。它的流程不复杂，所以都写在注释里面了。它的代码如下所示：

public class UsernamePasswordAuthenticationFilter extends AbstractAuthenticationProcessingFilter {

	// ... ...
    
    // 这个方法在父类，是过滤器执行的地方
    private void doFilter(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
			throws IOException, ServletException {
        // 1. 判断请求是否要求认证
		if (!requiresAuthentication(request, response)) {
			chain.doFilter(request, response);
			return;
		}
		try {
            // 2. attempAUthentication 是真正尝试认证的地方
			Authentication authenticationResult = attemptAuthentication(request, response);
			if (authenticationResult == null) {
				// return immediately as subclass has indicated that it hasn't completed
				return;
			}
			this.sessionStrategy.onAuthentication(authenticationResult, request, response);
			// 3. 认证成功处理
			if (this.continueChainBeforeSuccessfulAuthentication) {
				chain.doFilter(request, response);
			}
			successfulAuthentication(request, response, chain, authenticationResult);
		}
		catch (InternalAuthenticationServiceException failed) {
			this.logger.error("An internal error occurred while trying to authenticate the user.", failed);
            // 4. 认证失败处理
			unsuccessfulAuthentication(request, response, failed);
		}
		catch (AuthenticationException ex) {
			// Authentication failed
			unsuccessfulAuthentication(request, response, ex);
		}
	}
	
    // 2.真正实现认证的地方
	@Override
	public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response)
			throws AuthenticationException {
        // 2.1 不是POST请求直接失败
		if (this.postOnly && !request.getMethod().equals("POST")) {
			throw new AuthenticationServiceException("Authentication method not supported: " + request.getMethod());
		}
        // 2.2 获取请求用户名
		String username = obtainUsername(request);
		username = (username != null) ? username.trim() : "";
		// 2.3 获取请求密码
        String password = obtainPassword(request);
		password = (password != null) ? password : "";
		// 2.4 计算待认证token
        UsernamePasswordAuthenticationToken authRequest = UsernamePasswordAuthenticationToken.unauthenticated(username,
				password);
		// Allow subclasses to set the "details" property
		setDetails(request, authRequest);
        // 2.5 这里是真正校验用户名和密码
		return this.getAuthenticationManager().authenticate(authRequest);
	}

真正进行用户名和密码校验的地方在 this.getAuthenticationManager().authentication()这个方法中，这里的AuthenticationManager从上一节UsernamePasswordAuthenticationFilter配置中可以看出默认是AuthenticationManager是来自HttpSecurity中的，而HttpSecurity 中默认配置 ProviderManager （这个在构造HttpSecurity bean时默认初始化的）。

综上所示：真正校验用户名和密码的地方在 ProviderManager 中。其代码如下：

@Override
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;
	int currentPosition = 0;
	int size = this.providers.size();
	for (AuthenticationProvider provider : getProviders()) {
		if (!provider.supports(toTest)) {
			continue;
		}
		if (logger.isTraceEnabled()) {
			logger.trace(LogMessage.format("Authenticating request with %s (%d/%d)",
					provider.getClass().getSimpleName(), ++currentPosition, size));
		}
		try {
            // 主要的认证地方就在这里，其他的都是验证成功或失败的一些处理
            // 主要的认证地方就在这里，其他的都是验证成功或失败的一些处理
            // 主要的认证地方就在这里，其他的都是验证成功或失败的一些处理
			result = provider.authenticate(authentication);
			if (result != null) {
				copyDetails(authentication, result);
				break;
			}
		}
		catch (AccountStatusException | InternalAuthenticationServiceException ex) {
			prepareException(ex, authentication);
			// SEC-546: Avoid polling additional providers if auth failure is due to
			// invalid account status
			throw ex;
		}
		catch (AuthenticationException ex) {
			lastException = ex;
		}
	}
	if (result == null && this.parent != null) {
		// Allow the parent to try.
		try {
			parentResult = this.parent.authenticate(authentication);
			result = parentResult;
		}
		catch (ProviderNotFoundException ex) {
			// ignore as we will throw below if no other exception occurred prior to
			// calling parent and the parent
			// may throw ProviderNotFound even though a provider in the child already
			// handled the request
		}
		catch (AuthenticationException ex) {
			parentException = ex;
			lastException = ex;
		}
	}
	if (result != null) {
		if (this.eraseCredentialsAfterAuthentication && (result instanceof CredentialsContainer)) {
			// Authentication is complete. Remove credentials and other secret data
			// from authentication
			((CredentialsContainer) result).eraseCredentials();
		}
		// If the parent AuthenticationManager was attempted and successful then it
		// will publish an AuthenticationSuccessEvent
		// This check prevents a duplicate AuthenticationSuccessEvent if the parent
		// AuthenticationManager already published it
		if (parentResult == null) {
			this.eventPublisher.publishAuthenticationSuccess(result);
		}

		return result;
	}

	// Parent was null, or didn't authenticate (or throw an exception).
	if (lastException == null) {
		lastException = new ProviderNotFoundException(this.messages.getMessage("ProviderManager.providerNotFound",
				new Object[] { toTest.getName() }, "No AuthenticationProvider found for {0}"));
	}
	// If the parent AuthenticationManager was attempted and failed then it will
	// publish an AbstractAuthenticationFailureEvent
	// This check prevents a duplicate AbstractAuthenticationFailureEvent if the
	// parent AuthenticationManager already published it
	if (parentException == null) {
		prepareException(lastException, authentication);
	}
	throw lastException;
}

默认情况下，在InitializeUserDetailsBeanManagerConfigurer类中配置了Provider，它默认使用DaoAuthenticationProvider 来完成认证，其代码如下：

// 这个方法在父类中
@Override
public Authentication authenticate(Authentication authentication) throws AuthenticationException {
	Assert.isInstanceOf(UsernamePasswordAuthenticationToken.class, authentication,
			() -> this.messages.getMessage("AbstractUserDetailsAuthenticationProvider.onlySupports",
					"Only UsernamePasswordAuthenticationToken is supported"));
    // 1. 获取待验证用户名
	String username = determineUsername(authentication);
	boolean cacheWasUsed = true;
	UserDetails user = this.userCache.getUserFromCache(username);
	if (user == null) {
		cacheWasUsed = false;
		try {
            // 2. 获取用户信息
			user = retrieveUser(username, (UsernamePasswordAuthenticationToken) authentication);
		}
		catch (UsernameNotFoundException ex) {
			this.logger.debug("Failed to find user '" + username + "'");
			if (!this.hideUserNotFoundExceptions) {
				throw ex;
			}
			throw new BadCredentialsException(this.messages
					.getMessage("AbstractUserDetailsAuthenticationProvider.badCredentials", "Bad credentials"));
		}
		Assert.notNull(user, "retrieveUser returned null - a violation of the interface contract");
	}
	try {
		this.preAuthenticationChecks.check(user);
        // 3. 验证用户名和密码
		additionalAuthenticationChecks(user, (UsernamePasswordAuthenticationToken) authentication);
	}
	catch (AuthenticationException ex) {
		if (!cacheWasUsed) {
			throw ex;
		}
		// There was a problem, so try again after checking
		// we're using latest data (i.e. not from the cache)
		cacheWasUsed = false;
        // 4. 若验证出错，则从数据源重新获取用户信息进行认证，以免缓存失效。
		user = retrieveUser(username, (UsernamePasswordAuthenticationToken) authentication);
		this.preAuthenticationChecks.check(user);
		additionalAuthenticationChecks(user, (UsernamePasswordAuthenticationToken) authentication);
	}
	this.postAuthenticationChecks.check(user);
	if (!cacheWasUsed) {
		this.userCache.putUserInCache(user);
	}
	Object principalToReturn = user;
	if (this.forcePrincipalAsString) {
		principalToReturn = user.getUsername();
	}
	return createSuccessAuthentication(principalToReturn, authentication, user);
}

// 3. DaoAuthenticationProvider 真正校验用户名和密码的地方
protected void additionalAuthenticationChecks(UserDetails userDetails,
		UsernamePasswordAuthenticationToken authentication) throws AuthenticationException {
	if (authentication.getCredentials() == null) {
		this.logger.debug("Failed to authenticate since no credentials provided");
		throw new BadCredentialsException(this.messages
				.getMessage("AbstractUserDetailsAuthenticationProvider.badCredentials", "Bad credentials"));
	}
    // 3.1 获取请求中的密码
	String presentedPassword = authentication.getCredentials().toString();
    // 3.2 验证和后端保存的密码一致
	if (!this.passwordEncoder.matches(presentedPassword, userDetails.getPassword())) {
		this.logger.debug("Failed to authenticate since password does not match stored value");
		throw new BadCredentialsException(this.messages
				.getMessage("AbstractUserDetailsAuthenticationProvider.badCredentials", "Bad credentials"));
	}
}

这样用户身份认证就完成了。用户的授权过程类似，这里就不展开了。

zheyangyebuxingaaa
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【第二篇】SpringSecurity源码详解
筱白爱学习！的博客
06-06 835
SpringSecurity中的核心组件
DelegatingFilterProxy的作用与用法
u014191624的博客
05-07 2215
一、类结构 　　DelegatingFilterProxy类存在与spring-web包中，其作用就是一个filter的代理，用这个类的好处是可以通过spring容器来管理filter的生命周期，还有就是，可以通过spring注入的形式，来代理一个filter执行，如shiro，下面会说到；有上图我们可以看到，DelegatingFilterProxy类继承GenericFilterBean，间接实现了Filter这个接口，故而该类属于一个过滤器。那么就会有实现Filter中init、doFil...
Spring Security源码剖析从入门到精通.跟学尚硅谷
星哲最开心
05-29 1483
Spring Security源码剖析从入门到精通.跟学尚硅谷
SpringSecurity源码分析（一） SpringBoot集成SpringSecurity即Spring安全框架的加载过程
xl649138628的专栏
02-19 1370
SpringSecurity源码学习，本文主要讲述Spring安全框架的加载过程
Spring Security源码
moernagedian的博客
03-17 542
WebSecurityConfigurerAdapter已废弃，官方推荐使用HttpSecurity 或WebSecurity。new DebugFilter(filterChainProxy)对filterChainProxy进行装饰。可以通过@EnableWebSecurity(debug = true)开启debug模式。都继承了SecurityBuilder。
过滤器Filter
qq_41184981的博客
09-09 197
过滤器Filter 一、Filer简介 ​ Filter过滤是作用于客户端和服务端资源文件（servlet、jsp、html等）之间的一道过滤网，可以对不符合规则的客户端请求和服务端响应进行拦截和修改。 二、应用场景 过滤器一般用于登录权限验证、资源访问权限控制、敏感词汇过滤、字符编码转换等等操作，便于代码重用，不必每个servlet中还要进行相应的操作。 三、执行流程 过滤链代码执行流程如上图：客户端从浏览器发起请求，request先进入第一个Filter进行过滤，符合条件则进入下一个Filter进行
SpringSecurity源码
05-29
在学习SpringSecurity源码时，建议从以下几个方面入手： 1. **源码结构分析**：了解主要组件的类结构和它们之间的关系，如`Authentication`、`Authorization`、`FilterChainProxy`等。 2. **关键类的实现**：深入...
spring security 源码
05-28
本篇文章将深入探讨Spring Security的核心概念和源码分析。 1. **核心组件** - `SecurityContextHolder`: 它是Spring Security的核心，存储当前请求的安全上下文，包含认证信息和权限。 - `Authentication`: 表示...
SpringSecurity学习总结源代码
09-19
SpringSecurity是Java开发中用于构建安全Web应用的框架，它提供了强大的身份验证、授权和访问控制功能。在本文中，我们将深入探讨SpringSecurity的核心概念、关键组件以及如何配置和使用这个框架。 首先，Spring...
浅析Spring Security登录验证流程
08-25
Spring Security登录验证流程是Spring Security框架中最核心的部分之一，本文将详细介绍Spring Security登录验证流程的源码解析，通过源码讲解登录验证流程，具有很高的参考价值。 一、登录认证基于过滤器链 ...
spring-security-oauth2源码
06-30
Spring Security OAuth2 是一个强大的框架，用于为Java应用提供OAuth2和OpenID Connect...通过阅读和分析`spring-security-oauth-master`中的源码，可以更深入地了解其实现细节，有助于在实际项目中灵活运用和定制。
Spring Security 源码分析
snkkka163的博客
07-26 395
Spring Security 源码分析 1.Spring Security基本执行流程分析: 现在假设我们要发送一个新的请求给我们的项目，默认我们的项目已经配置了Spring Security 这个请求会先进入 1.UsernamePasswordAuthenticationFilter: 验证我们的请求中是否有这个过滤器所需要的信息，比如说账号密码 如果说带了账号密码，那将会尝试使用这些参数进行登录，如果没有带这个过滤器所需要的参数，那就往下走，进入BasicAuthenticationFilter
Spring Security源码解析
ThisLX的博客
11-01 405
1、SecurityContextPersistenceFilter: SecurityContextPersistenceFilter有两个主要任务: 在请求到达时处理之前，从SecurityContextRepository中获取安全上下文信息填充到SecurityContextHolder; 在请求处理结束后返回响应时，将SecurityContextHolder中的安全上下文信息保存回S...
SpringSecurity源码分析3--UserDetail部分
最新发布
moernagedian的博客
04-15 451
一个允许子类重写和处理UserDetails对象的基AuthenticationProvider。该类旨在响应UsernamePasswordAuthenticationToken身份验证请求。通过预先编码这个密码，可以确保在后续的时间攻击防护方法中，不会因为实时编码操作而导致时间差异，这些时间差异可能会被攻击者用来推断密码或其他敏感信息。默认都是null，可以通过setUserCache设置Cache。从缓存中获取UserDetail对象。加密方法升级后，重新更新密码。默认页面，生产不会使用。
SpringBoot Security安全认证框架初始化流程&amp；认证流程之源码分析_spring boot 接口权限认证 接口鉴权 源码
m0_60707685的博客
04-08 537
自定义安全配置类继承WebSecurityConfigurerAdapter，以对象名为authenticationManager的bean将AuthenticationManager对象注入到Spring容器中《authenticationManager的bean对象注入流程源码分析图》1、以@Bean的方式将AuthenticationManager的Bean以Id="authenticationManager"注入到Spring容器中；
SpringMVC - DelegatingFilterProxy的作用与SpringBoot环境中的用法 （【解决】shiro配置Filters时，为什么要配置代理？）
LawssssCat的博客
03-22 1131
https://www.cnblogs.com/zhanhaitao/p/7857245.html 初衷 DelegatingFilterProxy 就是一个对于servlet filter的代理 用这个类的好处主要是通过Spring容器来管理servlet filter的生命周期 还有就是如果filter中需要一些Spring容器的实例，可以通过spring直接注入 另外读取一些配置文件这些便...
Spring Boot：一文搞懂 Spring Security 是如何工作的？
Java技术攻略的博客
03-02 313
Nullable@Nullable这里的 delegate 就是前面架构图中的 Bean Filter0。那 Spring 为什么要设计这样一层代理呢？从前面的分析过程中我们知道，向 ServletContext 中注册 Filter 的时间发生的其实非常早，甚至这个时候 ApplicationContext 都还没有实例化完毕，更别说其中的 Filter Bean了。
SpringSecurity: 不能混用authorizeRequests和6.0里的authorizeHttpReuests
amadeus_liu2的博客
03-04 620
security
Spring Security 源码浅析
烈冬冰夏的博客
05-30 547
1.核心组件 1.1.SecurityContextHolder   SecurityContextHolder用于存储安全上下文（security context）的信息。当前操作的用户是谁，该用户是否已经被认证，他拥有哪些角色权限…这些都被保存在SecurityContextHolder中。SecurityContextHolder默认使用ThreadLocal 策略来存储认证信息。看到T...
springsecurity源码解析
09-15
Spring Security 是一个功能强大且广泛使用的安全框架，用于保护 Java 应用程序的身份验证和授权。...建议在阅读源码之前，先对 Spring Security 的基本概念和使用方法有一定的了解，这样会更有助于理解源码中的内容。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值