栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

SpringSecurity

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

SpringSecurity

SpringSecurity
  • 一、简介
    • 1.1 SpringSecurity简介
    • 1.2 JWT简介
    • 1.3 SpringSecurity完整流程
  • 二、快速入门
  • 三、认证
    • 3.1 登录校验流程
    • 3.2 认证流程
    • 3.3 实现
      • 3.3.1 思路分析
      • 3.3.2 相关准备
      • 3.3.3 核心实现
  • 四、授权
    • 4.1 权限系统的作用
    • 4.2 授权的方式
    • 4.3 授权流程
    • 4.4 实现
      • 4.4.1 限制访问资源所需权限
      • 4.4.2 封装权限信息
      • 4.4.3 从数据库查询权限信息
  • 五、前后端跨域问题
  • 六、自定义方法
    • 6.1 自定义失败处理
    • 6.2 自定义权限校验方法
    • 6.3 自定义认证成功处理器
    • 6.4 自定义认证失败处理器
    • 6.5 自定义登出成功处理器

一、简介 1.1 SpringSecurity简介

SpringSecurity是一个功能强大且高度可定制的身份验证和访问控制框架,提供了完善的认证机制和方法级的授权功能。它的核心是一组过滤器链,不同的功能经由不同的过滤器,项目启动后将会自动配置,从而实现安全管理。

一般Web应用都需要进行认证和授权,而这两部分也正是 SpringSecurity 作为安全框架的核心:
认证:验证当前访问系统的是不是本系统的用户,并且要确认具体是哪个用户;
授权:经过认证后判断当前用户是否有权限进行某个操作。

1.2 JWT简介

JWT(JSON Web Token),是一种用于通信双方之间传递安全信息的简洁的、URL安全的表述性声明规范。一个JWT实际上就是一个字符串,它由三部分组成:头部、载荷和签名。

最终生成的JWT令牌如下所示,由三部分组成,中间用 . 分割。

base64UrlEncode(JWT头) + “.” + base64UrlEncode(载荷) + “.” + HMACSHA256(base64UrlEncode(JWT头) + “.” + base64UrlEncode(有效载荷) ,密钥)

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9.TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONFh7HgQ

1.3 SpringSecurity完整流程

SpringSecurity 就是通过一个过滤器链(其内部包含了提供各种功能的过滤器),一个请求只有经过层层的过滤器后才可以到达API,从而实现认证和授权功能。

下图中只展示了核心过滤器:

  1. UsernamePasswordAuthenticationFilter:负责处理我们在登录页面填写了用户名密码后的登录请求。(入门案例的认证工作主要由它负责)

  2. ExceptionTranslationFilter:处理过滤器链中抛出的任何 AccessDeniedException 和AuthenticationException 异常。(做异常处理)

  3. FilterSecurityInterceptor:负责权限校验。(主要完成授权功能)

SpringSecurity 除了上面的过滤器之外,还有很多个过滤器,我们可以通过 debug 模式启动一个入门项目,利用计算属性来查看过滤器链中都有哪些过滤器以及它们的顺序:

@SpringBootApplication
@MapperScan("com.qhj.mapper")
public class SecurityApplication {
    public static void main(String[] args) {
        ConfigurableApplicationContext run = SpringApplication.run(SecurityApplication.class, args);
        System.out.println(111);
    }
}

在计算属性中输入:run.getBean(DefaultSecurityFilterChain.class)来查看:

二、快速入门
  • ① 创建工程

    创建一个新的 SpringBoot 工程,名为:Project_SpringSecurity。

  • ② 导入依赖

    在 SpringBoot 项目中使用 SpringSecurity 时,只需要引入依赖即可。引入依赖后在访问接口时就会自动跳转到一个 SpringSecurity 的默认登录页面,默认的用户名是 user,密码会在控制台输出。

    
        org.springframework.boot
        spring-boot-starter-parent
        2.5.0
    
    
       org.springframework.boot
        spring-boot-starter-web
        2.5.12
    
    
    
        org.projectlombok
        lombok
        true
    
    
    
        org.springframework.boot
        spring-boot-starter-security
    
    
  • ③ yml配置

    在 application.yml 中只配置了端口号。

    server:
      port: 8888
    
  • ④ 启动类

    package com;
    
    import org.mybatis.spring.annotation.MapperScan;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
    import org.springframework.context.ConfigurableApplicationContext;
    
    
    
    @SpringBootApplication
    @MapperScan("com.qhj.mapper")
    public class SecurityApplication {
        public static void main(String[] args) {
        	// 这里是为了debug模式下查看所有的过滤器
            ConfigurableApplicationContext run = SpringApplication.run(SecurityApplication.class, args);
            System.out.println(111);
        }
    }
    
  • ⑤ 控制器API

    package com.qhj.controller;
    
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    
    @RestController
    public class HelloController {
    
        @RequestMapping("/hello")
        public String hello(){
            return "hello";
        }
    }
    
  • ⑥ 启动项目并访问

    启动项目并访问:localhost:8888/hello,进入了 SpringSecurity 的内置页面,需要验证后才可以访问,到控制台查看密码,输入用户名和密码后进行登录:

