Spring Security--短信验证码详解

转x33g5p2x  于2021-11-20 转载在 Spring  
字(16.7k)|赞(0)|评价(0)|浏览(507)

需求

  • 输入手机号码，点击获取按钮，服务端接受请求发送短信
  • 用户输入验证码点击登录
  • 手机号码必须属于系统的注册用户，并且唯一
  • 手机号与验证码正确性及其关系必须经过校验
  • 登录后用户具有手机号对应的用户的角色及权限

实现步骤

  • 获取短信验证码
  • 短信验证码校验过滤器
  • 短信验证码登录认证过滤器
  • 综合配置

获取短信验证码

在这一步我们需要写一个controller接收用户的获取验证码请求。注意：一定要为“/smscode”访问路径配置为permitAll访问权限,因为spring security默认拦截所有路径，除了默认配置的/login请求，只有经过登录认证过后的请求才会默认可以访问。

  1. @Slf4j
  2. @RestController
  3. public class SmsController {
  5.     @Autowired
  6.     private UserDetailsService userDetailsService;
  8.     //获取短信验证码
  9.     @RequestMapping(value="/smscode",method = RequestMethod.GET)
  10.     public String sms(@RequestParam String mobile, HttpSession session) throws IOException {
  11.          //先从数据库中查找，判断对应的手机号是否存在
  12.         UserDetails userDetails = userDetailsService.loadUserByUsername(mobile);
  13.         //这个地方userDetailsService如果使用spring security提供的话，找不到用户名会直接抛出异常，走不到这里来
  14.         //即直接去了登录失败的处理器
  15.         if(userDetails == null){
  16.             return "您输入的手机号不是系统注册用户";
  17.         }
  18.         //commons-lang3包下的工具类,生成指定长度为4的随机数字字符串
  19.         String randomNumeric = RandomStringUtils.randomNumeric(4);
  20.         //验证码,过期时间，手机号
  21.         SmsCode smsCode = new SmsCode(randomNumeric,60,mobile);
  22.         //TODO 此处调用验证码发送服务接口
  23.         //这里只是模拟调用
  24.         log.info(smsCode.getCode() + "=》" + mobile);
  26.         //将验证码存放到session中
  27.         session.setAttribute("sms_key",smsCode);
  29.         return "短信息已经发送到您的手机";
  30.     }
  31. }
  • 上文中我们只做了短信验证码接口调用的模拟，没有真正的向手机发送验证码。此部分接口请结合短信发送服务提供商接口实现。
  • 短信验证码发送之后，将验证码“谜底”保存在session中。
  • 使用SmsCode封装短信验证码的谜底，用于后续登录过程中进行校验。
  1. public class SmsCode {
  2.     private String code;  //短信验证码
  3.     private LocalDateTime expireTime; //验证码的过期时间
  4.     private String mobile; //发送手机号
  6.     public SmsCode(String code,int expireAfterSeconds,String mobile){
  7.         this.code = code;
  8.         this.expireTime = LocalDateTime.now().plusSeconds(expireAfterSeconds);
  9.         this.mobile = mobile;
  10.     }
  12.     public boolean isExpired(){
  13.         return  LocalDateTime.now().isAfter(expireTime);
  14.     }
  16.     public String getCode() {
  17.         return code;
  18.     }
  20.     public String getMobile() {
  21.        return mobile;
  22.     }
  24. }

