Spring Security认证：获得认证、持久化认证模块详解

已于 2023-10-31 11:57:12 修改
阅读量412 收藏
点赞数
分类专栏： Spring Security框架学习 文章标签： spring java 数据库 Spring Security
于 2023-10-31 11:56:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lifetime_gear/article/details/134136996
版权

参考：认证 :: Spring Security Reference (springdoc.cn)

本文将讲述Spring Security中与认证相关的各个基本模块，力求对整个认证框架提供完善的认知。

众所周知，认证Authentication实际上就是一个代表身份的类，实例就是具体的身份，那么与这个身份有关的操作有哪些呢：

  1. 用户名/密码 认证：通过用户提供的用户名/密码信息构建一个认证实例用于校验；校验后提供用户一个认证代表用户的身份。
    1. 读取用户名/密码（从用户的请求中获得账号密码）
    2. 密码存储（获得数据库等空间中的用户信息，进行验证操作）
  2. 持久化认证：让用户未来的请求也能携带或使用当前的身份（认证实例）。
  3. 会话管理：管理用户的登录状态，比如限制同时可登录的数量、自己存储认证而不是让 Spring Security 负责。（自行了解：认证持久性和会话（Session）管理 :: Spring Security Reference (springdoc.cn)）
  4. 其他如remember me、预认证等（自行了解：认证 :: Spring Security Reference (springdoc.cn)）

一、获得认证

验证用户最常见的方法之一是验证用户名和密码。 Spring Security 为此进行验证提供了全面的支持。

1.1读取用户名和密码

之前的Spring Security：总体架构中，我们已经讲过，Spring Security是依赖于一个个过滤器实现所有功能模块的。读取用户名和密码，自然靠的也是过滤器。

1.1.1读取表单登录参数

Spring Security提供了对通过HTML表单提供用户名和密码的支持，并通过UsernamePasswordAuthenticationFilter类从用户请求中获得表单的属性。

先讲一下总体流程（可参考Spring Security：认证默认流程解析），然后讲一部分源码。

前置流程

  1. 一个用户向一个需要授权的资源发出一个未经认证的请求。
  2. AuthorizationFilter 在判断有无权限后抛出 AccessDeniedException 异常。
  3. 该异常被 ExceptionTranslationFilter 捕获，并判断当前用户认证为匿名认证（即未认证用户）后，调用 Start Authentication 函数，使用一个AuthenticationEntryPoint（默认为LoginUrlAuthenticationEntryPoint的实例）将请求重定向到登录页面。
  4. 浏览器请求登录页面。
  5. 后端渲染登录界面，并返回动态网页。
认证流程

  1. 用户提交他们的用户名和密码后，UsernamePasswordAuthenticationFilter 从请求中提取用户名和密码，并创建一个Authentication（UsernamePasswordAuthenticationToken的实例）。
  2. UsernamePasswordAuthenticationFilter 调用 AuthenticationManager（ProviderManager 的一个实例）对 Authentication 进行校验。
  3. 如果认证失败：
    1. 清除 SecurityContextHolder 中当前的 SecurityContext。
    2. 调用 RememberMeServices的loginFail 函数。
    3. 调用 AuthenticationFailureHandler 进行处理。
  4. 如果认证成功：
    1. SessionAuthenticationStrategy 被通知有新的登录。
    2. 将 Authentication 保存到 SecurityContextHolder 中当前的 SecurityContext。
    3. 调用 RememberMeServices 的 loginSuccess 函数。
    4. ApplicationEventPublisher 发布 InteractiveAuthenticationSuccessEvent 事件。
    5. AuthenticationSuccessHandler 被调用，通常这会重定向到原先 ExceptionTranslationFilter 中保存的原请求。
配置方式

在SecurityFilterChain中启用表单登录的最小配置：

public SecurityFilterChain filterChain(HttpSecurity http) {
    http
        .formLogin(withDefaults());
    // ...
}

在SecurityFilterChain中设置一个自定义的登录表单：用于更改重定向到的登录页面

public SecurityFilterChain filterChain(HttpSecurity http) {
    http
        .formLogin(form -> form
            .loginPage("/login")
            .permitAll()
        );
    // ...
}

然后在实现这个登录表单：文件位置为src/main/resources/templates/login.html