三、认证 3.1 登录校验流程

用户执行登录时会有以下几个步骤:

  1. 前端:用户输入用户名和密码后访问登录接口;
  2. 后端:服务器会执行与数据库中的用户名和密码进行比较操作,如果用户名和密码正确,使用用户名/用户id 生成一个 JWT 响应给前端;
  3. 前端:收到后端服务器响应的JWT,并将其保存,待访问其他请求时随身携带;
  4. 前端:登录后需要访问其他请求时在请求头中携带 token,发起请求;
  5. 后端:获取请求头中的 token 进行解析后获取 userID,根据 userID 获取用户的相关信息(如果有权限则允许访问相关资源),最后访问目标资源响应给前端。
  6. 前端:收到请求后的响应信息。

3.2 认证流程

认证流程:

  1. 用户提交用户名和密码后被 SecurityFilterChain 中的 UsernamePasswordAuthenticationFilter 过滤器获取到,封装成 Authentication 对象(通常情况下是 UsernamePasswordAuthenticationToken 这个实现类)。
  2. 然后过滤器将 Authentication 提交至认证管理器(ProviderManager)进行认证后,再交给 DaoAuthenticationProvider 进行委托认证。
  3. DaoAuthenticationProvider 进行认证的时候,首先调用自己的父类 AbstractUserDetailsAuthenticationProvider 的 authenticate方法进行委托认证。
  4. 然后调用 UserDetailsService 中的 loadUserByUsername 方法获取用户信息以及用户的权限信息,如果获取到了,就将用户信息包括其权限信息封装成 UserDetails 对象后返回。
  5. 然后 AbstractUserDetailsAuthenticationProvider 进行密码验证。
  6. 认证成功后 AuthenticationManager 身份管理器返回一个被填充满信息的(包括权限信息、身份信息、细节想信息,但是密码通常会被移除)Authentication 实例。
  7. SecurityContextHolder 安全上下文容器将填充了信息的 Authentication 通过 SecurityContextHolder.getContext().setAuthentication(…)方法设置到其中。

小贴士:

  1. 可以看出 AuthenticationManager 接口(认证管理器)是认证相关的核心接口,也是发起认证的出发点,它的实现类为 ProviderManager。而 Spring Security 支持多种认证方式,因此 ProviderManager 维护着一个 List 列表,存放多种认证方式,最终实际的认证工作是由 AuthenticationProvider 完成的。
  2. web表单对应的 AuthenticationProvide 实现类为 DaoAuthenticationProvider,它的内部又维护着一个 UserDetailsService 负责 UserDetails 的获取。最终 AuthenticationProvide r将 UserDetails填充至 Authentication。
3.3 实现 3.3.1 思路分析

从认证流程中我们可以看出,获取用户信息和其权限时通过调用 loadUserByUsername 方法从内存中查找的,但是在日常的开发中,我们习惯于从数据库中查询相关数据,因此需要自己来定义接口及其实现类,以便实现从数据库中查询数据。

登录操作涉及到两个步骤:登录和校验。

  • 登录
  1. 自定义登录接口

    ① 调用 ProviderManager 的方法进行认证,如果认证通过就生成 JWT;
    ② 把用户信息存入 redis中。

  2. 自定义 UserDetailsService

    在这个实现类中编写去数据库中查询数据的逻辑。

  • 校验

    ① 自定义 JWT 认证过滤器;
    ② 获取 token;
    ③ 解析 token,获取其中的 userID;
    ④ 从 redis 中获取用户信息;
    ⑤ 将用户信息及其权限信息存取 SecurityContextHolder 中。