前端初始化短信登录界面

  1. <h1>短信登陆</h1>
  2. <form action="/smslogin" method="post">
  3.     <span>手机号码：</span><input type="text" name="mobile" id="mobile"> <br>
  4.     <span>短信验证码：</span><input type="text" name="smsCode" id="smsCode" >
  5.     <input type="button" onclick="getSmsCode()" value="获取"><br>
  6.     <input type="button" onclick="smslogin()" value="登陆">
  7. </form>
  9. <script>
  11.    function getSmsCode()
  12.    {
  13.      $.ajax({
  14.        type: "GET",
  15.        url: "/smscode",
  16.         data:{"mobile":$("#mobile").val()},
  17.        success: function (res) {
  18.          console.log(res)
  19.        },
  20.        error: function (e) {
  21.          console.log(e.responseText);
  22.        }
  23.      });
  24.    }
  26.     function smslogin() {
  27.       var mobile = $("#mobile").val();
  28.       var smsCode = $("#smsCode").val();
  29.       if (mobile === "" || smsCode === "") {
  30.         alert('手机号和短信验证码均不能为空');
  31.         return;
  32.       }
  33.       $.ajax({
  34.         type: "POST",
  35.         url: "/smslogin",
  36.         data: {
  37.           "mobile": mobile,
  38.           "smsCode": smsCode
  39.         },
  40.         success: function (res) {
  41.           console.log(res)
  42.         },
  43.         error: function (e) {
  44.           console.log(e.responseText);
  45.         }
  46.       });
  47.     }
  48. </script>

spring security配置类

  1. @Configuration
  2. public class SecurityConfig extends WebSecurityConfigurerAdapter {
  4.    private ObjectMapper objectMapper=new ObjectMapper();
  6.    @Resource
  7.    private CaptchaCodeFilter captchaCodeFilter;
  9.    @Bean
  10.    PasswordEncoder passwordEncoder() {
  11.       return NoOpPasswordEncoder.getInstance();
  12.    }
  14.    @Override
  15.    public void configure(WebSecurity web) throws Exception {
  16.       web.ignoring().antMatchers("/js/**", "/css/**","/images/**");
  17.    }
  19.    //数据源注入
  20.    @Autowired
  21.    DataSource dataSource;
  23.    //持久化令牌配置
  24.    @Bean
  25.    JdbcTokenRepositoryImpl jdbcTokenRepository() {
  26.       JdbcTokenRepositoryImpl jdbcTokenRepository = new JdbcTokenRepositoryImpl();
  27.       jdbcTokenRepository.setDataSource(dataSource);
  28.       return jdbcTokenRepository;
  29.    }
  31.    //用户配置
  32.    @Override
  33.    @Bean
  34.    protected UserDetailsService userDetailsService() {
  35.       JdbcUserDetailsManager manager = new JdbcUserDetailsManager();
  36.       manager.setDataSource(dataSource);
  37.       if (!manager.userExists("dhy")) {
  38.          manager.createUser(User.withUsername("dhy").password("123").roles("admin").build());
  39.       }
  40.       if (!manager.userExists("大忽悠")) {
  41.          manager.createUser(User.withUsername("大忽悠").password("123").roles("user").build());
  42.       }
  43.       //模拟电话号码
  44.       if (!manager.userExists("123456789")) {
  45.          manager.createUser(User.withUsername("123456789").password("").roles("user").build());
  46.       }
  47.       return manager;
  48.    }
  50.    @Override
  51.    protected void configure(HttpSecurity http) throws Exception {
  52.       http.//处理需要认证的请求
  53.               authorizeRequests()
  54.               //放行请求，前提:是对应的角色才行
  55.               .antMatchers("/admin/**").hasRole("admin")
  56.               .antMatchers("/user/**").hasRole("user")
  57.               //无需登录凭证，即可放行
  58.               .antMatchers("/kaptcha","/smscode").permitAll()//放行验证码的显示请求
  59.               //剩余的请求都需要认证才可以放行
  60.               .anyRequest().authenticated()
  61.               .and()
  62.               //表单形式登录的个性化配置
  63.               .formLogin()
  64.               .loginPage("/login.html").permitAll()
  65.               .loginProcessingUrl("/login").permitAll()
  66.               .defaultSuccessUrl("/main.html")//可以记住上一次的请求路径
  67.               //登录失败的处理器
  68.               .failureHandler(new MyFailHandler())
  69.               .and()
  70.               //退出登录相关设置
  71.               .logout()
  72.               //退出登录的请求，是再没退出前发出的，因此此时还有登录凭证
  73.               //可以访问
  74.               .logoutUrl("/logout")
  75.               //此时已经退出了登录，登录凭证没了
  76.               //那么想要访问非登录页面的请求，就必须保证这个请求无需凭证即可访问
  77.               .logoutSuccessUrl("/logout.html").permitAll()
  78.               //退出登录的时候，删除对应的cookie
  79.               .deleteCookies("JSESSIONID")
  80.               .and()
  81.               //记住我相关设置
  82.               .rememberMe()
  83.               //预定义key相关设置，默认是一串uuid
  84.               .key("dhy")
  85.               //令牌的持久化
  86.               .tokenRepository(jdbcTokenRepository())
  87.               .and()
  88.               .addFilterBefore(captchaCodeFilter, UsernamePasswordAuthenticationFilter.class)
  89.               //csrf关闭
  90.               .csrf().disable();
  92.    }
  94.    //角色继承
  95.    @Bean
  96.    RoleHierarchy roleHierarchy() {
  97.       RoleHierarchyImpl hierarchy = new RoleHierarchyImpl();
  98.       hierarchy.setHierarchy("ROLE_admin > ROLE_user");
  99.       return hierarchy;
  100.    }
  102. }