<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml" xmlns:th="https://www.thymeleaf.org">
    <head>
        <title>Please Log In</title>
    </head>
    <body>
        <h1>Please Log In</h1>
        <div th:if="${param.error}">
            Invalid username and password.</div>
        <div th:if="${param.logout}">
            You have been logged out.</div>
        <form th:action="@{/login}" method="post">
            <div>
            <input type="text" name="username" placeholder="Username"/>
            </div>
            <div>
            <input type="password" name="password" placeholder="Password"/>
            </div>
            <input type="submit" value="Log in" />
        </form>
    </body>
</html>
  • 表单以 post 方法请求 /login。
  • 在一个名为 username 的参数中指定用户名。
  • 在一个名为 password 的参数中指定密码。
  • 如果发现名为 error 的HTTP参数，表明用户未能提供一个有效的用户名或密码。
  • 如果发现名为 logout 的HTTP参数，表明用户已经成功注销。

如果使用了Spring MVC，需要将 GET /login 映射到我们创建的登录模板。

@Controller
class LoginController {
    @GetMapping("/login")
    String login() {
        return "login";
    }
}

接下来讲解一下源码：（看源码前请保证已阅读总体架构、认证架构、默认流程示意图）

AbstractAuthenticationProcessingFilter

UsernamePasswordAuthenticationFilter的父类，doFilter函数的实现实际上是写在AbstractAuthenticationProcessingFilter中的，大致代码为：

private void doFilter(HttpServletRequest request, HttpServletResponse response, FilterChain chain){
    //...
    try {
        //...
        Authentication authenticationResult = attemptAuthentication(request, response);//调用UsernamePasswordAuthenticationFilter中实现
        //...
        successfulAuthentication(request, response, chain, authenticationResult);//认证成功的处理流程
    }catch(AuthenticationException ex){
        unsuccessfulAuthentication(request, response, ex);//认证失败的处理流程
    }
}
UsernamePasswordAuthenticationFilter

UsernamePasswordAuthenticationFilter类实现了attemptAuthentication方法，用于获得login表单中参数，并进行验证，大致代码为：

@Override
public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response)
      throws AuthenticationException {
   if (this.postOnly && !request.getMethod().equals("POST")) {//判断是否为post请求类型
      throw new AuthenticationServiceException("Authentication method not supported: " + request.getMethod());
   }
   String username = obtainUsername(request);//提取username参数
   username = (username != null) ? username.trim() : "";
   String password = obtainPassword(request);//提取password参数
   password = (password != null) ? password : "";
   UsernamePasswordAuthenticationToken authRequest = UsernamePasswordAuthenticationToken.unauthenticated(username,
         password);//封装为Authentication
   setDetails(request, authRequest);
   return this.getAuthenticationManager().authenticate(authRequest);//对封装的Authentication进行验证
}

1.1.2读取Basic认证参数

Spring Security同样提供了对 Basic HTTP Authentication（HTTP基础认证） 的支持。

前置流程

  1. 一个用户向一个需要授权的资源发出一个未经认证的请求。（与表单登录一样）
  2. AuthorizationFilter 在判断有无权限后抛出 AccessDeniedException 异常。（与表单登录一样）
  3. 该异常被 ExceptionTranslationFilter 捕获，并判断当前用户认证为匿名认证（即未认证用户）后，调用 Start Authentication 函数，使用一个AuthenticationEntryPoint（更改为 BasicAuthenticationEntryPoint 的实例）发送一个 WWW-Authenticate 头。（注意：不同于原先会在 ExceptionTranslationFilter 中存储请求，Basic HTTP Authentication 的情况下浏览器会自动重放它最初的请求。）
认证流程

  1. 用户提交他们的用户名和密码后，BasicAuthenticationFilter 从请求中提取用户名和密码，并创建一个Authentication（UsernamePasswordAuthenticationToken的实例）。
  2. BasicAuthenticationFilter 调用 AuthenticationManager（ProviderManager 的一个实例）对 Authentication 进行校验。
  3. 如果认证失败：
    1. 清除 SecurityContextHolder 中当前的 SecurityContext。
    2. 调用 RememberMeServices的loginFail 函数。
    3. 调用 AuthenticationFailureHandler 进行处理，触发 WWW-Authenticate 再次发送。
  1. 如果认证成功：
    1. 将 Authentication 保存到 SecurityContextHolder 中当前的 SecurityContext。
    2. 调用 RememberMeServices 的 loginSuccess 函数。
    3. 调用 FilterChain.doFilter(request,response) 来继续执行其余的应用逻辑。