3.3.2 相关准备
  • 引入相关依赖

    
    
        org.springframework.boot
        spring-boot-starter-data-redis
    
    
    
        com.alibaba
        fastjson
        1.2.33
    
    
    
        io.jsonwebtoken
        jjwt
        0.9.0
    
    
    
        com.baomidou
        mybatis-plus-boot-starter
        3.4.3
    
    
    
        mysql
        mysql-connector-java
    
    
    
        org.springframework.boot
        spring-boot-starter-test
    
    
  • yml配置

    spring:
      datasource:
        driver-class-name: com.mysql.jdbc.Driver
        url: jdbc:mysql://localhost:3306/数据库名称?characterEncoding=utf-8&serverTimezone=UTC
        username: root
        password: root
    
      redis:
        # 超时时间
        timeout: 10000ms
        # 服务器地址
        host: redis地址
    
    # 开启 Mybatis下划线命名转驼峰命名
    mybatis-plus:
      configuration:
        map-underscore-to-camel-case: true
      mapper-locations: classpath*:/mapper*.xml
    
  • 其他

    数据库、pojo类、Redis配置类、响应类、JWT工具类这些就不展示了…

3.3.3 核心实现
  • 基础实现及测试

    ① 重新定义一个实体类实现 UserDetails 接口,用来封装用户信息

    @Data
    @NoArgsConstructor
    public class LoginUser implements UserDetails {
    
        private User user;
    
        @Override
        public Collection getAuthorities() {
            return null;
        }
    
        @Override
        public String getPassword() {
            return user.getPassword();
        }
    
        @Override
        public String getUsername() {
            return user.getUserName();
        }
    
        @Override
        public boolean isAccountNonExpired() {
            return true;
        }
    
        @Override
        public boolean isAccountNonLocked() {
            return true;
        }
    
        @Override
        public boolean isCredentialsNonExpired() {
            return true;
        }
    
        @Override
        public boolean isEnabled() {
            return true;
        }
    }
    

    ② mapper接口

    public interface UserMapper extends BaseMapper {
    }
    

    ③ 自定义 UserDetailsServiceImpl 类

    @Service
    public class UserDetailsServiceImpl implements UserDetailsService {
    
        @Autowired
        private UserMapper userMapper;
    
        @Override
        public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
            // 1.认证:根据用户名查询用户信息
    //        QueryWrapper queryWrapper = new QueryWrapper<>();
    //        queryWrapper.eq("user_name", username);
    //        User user = userMapper.selectOne(queryWrapper);
            LambdaQueryWrapper lambdaQueryWrapper = new LambdaQueryWrapper<>();
            lambdaQueryWrapper.eq(User::getUserName, username);
            User user = userMapper.selectOne(lambdaQueryWrapper);
            // 如果没有查询到用户信息
            if (Objects.isNull(user)){
                throw new RuntimeException("用户名或密码错误!");
            }
            // TODO
            // 2.授权:根据用户信息查询权限,一个用户可能对应多个权限
            return new LoginUser(user);
        }
    }
    

    ④ 启动测试

    启动项目后,就可以使用 qhj 作为用户名,1234作为密码来登录了。

    注意:
    如果想让用户的密码是明文存储,需要在密码前加 {noop}。

  • 密码加密存储

    在实际项目中我们时不会把密码明文存储在数据库中的。

    默认使用的 PasswordEncoder 要求数据库中的密码格式为:{id}password 。它会根据id去判断密码的加密方式。但是我们一般不会采用这种方式。所以就需要替换 PasswordEncoder。

    我们一般使用SpringSecurity为我们提供的 BCryptPasswordEncoder。只需要使用把BCryptPasswordEncoder 对象注入到 Spring 容器中,SpringSecurity 就会使用该PasswordEncoder 来进行密码校验。

    ​ 通过定义一个 SpringSecurity 的配置类,SpringSecurity 要求这个配置类要继承WebSecurityConfigurerAdapter 来实现。

    @Configuration
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
    
        @Bean
        public BCryptPasswordEncoder bCryptPasswordEncoder(){
            return new BCryptPasswordEncoder();
        }
    }  
    
  • 登录接口

    接下来需要自定义一个登录接口,然后让 SpringSecurity 对这个接口放行,让用户访问这个接口的时候不用登录也能访问。

    在接口中通过 AuthenticationManager 的 authenticate 方法来进行用户认证,所以需要在SecurityConfig 中配置把 AuthenticationManager 注入容器。

    认证成功后会生成一个JWT,放入响应中返回。并且为了让用户下次请求时能通过 JWT 识别出具体的是哪个用户,我们需要把用户信息存入 redis 中,可以把用户 id 作为 key。

    @Configuration
    @EnableGlobalMethodSecurity(prePostEnabled = true) // 开启注解功能
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
    
    
        @Bean
        public BCryptPasswordEncoder bCryptPasswordEncoder(){
            return new BCryptPasswordEncoder();
        }
    
    	@Bean
        @Override
        public AuthenticationManager authenticationManagerBean() throws Exception {
            return super.authenticationManagerBean();
        }
    
        @Override
        protected void configure(HttpSecurity http) throws Exception {
            // 配置认证规则
            http
                // 关闭csrf
                .csrf().disable()
                // 不通过Session获取SecurityContext
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                .authorizeRequests()
                // 对于登录接口 允许匿名访问(放行请求)
                    // .permitAll() 未登录和已登录的都可以访问
                    // .anonymous() 匿名登录,未登录状态可以访问
                    // .anthenticated() 任意的用户必须认证之后才可以访问(请求需要鉴权认证)
                .antMatchers("/user/login").anonymous()
                // 除上面外的所有请求全部需要鉴权认证
                .anyRequest().authenticated();
        }
    }
    

    注意:
    .permitAll() 未登录和已登录的都可以访问;
    .anonymous() 匿名登录,未登录状态可以访问;
    .anthenticated() 任意的用户必须认证之后才可以访问(请求需要鉴权认证)。

    @Service
    public class LoginServiceImpl implements LoginService {
    
        @Autowired
        private AuthenticationManager authenticationManager;
        @Autowired
        private RedisCache redisCache;
    
        
        @Override
        public ResponseResult login(User user) {
            UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(user.getUserName(), user.getPassword());
            // 调用authenticate方法进行用户认证
            Authentication authenticate = authenticationManager.authenticate(authenticationToken);
            // 认证未通过
            if (Objects.isNull(authenticate)){
                throw new RuntimeException("用户名或密码错误!");
            }
            // 使用userid生成token
            LoginUser loginUser = (LoginUser) authenticate.getPrincipal();
            String userId = loginUser.getUser().getId().toString();
            // 生成jwt(token中要存放的数据)
            String jwt = JwtUtil.createJWT(userId);
            // 将authenticate存入redis
            redisCache.setCacheObject("login:" + userId, loginUser);
            // 把token响应给前端
            Map map = new HashMap<>();
            map.put("token", jwt);
            return new ResponseResult(200, "登录成功!", map);
        }
    }
    
    @RestController
    public class LoginController {
    
        @Autowired
        private LoginService loginService;
    
        @RequestMapping("/user/login")
        public ResponseResult login(@RequestBody User user){
            return loginService.login(user);
        }
    }
    
  • 认证过滤器

    通过自定义一个过滤器,这个过滤器会去获取请求头中的 token,对 token 进行解析取出其中的userid。然后使用 userid 去 redis 中获取对应的 LoginUser 对象。​最后封装 Authentication 对象存入 SecurityContextHolder 中。

    @Configuration
    public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {
    
        @Autowired
        private RedisCache redisCache;
    
        @Override
        protected void doFilterInternal(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, FilterChain filterChain) throws ServletException, IOException {
            // 1.获取token
            String token = httpServletRequest.getHeader("token");
            // 如果没有token信息,说明没有登录 放行
            if (!StringUtils.hasText(token)){
                // 放行
                filterChain.doFilter(httpServletRequest, httpServletResponse);
                return;
            }
            // 2.解析token
            String userId = null;
            try{
                Claims claims = JwtUtil.parseJWT(token);
                userId = claims.getSubject();
            }catch (Exception e){
                throw new RuntimeException("token是非法的!");
            }
            // 3.从redis中获取用户信息
            String redisKey = "login:" + userId;
            LoginUser loginUser = redisCache.getCacheObject(redisKey);
            // 如果redis中没有用户信息
            if (Objects.isNull(loginUser)){
                throw new RuntimeException("尚未登录,请登录!");
            }
            // 4.将用户信息存入SecurityContextHolder中
            // TODO 获取权限信息封装到Authentication中
            UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(loginUser, null, loginUser.getAuthorities());
            SecurityContextHolder.getContext().setAuthentication(authenticationToken);
            // 5.放行
            filterChain.doFilter(httpServletRequest, httpServletResponse);
        }
    }
    
    @Configuration
    @EnableGlobalMethodSecurity(prePostEnabled = true) // 开启注解功能
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
    
        @Autowired
        private JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;
    
        @Bean
        public BCryptPasswordEncoder bCryptPasswordEncoder(){
            return new BCryptPasswordEncoder();
        }
    
        @Override
        protected void configure(HttpSecurity http) throws Exception {
            // 配置认证规则
            http
                // 关闭csrf
                .csrf().disable()
                // 不通过Session获取SecurityContext
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                .authorizeRequests()
                // 对于登录接口 允许匿名访问(放行请求)
                    // .permitAll() 未登录和已登录的都可以访问
                    // .anonymous() 匿名登录,未登录状态可以访问
                    // .anthenticated() 任意的用户必须认证之后才可以访问(请求需要鉴权认证)
                .antMatchers("/user/login").anonymous()
                    // 基于配置的权限控制
                    // .antMatchers("/").hasAuthority("system:dept:list")
                // 除上面外的所有请求全部需要鉴权认证
                .anyRequest().authenticated();
    
            // 添加JWT登录授权过滤器(将token校验过滤器添加到过滤器链中)
            http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
        }
    }
    
  • 退出登录

    @Service
    public class LoginServiceImpl implements LoginService {
    
        @Autowired
        private RedisCache redisCache;
        
        
        @Override
        public ResponseResult logout() {
            // 1.获取SecurityContextHolder中的值
            UsernamePasswordAuthenticationToken authentication = (UsernamePasswordAuthenticationToken) SecurityContextHolder.getContext().getAuthentication();
            LoginUser loginUser = (LoginUser) authentication.getPrincipal();
            Long userId = loginUser.getUser().getId();
            // 2.删除redis中的值
            redisCache.deleteObject("login:" + userId);
            return new ResponseResult(200, "注销成功!");
        }
    }
    
