Spring Security(2) 自定义登录认证

心已赠人 2023-06-07 08:27 71阅读 0赞

一、前言

本篇文章将讲述Spring Security自定义登录认证校验用户名、密码，自定义密码加密方式，以及在前后端分离的情况下认证失败或成功处理返回json格式数据

温馨小提示：Spring Security中有默认的密码加密方式以及登录用户认证校验，但小编这里选择自定义是为了方便以后业务扩展，比如系统默认带一个超级管理员，当认证时识别到是超级管理员账号登录访问时给它赋予最高权限，可以访问系统所有api接口，或在登录认证成功后存入token以便用户访问系统其它接口时通过token认证用户权限等

Spring Security入门学习可参考之前文章：

SpringBoot集成Spring Security入门体验（一）

https://blog.csdn.net/qq_38225558/article/details/101754743

二、Spring Security 自定义登录认证处理

基本环境
  1. spring-boot 2.1.8
  2. mybatis-plus 2.2.0
  3. mysql
  4. maven项目

数据库用户信息表t_sys_user
在这里插入图片描述

案例中关于对该t_sys_user用户表相关的增删改查代码就不贴出来了，如有需要可参考文末提供的案例demo源码

1、Security 核心配置类

配置用户密码校验过滤器

  1. @Configuration
  2. @EnableWebSecurity
  3. @EnableGlobalMethodSecurity(prePostEnabled = true)
  4. public class SecurityConfig extends WebSecurityConfigurerAdapter { 
  6.     /** * 用户密码校验过滤器 */
  7.     private final AdminAuthenticationProcessingFilter adminAuthenticationProcessingFilter;
  9.     public SecurityConfig(AdminAuthenticationProcessingFilter adminAuthenticationProcessingFilter) { 
  10.         this.adminAuthenticationProcessingFilter = adminAuthenticationProcessingFilter;
  11.     }
  13.     /** * 权限配置 * @param http * @throws Exception */
  14.     @Override
  15.     protected void configure(HttpSecurity http) throws Exception { 
  16.         ExpressionUrlAuthorizationConfigurer<HttpSecurity>.ExpressionInterceptUrlRegistry registry = http.antMatcher("/**").authorizeRequests();
  18.         // 禁用CSRF 开启跨域
  19.         http.csrf().disable().cors();
  21.         // 登录处理 - 前后端一体的情况下
  22. //        registry.and().formLogin().loginPage("/login").defaultSuccessUrl("/").permitAll()
  23. //                // 自定义登陆用户名和密码属性名，默认为 username和password
  24. //                .usernameParameter("username").passwordParameter("password")
  25. //                // 异常处理
  26. //                .failureUrl("/login/error").permitAll()
  27. //                // 退出登录
  28. //                .and().logout().permitAll();
  30.         // 标识只能在 服务器本地ip[127.0.0.1或localhost] 访问`/home`接口，其他ip地址无法访问
  31.         registry.antMatchers("/home").hasIpAddress("127.0.0.1");
  32.         // 允许匿名的url - 可理解为放行接口 - 多个接口使用,分割
  33.         registry.antMatchers("/login", "/index").permitAll();
  34.         // OPTIONS(选项)：查找适用于一个特定网址资源的通讯选择。 在不需执行具体的涉及数据传输的动作情况下， 允许客户端来确定与资源相关的选项以及 / 或者要求， 或是一个服务器的性能
  35.         registry.antMatchers(HttpMethod.OPTIONS, "/**").denyAll();
  36.         // 自动登录 - cookie储存方式
  37.         registry.and().rememberMe();
  38.         // 其余所有请求都需要认证
  39.         registry.anyRequest().authenticated();
  40.         // 防止iframe 造成跨域
  41.         registry.and().headers().frameOptions().disable();
  43.         // 自定义过滤器认证用户名密码
  44.         http.addFilterAt(adminAuthenticationProcessingFilter, UsernamePasswordAuthenticationFilter.class);
  45.     }
  46. }