短信验证码校验过滤器

短信验证码的校验过滤器，和图片验证码的验证实现原理是一致的。都是通过继承OncePerRequestFilter实现一个Spring环境下的过滤器。其核心校验规则如下：

  • 用户登录时手机号不能为空
  • 用户登录时短信验证码不能为空
  • 用户登陆时在session中必须存在对应的校验谜底（获取验证码时存放的）
  • 用户登录时输入的短信验证码必须和“谜底”中的验证码一致
  • 用户登录时输入的手机号必须和“谜底”中保存的手机号一致
  • 用户登录时输入的手机号必须是系统注册用户的手机号，并且唯一
  1. @Component
  2. public class SmsCodeValidateFilter extends OncePerRequestFilter {
  4.     @Resource
  5.     UserDetailsService userDetailsService;
  7.     @Resource
  8.     MyFailHandler myAuthenticationFailureHandler;
  10.     @Override
  11.     protected void doFilterInternal(HttpServletRequest request,
  12.                                     HttpServletResponse response,
  13.                                     FilterChain filterChain)
  14.             throws ServletException, IOException {
  15.        //该过滤器只负责拦截验证码登录的请求
  16.        //并且请求必须是post
  17.         if (request.getRequestURI().equals("/smslogin")
  18.                 && request.getMethod().equalsIgnoreCase("post")) {
  19.             try {
  20.                 validate(new ServletWebRequest(request));
  22.             }catch (AuthenticationException e){
  23.                 myAuthenticationFailureHandler.onAuthenticationFailure(
  24.                         request,response,e);
  25.                 return;
  26.             }
  27.         }
  28.         filterChain.doFilter(request,response);
  29.     }
  31.     private void validate(ServletWebRequest request) throws ServletRequestBindingException {
  32.         HttpSession session = request.getRequest().getSession();
  33.         //从session取出获取验证码时,在session中存放验证码相关信息的类
  34.         SmsCode codeInSession = (SmsCode) session.getAttribute("sms_key");
  35.         //取出用户输入的验证码
  36.         String codeInRequest = request.getParameter("smsCode");
  37.         //取出用户输入的电话号码
  38.         String mobileInRequest = request.getParameter("mobile");
  39.         
  40.         //common-lang3包下的工具类
  41.         if(StringUtils.isEmpty(mobileInRequest)){
  42.             throw new SessionAuthenticationException("手机号码不能为空！");
  43.         }
  44.         if(StringUtils.isEmpty(codeInRequest)){
  45.             throw new SessionAuthenticationException("短信验证码不能为空！");
  46.         }
  47.         if(Objects.isNull(codeInSession)){
  48.             throw new SessionAuthenticationException("短信验证码不存在！");
  49.         }
  50.         if(codeInSession.isExpired())
  51.         {
  52.             //从session中移除保存的验证码相关信息
  53.             session.removeAttribute("sms_key");
  54.             throw new SessionAuthenticationException("短信验证码已过期！");
  55.         }
  56.         if(!codeInSession.getCode().equals(codeInRequest)){
  57.             throw new SessionAuthenticationException("短信验证码不正确！");
  58.         }
  60.         if(!codeInSession.getMobile().equals(mobileInRequest)){
  61.             throw new SessionAuthenticationException("短信发送目标与该手机号不一致！");
  62.         }
  63.         //数据库查询当前手机号是否注册过
  64.         UserDetails myUserDetails = userDetailsService.loadUserByUsername(mobileInRequest);
  65.         if(Objects.isNull(myUserDetails)){
  66.             throw new SessionAuthenticationException("您输入的手机号不是系统的注册用户");
  67.         }
  68.         //校验完毕并且没有抛出异常的情况下，移除session中保存的验证码信息
  69.         session.removeAttribute("sms_key");
  70.     }
  71. }

