Spring-Security（一）-源码分析及认证流程

已于 2024-06-06 22:14:26 修改
阅读量921 收藏 19
点赞数 25
分类专栏： spring cloud spring 探析 架构 文章标签： spring java 后端
于 2024-06-06 21:35:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lbmydream/article/details/139510466
版权

Spring Security & Oauth2系列：
 
Spring Security（一） 源码分析及认证流程
Spring Security（二）OAuth2认证详解及自定义异常处理

文章目录

1、Spring Security 概述

Spring Security 是能够为Spring 企业应用提供声明式的安全访问控制解决方案的安全框架，为应用系统提供声明式的安全访问控制功能，减少为企业系统安全访问控制编写大量重复的代码。
文章基于Spring Boot 2.3.6 + Oauth 2.0

1.1 Spring Security项目核心模块

spring-security
├── 核心 - spring-security-core.jar
├── Remoting - spring-security-remoting.jar
├── Web - spring-security-web.jar
├── 配置 - spring-security-config.jar
├── LDAP - spring-security-ldap.jar
├── OAuth 2.0核心 - spring-security-oauth2-core.jar
├── OAuth 2.0客户端 - spring-security-oauth2-client.jar
├── OAuth 2.0 JOSE - spring-security-oauth2-jose.jar
├── ACL - spring-security-acl.jar
├── CAS - spring-security-cas.jar
├── OpenID - spring-security-openid.jar
└── 测试 - spring-security-test.jar

核心详细描述参考中文官网

1.2 Spring Security 简单集成

Spring Security 支持Maven和Gradle集成，本文主要使用Spring Boot与Maven：
pom.xml

<dependencies>
    <!-- ... other dependency elements ... -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-security</artifactId>
    </dependency>
</dependencies>

1.2.1 使用Security安全功能

  • 增加配置类，使用注解@EnableWebSecurity开启Web安全功能
  • 实现了接口WebSecurityConfigurer或者继承自WebSecurityConfigurerAdapter)，增加Security安全配置。

代码清单：

@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

  @Override
  protected void configure(HttpSecurity http) throws Exception {
    http
        .authorizeRequests((authorize) -> authorize
            .antMatchers("/css/**", "/index").permitAll()
            .antMatchers("/user/**").hasRole("USER")
        )
        .formLogin((formLogin) -> formLogin
            .loginPage("/login")
            .failureUrl("/login-error")
        );
  }
  @Bean
  public UserDetailsService userDetailsService() {
    UserDetails userDetails = User.withDefaultPasswordEncoder()
        .username("user")
        .password("password")
        .roles("USER")
        .build();
    return new InMemoryUserDetailsManager(userDetails);
  }
}

当添加了SecurityConfig 之后我们的应用就具备如下功能：

2、源码分析-Security安全认证实现

2.1 Security安全认证过程类图

类图

2.2 Security安全认证自动化配置

2.2.1 @EnableWebSecurity

从类关系图可以清楚**@EnableWebSecurity**注解是开启Security安全功能的核心注解，EnableWebSecurity源码清单：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import({ WebSecurityConfiguration.class, SpringWebMvcImportSelector.class, OAuth2ImportSelector.class,
		HttpSecurityConfiguration.class })
@EnableGlobalAuthentication
@Configuration
public @interface EnableWebSecurity {

	/**
	 * Controls debugging support for Spring Security. Default is false.
	 * @return if true, enables debug support with Spring Security
	 */
	boolean debug() default false;

}

@EnableWebSecurity是组合注解，引入了Impost注解包含的外部配置以及激活了@EnableGlobalAuthentication注解，而@EnableGlobalAuthentication注解激活了AuthenticationConfiguration认证配置类。

2.2.2 WebSecurityConfiguration

WebSecurityConfiguration 是web安全配置核心类，WebSecurityConfiguration最主要的功能就是创建了springSecurityFilterChain Bean，springSecurityFilterChain 是spring security的核心过滤器，是整个认证的入口。WebSecurityConfiguration中完成了声明springSecurityFilterChain的作用，并且最终交给DelegatingFilterProxy这个代理类，负责拦截请求（注意DelegatingFilterProxy这个类不是spring security包中的，而是存在于web包中，spring使用了代理模式来实现安全过滤的解耦）。WebSecurityConfiguration源码清单：

@Configuration(proxyBeanMethods = false)
public class WebSecurityConfiguration implements ImportAware, BeanClassLoaderAware {
//省略==========================================
	@Bean(name = AbstractSecurityWebApplicationInitializer.DEFAULT_FILTER_NAME)
	public Filter springSecurityFilterChain() throws Exception {
		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);
		}
		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);
		}
		return this.webSecurity.build();
	}

	//省略=====================

}

