spring security——用户认证流程（二）

短命女 2021-10-13 02:49 800阅读 0赞

# 一、用户认证逻辑 #

在自定义用户认证逻辑中我们需要完成的内容有：

*  处理用户信息获取逻辑
 *  处理用户校验逻辑
 *  处理密码加密解密

## 1、处理用户信息获取逻辑（UserDetailsService） ##

org.springframework.security.core.userdetails.UserDetailsService

UserDetailsService接口用于加载用户特定的数据，它在整个框架中作为用户DAO使用，是验证提供者使用的策略。 该接口只需要一个只读方法，这简化了对新的数据访问策略的支持。实现一个自定义的UserDetailsService

// 自定义数据源来获取数据
    // 这里只要是存在一个自定义的 UserDetailsService ，那么security将会使用该实例进行配置
    @Component
    public class MyUserDetailsService implements UserDetailsService {
        Logger logger = LoggerFactory.getLogger(getClass());
    
        // 可以从任何地方获取数据
        @Override
        public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
            // 根据用户名查找用户信息
            logger.info("登录用户名", username);
            // 写死一个密码，赋予一个admin权限
            return new User(username, "123456",
                            AuthorityUtils.commaSeparatedStringToAuthorityList("admin"));
        }
    }

这样就能让自定义的UserdetailsService生效了。但是在浏览器中登录的时候，后台报错了

java.lang.IllegalArgumentException: There is no PasswordEncoder mapped for the id "null"

这个异常是spring security5+后密码策略变更了。**必须使用 PasswordEncoder 方式**，也就是你存储密码的时候需要使用\{noop\}123456这样的方式。这个在官网文档中有讲到，花括号里面的是encoder id ，这个支持的全部列表在以下的方法中定义

org.springframework.security.crypto.factory.PasswordEncoderFactories#createDelegatingPasswordEncoder

noop 对应的处理类是org.springframework.security.crypto.password.NoOpPasswordEncoder，只用于测试，因为没有做任何加密功能。

## 2、处理用户校验逻辑（UserDetails） ##

自定义的其他逻辑是在 org.springframework.security.core.userdetails.User 中提供的，只要在登录的时候把user中提供的信息返回即可达到支持的业务逻辑，下面列出支持的业务场景：

*  isEnabled 账户是否启用
 *  isAccountNonExpired 账户没有过期
 *  isCredentialsNonExpired 身份认证是否是有效的
 *  isAccountNonLocked 账户没有被锁定

对于 isAccountNonLocked 和 isEnabled 没有做业务处理，只是抛出了对于的异常信息；

// 这里的几个布尔值的含义对应上面列出来的顺序
    User admin = new User(username, "{noop}123456",
                          true, true, true, false,
                          AuthorityUtils.commaSeparatedStringToAuthorityList("admin"));

## 3、处理密码加密解密（PasswordEncoder） ##

密码加密解密是使用了下面这个类

org.springframework.security.crypto.password.PasswordEncoder

配置只需要提供一个实例即可，会自动使用该实例

@Configuration
    public class BrowserSecurityConfig extends WebSecurityConfigurerAdapter {
        @Bean
        public PasswordEncoder passwordEncoder() {
            return new BCryptPasswordEncoder();
        }

在UserDetailsService中需要模拟存入数据库中的密码就是加密后的字符串

@Component
    public class MyUserDetailsService implements UserDetailsService {
        Logger logger = LoggerFactory.getLogger(getClass());
    
        @Autowired
        private PasswordEncoder passwordEncoder;
    
        @Override
        public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
            logger.info("登录用户名:{}", username);
            String password = passwordEncoder.encode("123456");
            logger.info("数据库密码{}", password);
            User admin = new User(username,
    // "{noop}123456",
                                  password,
                                  true, true, true, true,
                                  AuthorityUtils.commaSeparatedStringToAuthorityList("admin"));
        }
    }

其框架会把提交的密码使用我们定义的passwordEncode加密后调用org.springframework.security.crypto.password.PasswordEncoder\#matches方法，与 返回的User中的密码进行比对。配对正常就验证通过。

# 二、自定义登录 #

上面使用spring security默认的认证流程。处理了自定义的用户数据，密码加密等。但是在实际开发中，肯定是要使用自己开发的页面、登录成功失败的业务处理等。