配置方式

在SecurityFilterChain中启用 HTTP Basic 认证 的最小配置：

@Bean
public SecurityFilterChain filterChain(HttpSecurity http) {
    http
        // ...
        .httpBasic(withDefaults());
    return http.build();
}

1.1.3摘要认证

请自行了解：摘要（Digest）认证 :: Spring Security Reference (springdoc.cn)。

1.2密码存储与验证

Spring Security提供了优秀的分层机制，之前提过的任何读取用户名和密码的方式都可以和任意密码存储与验证的方式搭配。

不过要讲密码的存储与验证，就必须先知道DaoAuthenticationProvider、UserDetailsService、PasswordEncoder、UserDetails等的概念。

1.2.1基础概念

UserDetails

顾名思义，是详细的用户信息，其内部封装了用户的核心安全数据，通常包含（用户名、密码、是否可用、是否过期、是否被锁定、权限/角色集合）。

常用于验证一个 Authentication 是否有效。

UserDetailsService

用于提供 UserDetails 的 service 类，会被 DaoAuthenticationProvider 调用，用来检索一个 Authentication 对应的实际用户类的用户名、密码和其他属性。

（注意：如果想要自定义认证方式，除了直接使用 AuthenticationManagerBuilder 或 AuthenticationProvider Bean 来提供新的AuthenticationProvider之外，也可以复用 DaoAuthenticationProvider，并使用自定义的 UserDetailsService Bean 来更改自定义认证的逻辑。）

PasswordEncoder

用来对用户密码明文进行加密的工具。

DaoAuthenticationProvider

DaoAuthenticationProvider的工作原理：

  1. Filter 将用户名/密码封装成了 Authentication，以备校验使用。
  2. Filter 调用 ProviderManager 进行校验，而 ProviderManager 会使用 DaoAuthenticationProvider 来进行校验。
  3. DaoAuthenticationProvider 从 UserDetailsService 中查找 UserDetails。
  4. DaoAuthenticationProvider 使用 PasswordEncoder 来验证上一步返回的 UserDetails 上的密码。
  5. 当认证成功时，将 Authentication 的 principal（委托人）属性设置为之前返回的 UserDetails，并返回 Authentication。

看一下默认情况下的源码：

DaoAuthenticationProvider 的父类是 AbstractUserDetailsAuthenticationProvider，ProviderManager 调用验证的方法 authenticate 的实现也是写在 AbstractUserDetailsAuthenticationProvider 中的：

public Authentication authenticate(Authentication authentication){
    //...
    user = retrieveUser(username, (UsernamePasswordAuthenticationToken) authentication);
    //...
}

retrieveUser的实现在 DaoAuthenticationProvider 中：

protected final UserDetails retrieveUser(String username, UsernamePasswordAuthenticationToken authentication){
    //...
    UserDetails loadedUser = this.getUserDetailsService().loadUserByUsername(username);
    //...
}

调用了 UserDetailsService（InMemoryUserDetailsManager 的实例）的 loadUserByUsername 方法，用来获得 UserDetails：

public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
   UserDetails user = this.users.get(username.toLowerCase());//获得UserDetails
   if (user == null) {
      throw new UsernameNotFoundException(username);
   }
   return new User(user.getUsername(), user.getPassword(), user.isEnabled(), user.isAccountNonExpired(),
         user.isCredentialsNonExpired(), user.isAccountNonLocked(), user.getAuthorities());
}

这样就获得了 UserDetails，接下来就要 DaoAuthenticationProvider（AbstractUserDetailsAuthenticationProvider）继续验证 Authentication 了：

public Authentication authenticate(Authentication authentication){
    //...
    user = retrieveUser(username, (UsernamePasswordAuthenticationToken) authentication);//刚刚运行到这
    //...
    additionalAuthenticationChecks(user, (UsernamePasswordAuthenticationToken) authentication);//现在运行这个
}

additionalAuthenticationChecks 实现在 DaoAuthenticationProvider中：

protected void additionalAuthenticationChecks(UserDetails userDetails, UsernamePasswordAuthenticationToken authentication){
   //...
   String presentedPassword = authentication.getCredentials().toString();//获得密码
   if (!this.passwordEncoder.matches(presentedPassword, userDetails.getPassword())) {//调用passwordEncoder进行验证，不通过就抛异常
      this.logger.debug("Failed to authenticate since password does not match stored value");
      throw new BadCredentialsException(this.messages
            .getMessage("AbstractUserDetailsAuthenticationProvider.badCredentials", "Bad credentials"));
   }
}