2.2.3 SpringWebMvcImportSelector

SpringWebMvcImportSelector主要作用是判断当前的环境是否包含springmvc，因为spring security可以在非spring环境下使用，为了避免DispatcherServlet的重复配置，所以使用了这个注解来区分。

2.2.4 OAuth2ImportSelector

OAuth2ImportSelector类是为了对 OAuth2.0 开放授权协议进行支持。ClientRegistration 如果被引用，具体点也就是 spring-security-oauth2 模块被启用（引入依赖jar）时。会启用 OAuth2 客户端配置 OAuth2ClientConfiguration

2.2.5 HttpSecurityConfiguration

HttpSecurityConfiguration配置类首先通过@Autowired去获取容器中的一个AuthenticationManager实例，如果没能获取到则使用依赖注入的AuthenticationConfiguration实例创建一个AuthenticationManager实例，这个实例其实就是ProviderManager。然后初始化httpSecurity。

2.2.5.1 HttpSecurity

通过HttpSecurity配置指明了Web Security 拦截什么URL、登录认证方式、设置什么权限等。

2.2.6 AuthenticationConfiguration

AuthenticationConfiguration 主要作用就是创建全局的身份认证管理者AuthenticationManager，AuthenticationManager便是最核心的身份认证管理器。
AuthenticationConfiguration源码清单：

@Configuration(proxyBeanMethods = false)
@Import(ObjectPostProcessorConfiguration.class)
public class AuthenticationConfiguration {

	//省略================

	@Bean
	public AuthenticationManagerBuilder authenticationManagerBuilder(ObjectPostProcessor<Object> objectPostProcessor,
			ApplicationContext context) {
		LazyPasswordEncoder defaultPasswordEncoder = new LazyPasswordEncoder(context);
		AuthenticationEventPublisher authenticationEventPublisher = getBeanOrNull(context,
				AuthenticationEventPublisher.class);
		DefaultPasswordEncoderAuthenticationManagerBuilder result = new DefaultPasswordEncoderAuthenticationManagerBuilder(
				objectPostProcessor, defaultPasswordEncoder);
		if (authenticationEventPublisher != null) {
			result.authenticationEventPublisher(authenticationEventPublisher);
		}
		return result;
	}

	@Bean
	public static GlobalAuthenticationConfigurerAdapter enableGlobalAuthenticationAutowiredConfigurer(
			ApplicationContext context) {
		return new EnableGlobalAuthenticationAutowiredConfigurer(context);
	}

	@Bean
	public static InitializeUserDetailsBeanManagerConfigurer initializeUserDetailsBeanManagerConfigurer(
			ApplicationContext context) {
		return new InitializeUserDetailsBeanManagerConfigurer(context);
	}

	@Bean
	public static InitializeAuthenticationProviderBeanManagerConfigurer initializeAuthenticationProviderBeanManagerConfigurer(
			ApplicationContext context) {
		return new InitializeAuthenticationProviderBeanManagerConfigurer(context);
	}

	public AuthenticationManager getAuthenticationManager() throws Exception {
		if (this.authenticationManagerInitialized) {
			return this.authenticationManager;
		}
		AuthenticationManagerBuilder authBuilder = this.applicationContext.getBean(AuthenticationManagerBuilder.class);
		if (this.buildingAuthenticationManager.getAndSet(true)) {
			return new AuthenticationManagerDelegator(authBuilder);
		}
		for (GlobalAuthenticationConfigurerAdapter config : this.globalAuthConfigurers) {
			authBuilder.apply(config);
		}
		this.authenticationManager = authBuilder.build();
		if (this.authenticationManager == null) {
			this.authenticationManager = getAuthenticationManagerBean();
		}
		this.authenticationManagerInitialized = true;
		return this.authenticationManager;
	}

//省略================

	private AuthenticationManager getAuthenticationManagerBean() {
		return lazyBean(AuthenticationManager.class);
	}

2.3 验证逻辑

2.3.1 AuthenticationManager

AuthenticationManager 提供了认证的入口，源码清单:

public interface AuthenticationManager {
	Authentication authenticate(Authentication authentication) throws AuthenticationException;
}

AuthenticationManager 接收 Authentication 对象作为参数，并通过 authenticate(Authentication) 方法对其进行验证；AuthenticationProvider实现类用来支撑对 Authentication 对象的验证动作；UsernamePasswordAuthenticationToken实现了 Authentication主要是将用户输入的用户名和密码进行封装，并供给 AuthenticationManager 进行验证；验证完成以后将返回一个认证成功的 Authentication 对象；

2.3.2 Authentication

Authentication 源码：

public interface Authentication extends Principal, Serializable {

