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";
      }
}

原文链接: https://blog.csdn.net/friggly/article/details/123651434