passwordEncoder的代码不重要，忽略，现在 additionalAuthenticationChecks 已经执行完了，继续看 AbstractUserDetailsAuthenticationProvider 的 authenticate 方法：

public Authentication authenticate(Authentication authentication){
    //...
    user = retrieveUser(username, (UsernamePasswordAuthenticationToken) authentication);
    //...
    additionalAuthenticationChecks(user, (UsernamePasswordAuthenticationToken) authentication);//刚刚运行到这
    //...
    this.userCache.putUserInCache(user);//将验证后的Authentication存入缓存
    //...
    return createSuccessAuthentication(principalToReturn, authentication, user);
}

createSuccessAuthentication 会返回一个验证成功的 Authentication 对象，并使用PasswordEncoder做好加密处理：

protected Authentication createSuccessAuthentication(Object principal, Authentication authentication, UserDetails user) {
    //...
    String presentedPassword = authentication.getCredentials().toString();
    String newPassword = this.passwordEncoder.encode(presentedPassword);
    user = this.userDetailsPasswordService.updatePassword(user, newPassword);
    //...
    return super.createSuccessAuthentication(principal, authentication, user);//超类的工作请自行了解
}

至此，DaoAuthenticationProvider 的方法执行结束，ProviderManager 已获得一个验证完成、代表用户身份的新 Authentication。

1.2.2存储在内存中的用户名/密码

Spring Security 的 InMemoryUserDetailsManager 实现了 UserDetailsService，为存储在内存中的基于用户名/密码的认证提供支持。

让我们回忆一下，UserDetailsService 干了什么？当然是提供UserDetails。InMemoryUserDetailsManager 是一种直接在内存中存放 UserDetails 的 UserDetailsService 实现类。

通过 InMemoryUserDetailsManager 的构造方法，我们可以直接创建 UserDetails 类用于验证：

@Bean
public UserDetailsService users() {
    UserDetails user = User.builder()
        .username("user")
        .password("{bcrypt}$2a$10$GRLdNijSQMUvl/au9ofL.eDwmoohzzS7.rmNSJZ.0FxO/BTk76klW")
        .roles("USER")
        .build();
    UserDetails admin = User.builder()
        .username("admin")
        .password("{bcrypt}$2a$10$GRLdNijSQMUvl/au9ofL.eDwmoohzzS7.rmNSJZ.0FxO/BTk76klW")
        .roles("USER", "ADMIN")
        .build();
    return new InMemoryUserDetailsManager(user, admin);
}

这种方式需要提前加密 Password，当然也可以现场调用PasswordEncoder进行加密：

@Bean
public UserDetailsService users() {
    // The builder will ensure the passwords are encoded before saving in memory
    UserBuilder users = User.withDefaultPasswordEncoder();
    UserDetails user = users
        .username("user")
        .password("password")
        .roles("USER")
        .build();
    UserDetails admin = users
        .username("admin")
        .password("password")
        .roles("USER", "ADMIN")
        .build();
    return new InMemoryUserDetailsManager(user, admin);
}

1.2.3存储在数据库中的用户名/密码

Spring Security 的 JdbcDaoImpl 实现了 UserDetailsService，以提供对基于用户名和密码的认证的支持。

（实际上就是 Spring Security 自己提供了一套使用 JDBC 进行检索的框架，当然我们也可以自己实现 UserDetailsService 进行查询数据库并提供 UserDetails。）

要求数据库格式

默认格式：

create table users(
    username varchar_ignorecase(50) not null primary key,
    password varchar_ignorecase(500) not null,
    enabled boolean not null
);
create table authorities (
    username varchar_ignorecase(50) not null,
    authority varchar_ignorecase(50) not null,
    constraint fk_authorities_users foreign key(username) references users(username)
);
create unique index ix_auth_username on authorities (username,authority);

如果是按组进行权限分配的形式：

create table groups (
    id bigint generated by default as identity(start with 0) primary key,
    group_name varchar_ignorecase(50) not null
);

create table group_authorities (
    group_id bigint not null,
    authority varchar(50) not null,
    constraint fk_group_authorities_group foreign key(group_id) references groups(id)
);

create table group_members (
    id bigint generated by default as identity(start with 0) primary key,
    username varchar(50) not null,
    group_id bigint not null,
    constraint fk_group_members_group foreign key(group_id) references groups(id)
);
设置数据源