	//#1.权限集合
	Collection<? extends GrantedAuthority> getAuthorities();
	//#2. 用户密码认证时，可以理解为密码
    Object getCredentials();
     //#3. 认证时包含的信息
	Object getDetails();
    //# 4. 用户密码认证时，可以理解为用户名
	Object getPrincipal();
    //# 5. 是否被认证，认证为true
	boolean isAuthenticated();
    //# 6. 设置是否能够被认证
	void setAuthenticated(boolean isAuthenticated) throws IllegalArgumentException;
}

2.3.3 ProviderManager

ProviderManager 它是 AuthenticationManager 的一个实现类，提供了基本的认证逻辑和方法；它包含了一个 List 对象，通过 AuthenticationProvider 接口来扩展出不同的认证提供者(当Spring Security默认提供的实现类不能满足需求的时候可以扩展AuthenticationProvider 覆盖supports(Class<?> authentication) 方法)；

@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();
                //遍历所有providers，调用supports验证是否支持当前认证
		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 {
               //调用provider的认证方法进行认证
				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;
	}

2.3.3 AuthenticationProvider

AuthenticationProvider， ProviderManager通过AuthenticationProvider扩展多种认证方法，AuthenticationProvider 本身也就是一个接口，从类图中我们可以看出它的实现类AbstractUserDetailsAuthenticationProvider 和AbstractUserDetailsAuthenticationProvider的子类DaoAuthenticationProvider 。

2.3.4 DaoAuthenticationProvider

DaoAuthenticationProvider 是Spring Security中一个核心的Provider,对所有的数据库提供了基本方法和入口。DaoAuthenticationProvider源码清单：

public class DaoAuthenticationProvider extends AbstractUserDetailsAuthenticationProvider {

	/**
	 * 实现用户密码加密，这里我们定义了全局的bean，
	 * 主要是为了保证用户中心和认证中心的密码加密算法一致
	 */
	private PasswordEncoder passwordEncoder;

	//省略

	/**
	 *
	 * 实现 additionalAuthenticationChecks 的验证方法(主要验证密码)；
	 */
	@Override
	@SuppressWarnings("deprecation")
	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"));
		}
		String presentedPassword = authentication.getCredentials().toString();
		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"));
		}
	}

//省略

	/**
	 * 实现了 AbstractUserDetailsAuthenticationProvider retrieveUser 抽象方法
	 * 主要是通过注入UserDetailsService接口对象，并调用其接口方法 loadUserByUsername(String username)获取得到相关的用户信息。
	 * UserDetailsService接口非常重要。
	 */
	@Override
	protected final UserDetails retrieveUser(String username, UsernamePasswordAuthenticationToken authentication)
			throws AuthenticationException {
		prepareTimingAttackProtection();
		try {
			//数据库获取用户信息的扩展点
			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);
		}
	}

	//省略
}

2.3.4 AbstractUserDetailsAuthenticationProvider

AbstractUserDetailsAuthenticationProvider主要实现了AuthenticationProvider的接口方法 authenticate 并提供了相关的验证逻辑；

    1. 抽象获取用户信息方法
protected abstract UserDetails retrieveUser(String username, UsernamePasswordAuthenticationToken authentication)
			throws AuthenticationException;
    1. 三步验证工作：
      i. preAuthenticationChecks
      ii. additionalAuthenticationChecks（抽象方法，子类实现）
      iii. postAuthenticationChecks
    1. 将验证结果封装成UsernamePasswordAuthenticationToken返回。

源码清单：