2、自定义用户密码校验过滤器

  1. @Slf4j
  2. @Component
  3. public class AdminAuthenticationProcessingFilter extends AbstractAuthenticationProcessingFilter { 
  5.     /** * @param authenticationManager: 认证管理器 * @param adminAuthenticationSuccessHandler: 认证成功处理 * @param adminAuthenticationFailureHandler: 认证失败处理 */
  6.     public AdminAuthenticationProcessingFilter(CusAuthenticationManager authenticationManager, AdminAuthenticationSuccessHandler adminAuthenticationSuccessHandler, AdminAuthenticationFailureHandler adminAuthenticationFailureHandler) { 
  7.         super(new AntPathRequestMatcher("/login", "POST"));
  8.         this.setAuthenticationManager(authenticationManager);
  9.         this.setAuthenticationSuccessHandler(adminAuthenticationSuccessHandler);
  10.         this.setAuthenticationFailureHandler(adminAuthenticationFailureHandler);
  11.     }
  13.     @Override
  14.     public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException { 
  15.         if (request.getContentType() == null || !request.getContentType().contains(Constants.REQUEST_HEADERS_CONTENT_TYPE)) { 
  16.             throw new AuthenticationServiceException("请求头类型不支持: " + request.getContentType());
  17.         }
  19.         UsernamePasswordAuthenticationToken authRequest;
  20.         try { 
  21.             MultiReadHttpServletRequest wrappedRequest = new MultiReadHttpServletRequest(request);
  22.             // 将前端传递的数据转换成jsonBean数据格式
  23.             User user = JSONObject.parseObject(wrappedRequest.getBodyJsonStrByJson(wrappedRequest), User.class);
  24.             authRequest = new UsernamePasswordAuthenticationToken(user.getUsername(), user.getPassword(), null);
  25.             authRequest.setDetails(authenticationDetailsSource.buildDetails(wrappedRequest));
  26.         } catch (Exception e) { 
  27.             throw new AuthenticationServiceException(e.getMessage());
  28.         }
  29.         return this.getAuthenticationManager().authenticate(authRequest);
  30.     }
  31. }

3、自定义认证管理器

  1. @Component
  2. public class CusAuthenticationManager implements AuthenticationManager { 
  4.     private final AdminAuthenticationProvider adminAuthenticationProvider;
  6.     public CusAuthenticationManager(AdminAuthenticationProvider adminAuthenticationProvider) { 
  7.         this.adminAuthenticationProvider = adminAuthenticationProvider;
  8.     }
  10.     @Override
  11.     public Authentication authenticate(Authentication authentication) throws AuthenticationException { 
  12.         Authentication result = adminAuthenticationProvider.authenticate(authentication);
  13.         if (Objects.nonNull(result)) { 
  14.             return result;
  15.         }
  16.         throw new ProviderNotFoundException("Authentication failed!");
  17.     }
  18. }

4、自定义认证处理

这里的密码加密验证工具类PasswordUtils可在文末源码中查看

  1. @Component
  2. public class AdminAuthenticationProvider implements AuthenticationProvider { 
  4.     @Autowired
  5.     UserDetailsServiceImpl userDetailsService;
  6.     @Autowired
  7.     private UserMapper userMapper;
  9.     @Override
  10.     public Authentication authenticate(Authentication authentication) throws AuthenticationException { 
  11.         // 获取前端表单中输入后返回的用户名、密码
  12.         String userName = (String) authentication.getPrincipal();
  13.         String password = (String) authentication.getCredentials();
  15.         SecurityUser userInfo = (SecurityUser) userDetailsService.loadUserByUsername(userName);
  17.         boolean isValid = PasswordUtils.isValidPassword(password, userInfo.getPassword(), userInfo.getCurrentUserInfo().getSalt());
  18.         // 验证密码
  19.         if (!isValid) { 
  20.             throw new BadCredentialsException("密码错误！");
  21.         }
  23.         // 前后端分离情况下 处理逻辑...
  24.         // 更新登录令牌 - 之后访问系统其它接口直接通过token认证用户权限...
  25.         String token = PasswordUtils.encodePassword(System.currentTimeMillis() + userInfo.getCurrentUserInfo().getSalt(), userInfo.getCurrentUserInfo().getSalt());
  26.         User user = userMapper.selectById(userInfo.getCurrentUserInfo().getId());
  27.         user.setToken(token);
  28.         userMapper.updateById(user);
  29.         userInfo.getCurrentUserInfo().setToken(token);
  30.         return new UsernamePasswordAuthenticationToken(userInfo, password, userInfo.getAuthorities());
  31.     }
  33.     @Override
  34.     public boolean supports(Class<?> aClass) { 
  35.         return true;
  36.     }
  37. }

其中小编自定义了一个UserDetailsServiceImpl类去实现UserDetailsService类 -> 用于认证用户详情
和自定义一个SecurityUser类实现UserDetails类 -> 安全认证用户详情信息

  1. @Service("userDetailsService")
  2. public class UserDetailsServiceImpl implements UserDetailsService { 
  4.     @Autowired
  5.     private UserMapper userMapper;
  7.     /*** * 根据账号获取用户信息 * @param username: * @return: org.springframework.security.core.userdetails.UserDetails */
  8.     @Override
  9.     public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException { 
  10.         // 从数据库中取出用户信息
  11.         List<User> userList = userMapper.selectList(new EntityWrapper<User>().eq("username", username));
  12.         User user;
  13.         // 判断用户是否存在
  14.         if (!CollectionUtils.isEmpty(userList)){ 
  15.             user = userList.get(0);
  16.         } else { 
  17.             throw new UsernameNotFoundException("用户名不存在！");
  18.         }
  19.         // 返回UserDetails实现类
  20.         return new SecurityUser(user);
  21.     }
  22. }