必须创建一个数据源用以获得用户信息：

@Bean
DataSource dataSource() {
    return new EmbeddedDatabaseBuilder()
        .setType(H2)
        .addScript(JdbcDaoImpl.DEFAULT_USER_SCHEMA_DDL_LOCATION)
        .build();
}

（设置了一个嵌入式的数据源，用默认的 user schema 进行初始化。）

常用数据源设置方法：

@Bean
public DataSource dataSource() {
    DriverManagerDataSource dataSource = new DriverManagerDataSource();
    dataSource.setDriverClassName("com.mysql.jdbc.Driver");
    dataSource.setUrl("jdbc:mysql://localhost:3306/db_name");
    dataSource.setUsername("username");
    dataSource.setPassword("password");
    return dataSource;
}
配置JdbcDaoImpl

案例：

@EnableWebSecurity
@Configuration
public class MySecurityConfig {
    public DataSource dataSource() {//创建数据源的函数
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://127.0.0.1:3306/securitytest?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=true");
        dataSource.setUsername("XXXXXX");
        dataSource.setPassword("XXXXXX");
        return dataSource;
    }

    public JdbcDaoImpl myJdbcDaoImpl(){//创建JdbcDaoImpl的函数
        JdbcDaoImpl jdbcDao = new JdbcDaoImpl();
        jdbcDao.setDataSource(dataSource());
        jdbcDao.setUsersByUsernameQuery("SELECT username, password, enabled FROM users WHERE username = ?");
        jdbcDao.setAuthoritiesByUsernameQuery("SELECT username, authority FROM authorities WHERE username = ?");
        return jdbcDao;
    }

    @Bean
    public PasswordEncoder nullPassword(){//由于我数据库中存的是明文密码，需要将PasswordEncoder的matches重写为直接比较，而不是原先的加密输入密码后比较
        return new PasswordEncoder() {
            private final PasswordEncoder delegate = new Pbkdf2PasswordEncoder("mySecret", 10000, 128, Pbkdf2PasswordEncoder.SecretKeyFactoryAlgorithm.PBKDF2WithHmacSHA512);
            @Override
            public String encode(CharSequence rawPassword) {
                return delegate.encode(rawPassword);
            }
            @Override
            public boolean matches(CharSequence rawPassword, String encodedPassword) {
                return rawPassword.toString().equals(encodedPassword);
            }
        };
    }

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http.authorizeHttpRequests(authorize -> authorize
                        .anyRequest().authenticated()
                )
                .formLogin(Customizer.withDefaults());
        http.userDetailsService(myJdbcDaoImpl());//添加一个UserDetailsService用来验证，保证可以根据数据库中账号密码进行登录
        return http.build();
    }
}

JdbcUserDetailsManager 扩展了 JdbcDaoImpl，通过 UserDetailsManager 接口提供对 UserDetails 的管理，提供了一组便利的方法来管理用户的创建、更新、删除等操作。相关的应用可自行了解。

1.2.4LDAP 认证

请自行了解：LDAP 认证 :: Spring Security Reference (springdoc.cn)

二、持久化认证

Spring Security 会将 Authentication 存入到 SecurityContext 中，用以代表用户的身份。

那么当用户在未来再次发起请求时，该如何将未来的请求与当前的 SecurityContext 联系起来呢？

在Spring Security中，用户与未来请求的关联是通过 SecurityContextRepository 实现的。

2.1常用配置

SecurityContextRepository 是一个接口，通常使用其实现类 DelegatingSecurityContextRepository、HttpSessionSecurityContextRepository、RequestAttributeSecurityContextRepository、NullSecurityContextRepository。

  • DelegatingSecurityContextRepository：一个代理类，这个类可以包含很多的 SecurityContextRepository 的具体实现，然后通过这些具体实现将认证保存。（默认包含下面两者）
  • HttpSessionSecurityContextRepository：将 SecurityContext 与 HttpSession 相关联，即将 Authentication 存入 HttpSession。
  • RequestAttributeSecurityContextRepository：将 SecurityContext 保存为请求属性（request attribute），以确保 SecurityContext 可用于跨调度（dispatch）类型发生的单个请求，这些调度类型可能会清除 SecurityContext。
  • NullSecurityContextRepository：不做任何事情。

设置方式：

