SpringSecurity知识总结

该笔记基于B站视频和自己的理解整理而成。视频地址:SpringSecurity框架教程-Spring Security+JWT实现项目级前端分离认证授权-B站最通俗易懂的Spring Security课程_哔哩哔哩_bilibili课程已完结,资料获取方式请看置顶评论。https://www.bilibili.com/video/BV1mm4y1X7Hc?p=41&spm_id_from=333.337.header_right.history_list.click

什么是springsecurity?

        Spring Security 是 Spring 家族中的一个安全管理框架侧重于为Java应用程序提供身份验证和授权

        优点:在用户认证方面,Spring Security 框架支持主流的认证方式,包括 HTTP 基本认证、HTTP 表单验证、HTTP 摘要认证、OpenID 和 LDAP 等。在用户授权方面,Spring Security 提供了基于角色的访问控制和访问控制列表(Access Control List,ACL),可以对应用中的领域对象进行细粒度的控制。

        对于中大型的项目来说一般更倾向于用springsecurity来做安全框架,小项目用一般Shiro的比较多,因为Shiro的上手更加的简单。

实战测试:

一、实验环境搭建

1.新建一个springboot项目(此处是基于idea编译器进行操作演示的)

2.创建HelloController

@RestController
public class HelloController {
    @RequestMapping("/hello")
    public String hello() {
        return "hello";
    }
}

3.启动SpringBootApplication,检查测试实验环境是否OK!

二、引入SpringSecurity

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-security</artifactId>
</dependency>

        引入依赖后我们在尝试去访问之前的接口就会自动跳转到一个SpringSecurity的默认登陆页面,默认用户名是user,密码会输出在控制台

必须登陆之后才能对接口进行访问。此时springsecurity身份认证的效果就体现出来了。

三、认证

3.1、登录校验流程:

 3.2、原理剖析:

上述图片我们可以很清楚的了解springsecurity认证授权的过程是怎样的,那么我们又该如何去实现呢?

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

ExceptionTranslationFilter:处理过滤器链中抛出的任何AccessDeniedException和AuthenticationException 。

FilterSecurityInterceptor:负责权限校验的过滤器。

3.3、认证流程详解:

Authentication接口: 它的实现类,表示当前访问系统的用户,封装了用户相关信息。

AuthenticationManager接口:定义了认证Authentication的方法

UserDetailsService接口:加载用户特定数据的核心接口。里面定义了一个根据用户名查询用户信息的方法。

UserDetails接口:提供核心用户信息。通过UserDetailsService根据用户名获取处理的用户信息要封装成UserDetails对象返回。然后将这些信息封装到Authentication对象中。

3.4、思路分析

登录:

​         ①自定义登录接口

​                 调用ProviderManager的方法进行认证 如果认证通过生成jwt

​                 把用户信息存入redis中

​         ②自定义UserDetailsService

​                 在这个实现类中去查询数据库

校验:

​         ①定义Jwt认证过滤器

​                 获取token

​                 解析token获取其中的userid

​                 从redis中获取用户信息

​                 存入SecurityContextHolder