## 1、自定义登录页面 ##

我们在自定义的WebSecurityConfig中修改配置如下：

protected void configure(HttpSecurity http) throws Exception {
        http
            // 定义表单登录 - 身份认证的方式
            .formLogin()
            .loginPage("/tin-signIn.html")
            .and()
            .authorizeRequests()
            // 放行这个路径
            .antMatchers("/tin-signIn.html").permitAll()
    }

如果不对该静态文件放行的话，将会无限跳转，造成错误："localhost 将您重定向的次数过多"。关于html存放资源文件夹下的哪一个目录，这个有点懵，开始放在static下面访问不到，最后放到resources下面才对（因为我的项目没有整合Thymeleaf，spring boot的默认静态文件路径应该是下面的）

![20190821103513878.png][]

html内容如下

<body>
    <h2>标准登录页面</h2>
    <form action="/authentication/form" method="post">
        <table>
            <tr>
                <td>用户名：</td>
                <td><input type="text" name="username"></td>
            </tr>
            <tr>
                <td>密码：</td>
                <td><input type="password" name="password"></td>
            </tr>
            <tr>
                <td colspan="2">
                    <button type="submit">登录</button>
                </td>
            </tr>
        </table>
    </form>
    </body>

注意这里的路径：acrion="/authentication/form"，路径是自定义的，而UsernamePasswordAuthenticationFilter 默认是处理/login路径的登录请求

public UsernamePasswordAuthenticationFilter() {
      super(new AntPathRequestMatcher("/login", "POST"));
    }

这里我们自定义如下：

.formLogin()
    .loginPage("/tin-signIn.html")
    // 处理登录请求路径，像是对security默认/login路径的重命名
    .loginProcessingUrl("/authentication/form")
    .and()
    .authorizeRequests()
    .antMatchers("/tin-signIn.html").permitAll()
    .and()
    .csrf().disable();//不加出现_csrf的错误情况,跳回登录页面

## 2、处理不同类型的请求 ##

上面虽然配置了自定义的路径，但是都统一跳转到了静态页面，那么要怎么实现 根据请求来分发是返回html内容？还是返回json内容呢？在前后分离的情况下，都用ajax来请求，肯定不能返回html了。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMTcyMTMz_size_16_color_FFFFFF_t_70][]

思路是上面图中这样。那么很简单只要把登录地址换成自定义的就好了。

.formLogin()
        //.loginPage("/tin-signIn.html")
        // 更换成自定义的一个真实存在的处理器地址
        .loginPage("/authentication/require")

编写处理请求的处理器

@RestController
    @Slf4j
    public class BrowserSecurityController {
        // 封装了引发跳转请求的工具类，看实现类应该是从session中获取的
        private RequestCache requestCache = new HttpSessionRequestCache();
    
        // spring的工具类：封装了所有跳转行为策略类
        private RedirectStrategy redirectStrategy = new DefaultRedirectStrategy();
    
        /**
         * 当需要身份认证时跳转到这里
         */
        @RequestMapping("/authentication/require")
        @ResponseStatus(code = HttpStatus.UNAUTHORIZED)
        public SimpleResponse requirAuthentication(HttpServletRequest request, HttpServletResponse response) throws IOException {
    
            SavedRequest savedRequest = requestCache.getRequest(request, response);
            // 如果有引发认证的请求
            // spring 在跳转前应该会把信息存放在某个地方？
            if (savedRequest != null) {
                String targetUrl = savedRequest.getRedirectUrl();
                logger.info("引发跳转的请求：" + targetUrl);
                // 如果是html请求，则跳转到登录页
                if (StringUtils.endsWithIgnoreCase(targetUrl, ".html")) {
                    redirectStrategy.sendRedirect(request, response, "/tin-signIn.html");
                }
            }
            // 否则都返回需要认证的json串
            return new SimpleResponse("访问的服务需要身份认证，请引导用户到登录页");
        }
    }

SimpleResponse 类只是一个返回结果的信息类。

## 3、登录成功处理 ##

security 默认的登录成功处理是跳转到需要授权之前访问的url。而在一些场景下：比如前后分离，登录是通过ajax访问，没有办法处理301跳转。而是登录成功则返回相关的数据即可。自定义入口还是在表单登录处配置的