@Bean
public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
    http
        // ...
        .securityContext((securityContext) -> securityContext
            .securityContextRepository(new DelegatingSecurityContextRepository(
                new RequestAttributeSecurityContextRepository(),
                new HttpSessionSecurityContextRepository()
            ))
        );
    return http.build();
}

2.2基本原理

与持久化认证的过滤器有两个：SecurityContextPersistenceFilter 和 SecurityContextHolderFilter，不过SecurityContextPersistenceFilter已经弃用了，这里就只讲 SecurityContextHolderFilter 了。

2.2.1SecurityContextHolderFilter

SecurityContextHolderFilter的作用：使用 SecurityContextRepository 加载 SecurityContext。

  1. SecurityContextHolderFilter 从S ecurityContextRepository 加载 SecurityContext 并将其设置在 SecurityContextHolder 上。
  2. 接下来，继续运行过滤器链剩余部分。

注意：SecurityContextHolderFilter 只加载 SecurityContext，并不保存 SecurityContext。如果使用的是 SecurityContextHolderFilter 而不是 SecurityContextPersistenceFilter，需要明确地保存 SecurityContext。

保存方式：（参考Spring Security：认证架构）

SecurityContext context = SecurityContextHolder.createEmptyContext(); //创建一个空的 SecurityContext 
context.setAuthentication(authentication); //设置认证信息到安全上下文中
SecurityContextHolder.setContext(context); //在 SecurityContextHolder 上设置 SecurityContext。

2.2.2SecurityContextPersistenceFilter

自行了解，可参考：持久化认证 :: Spring Security Reference (springdoc.cn)。