四、授权 4.1 权限系统的作用

例如:一个学校图书馆的管理系统,如果是普通学生登录就能看到借书还书相关的功能,但是他看不到并且不能使用添加书籍信息、删除书籍信息等功能。如果是一个图书馆管理员的账号登录,他就能看到并且可以使用添加书籍信息、删除书籍信息等功能。

也就是说不同的用户可以使用不同的功能,这就是权限系统要去实现的效果。

​在日常的开发中,我们不能只依赖前端去判断用户的权限来选择显示哪些菜单哪些按钮。因为如果只是这样的话,如果有人知道了对应功能的接口地址就可以不通过前端,直接去发送请求来实现相关功能操作,而这样做的后果是我们都无法想象的。

​所以还需要在后台进行用户权限的判断,判断当前用户是否有相应的权限,必须具有所需权限才能进行相应的操作。

4.2 授权的方式

授权的方式包括: web 授权和方法授权。web授权是通过 url 拦截进行授权,一般在配置类中做拦截;方法授权是通过方法拦截进行授权,一般在 controller 中添加注解进行方法的授权。

他们都会调用 accessDecisionManager 进行授权决策:若为 web 授权则拦截器为 FilterSecurityInterceptor;若为方法授权则拦截器为 MethodSecurityInterceptor。