http
            // 定义表单登录 - 身份认证的方式
            .formLogin()
            .loginPage("/authentication/require")
            .loginProcessingUrl("/authentication/form")
            .successHandler(myAuthenticationSuccessHandler)

myAuthenticationSuccessHandler 的编写如下：

/**
     * formLogin().successHandler() 中需要的处理器类型
     */
    @Component("myAuthenticationSuccessHandler")
    public class MyAuthenticationSuccessHandler implements AuthenticationSuccessHandler {
        private org.slf4j.Logger logger = LoggerFactory.getLogger(getClass());
    
        // spring 是使用jackson来进行处理返回数据的，所以这里可以得到他的实例
        @Autowired
        private com.fasterxml.jackson.databind.ObjectMapper objectMapper;
    
        /**
         * authentication 封装了所有的认证信息
         */
        @Override
        public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
            logger.info("登录成功");
    
            response.setContentType("application/json;charset=UTF-8");
            response.getWriter().write(objectMapper.writeValueAsString(authentication));
        }
    }

查看输出的authentication

{
        "authorities": [
            {
                "authority": "admin"
            }
        ],
        "details": {
            "remoteAddress": "0:0:0:0:0:0:0:1",
            "sessionId": "FE0F33577E7E5D89AF15FCCD6FE5A4B3"
        },
        "authenticated": true,
        "principal": {
            "password": null,
            "username": "admin",
            "authorities": [
                {
                    "authority": "admin"
                }
            ],
            "accountNonExpired": true,
            "accountNonLocked": true,
            "credentialsNonExpired": true,
            "enabled": true
        },
        "credentials": null,
        "name": "admin"
    }

如果我们想在ajax访问时返回JSON数据，在普通处理下跳转到之前访问的url该怎么办？

@Component("myAuthenticationSuccessHandler")
    public class MyAuthenticationSuccessHandler extends SavedRequestAwareAuthenticationSuccessHandler {
        private org.slf4j.Logger logger = LoggerFactory.getLogger(getClass());
    
        // com.fasterxml.jackson.databind.
        // spring 是使用jackson来进行处理返回数据的
        // 所以这里可以得到他的实例
        @Autowired
        private com.fasterxml.jackson.databind.ObjectMapper objectMapper;
    
        @Autowired
        private SecurityProperties securityProperties;
    
        /**
         * @param authentication 封装了所有的认证信息
         */
        @Override
        public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
            logger.info("登录成功");
            if (LoginResponseType.JSON.equals(securityProperties.getBrowser().getLoginType())) {
                response.setContentType("application/json;charset=UTF-8");
                response.getWriter().write(objectMapper.writeValueAsString(authentication));
            } else {
                // 把本类实现父类改成 AuthenticationSuccessHandler 的子类 SavedRequestAwareAuthenticationSuccessHandler
                // 之前说spring默认成功是跳转到登录前的url地址
                // 就是使用的这个类来处理的
                super.onAuthenticationSuccess(request, response, authentication);
            }
        }
    }

这样登录成功的就ok了。对于失败的来说是一样的，继承的父类改成spring默认的处理器

org.springframework.security.web.authentication.SimpleUrlAuthenticationFailureHandler

下面简单写一下失败处理器，其实和成功处理器一样

@Component("myAuthenticationFailureHandler")
    @Slf4j
    public class MyAuthenticationFailureHandler extends SimpleUrlAuthenticationFailureHandler {
    
        @Autowired
        private SecurityProperties securityProperties;
    
        @Override
        public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) throws IOException, ServletException {
    
            log.info("用户信息校验失败：" + exception.getMessage());
    
            if(LoginResponseType.JSON.equals(securityProperties.getBrowser().getLoginType())){
                //response.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value());
                response.setContentType("application/json;charset=UTF-8");
                response.getWriter().write(JsonUtils.objectToJson(RestResult.build(CodeMsg.USER_LOGIN_FAILURE)));
            }else {
                super.onAuthenticationFailure(request, response, exception);
            }
        }
    }

# 三、认证流程详解 #

上面讲的都是实现spring给出的扩展钩子。比如：自定义登录页，自定义登录成功处理等。但是是很碎片化的，在脑海中链接不起来，下面我们就来梳理一下用户认证流程的源码。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMTcyMTMz_size_16_color_FFFFFF_t_70 1][]