四、搭建项目(这里只是准备工作,详细代码见Gitee

spring_security: springSecurity学习记录https://gitee.com/DZ_QY/spring_security.git1、在pom中引入相关依赖;

2、在com/zhao/config下添加Redis相关配置 (RedisConfig.class);

      在com/zhao/utils下添加Redis使用FastJson序列化工具类(FastJsonRedisSerializer.class);

3、封装ResponseResult响应类(返回相应的提示信息);

4、封装JwtUtil工具类;

5、封装RedisCache工具类,缓存基本的对象,Integer、String、实体类等等;

6、封装WebUtils工具类,将字符串渲染到客户端;

7、定义一个User实体类并实现Serializable接口,使得User对象可序列化;

8、在MySQL数据库中创建sys_user表;

CREATE TABLE `sys_user` (
  `id` BIGINT(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
  `user_name` VARCHAR(64) NOT NULL DEFAULT 'NULL' COMMENT '用户名',
  `nick_name` VARCHAR(64) NOT NULL DEFAULT 'NULL' COMMENT '昵称',
  `password` VARCHAR(64) NOT NULL DEFAULT 'NULL' COMMENT '密码',
  `status` CHAR(1) DEFAULT '0' COMMENT '账号状态(0正常 1停用)',
  `email` VARCHAR(64) DEFAULT NULL COMMENT '邮箱',
  `phonenumber` VARCHAR(32) DEFAULT NULL COMMENT '手机号',
  `sex` CHAR(1) DEFAULT NULL COMMENT '用户性别(0男,1女,2未知)',
  `avatar` VARCHAR(128) DEFAULT NULL COMMENT '头像',
  `user_type` CHAR(1) NOT NULL DEFAULT '1' COMMENT '用户类型(0管理员,1普通用户)',
  `create_by` BIGINT(20) DEFAULT NULL COMMENT '创建人的用户id',
  `create_time` DATETIME DEFAULT NULL COMMENT '创建时间',
  `update_by` BIGINT(20) DEFAULT NULL COMMENT '更新人',
  `update_time` DATETIME DEFAULT NULL COMMENT '更新时间',
  `del_flag` INT(11) DEFAULT '0' COMMENT '删除标志(0代表未删除,1代表已删除)',
  PRIMARY KEY (`id`)
) ENGINE=INNODB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb4 COMMENT='用户表'

9、在.yml中配置数据库信息;

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/sys_security?characterEncoding=utf-8&serverTimezone=UTC
    username: root
    password: root
    driver-class-name: com.mysql.cj.jdbc.Driver
  redis:
    database: 0
    # Redis服务器地址
    host: 127.0.0.1
    # Redis服务器连接端口
    port: 6379
    # Redis服务器连接密码(默认为空)
mybatis-plus:
  mapper-locations: classpath*:/mapper/**/*.xml
server:
  port: 8888

五、登录认证具体实现(重要)

一、基础代码:

1、在com/zhao/mapper下定义UserMapper接口:

public interface UserMapper extends BaseMapper<User> {}

2、在该项目的启动类上配置Mapper扫描:

@MapperScan("com.zhao.mapper")
@SpringBootApplication
public class SecurityApplication {
	public static void main(String[] args) {
		SpringApplication.run(SecurityApplication.class, args);
	}
}

3、测试mapper能否正常使用:

//....省略部分代码
@Autowired //注入UserMapper 
private UserMapper userMapper;

@Test
public void testUserMapper(){
	List<User> users = userMapper.selectList(null);
	System.out.println(users);
}

二、核心代码:

1、创建一个类实现UserDetailsService接口,重写其中的方法。根据用户名从数据库中查询用户信息;

/**
 * @description 用于security根据用户名获取用户对象
 */
@Service //注入到spring容器中
public class UserDetailsServiceImpl implements UserDetailsService {
    //注入相应的mapper即可操作数据库
    @Autowired
    private UserMapper userMapper;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        //查询用户信息
        LambdaQueryWrapper<User> queryWrapper =new LambdaQueryWrapper();
        queryWrapper.eq(User::getUserName,username);
        User user = userMapper.selectOne(queryWrapper);
        //如果没有查询到用户,就抛出异常
        if (Objects.isNull(user)){
            throw new RuntimeException("用户名或密码错误");
        }
        //TODO 查询对应的权限信息(就是一个个有特殊含义的字符串)
        
        //把数据封装成UserDetails返回
        return new LoginUser(user);
    }
}

2、由于UserDetailsService方法的返回值是UserDetails类型,所以需要定义一个类,实现该接口,把用户信息封装在其中。

@Data
@NoArgsConstructor
@AllArgsConstructor
public class LoginUser implements UserDetails {

    private User user;

    //返回权限信息
    @Override
    public Collection<? extends GrantedAuthority> 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; }
}

注意:如果这时候需要进行测试,需要往sys_user表中写入用户数据,并且如果你想让用户的密码是明文存储,需要在密码前加{noop}

但是在实际的开发过程中我们并不会把密码明文存储在数据库中,此时就需要对密码进行加密;

在springsecurity中,我们一般使用它为我们提供的BCryptPasswordEncoder进行加密。具体操作如下:

        <1>定义SecurityConfig配置类,要求继承WebSecurityConfigurerAdapter(com/zhao/config/SecurityConfig.class)

        <2>将BCryptPasswordEncode注入到spring容器中

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Bean
    public PasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder();
    }

}

 3、自定义登录接口LoginController(com/zhao/controller),然后让SpringSecurity对这个接口放行,用户在访问这个接口的时候不用登录也能访问。