注意：一定要为"/smslogin"访问路径配置为permitAll访问权限

到这里，我们可以讲一下整体的短信验证登录流程，如上面的时序图。

  • 首先用户发起“获取短信验证码”请求，SmsCodeController中调用短信服务商接口发送短信，并将短信发送的“谜底”保存在session中。
  • 当用户发起登录请求，首先要经过SmsCodeValidateFilter对谜底和用户输入进行比对，比对失败则返回短信验证码校验失败
  • 当短信验证码校验成功，继续执行过滤器链中的SmsCodeAuthenticationFilter对用户进行认证授权。

短信验证码登录认证

我们可以仿照用户密码登录的流程，完成相关类的动态替换

由上图可以看出，短信验证码的登录认证逻辑和用户密码的登录认证流程是一样的。所以：

  • SmsCodeAuthenticationFilter仿造UsernamePasswordAuthenticationFilter进行开发
  • SmsCodeAuthenticationProvider仿造DaoAuthenticationProvider进行开发。

模拟实现：只不过将用户名、密码换成手机号进行认证，短信验证码在此部分已经没有用了，因为我们在SmsCodeValidateFilter已经验证过了。

  1. /** * 仿造UsernamePasswordAuthenticationFilter开发 */
  2. public class SmsCodeAuthenticationFilter extends AbstractAuthenticationProcessingFilter {
  4.     public static final String SPRING_SECURITY_FORM_MOBILE_KEY = "mobile";
  5.     private String mobileParameter = SPRING_SECURITY_FORM_MOBILE_KEY ;    //请求中携带手机号的参数名称
  6.     private boolean postOnly = true;    //指定当前过滤器是否只处理POST请求
  7.     //默认处理的请求
  8.     private static final AntPathRequestMatcher DEFAULT_ANT_PATH_REQUEST_MATCHER = new AntPathRequestMatcher("/smslogin", "POST");
  10.     public SmsCodeAuthenticationFilter() {
  11.         //指定当前过滤器处理的请求
  12.         super(DEFAULT_ANT_PATH_REQUEST_MATCHER);
  13.     }
  15.     //尝试进行认证
  16.     public Authentication attemptAuthentication(
  17.             HttpServletRequest request,
  18.             HttpServletResponse response)
  19.             throws AuthenticationException {
  20.         if (this.postOnly && !request.getMethod().equals("POST")) {
  21.             throw new AuthenticationServiceException("Authentication method not supported: " + request.getMethod());
  22.         } else {
  23.             String mobile = this.obtainMobile(request);
  24.             if (mobile == null) {
  25.                 mobile = "";
  26.             }
  27.             mobile = mobile.trim();
  28.             //认证前---手机号码是认证主体
  29.             SmsCodeAuthenticationToken authRequest = new SmsCodeAuthenticationToken(mobile);
  30.             //设置details---默认是sessionid和remoteaddr
  31.             this.setDetails(request, authRequest);
  32.             return this.getAuthenticationManager().authenticate(authRequest);
  33.         }
  34.     }
  36.     protected String obtainMobile(HttpServletRequest request) {
  37.         return request.getParameter(this.mobileParameter);
  38.     }
  40.     protected void setDetails(HttpServletRequest request, SmsCodeAuthenticationToken authRequest) {
  41.         authRequest.setDetails(this.authenticationDetailsSource.buildDetails(request));
  42.     }
  44.     public void setMobileParameter(String mobileParameter) {
  45.         Assert.hasText(mobileParameter, "Username parameter must not be empty or null");
  46.         this.mobileParameter = mobileParameter;
  47.     }
  49.     public void setPostOnly(boolean postOnly) {
  50.         this.postOnly = postOnly;
  51.     }
  53.     public final String getMobileParameter() {
  54.         return this.mobileParameter;
  55.     }
  57. }