安全认证用户详情信息

  1. @Data
  2. @Slf4j
  3. public class SecurityUser implements UserDetails { 
  4.     /** * 当前登录用户 */
  5.     private transient User currentUserInfo;
  7.     public SecurityUser() { 
  8.     }
  10.     public SecurityUser(User user) { 
  11.         if (user != null) { 
  12.             this.currentUserInfo = user;
  13.         }
  14.     }
  16.     @Override
  17.     public Collection<? extends GrantedAuthority> getAuthorities() { 
  18.         Collection<GrantedAuthority> authorities = new ArrayList<>();
  19.         SimpleGrantedAuthority authority = new SimpleGrantedAuthority("admin");
  20.         authorities.add(authority);
  21.         return authorities;
  22.     }
  24.     @Override
  25.     public String getPassword() { 
  26.         return currentUserInfo.getPassword();
  27.     }
  29.     @Override
  30.     public String getUsername() { 
  31.         return currentUserInfo.getUsername();
  32.     }
  34.     @Override
  35.     public boolean isAccountNonExpired() { 
  36.         return true;
  37.     }
  39.     @Override
  40.     public boolean isAccountNonLocked() { 
  41.         return true;
  42.     }
  44.     @Override
  45.     public boolean isCredentialsNonExpired() { 
  46.         return true;
  47.     }
  49.     @Override
  50.     public boolean isEnabled() { 
  51.         return true;
  52.     }
  53. }

5、自定义认证成功或失败处理方式

  1. 认证成功处理类实现AuthenticationSuccessHandler类重写onAuthenticationSuccess方法
  2. 认证失败处理类实现AuthenticationFailureHandler类重写onAuthenticationFailure方法

在前后端分离情况下小编认证成功和失败都返回json数据格式

认证成功后这里小编只返回了一个token给前端，其它信息可根据个人业务实际处理

  1. @Component
  2. public class AdminAuthenticationSuccessHandler implements AuthenticationSuccessHandler { 
  3.     @Override
  4.     public void onAuthenticationSuccess(HttpServletRequest httpServletRequest, HttpServletResponse response, Authentication auth) throws IOException, ServletException { 
  5.         User user = new User();
  6.         SecurityUser securityUser = ((SecurityUser) auth.getPrincipal());
  7.         user.setToken(securityUser.getCurrentUserInfo().getToken());
  8.         ResponseUtils.out(response, ApiResult.ok("登录成功!", user));
  9.     }
  10. }

认证失败捕捉异常自定义错误信息返回给前端

  1. @Slf4j
  2. @Component
  3. public class AdminAuthenticationFailureHandler implements AuthenticationFailureHandler { 
  4.     @Override
  5.     public void onAuthenticationFailure(HttpServletRequest httpServletRequest, HttpServletResponse response, AuthenticationException e) throws IOException, ServletException { 
  6.         ApiResult result;
  7.         if (e instanceof UsernameNotFoundException || e instanceof BadCredentialsException) { 
  8.             result = ApiResult.fail(e.getMessage());
  9.         } else if (e instanceof LockedException) { 
  10.             result = ApiResult.fail("账户被锁定，请联系管理员!");
  11.         } else if (e instanceof CredentialsExpiredException) { 
  12.             result = ApiResult.fail("证书过期，请联系管理员!");
  13.         } else if (e instanceof AccountExpiredException) { 
  14.             result = ApiResult.fail("账户过期，请联系管理员!");
  15.         } else if (e instanceof DisabledException) { 
  16.             result = ApiResult.fail("账户被禁用，请联系管理员!");
  17.         } else { 
  18.             log.error("登录失败：", e);
  19.             result = ApiResult.fail("登录失败!");
  20.         }
  21.         ResponseUtils.out(response, result);
  22.     }
  23. }
温馨小提示：

前后端一体的情况下可通过在Spring Security核心配置类中配置异常处理接口然后通过如下方式获取异常信息

  1. AuthenticationException e = (AuthenticationException) request.getSession().getAttribute("SPRING_SECURITY_LAST_EXCEPTION");
  2. System.out.println(e.getMessage());

三、前端页面

这里2个简单的html页面模拟前后端分离情况下登陆处理场景