具体操作:        

        <1>在SecurityConfig中配置把AuthenticationManager注入容器。

        <2>在SpringSecurity进行配置,对登录接口放行,使用户不用登陆也能访问该接口;

        <3>注入AuthenticationManager,通过它的authenticate方法来进行用户认证​;

        <4>如果认证成功,就生成一个jwt,通过ResponseResult响应返回【调用service,具体操作在service层实现】;

        <5>为了让用户下回请求时能通过jwt识别出具体的是哪个用户,我们需要把用户信息存入redis,可以把用户id作为key。

(1)SecurityConfig 配置类:

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

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                //关闭csrf
                .csrf().disable()
                //不通过Session获取SecurityContext
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                .authorizeRequests()
                // 对于登录接口 允许匿名访问
                .antMatchers("/user/login").anonymous()
                // 除上面外的所有请求全部需要鉴权认证
                .anyRequest().authenticated();
    }

    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }
}
LoginController.class:
@RestController
public class LoginController {

    @Autowired
    private LoginServcie loginServcie;

    @PostMapping("/user/login")
    public ResponseResult login(@RequestBody User user){
        return loginServcie.login(user);
    }
}

LoginServcie 接口:

public interface LoginServcie {
    ResponseResult login(User user);
}

接口实现类:

@Service
public class LoginServiceImpl implements LoginServcie {

    @Autowired
    private AuthenticationManager authenticationManager;
    @Autowired
    private RedisCache redisCache;

    @Override
    public ResponseResult login(User user) {
        //当在页面中输入用户名和密码之后首先会进入到UsernamePasswordAuthenticationToken验证(Authentication),
        //然后生成的Authentication会被交由AuthenticationManager来进行管理
        UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(user.getUserName(),user.getPassword());
        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();
        String jwt = JwtUtil.createJWT(userId);
        //authenticate存入redis
        redisCache.setCacheObject("login:"+userId,loginUser);
        //把token响应给前端
        HashMap<String,String> map = new HashMap<>();
        map.put("token",jwt);
        return new ResponseResult(200,"登陆成功",map);
    }
}

4、认证过滤器:

        <1>在SecurityConfig 配置类中注入JwtAuthenticationTokenFilter

        <2>自定义一个过滤器JwtAuthenticationTokenFilter继承OncePerRequestFilter

        <3>在这个过滤器中去获取请求头中的token,对token进行解析取出其中的userid。

        <4>使用userid去redis中获取对应的LoginUser对象。

        <5>然后封装Authentication对象存入SecurityContextHolder

SecurityConfig配置类:

//....省略代码
@Autowired
JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;

JwtAuthenticationTokenFilter类:

@Component
public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {

    @Autowired
    private RedisCache redisCache;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        //获取token
        String token = request.getHeader("token");
        if (!StringUtils.hasText(token)) {
            //放行
            filterChain.doFilter(request, response);
            return;
        }
        //解析token
        String userid;
        try {
            Claims claims = JwtUtil.parseJWT(token);
            userid = claims.getSubject();
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("token非法");
        }
        //从redis中获取用户信息
        String redisKey = "login:" + userid;
        LoginUser loginUser = redisCache.getCacheObject(redisKey);
        if(Objects.isNull(loginUser)){
            throw new RuntimeException("用户未登录");
        }
        //存入SecurityContextHolder
        //TODO 获取权限信息封装到Authentication中
        UsernamePasswordAuthenticationToken authenticationToken =
                new UsernamePasswordAuthenticationToken(loginUser,null,null);
        SecurityContextHolder.getContext().setAuthentication(authenticationToken);
        //放行
        filterChain.doFilter(request, response);
    }
}

5、退出登录:

        <1>获取SecurityContextHolder中的认证信息

        <2>删除redis中对应的数据

LoginController.class:

//...省略代码
@RequestMapping("/user/logout")
public ResponseResult logOut(){
    //注销
    return loginService.logout();
}
LoginService接口:
//....省略部分代码
public interface LoginServcie {
    ResponseResult login(User user);

    ResponseResult logout();

}

接口实现类:

//...省略部分代码
@Override
public ResponseResult logout() {
    //获取SecurityContextHolder中的用户id
    Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
    LoginUser loginUser = (LoginUser) authentication.getPrincipal();
    Long userid = loginUser.getUser().getId();
    //删除redis中的值
    redisCache.deleteObject("login:"+userid);
    return new ResponseResult(200,"注销成功");
}

六、授权认证具体实现(重要)

授权认证的作用:不同的用户可以使用不同的功能