认证令牌也需要替换:

  1. public class SmsCodeAuthenticationToken extends AbstractAuthenticationToken {
  2.     private static final long serialVersionUID = SpringSecurityCoreVersion.SERIAL_VERSION_UID;
  4.     //存放认证信息，认证之前存放手机号，认证之后存放登录的用户
  5.     private final Object principal;
  7. //认证前
  8.     public SmsCodeAuthenticationToken(String mobile) {
  9.         super((Collection)null);
  10.         this.principal = mobile;
  11.         this.setAuthenticated(false);
  12.     }
  14. //认证后，会设置相关的权限
  15.     public SmsCodeAuthenticationToken(Object principal, Collection<? extends GrantedAuthority> authorities) {
  16.         super(authorities);
  17.         this.principal = principal;
  18.         super.setAuthenticated(true);
  19.     }
  21.     public Object getCredentials() {
  22.         return null;
  23.     }
  25.     public Object getPrincipal() {
  26.         return this.principal;
  27.     }
  29.     public void setAuthenticated(boolean isAuthenticated) throws IllegalArgumentException {
  30.         if (isAuthenticated) {
  31.             throw new IllegalArgumentException("Cannot set this token to trusted - use constructor which takes a GrantedAuthority list instead");
  32.         } else {
  33.             super.setAuthenticated(false);
  34.         }
  35.     }
  37.     public void eraseCredentials() {
  38.         super.eraseCredentials();
  39.     }
  40. }

当前还需要提供能够对我们当前自定义令牌对象起到认证作用的provider,仿照DaoAuthenticationProvider

  1. public class SmsCodeAuthenticationProvider implements AuthenticationProvider{
  3.     private UserDetailsService userDetailsService;
  5.     public UserDetailsService getUserDetailsService() {
  6.         return userDetailsService;
  7.     }
  9.     public void setUserDetailsService(UserDetailsService userDetailsService) {
  10.         this.userDetailsService = userDetailsService;
  11.     }
  13.     /** * 进行身份认证的逻辑 * @param authentication 就是我们传入的Token * @return * @throws AuthenticationException */
  14.     @Override
  15.     public Authentication authenticate(Authentication authentication) throws AuthenticationException {
  17.         //利用UserDetailsService获取用户信息，拿到用户信息后重新组装一个已认证的Authentication
  18.         SmsCodeAuthenticationToken authenticationToken = (SmsCodeAuthenticationToken)authentication;
  19.         UserDetails user = userDetailsService.loadUserByUsername((String) authenticationToken.getPrincipal());  //根据手机号码拿到用户信息
  20.         if(user == null){
  21.             throw new InternalAuthenticationServiceException("无法获取用户信息");
  22.         }
  23.         //设置新的认证主体
  24.         SmsCodeAuthenticationToken authenticationResult = new SmsCodeAuthenticationToken(user,user.getAuthorities());
  25.         //copy details
  26.         authenticationResult.setDetails(authenticationToken.getDetails());
  27.         //返回新的令牌对象
  28.         return authenticationResult;
  29.     }
  31.     /** * AuthenticationManager挑选一个AuthenticationProvider * 来处理传入进来的Token就是根据supports方法来判断的 * @param aClass * @return */
  32.     @Override
  33.     public boolean supports(Class<?> aClass) {
  34.         //isAssignableFrom： 判断当前的Class对象所表示的类，
  35.         // 是不是参数中传递的Class对象所表示的类的父类，超接口，或者是相同的类型。
  36.         // 是则返回true，否则返回false。
  37.         return SmsCodeAuthenticationToken.class.isAssignableFrom(aClass);
  38.     }
  39. }