public abstract class AbstractUserDetailsAuthenticationProvider
		implements AuthenticationProvider, InitializingBean, MessageSourceAware {
//省略
	//抽象验证方法(主要验证密码)
	protected abstract void additionalAuthenticationChecks(UserDetails userDetails,
			UsernamePasswordAuthenticationToken authentication) throws AuthenticationException;

//省略

	/**
	 *
	 * 实现AuthenticationProvider.authenticate验证方法
	 */
	@Override
	public Authentication authenticate(Authentication authentication) throws AuthenticationException {
		Assert.isInstanceOf(UsernamePasswordAuthenticationToken.class, authentication,
				() -> this.messages.getMessage("AbstractUserDetailsAuthenticationProvider.onlySupports",
						"Only UsernamePasswordAuthenticationToken is supported"));
		String username = determineUsername(authentication);
		boolean cacheWasUsed = true;
		UserDetails user = this.userCache.getUserFromCache(username);
		if (user == null) {
			cacheWasUsed = false;
			try {
				//1. 获取用户信息
				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 {
			//2. 预检查由DefaultPreAuthenticationChecks类实现（主要判断当前用户是否锁定，过期，冻结User接口）
			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;
			user = retrieveUser(username, (UsernamePasswordAuthenticationToken) authentication);
			this.preAuthenticationChecks.check(user);
			additionalAuthenticationChecks(user, (UsernamePasswordAuthenticationToken) authentication);
		}
		//#4.检测用户密码是否过期对应#2 的User接口
		this.postAuthenticationChecks.check(user);
		if (!cacheWasUsed) {
			this.userCache.putUserInCache(user);
		}
		Object principalToReturn = user;
		if (this.forcePrincipalAsString) {
			principalToReturn = user.getUsername();
		}
		//5. 将验证结果封装成UsernamePasswordAuthenticationToken
		return createSuccessAuthentication(principalToReturn, authentication, user);
	}

	private String determineUsername(Authentication authentication) {
		return (authentication.getPrincipal() == null) ? "NONE_PROVIDED" : authentication.getName();
	}

	//封装验证结果
	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(), this.authoritiesMapper.mapAuthorities(user.getAuthorities()));
		result.setDetails(authentication.getDetails());
		this.logger.debug("Authenticated user");
		return result;
	}

	//抽象获取用户信息接口
	protected abstract UserDetails retrieveUser(String username, UsernamePasswordAuthenticationToken authentication)
			throws AuthenticationException;

	//省略

}

2.3.4 UserDetailsService

UserDetailsService接口作为桥梁，是DaoAuthenticationProvier与特定用户信息来源进行解耦的地方，UserDetailsService由UserDetails和UserDetailsManager所构成；UserDetails和UserDetailsManager各司其责，一个是对基本用户信息进行封装，一个是对基本用户信息进行管理；特别注意，UserDetailsService、UserDetails以及UserDetailsManager都是可被用户自定义的扩展点，我们可以继承这些接口提供自己的读取用户来源和管理用户的方法，比如我们可以自己实现一个 与特定 ORM 框架，比如 Mybatis 或者 Hibernate，相关的UserDetailsService和UserDetailsManager；

2.3.4.1 UserDetailsService

UserDetails 验证用户实体

public interface UserDetails extends Serializable {
 #1.权限集合
 Collection<? extends GrantedAuthority> getAuthorities();
 #2.密码	
 String getPassword();
 #3.用户民
 String getUsername();
 #4.用户是否过期
 boolean isAccountNonExpired();
 #5.是否锁定	
 boolean isAccountNonLocked();
 #6.用户密码是否过期	
 boolean isCredentialsNonExpired();
 #7.账号是否可用（可理解为是否删除）
 boolean isEnabled();
}

2.4 认证流程图

认证流程