1、授权认证的基本流程:

        <1>把当前登录用户的权限信息存入Authentication。

        <2>在springsecurity中,默认使用FilterSecurityInterceptor来进行权限校验。

        <3>在FilterSecurityInterceptor中会从SecurityContextHolder获取其中的Authentication,然后获取其中的权限信息。

        <4>判断当前用户是否拥有访问当前资源所需的权限。

2、具体实现:

        (1)SpringSecurity为我们提供了基于注解的权限控制方案,我们可以使用注解去指定访问对应的资源所需的权限。但是要使用它我们需要先在SecurityConfig开启相关配置。然后就可以使用对应的注解@PreAuthorize。

@EnableGlobalMethodSecurity(prePostEnabled = true)

HelloController:

@RestController
public class HelloController {

    @RequestMapping("/hello")
    @PreAuthorize("hasAuthority('test')")
    public String hello(){
        return "hello";
    }
}

        (2)在认证UserDetailsServiceImpl阶段,我们查询出用户后还要获取对应的权限信息,封装到UserDetails中返回

​ 我们先直接把权限信息在实现类UserDetailsServiceImpl中 写死,然后封装到LoginUser中进行测试

UserDetailsService接口实现类:
//...省略
//查询对应的权限信息(就是一个个有特殊含义的字符串)
List<String> list = new ArrayList<>(Arrays.asList("test","admin"));
//把数据封装成UserDetails返回
return new LoginUser(user,list);

UserDetails实现类:

@Data
@NoArgsConstructor
public class LoginUser implements UserDetails {

    private User user;
        
    //存储权限信息
    private List<String> permissions;
    
    
    public LoginUser(User user,List<String> permissions) {
        this.user = user;
        this.permissions = permissions;
    }


    //存储SpringSecurity所需要的权限信息的集合
    @JSONField(serialize = false) //避免在redis中序列化
    private List<GrantedAuthority> authorities;
    @Override
    //返回权限信息
    public Collection<? extends GrantedAuthority> getAuthorities() {
        if (authorities!=null){
            return authorities;
        }
        //把permissions中字符串类型的权限信息转换成GrantedAuthority对象存入authorities中
        authorities = new ArrayList<>();
        for (String permission : permissions) {
            SimpleGrantedAuthority authority = new SimpleGrantedAuthority(permission);
            authorities.add(authority);
        }
        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; }
}

  3、从数据库查询用户权限信息【RBAC权限模型基于角色的权限控制。这是目前最常被开发者使用也是相对易用、通用权限模型。

 (1)数据库建表:

CREATE DATABASE /*!32312 IF NOT EXISTS*/`sg_security` /*!40100 DEFAULT CHARACTER SET utf8mb4 */;

USE `sg_security`;

/*Table structure for table `sys_menu` */

DROP TABLE IF EXISTS `sys_menu`;

CREATE TABLE `sys_menu` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `menu_name` varchar(64) NOT NULL DEFAULT 'NULL' COMMENT '菜单名',
  `path` varchar(200) DEFAULT NULL COMMENT '路由地址',
  `component` varchar(255) DEFAULT NULL COMMENT '组件路径',
  `visible` char(1) DEFAULT '0' COMMENT '菜单状态(0显示 1隐藏)',
  `status` char(1) DEFAULT '0' COMMENT '菜单状态(0正常 1停用)',
  `perms` varchar(100) DEFAULT NULL COMMENT '权限标识',
  `icon` varchar(100) DEFAULT '#' COMMENT '菜单图标',
  `create_by` bigint(20) DEFAULT NULL,
  `create_time` datetime DEFAULT NULL,
  `update_by` bigint(20) DEFAULT NULL,
  `update_time` datetime DEFAULT NULL,
  `del_flag` int(11) DEFAULT '0' COMMENT '是否删除(0未删除 1已删除)',
  `remark` varchar(500) DEFAULT NULL COMMENT '备注',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb4 COMMENT='菜单表';

/*Table structure for table `sys_role` */

DROP TABLE IF EXISTS `sys_role`;

CREATE TABLE `sys_role` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `name` varchar(128) DEFAULT NULL,
  `role_key` varchar(100) DEFAULT NULL COMMENT '角色权限字符串',
  `status` char(1) DEFAULT '0' COMMENT '角色状态(0正常 1停用)',
  `del_flag` int(1) DEFAULT '0' COMMENT 'del_flag',
  `create_by` bigint(200) DEFAULT NULL,
  `create_time` datetime DEFAULT NULL,
  `update_by` bigint(200) DEFAULT NULL,
  `update_time` datetime DEFAULT NULL,
  `remark` varchar(500) DEFAULT NULL COMMENT '备注',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8mb4 COMMENT='角色表';