配置类进行综合组装

最后我们将以上实现进行组装，并将以上接口实现以配置的方式告知Spring Security。因为配置代码比较多，所以我们单独抽取一个关于短信验证码的配置类SmsCodeSecurityConfig，继承自SecurityConfigurerAdapter。

  1. @Component
  2. public class SmsCodeSecurityConfig extends SecurityConfigurerAdapter<DefaultSecurityFilterChain, HttpSecurity> {
  4.     @Resource
  5.     private MyFailHandler myAuthenticationFailureHandler;
  7.       //这里不能直接注入，否则会造成依赖注入的问题发生
  8.     private UserDetailsService myUserDetailsService;
  10.     @Resource
  11.     private SmsCodeValidateFilter smsCodeValidateFilter;
  13.     @Override
  14.     public void configure(HttpSecurity http) throws Exception {
  16.         SmsCodeAuthenticationFilter smsCodeAuthenticationFilter = new SmsCodeAuthenticationFilter();
  17.         smsCodeAuthenticationFilter.setAuthenticationManager(http.getSharedObject(AuthenticationManager.class));
  18.         //有则配置，无则不配置
  19.         //smsCodeAuthenticationFilter.setAuthenticationSuccessHandler(myAuthenticationSuccessHandler);
  20.         smsCodeAuthenticationFilter.setAuthenticationFailureHandler(myAuthenticationFailureHandler);
  22.         // 获取验证码登录令牌校验的提供者
  23.         SmsCodeAuthenticationProvider smsCodeAuthenticationProvider = new SmsCodeAuthenticationProvider();
  24.         smsCodeAuthenticationProvider.setUserDetailsService(myUserDetailsService);
  26.         //在用户密码过滤器前面加入短信验证码校验过滤器
  27.         http.addFilterBefore(smsCodeValidateFilter, UsernamePasswordAuthenticationFilter.class);
  28.         //在用户密码过滤器后面加入短信验证码认证授权过滤器 
  29.         http.authenticationProvider(smsCodeAuthenticationProvider)
  30.             .addFilterAfter(smsCodeAuthenticationFilter, UsernamePasswordAuthenticationFilter.class);
  32.     }
  33. }

该配置类可以用以下代码，集成到SecurityConfig中。