如果同时通过web授权和方法授权,则先执行 web 授权再执行方法授权,最后决策通过则允许访问,否则将禁止访问。

4.3 授权流程

授权流程:

  1. 拦截请求,已认证用户访问受保护的 web 资源将被 SecurityFilterChain 中的 FilterSecurityInterceptor 的子类拦截。
  2. 获取资源访问策略,FilterSecurityInterceptor 会从 SecurityMetadataSource 的子类 DefaultFilterInvocationSecurityMetadataSource 获取要访问当前资源所需要的权限 Collection 。 SecurityMetadataSource 其实就是读取访问策略的抽象,而读取的内容,其实就是我们配置的访问规则。
  3. 最后,FilterSecurityInterceptor 会调用 AccessDecisionManager 进行授权决策,若决策通过,则允许访问资源,否则将禁止访问。

4.4 实现 4.4.1 限制访问资源所需权限

​ SpringSecurity 为我们提供了基于注解和基于配置的权限控制方案,这也是项目中主要采用的方式。我们可以使用注解去指定访问对应的资源所需的权限,但是要使用它我们需要先在 Security 配置类中开启相关配置。也可以在配置类中配置访问对应的资源所需的权限。

  • 方式一:基于注解

    // 开启注解功能
    @EnableGlobalMethodSecurity(prePostEnabled = true) 
    

    开启注解功能后就可以在 controller 中使用相关注解了:

    @RestController
    public class HelloController {
    
        @RequestMapping("/hello")
        
        @PreAuthorize("hasAuthority('system:dept:list')")
        public String hello(){
            return "hello";
        }
    }
    

    小贴士:权限校验方法有以下几种

    1. @PreAuthorize(“hasAuthority(‘system:dept:list’)”)表示验证一个权限。
    2. @PreAuthorize(“hasAnyAuthority(‘admin’,‘test’,‘system:dept:list’)”)表示验证多个权限,用户只要有其中任意一个权限就可以访问。
    3. @PreAuthorize(“hasRole(‘system:dept:list’)”)表示验证一个权限,但是内部会在参数前拼接“ROLE_”后再做比较。
    4. @PreAuthorize(“hasAnyRole(‘admin’,‘system:dept:list’)”)表示验证多个权限,在比较时都会在参数前拼接“ROLE_”后再做比较。
  • 方式二:基于配置

    @RestController
    public class HelloController {
    
        @RequestMapping("/hello")
        public String hello(){
            return "hello";
        }
    }
    
    @Configuration
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
    
        @Autowired
        private JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;
    
        @Bean
        public BCryptPasswordEncoder bCryptPasswordEncoder(){
            return new BCryptPasswordEncoder();
        }
    
        @Bean
        @Override
        public AuthenticationManager authenticationManagerBean() throws Exception {
            return super.authenticationManagerBean();
        }
    
        @Override
        protected void configure(HttpSecurity http) throws Exception {
            // 配置认证规则
            http
                // 关闭csrf
                .csrf().disable()
                // 不通过Session获取SecurityContext
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                .authorizeRequests()
                // 对于登录接口 允许匿名访问(放行请求)
                    // .permitAll() 未登录和已登录的都可以访问
                    // .anonymous() 匿名登录,未登录状态可以访问
                    // .anthenticated() 任意的用户必须认证之后才可以访问(请求需要鉴权认证)
                .antMatchers("/user/login").anonymous()
                // 基于配置的权限控制(表示上面的请求/hello具有此权限)
                .antMatchers("/hello").hasAuthority("system:dept:list")
                // 除上面外的所有请求全部需要鉴权认证
                .anyRequest().authenticated();
    
            // 添加JWT登录授权过滤器(将token校验过滤器添加到过滤器链中)
            http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
    
4.4.2 封装权限信息

前面在写 UserDetailsServiceImpl 的时候说过,在查询出用户后还要获取对应的权限信息,封装到UserDetails 中返回。我们之前定义了 UserDetails 的实现类 LoginUser,想要让其能封装权限信息就要对其进行修改:

@Data
@NoArgsConstructor
public class LoginUser implements UserDetails {

    private User user;

    // 存储权限信息
    private List permissions;

    public LoginUser(User user, List permissions) {
        this.user = user;
        this.permissions = permissions;
    }

    // 存储SpringSecurity所需要的权限信息的集合(将permissions集合转化后存储,存入redis时不需要序列化)
    @JSONField(serialize = false)
    private List authorities;

    @Override
    public Collection getAuthorities() {
        // 重写此方法
        if (authorities != null){
            return authorities;
        }
        
        // 把permissions中的字符串类型的权限信息转换成GrantedAuthority对象后存入authorities中
        // 方法一:遍历后存储
        

        // 方法二:使用stream流
        authorities = permissions.stream().map(SimpleGrantedAuthority::new).collect(Collectors.toList());
        return authorities;
    }

    @Override
    public String getPassword() {
        return user.getPassword();
    }

    @Override
    public String getUsername() {
        return user.getUserName();
    }

    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    @Override
    public boolean isEnabled() {
        return true;
    }
}

LoginUser 修改完后就可以在 UserDetailsServiceImpl 中把权限信息封装到 LoginUser 中了,我们先使用固定写死的权限进行测试,测试通过后再从数据库中查询权限信息:

@Service
public class UserDetailsServiceImpl implements UserDetailsService {

    @Autowired
    private UserMapper userMapper;
    @Autowired
    private PasswordEncoder passwordEncoder;
    @Autowired
    private MenuMapper menuMapper;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        // 1.认证:根据用户名查询用户信息
//        QueryWrapper queryWrapper = new QueryWrapper<>();
//        queryWrapper.eq("user_name", username);
//        User user = userMapper.selectOne(queryWrapper);
        LambdaQueryWrapper lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.eq(User::getUserName, username);
        User user = userMapper.selectOne(lambdaQueryWrapper);
        // 如果没有查询到用户信息
        if (Objects.isNull(user)){
            throw new RuntimeException("用户名或密码错误!");
        }
        // TODO
        // 2.授权:根据用户信息查询权限,一个用户可能对应多个权限
        List list = new ArrayList<>(Arrays.asList("test", "hello"));
        return new LoginUser(user, list);
    }
}
4.4.3 从数据库查询权限信息
  • ① RBAC权限模型

    RBAC权限模型(Role-Based Access Control)即:基于角色的权限控制。这是目前最常被开发者使用,也是相对易用、通用权限模型。

  • ② 准备

    创建用户表、权限表、角色表、用户角色表、角色权限表五张表,并创建 menu 的实体类:

  • ③ 代码实现

    mapper接口:

    public interface MenuMapper extends BaseMapper {
    
        List selectPermsByUserId(Long id);
    }
    

    mapper.xml:

    
    
    
    
        
    
    

    在 UserDetailsServiceImpl 中调用该 mapper 的方法查询权限信息封装到 LoginUser 对象中:

    @Service
    public class UserDetailsServiceImpl implements UserDetailsService {
    
        @Autowired
        private UserMapper userMapper;
        @Autowired
        private PasswordEncoder passwordEncoder;
        @Autowired
        private MenuMapper menuMapper;
    
        @Override
        public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
            // 1.认证:根据用户名查询用户信息
    //        QueryWrapper queryWrapper = new QueryWrapper<>();
    //        queryWrapper.eq("user_name", username);
    //        User user = userMapper.selectOne(queryWrapper);
            LambdaQueryWrapper lambdaQueryWrapper = new LambdaQueryWrapper<>();
            lambdaQueryWrapper.eq(User::getUserName, username);
            User user = userMapper.selectOne(lambdaQueryWrapper);
            // 如果没有查询到用户信息
            if (Objects.isNull(user)){
                throw new RuntimeException("用户名或密码错误!");
            }
            // TODO
            // 2.授权:根据用户信息查询权限,一个用户可能对应多个权限
            List list = menuMapper.selectPermsByUserId(user.getId());
            return new LoginUser(user, list);
        }
    }
    