/*Table structure for table `sys_role_menu` */

DROP TABLE IF EXISTS `sys_role_menu`;

CREATE TABLE `sys_role_menu` (
  `role_id` bigint(200) NOT NULL AUTO_INCREMENT COMMENT '角色ID',
  `menu_id` bigint(200) NOT NULL DEFAULT '0' COMMENT '菜单id',
  PRIMARY KEY (`role_id`,`menu_id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb4;

/*Table structure for table `sys_user` */

DROP TABLE IF EXISTS `sys_user`;

CREATE TABLE `sys_user` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
  `user_name` varchar(64) NOT NULL DEFAULT 'NULL' COMMENT '用户名',
  `nick_name` varchar(64) NOT NULL DEFAULT 'NULL' COMMENT '昵称',
  `password` varchar(64) NOT NULL DEFAULT 'NULL' COMMENT '密码',
  `status` char(1) DEFAULT '0' COMMENT '账号状态(0正常 1停用)',
  `email` varchar(64) DEFAULT NULL COMMENT '邮箱',
  `phonenumber` varchar(32) DEFAULT NULL COMMENT '手机号',
  `sex` char(1) DEFAULT NULL COMMENT '用户性别(0男,1女,2未知)',
  `avatar` varchar(128) DEFAULT NULL COMMENT '头像',
  `user_type` char(1) NOT NULL DEFAULT '1' COMMENT '用户类型(0管理员,1普通用户)',
  `create_by` bigint(20) DEFAULT NULL COMMENT '创建人的用户id',
  `create_time` datetime DEFAULT NULL COMMENT '创建时间',
  `update_by` bigint(20) DEFAULT NULL COMMENT '更新人',
  `update_time` datetime DEFAULT NULL COMMENT '更新时间',
  `del_flag` int(11) DEFAULT '0' COMMENT '删除标志(0代表未删除,1代表已删除)',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8mb4 COMMENT='用户表';

/*Table structure for table `sys_user_role` */

DROP TABLE IF EXISTS `sys_user_role`;

CREATE TABLE `sys_user_role` (
  `user_id` bigint(200) NOT NULL AUTO_INCREMENT COMMENT '用户id',
  `role_id` bigint(200) NOT NULL DEFAULT '0' COMMENT '角色id',
  PRIMARY KEY (`user_id`,`role_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

(2)创建对应的实体类Menu.class并实现序列化【代码见gitee】

(3)根据用户id去查询对应的权限

MenuMapper:

public interface MenuMapper extends BaseMapper<Menu> {
    List<String> selectPermsByUserId(Long id);
}

(4)自定义mapper文件,定义对应的SQL语句

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.zhao.mapper.MenuMapper">

    <select id="selectPermsByUserId" resultType="java.lang.String" parameterType="long">
        SELECT
            DISTINCT m.`perms`
        FROM
            sys_user_role ur
            LEFT JOIN `sys_role` r ON ur.`role_id` = r.`id`
            LEFT JOIN `sys_role_menu` rm ON ur.`role_id` = rm.`role_id`
            LEFT JOIN `sys_menu` m ON m.`id` = rm.`menu_id`
        WHERE
            user_id = #{userid}
            AND r.`status` = 0
            AND m.`status` = 0
    </select>
</mapper>

(5)在application.yml中配置mapperXML文件的位置

mybatis-plus:
  mapper-locations: classpath*:/mapper/**/*.xml 

(6)在UserDetailsServiceImpl中去调用该mapper的方法查询权限信息封装到LoginUser对象中,替换掉之前写死的权限集合。

//注入相应的mapper即可操作数据库
@Autowired
private UserMapper userMapper;

 
//查询对应的权限信息(就是一个个有特殊含义的字符串)
 List<String> list = menuMapper.selectPermsByUserId(user.getId());

七、自定义失败处理

说明:

        在认证或者授权的过程中出现了异常会被ExceptionTranslationFilter捕获到。在ExceptionTranslationFilter中会去判断是认证失败还是授权失败出现的异常。

​         如果是认证过程中出现的异常会被封装成AuthenticationException然后调用AuthenticationEntryPoint对象的方法去进行异常处理。

​         如果是授权过程中出现的异常会被封装成AccessDeniedException然后调用AccessDeniedHandler对象的方法去进行异常处理。

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

具体实现:

        (1)在com/zhao/handler下自定义AccessDeniedHandlerImpl实现AccessDeniedHandler(重写该方法)

@Component //注入到Spring容器中
public class AccessDeniedHandlerImpl implements AccessDeniedHandler {

    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) throws IOException, ServletException {
        ResponseResult result = new ResponseResult(HttpStatus.FORBIDDEN.value(), "您的权限不足");
        String json = JSON.toJSONString(result);
        WebUtils.renderString(response,json);
    }
}

        在com/zhao/handler下自定义AuthenticationEntryPointImpl实现AuthenticationEntryPoint(重写该方法)

@Component //注入到Spring容器中
public class AuthenticationEntryPointImpl implements AuthenticationEntryPoint {
    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
        //处理异常
        //通过枚举类型设置状态码
        ResponseResult responseResult = new ResponseResult(HttpStatus.UNAUTHORIZED.value(), "用户认证失败,请重新登录");
        String json = JSON.toJSONString(responseResult);
        WebUtils.renderString(response,json);
    }
}

        (2)配置给SpringSecurity:

@Autowired
private AuthenticationEntryPoint authenticationEntryPoint;

@Autowired
private AccessDeniedHandler accessDeniedHandler;

//....省略部分代码

@Override
protected void configure(HttpSecurity http) throws Exception {
    //...省略部分代码
    //配置异常处理器
    http.exceptionHandling()
            .authenticationEntryPoint(authenticationEntryPoint)
            .accessDeniedHandler(accessDeniedHandler);

}

八、跨域

说明:

        前后端分离项目,前端项目和后端项目一般都不是同源的,所以肯定会存在跨域请求的问题。

具体实现:

        <1>对SpringBoot配置,执行跨域请求【定义一个CorsConfig 配置文件】

@Configuration
public class CorsConfig implements WebMvcConfigurer {

    @Override
    public void addCorsMappings(CorsRegistry registry) {
      // 设置允许跨域的路径
        registry.addMapping("/**")
                // 设置允许跨域请求的域名
                .allowedOriginPatterns("*")
                // 是否允许cookie
                .allowCredentials(true)
                // 设置允许的请求方式
                .allowedMethods("GET", "POST", "DELETE", "PUT")
                // 设置允许的header属性
                .allowedHeaders("*")
                // 跨域允许时间
                .maxAge(3600);
    }
}

        <2>开启SpringSecurity的跨域访问

在上述这种安全模式框架下资源会受到SpringSecurity的保护,所以想要跨域访问还要让SpringSecurity运行跨域访问。

@Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                //关闭csrf
                .csrf().disable()
                //不通过Session获取SecurityContext
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                .authorizeRequests()
                // 对于登录接口 允许匿名访问
                .antMatchers("/user/login").anonymous()//匿名访问,登录才能访问
                .antMatchers("/testCors").hasAnyAuthority("system:test:list")
                // 除上面外的所有请求全部需要鉴权认证
                .anyRequest().authenticated();

        //添加自定义过滤器在UsernamePasswordAuthenticationFilter前
        http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
        //配置异常处理器
        http.exceptionHandling()
                .authenticationEntryPoint(authenticationEntryPoint)
                .accessDeniedHandler(accessDeniedHandler);
        //允许跨域
        http.cors();

    }

九、其它权限校验方法

        在上述权限校验时我们使用的是@PreAuthorize注解,然后在其中使用的是hasAuthority方法进行校验。SpringSecurity还为我们提供了其它方法例如:hasAnyAuthority,hasRole,hasAnyRole等。

        hasAnyAuthority方法可以传入多个权限,只有用户有其中任意一个权限都可以访问对应资源

@RestController
public class HelloController {
     @PreAuthorize("hasAnyAuthority('admin','test','system:dept:list')")
     public String hello(){
         return "hello";
     }
}

        hasRole要求有对应的角色才可以访问,但是它内部会把我们传入的参数拼接上 ROLE_ 后再去比较。所以这种情况下要用用户对应的权限也要有 ROLE_ 这个前缀才可以。

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

        hasAnyRole 有任意的角色就可以访问。它内部也会把我们传入的参数拼接上 ROLE_ 后再去比较。所以这种情况下要用用户对应的权限也要有 ROLE_ 这个前缀才可以。

@RestController
public class HelloController {
      @PreAuthorize("hasAnyRole('admin','system:dept:list')")
      public String hello(){
          return "hello";
      }
}

评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

星悦糖

你的鼓励是我最大的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值