完整配置

  1. @Configuration
  2. public class SecurityConfig extends WebSecurityConfigurerAdapter {
  4.    private ObjectMapper objectMapper=new ObjectMapper();
  6.    @Resource
  7.    private CaptchaCodeFilter captchaCodeFilter;
  9.    @Resource
  10.    private SmsCodeSecurityConfig smsCodeSecurityConfig;
  12.    @Bean
  13.    PasswordEncoder passwordEncoder() {
  14.       return NoOpPasswordEncoder.getInstance();
  15.    }
  17.    @Override
  18.    public void configure(WebSecurity web) throws Exception {
  19.       web.ignoring().antMatchers("/js/**", "/css/**","/images/**");
  20.    }
  22.    //数据源注入
  23.    @Autowired
  24.    DataSource dataSource;
  26.    //持久化令牌配置
  27.    @Bean
  28.    JdbcTokenRepositoryImpl jdbcTokenRepository() {
  29.       JdbcTokenRepositoryImpl jdbcTokenRepository = new JdbcTokenRepositoryImpl();
  30.       jdbcTokenRepository.setDataSource(dataSource);
  31.       return jdbcTokenRepository;
  32.    }
  34.    //用户配置
  35.    @Override
  36.    @Bean
  37.    protected UserDetailsService userDetailsService() {
  38.       JdbcUserDetailsManager manager = new JdbcUserDetailsManager();
  39.       manager.setDataSource(dataSource);
  40.       if (!manager.userExists("dhy")) {
  41.          manager.createUser(User.withUsername("dhy").password("123").roles("admin").build());
  42.       }
  43.       if (!manager.userExists("大忽悠")) {
  44.          manager.createUser(User.withUsername("大忽悠").password("123").roles("user").build());
  45.       }
  46.       //模拟电话号码
  47.       if (!manager.userExists("123456789")) {
  48.          manager.createUser(User.withUsername("123456789").password("").roles("user").build());
  49.       }
  50.       return manager;
  51.    }
  53.    @Override
  54.    protected void configure(HttpSecurity http) throws Exception {
  56.  //设置一下userDetailService
  57.       smsCodeSecurityConfig.setMyUserDetailsService(userDetailsService());
  59.       http.//处理需要认证的请求
  60.               authorizeRequests()
  61.               //放行请求，前提:是对应的角色才行
  62.               .antMatchers("/admin/**").hasRole("admin")
  63.               .antMatchers("/user/**").hasRole("user")
  64.               //无需登录凭证，即可放行
  65.               .antMatchers("/kaptcha","/smscode","/smslogin").permitAll()//放行验证码的显示请求
  66.               //剩余的请求都需要认证才可以放行
  67.               .anyRequest().authenticated()
  68.               .and()
  69.               //表单形式登录的个性化配置
  70.               .formLogin()
  71.               .loginPage("/login.html").permitAll()
  72.               .loginProcessingUrl("/login").permitAll()
  73.               .defaultSuccessUrl("/main.html")//可以记住上一次的请求路径
  74.               //登录失败的处理器
  75.               .failureHandler(new MyFailHandler())
  76.               .and()
  77.               //退出登录相关设置
  78.               .logout()
  79.               //退出登录的请求，是再没退出前发出的，因此此时还有登录凭证
  80.               //可以访问
  81.               .logoutUrl("/logout")
  82.               //此时已经退出了登录，登录凭证没了
  83.               //那么想要访问非登录页面的请求，就必须保证这个请求无需凭证即可访问
  84.               .logoutSuccessUrl("/logout.html").permitAll()
  85.               //退出登录的时候，删除对应的cookie
  86.               .deleteCookies("JSESSIONID")
  87.               .and()
  88.               //记住我相关设置
  89.               .rememberMe()
  90.               //预定义key相关设置，默认是一串uuid
  91.               .key("dhy")
  92.               //令牌的持久化
  93.               .tokenRepository(jdbcTokenRepository())
  94.               .and()
  95.               //应用手机验证码的配置
  96.               .apply(smsCodeSecurityConfig)
  97.               .and()
  98.               //图形验证码
  99.               .addFilterBefore(captchaCodeFilter, UsernamePasswordAuthenticationFilter.class)
  100.               //csrf关闭
  101.               .csrf().disable();
  103.    }
  105.    //角色继承
  106.    @Bean
  107.    RoleHierarchy roleHierarchy() {
  108.       RoleHierarchyImpl hierarchy = new RoleHierarchyImpl();
  109.       hierarchy.setHierarchy("ROLE_admin > ROLE_user");
  110.       return hierarchy;
  111.    }
  113. }

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/m0_53157173/article/details/121438527

内容来源于网络，如有侵权，请联系作者删除！

运维服务器网络

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com