五、前后端跨域问题

浏览器出于安全的考虑,使用 XMLHttpRequest 对象发起 HTTP 请求时必须遵守同源策略,否则就是跨域的 HTTP 请求,默认情况下是被禁止的。 同源策略要求源相同才能正常进行通信,即协议、域名、端口号都完全一致。在前后端分离项目中,前端项目和后端项目一般都不是同源的,所以也一定会存在跨域请求的问题,所以就需要做一些处理,让前端能够进行跨域请求。

一般情况下解决跨域问题既可以在前端做处理,也可以在后端做的处理。在做毕业设计项目的时候因为跨域问题也没少折腾,最后是在前端处理的,所以今天尝试使用在后端做配置处理。

  • ① 对 SpringBoot 配置,运行跨域请求

    @Configuration
    public class CorsConfig implements WebMvcConfigurer {
    
        @Override
        public void addCorsMappings(CorsRegistry registry) {
            // 设置允许跨域的路径
            registry.addMapping("
    @Configuration
    @EnableGlobalMethodSecurity(prePostEnabled = true) // 开启注解功能
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
    
        @Autowired
        private JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;
    
        @Bean
        public BCryptPasswordEncoder bCryptPasswordEncoder(){
            return new BCryptPasswordEncoder();
        }
    
        @Bean
        @Override
        public AuthenticationManager authenticationManagerBean() throws Exception {
            return super.authenticationManagerBean();
        }
    
        @Override
        protected void configure(HttpSecurity http) throws Exception {
            // 配置认证规则
            http
                // 关闭csrf
                .csrf().disable()
                // 不通过Session获取SecurityContext
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                .authorizeRequests()
                // 对于登录接口 允许匿名访问(放行请求)
                    // .permitAll() 未登录和已登录的都可以访问
                    // .anonymous() 匿名登录,未登录状态可以访问
                    // .anthenticated() 任意的用户必须认证之后才可以访问(请求需要鉴权认证)
                .antMatchers("/user/login").anonymous()
                // 除上面外的所有请求全部需要鉴权认证
                .anyRequest().authenticated();
    
            // 添加JWT登录授权过滤器(将token校验过滤器添加到过滤器链中)
            http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
    
            // 允许跨域
            http.cors();
        }
    }
    
六、自定义方法 6.1 自定义失败处理

我还希望在认证失败或者是授权失败的情况下也能和我的接口一样返回相同结构的 json,这样可以让前端能对响应进行统一的处理。要实现这个功能就需要知道 SpringSecurity 的异常处理机制。

​在 SpringSecurity 中,如果在认证或者授权的过程中出现了异常会被 ExceptionTranslationFilter 捕获到,在 ExceptionTranslationFilter 中会去判断是认证失败还是授权失败出现的异常。如果是认证过程中出现的异常会被封装成 AuthenticationException 然后调用 AuthenticationEntryPoint 对象的方法去进行异常处理。如果是授权过程中出现的异常会被封装成 AccessDeniedException 然后调用 AccessDeniedHandler 对象的方法去进行异常处理。

​所以如果需要自定义异常处理,就只需要自定义 AuthenticationEntryPoint 和 AccessDeniedHandler 然后配置给 SpringSecurity 即可。

  • ① 自定义实现类

    @Component
    public class AccessDeniedHandlerImpl implements AccessDeniedHandler {
    
        @Override
        public void handle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AccessDeniedException e) throws IOException, ServletException {
            ResponseResult result = new ResponseResult(HttpStatus.FORBIDDEN.value(), "您的权限不足!");
            String json = JSON.toJSONString(result);
            WebUtils.renderString(httpServletResponse, json);
        }
    }
    
    @Component
    public class AuthenticationEntryPointImpl implements AuthenticationEntryPoint {
    
        @Override
        public void commence(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AuthenticationException e) throws IOException, ServletException {
            ResponseResult result = new ResponseResult(HttpStatus.UNAUTHORIZED.value(), "认证失败,请重新登录!");
            String json = JSON.toJSONString(result);
            WebUtils.renderString(httpServletResponse, json);
        }
    }
    
  • ② 配置给 SpringSecurity

    // 添加自定义未授权和未登录结果返回
    http.exceptionHandling()
            .authenticationEntryPoint(authenticationEntryPoint)
            .accessDeniedHandler(accessDeniedHandler);
    
6.2 自定义权限校验方法

除了使用注解中的权限校验方法外,还可以定义自己的权限校验方法,在 @PreAuthorize 注解中使用自定义的方法。

@Component("expressionDefined")
public class ExpressionRoot {

    public boolean hasAuthority(String authority){
        // 获取当前用户的权限
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        LoginUser loginUser = (LoginUser) authentication.getPrincipal();
        List permissions = loginUser.getPermissions();
        // 判断用户权限集合中是否存在authority
        return permissions.contains(authority);
    }
}
@RestController
public class HelloController {

    @RequestMapping("/hello")
    // 在注解中使用自定义的权限校验方法
    @PreAuthorize("@expressionDefined.hasAuthority('system:dept:list')")
    public String hello(){
        return "hello";
    }
}
6.3 自定义认证成功处理器

实际上在 UsernamePasswordAuthenticationFilter 进行登录认证的时候,如果登录成功了是会调用 AuthenticationSuccessHandler 的方法进行认证成功后的处理的。 AuthenticationSuccessHandler 就是登录成功处理器。当然,我们也可以自己去自定义成功处理器进行成功后的相应处理。

@Component
public class SuccessHandler implements AuthenticationSuccessHandler {

    @Override
    public void onAuthenticationSuccess(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Authentication authentication) throws IOException, ServletException {
        // 在这里编写认证成功后的逻辑代码
        System.out.println("认证成功...");
    }
}
@Autowired
private AuthenticationSuccessHandler successHandler;

http.formLogin()
     // 配置自定义认证成功处理器
     .successHandler(successHandler);
6.4 自定义认证失败处理器

实际上在 UsernamePasswordAuthenticationFilte r进行登录认证的时候,如果认证失败了是会调用AuthenticationFailureHandler 的方法进行认证失败后的处理的。AuthenticationFailureHandler 就是登录失败处理器。当然,我们也可以自己去自定义失败处理器进行失败后的相应处理。

@Component
public class FailureHandler implements AuthenticationFailureHandler {

    @Override
    public void onAuthenticationFailure(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AuthenticationException e) throws IOException, ServletException {
        // 在这里写认证失败的逻辑代码
        System.out.println("认证失败...");
    }
}
@Autowired
private AuthenticationFailureHandler failureHandler;

http.formLogin()
     // 配置自定义认证失败处理器
     .failureHandler(failureHandler);
6.5 自定义登出成功处理器
public class DefinedLogoutSuccessHandler implements LogoutSuccessHandler {

    @Override
    public void onLogoutSuccess(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Authentication authentication) throws IOException, ServletException {
        // 这里编写注销成功的逻辑代码
        System.out.println("注销成功...");
    }
}
@Autowired
private LogoutSuccessHandler logoutSuccessHandler;

http.logout()
     //配置注销成功处理器
     .logoutSuccessHandler(logoutSuccessHandler);
转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/961711.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号