寿命齿轮
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring security实现记住我下次自动登录功能过程详解
08-24
Spring Security 实现记住我下次自动登录功能过程详解 Spring Security 是一个功能强大且广泛使用的 Java 认证和授权框架，提供了许多功能强大的功能，例如认证、授权、RememberMe 等。在本文中，我们将详细介绍...
Spring Security学习之rememberMe自动登录的实现
08-18
本文将深入探讨如何在Spring Security中配置和使用`rememberMe`自动登录，以及其背后的持久化令牌方案。 ### 一、`rememberMe`基础配置 在Spring Security中，启用`rememberMe`功能非常直观。首先，你需要在`...
Spring Security6.x快速入门——用户认证模块
coder184的博客
03-03 1024
Spring Security是基于过滤器进行设计的，它自身是一个SecurityFilterChain，在spring官网中，有很长的一个篇幅，对其架构进行介绍；而在这里，我推荐的入门方式是：可以将其快速地浏览一遍，心中只需要留下印象的是——Spring Security和过滤器链，你甚至直接可以将Spring Security看作是"一堆过滤器"，这些过滤器组成了"过滤器链"，而过滤器链中最重要的一个过滤器是：AuthorizationFilter。@Override。
Spring Security 5.7.1安全过滤器链配置方法
DDDInJava
05-31 4053
@RequiredArgsConstructor(onConstructor_ = @Autowired) @EnableWebSecurity @EnableGlobalMethodSecurity(prePostEnabled = true) public class WebSecurityConfiguration { @NonNull private AuthenticationSuccessHandler authenticationSuccessHandler; @NonNull p.
SpringSecurity入门（一）
最新发布
qq_27352081的博客
06-07 920
SpringSecurity入门
Spring Security登录账户自定义与数据持久化（5）
weixin_43831002的博客
08-03 1027
在前面的案例中，我们的登录用户是基于配置文件来配置的(本质是基于内存)，但是在实际开发中，这种方式肯定是不可取的，在实际项目中，用户信息肯定要存入数据库之中。Spring Security支持多种用户定义方式，接下来我们就逐个来看一下这些定义方式。...
SpringSecurity去掉WebSecurityConfigurerAdapter的配置方法
2301_77345366的博客
03-30 842
从 Spring Security 5.7.0-M2开始 WebSecurityConfigurerAdapter 被标记为过期，鼓励用户转向基于组件的 security 配置。
Spring Security漏洞防护—HTTP 安全响应头
深圳市多克创新科技有限公司
10-24 1999
Spring Security漏洞防护—HTTP 安全响应头
spring-boot-2-security-jwt:使用JWT和持久用户的基本Spring Boot 2和Spring Security应用程序
05-16
《基于Spring Boot 2与Spring Security的JWT身份验证详解》 在现代Web应用程序开发中，安全性和用户认证是至关重要的部分。Spring Boot 2作为Java生态中的热门框架，结合Spring Security提供了强大的安全解决方案。...
SpringBoot2+MybatisPlus+SpringSecurity+jwt+redis+Vue人事管理系统源码
08-12
《SpringBoot2+MybatisPlus+SpringSecurity+jwt+redis+Vue人事管理系统详解》 在当前的互联网开发环境中，高效、稳定且易于维护的系统架构是至关重要的。本篇文章将详细解析一个基于SpringBoot2、MybatisPlus、...
spring-features:Spring项目的种子项目
05-16
Spring Data提供了一种简化数据库访问的方式，支持多种持久化技术，如JPA（Java Persistence API）和JDBC。在种子项目中，可能会有使用Spring Data JPA的例子，展示如何通过Repository接口实现数据库操作。 7. **...
SpringBoot Security安全认证框架初始化流程&amp；认证流程之源码分析_spring boot 接口权限认证 接口鉴权 源码
m0_60707685的博客
04-08 540
自定义安全配置类继承WebSecurityConfigurerAdapter，以对象名为authenticationManager的bean将AuthenticationManager对象注入到Spring容器中《authenticationManager的bean对象注入流程源码分析图》1、以@Bean的方式将AuthenticationManager的Bean以Id="authenticationManager"注入到Spring容器中；
Spring Security配置（包含WebSecurityConfigurerAdapter和authenticationManager()过时问题）
小鬼的博客
06-27 3541
Spring Security配置（包含WebSecurityConfigurerAdapter和authenticationManager()过时问题）
Spring Security在前后端分离项目中的使用
zy1992As的博客
12-27 1476
然后设置我们的资源所需要的权限即可。报错的原因：默认情况下Spring Security在获取到UserDetailsService返回的用户信息以后，会调用PasswordEncoder中的matches方法进行校验，但是此时在Spring容器中并不存在任何的PasswordEncoder的对象，因此无法完成校验操作。但是在前后端分离的项目中我们的认证信息其实是token，而token并不是存储在cookie中，并且需要前端代码去把token设置到请求头中才可以，所以CSRF攻击也就不用担心了。
从源码角度拆解SpringSecurity之C位的AuthenticationManager
会飞的耗子
04-29 386
上一篇我们简单拆解了运行时的大致流程，知道了拦截动作都来自于FilterChainProxy，以及内部的Filter链怎么来的，顺序的重要性，以及如何分发的，还针对所学习内容介绍了一个简单但实际的小需求——如何自定义异常返回数据。本章我们将基于框架中处于C位的AuthenticationManager为切入点，对框架的认证和授权两个核心步骤进行拆解以及数据权限校验框架的实现
Spring Security配置全局 AuthenticationManager
Leon_Jinhai_Sun的博客
05-06 6588
Topical Guide | Spring Security Architecture 默认的全局 AuthenticationManager @Configuration public class WebSecurityConfigurer extends WebSecurityConfigurerAdapter { @Autowired public void initialize(AuthenticationManagerBuilder builder) { //buil
SpringSecurity框架原理浅谈之AuthenticationManager
黄先生的博客
02-10 3007
AuthenticationManager这个接口方法非常奇特，入参和返回值的类型都是Authentication。该接口的作用是对用户的未授信凭据进行认证，认证通过则返回授信状态的凭据，否则将抛出认证异常AuthenticationException。
Spring Security 4 整合Hibernate 实现持久化登录验证（带源码）
明明如月的技术博客
05-05 8475
上一篇文章：Spring Security 4 整合Hibernate Bcrypt密码加密（带源码） 原文地址：http://websystique.com/spring-security/spring-security-4-remember-me-example-with-hibernate/ 【相关已翻译的本系列其他文章，点击分类里面的spring security 4】
SpringSecurity【用户+权限的数据库持久化】
Marvel__Dead 胡艺宝的博客
08-11 1857
实战前理论讲解Github代码查看数据库文件要想达到这个目的：主要是实现一个接口，UserDetilsService。 然后，把这个类配置到SpringSecurity的配置文件中。这个接口只有一个方法：public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException{}这个方法的作用就是
Spring Security教程：从基础到OAuth2.0详解
SpringSecurity是Spring框架中的一个强大的安全模块，用于保护Web应用程序免受未经授权的访问。它提供了身份验证、授权、会话管理和跨站请求伪造(CSRF)防护等多种功能。 2. **HelloWorld示例**： 开始时，教程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值