1、登陆页

login.html

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Login</title>
  6. </head>
  7. <body>
  8. <h1>Spring Security</h1>
  9. <form method="post" action="" onsubmit="return false">
  10.     <div>
  11.         用户名：<input type="text" name="username" id="username">
  12.     </div>
  13.     <div>
  14.         密码：<input type="password" name="password" id="password">
  15.     </div>
  16.     <div>
  17. <!-- <label><input type="checkbox" name="remember-me" id="remember-me"/>自动登录</label>-->
  18.         <button onclick="login()">登陆</button>
  19.     </div>
  20. </form>
  21. </body>
  22. <script src="http://libs.baidu.com/jquery/1.9.0/jquery.js" type="text/javascript"></script>
  23. <script type="text/javascript"> function login() { var username = document.getElementById("username").value; var password = document.getElementById("password").value; // var rememberMe = document.getElementById("remember-me").value; $.ajax({ async: false, type: "POST", dataType: "json", url: '/login', contentType: "application/json", data: JSON.stringify({ "username": username, "password": password // "remember-me": rememberMe }), success: function (result) { console.log(result) if (result.code == 200) { alert("登陆成功"); window.location.href = "../home.html"; } else { alert(result.message) } } }); } </script>
  24. </html>
2、首页

home.html

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Title</title>
  6. </head>
  7. <body>
  8. <h3>您好，登陆成功</h3>
  9. <button onclick="window.location.href='/logout'">退出登录</button>
  10. </body>
  11. </html>

四、测试接口

  1. @Slf4j
  2. @RestController
  3. public class IndexController { 
  5.     @GetMapping("/")
  6.     public ModelAndView showHome() { 
  7.         return new ModelAndView("home.html");
  8.     }
  10.     @GetMapping("/index")
  11.     public String index() { 
  12.         return "Hello World ~";
  13.     }
  15.     @GetMapping("/login")
  16.     public ModelAndView login() { 
  17.         return new ModelAndView("login.html");
  18.     }
  20.     @GetMapping("/home")
  21.     public String home() { 
  22.         String name = SecurityContextHolder.getContext().getAuthentication().getName();
  23.         log.info("登陆人：" + name);
  24.         return "Hello~ " + name;
  25.     }
  27.     @GetMapping(value ="/admin")
  28.     // 访问路径`/admin` 具有`crud`权限
  29.     @PreAuthorize("hasPermission('/admin','crud')")
  30.     public String admin() { 
  31.         return "Hello~ 管理员";
  32.     }
  34.     @GetMapping("/test")
  35. // @PreAuthorize("hasPermission('/test','t')")
  36.     public String test() { 
  37.         return "Hello~ 测试权限访问接口";
  38.     }
  40.     /** * 登录异常处理 - 前后端一体的情况下 * @param request * @param response */
  41.     @RequestMapping("/login/error")
  42.     public void loginError(HttpServletRequest request, HttpServletResponse response) { 
  43.         AuthenticationException e = (AuthenticationException) request.getSession().getAttribute("SPRING_SECURITY_LAST_EXCEPTION");
  44.         log.error(e.getMessage());
  45.         ResponseUtils.out(response, ApiResult.fail(e.getMessage()));
  46.     }
  47. }

五、测试访问效果

数据库账号:admin 密码:123456

1. 输入错误用户名提示该用户不存在

在这里插入图片描述

2. 输入错误密码提示密码错误

在这里插入图片描述

3. 输入正确用户名和账号，提示登陆成功，然后跳转到首页

在这里插入图片描述
在这里插入图片描述

登陆成功后即可正常访问其他接口，如果是未登录情况下将访问不了

在这里插入图片描述

温馨小提示：这里在未登录时或访问未授权的接口时，后端暂时没有做处理，相关案例将会放在后面的权限控制案例教程中讲解

在这里插入图片描述

六、总结

  1. 在Spring Security核心配置类中设置自定义的用户密码校验过滤器(AdminAuthenticationProcessingFilter)
  2. 在自定义的用户密码校验过滤器中配置认证管理器(CusAuthenticationManager)、认证成功处理(AdminAuthenticationSuccessHandler)和认证失败处理(AdminAuthenticationFailureHandler)等
  3. 在自定义的认证管理器中配置自定义的认证处理(AdminAuthenticationProvider)
  4. 然后就是在认证处理中实现自己的相应业务逻辑等
Security相关代码结构：

在这里插入图片描述

本文案例源码

https://gitee.com/zhengqingya/java-workspace

发表评论

表情：
评论列表 （有 0 条评论，71人围观）

还没有评论，来说两句吧...

相关阅读