下面我们就跟着这个流程和之前配置的地方，去一步一步的看源码

*  AuthenticationManager 管理所有的Provider，并选择适合的进行验证
 *  AuthenticationProvider 验证提供者，可以自己写provider处理自己的业务场景逻辑

## 1、认证结果如何在多个请求之间共享 ##

在认证成功的情况下，SecurityContext 默策略是一个org.springframework.security.core.context.ThreadLocalSecurityContextHolderStrategy 对象，内部使用\`ThreadLocal<SecurityContext>\`来存储

org.springframework.security.web.authentication.AbstractAuthenticationProcessingFilter#successfulAuthentication
    
    SecurityContextHolder.getContext().setAuthentication(authResult);

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMTcyMTMz_size_16_color_FFFFFF_t_70 2][]

上面的源码也就是上图右边部分，SecurityContext会在同一个线程中可以通过这个context来获取到的。然后SecurityContextPersistenceFilter 所在的位置如下图

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMTcyMTMz_size_16_color_FFFFFF_t_70 3][]

## 2、获取认证用户信息 ##

这里我们在UserController中写获取用户信息的api。在前面分析了源码，所以这里可以使用SecurityContextHolder获取到当前的认证用户信息

@GetMapping("/me")
    public Authentication getCurrentUser() {
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        return authentication;
    }
    
    // 这样写 spring 会自动注入
    @GetMapping("/me")
    public Authentication getCurrentUser(Authentication authentication) {
        return authentication;
    }

输出

{
        "authorities": [
            {
                "authority": "admin"
            }
        ],
        "details": {
            "remoteAddress": "0:0:0:0:0:0:0:1",
            "sessionId": "CB434B240B0B1810ED922C9D877F5842"
        },
        "authenticated": true,
        "principal": {
            "password": null,
            "username": "test001",
            "authorities": [
                {
                    "authority": "admin"
                }
            ],
            "accountNonExpired": true,
            "accountNonLocked": true,
            "credentialsNonExpired": true,
            "enabled": true
        },
        "credentials": null,
        "name": "test001"
    }

注意看，password是不会返回来的！如果上面的信息太多了，也可以使用参数注解@AuthenticationPrincipal UserDetails获取User的信息。比如

public RestResult validatePassword(@AuthenticationPrincipal UserExt user, String password) {
        return userService.validatePassword(user, password);
    }

# 四、添加记住我功能 #

## 1、基本原理 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMTcyMTMz_size_16_color_FFFFFF_t_70 4][]

在security中认证过滤链中的org.springframework.security.web.authentication.rememberme.RememberMeAuthenticationFilter 过滤器来实现的。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMTcyMTMz_size_16_color_FFFFFF_t_70 5][]

当没有其他的认证过滤器处理的时候，记住我这个过滤器就尝试工作。

## 2、实现记住我的功能 ##

首先给默认登录页面增加选项

<input type="checkbox" value="true" name="remember-me">记住我

nam的名称是以下类中被定义

org.springframework.security.config.annotation.web.configurers.RememberMeConfigurer
    
    private static final String DEFAULT_REMEMBER_ME_NAME = "remember-me";

然后在SecurityConfig 中进行配置

public class BrowserSecurityConfig extends WebSecurityConfigurerAdapter {
    
      // 数据源是需要在使用处配置数据源的信息
       @Autowired
       private DataSource dataSource;
       @Autowired
       private PersistentTokenRepository persistentTokenRepository;
       // 之前已经写好的 MyUserDetailsService，
       @Autowired
       private UserDetailsService userDetailsService;
    
       @Bean
       public PersistentTokenRepository persistentTokenRepository() {
           // org.springframework.security.config.annotation.web.configurers.RememberMeConfigurer.tokenRepository
           JdbcTokenRepositoryImpl jdbcTokenRepository = new JdbcTokenRepositoryImpl();
           jdbcTokenRepository.setDataSource(dataSource);
           // 该对象里面有定义创建表的语句，可以设置让该类来创建表
           // 但是该功能只用使用一次，如果数据库已经存在表则会报错
            // jdbcTokenRepository.setCreateTableOnStartup(true);
           return jdbcTokenRepository;
       }
    
       @Override
       protected void configure(HttpSecurity http) throws Exception {
         http
             // 定义表单登录 - 身份认证的方式
             .formLogin()
             .loginPage("/authentication/require")
             .loginProcessingUrl("/authentication/form")
             .and()
             // 从这里开始配置记住我的功能
             .rememberMe()
             .tokenRepository(persistentTokenRepository)
             // 新增过期配置，单位秒，默认配置写的60秒
             .tokenValiditySeconds(60 * 5)
             // userDetailsService 是必须的。不然就报错
             .userDetailsService(userDetailsService)

从数据库获取到记住我的token后，验证成功，则通过userDetailsService获取用户信息，然后在框架中写入认证信息，完成登录。

## 3、测试 ##

访问/user 肯定被拦截，无权限访问。访问标准登录页：/tin-signIn.html 记住勾选记住我的选项。退出浏览器或则重启系统，直接访问 /user（此时会明显的感觉到系统运行缓慢，这是因为需要从数据库获取信息）。在登录成功的时候会往数据库插入一条数据

INSERT INTO `tin-demo`.`persistent_logins` (`username`, `series`, `token`, `last_used`) VALUES 
    ('admin', 'eBbVlKvXSseasbH6yVGozQ==', '72sHS9ifyza2yTN3h0Kq7A==', '2018-08-04 14:05:31');

登录一次则会插入一条，那什么时候被删除呢？在源码中看到：

*  当携带的cookie和数据库中最后一次不匹配的时候，会删除所有与该用户相关的记录
 *  当使用logout功能退出的时候

所以该地方可能会有一些小小的问题，但是可以自己去解决这个数据过多的情况，增加定时任务多长时间清理一次等方法。

## 4、源码解析 ##

登录在验证成功之后会调用该方法org.springframework.security.web.authentication.AbstractAuthenticationProcessingFilter\#successfulAuthentication。然后委托了org.springframework.security.web.authentication.rememberme.PersistentTokenBasedRememberMeServices\#onLoginSuccess

protected void onLoginSuccess(HttpServletRequest request,
        HttpServletResponse response, Authentication successfulAuthentication) {
      String username = successfulAuthentication.getName();
    
      logger.debug("Creating new persistent login for user " + username);
    
      PersistentRememberMeToken persistentToken = new PersistentRememberMeToken(
          username, generateSeriesData(), generateTokenData(), new Date());
      try {
        tokenRepository.createNewToken(persistentToken);
        addCookie(persistentToken, request, response);
      }
      catch (Exception e) {
        logger.error("Failed to save persistent token ", e);
      }
    }

携带cookie访问的时候会触发这个方法org.springframework.security.web.authentication.rememberme.PersistentTokenBasedRememberMeServices\#processAutoLoginCookie，里面有验证过期等的逻辑。

**对于看本文比较困难的同学可以移步：[https://www.lanqiao.cn/courses/3013][https_www.lanqiao.cn_courses_3013]**

**邀请码：STyLDQzM**

**其实内容和博客差不多，只不过更详细（就是一步一步的来，所有步骤有详细过程记录和截图，按照课程步骤最终能完整的操作完整个项目过程，适合小白），版本上也有所升级，还有就是有问题可以直接沟通，谢谢支持！**

[20190821103513878.png]: /images/20211013/a02fc99e50c04740b81b5af8c505ec90.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMTcyMTMz_size_16_color_FFFFFF_t_70]: /images/20211013/25fe5c9107a74d7eacc963e70b8ed3a6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMTcyMTMz_size_16_color_FFFFFF_t_70 1]: /images/20211013/18fbfe4d51004a11b9cf02b817d1ae49.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMTcyMTMz_size_16_color_FFFFFF_t_70 2]: /images/20211013/b548feef187949fa913f2d6e5d54a931.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMTcyMTMz_size_16_color_FFFFFF_t_70 3]: /images/20211013/97c542e3bebb4e289c5c443dbd610a2c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMTcyMTMz_size_16_color_FFFFFF_t_70 4]: /images/20211013/6cc9f5f9455148a5b973eda9a50f13e6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMTcyMTMz_size_16_color_FFFFFF_t_70 5]: /images/20211013/dea8cc3504a64aaa9c2c02e06ec1c732.png
[https_www.lanqiao.cn_courses_3013]: https://www.lanqiao.cn/courses/3013