lbmydream
关注
  • 25
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
springsecurity原理流程图.pdf
09-08
SpringSecurity框架的权限认证流程原理，请求到来时SpringSecurity如果调用层层过滤器来完成认证；
Spring security oauth源码
10-28
通过分析这些源码，我们可以深入理解OAuth的工作原理，以及Spring Security OAuth如何支持这些功能。同时，Sparklr2和Tonr2示例能帮助我们直观地看到OAuth流程的每个步骤，包括授权、令牌交换和资源访问。 在实际...
spring security 流程
qq_21959403的博客
06-22 287
本质： 就是责任链模式，通过一系列的过滤器来实现安全认证。 入口：org.springframework.security.web.FilterChainProxy.class 容器启动后 ，加载一系列的过滤器到 private List<SecurityFilterChain> filterChains; ps: 自定义过滤器通过下面加入 轮到该过滤器执行的时候： 调用私有方法doFilterInternal,里面创建FilterChainProx...
springsecurity工作流程
qq_39321234的博客
04-27 1892
3.如果请求未认证,Spring Security 会将用户重定向到登录页面。用户登录后,Spring Security 会将用户信息存储于 SecurityContext 中。1.当用户请求一个受保护的资源时,Spring Security 的过滤器链会拦截该请求。4.如果请求已认证但未授权,Spring Security 会返回 403 禁止访问响应。5.如果请求已认证且已授权,过滤链会放行请求,调用链继续正常执行。1.用户访问首页,不需要认证,可以正常访问。3.用户访问需要权限的页面,请求被拦截。
springsecurity流程图
Kirito的博客
04-02 321
Spring Security流程详解
lzh_2_4的博客
09-15 440
安全框架 认证 Authentication 俗称登录 401 认证失败 授权 Authorization 根据角色和权限，决定能够执行哪些操作 403 权限不足 认证的执行流程 由spring监听器根据spring-security.xml 创建spring-security的对象，并把它们交给spring容器管理 当一个请求过来，首先经过 Delegatin...
spring-security源码，直接引用这个压缩文件即可
08-28
在分析`spring-security 5.0`的源码时，我们可以深入理解其核心机制，帮助我们更好地使用和扩展该框架。 1. **模块结构**： Spring Security 5.0 的源码包含多个模块，如`core`、`config`、`web`等。`core`模块...
spring-security-3.1.x.zip 源码下载
11-28
- **过滤器链（Filter Chain）**：Spring Security的核心在于一系列的过滤器，它们按特定顺序拦截请求，处理认证和授权。 2. **主要组件**： - **AuthenticationProvider**：处理用户的认证请求，实现具体的认证...
spring-security-3.2.9和spring-framework-3.2.4的jar包和源码
11-22
Spring Security和Spring Framework是Java开发中的两个核心组件，它们在构建安全、可扩展的企业级应用程序中扮演着重要角色。这两个库都是Spring生态系统的一...同时，源码分析也是提升编程技巧和解决问题的有效途径。
spring-security-3.2.9的jar包和源码包
09-23
7. **源码分析**：源码包允许开发者深入研究Spring Security的实现细节，了解其内部的工作流程，这对于自定义扩展和调试是非常有价值的。例如，可以通过阅读`AuthenticationManager`和`UserDetailsService`的实现来...
SpringSecurity工作流程
Cavan_C的博客
07-02 736
工作原理 SpringSecurity过滤器链 SpringSecurity采用的是责任链的设计模式，它有一条很长的过滤器链。 SecurityContextPersistenceFilter会在请求开始时从配置好的SecurityContextRepository中获取SecurityContext，然后把它设置给SecurityContextHolder。在请求完成后将SecurityHolder持有的SecurityContext再保存到配置好的SecurityContextReposit
SpringSecurity 流程图
Claroja
03-25 1101
spring security认证流程
Love_Long的博客
12-02 215
基本流程示意图 spring boot security默认的登录流程如下所示，弄懂登陆的流程，有助于我们后面扩展框架，解决遇到的问题 UsernamePasswordAuthenticationFilter过滤器过滤请求 调用ProviderManager认证 获取了authenticationManager处理登录，AuthenticationManager接口...
Spring-Security(一）整体认证流程及其相关概念
姑苏
11-13 167
Spring security整体认知。
Spring Security认证流程分析
最新发布
qq_62646841的博客
04-27 1151
EnableWebSecurity //@EnableWebSecurity是开启SpringSecurity的默认行为@EnableGlobalMethodSecurity(prePostEnabled = true)//开启注解功能，默认禁用注解@Resource@Resource@Resource@Bean@Override@Override// 这是配置的关键，决定哪些接口开启防护，哪些接口绕过防护http//关闭csrf。
SpringSecurity详细执行流程
qq_52066082的博客
01-22 1372
SpringSecurity的执行流程超详细讲解，SpringSecurity两大功能认证、授权。
SpringSecurity的认证流程分析（各个组件之间的关联）
SunRains
11-22 4053
我一开始对于SpringSecurity也不是很熟悉，但是Security 作为一个Spring家族中的安全管理框架，而且每个项目都有授权、认证、鉴权等功能，所以很有必要对Spring Security了解清楚。在说明各个流程之前，找了一张关于它的架构，我只截取了其中关于认证这一部分的内容。 由上图可以清楚的看到在Security 认证的过程涉及到的对象，以及各个对象之间的关联。对于刚入门Java Web开发的时候，Filter作为JavaWeb的三大组件之一给我们留...
SpringSecurity框架流程
鹏儿的博客
07-28 153
7.使用自己的登录界面时,security框架的登录认证流程不会自动启动,需要我们在UserController处理login请求时手动开启,手动开启时需要用到认证管理器,在Security配置类中进行配置。3.在login.html登录界面中向/login地址发出登录请求时,服务器中UserController里面的login方法处理该请求。1.在SecurityConfig配置类中配置好白名单,设置登录界面,关闭跨域攻击防御策略。主要作用:帮助我们进行登录的认证,和项目中涉及到权限时进行管理操作。
springsecurity源码分析
03-16
Spring Security 是一个基于 Spring 框架的安全框架，它提供了一系列的安全服务，包括身份认证、授权、攻击防护等。Spring Security 的源码分析可以帮助我们深入了解其实现原理，从而更好地使用和定制 Spring Security。在源码分析过程中，我们可以学习到 Spring Security 的核心组件、流程和设计思想，以及如何扩展和定制 Spring Security。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值