SpringSecurity知识总结

今天药忘吃喽~ 2023-09-30 10:31 11阅读 0赞

### 该笔记基于B站视频和自己的理解整理而成。视频地址：[SpringSecurity框架教程-Spring Security+JWT实现项目级前端分离认证授权-B站最通俗易懂的Spring Security课程\_哔哩哔哩\_bilibili课程已完结，资料获取方式请看置顶评论。![9f04ed3debf8620dea49a94f8cb8dcd2c38ba9ac.jpg_57w_57h_1c.png][]https://www.bilibili.com/video/BV1mm4y1X7Hc?p=41&spm\_id\_from=333.337.header\_right.history\_list.click][SpringSecurity_-Spring Security_JWT_-B_Spring Security_bilibili_9f04ed3debf8620dea49a94f8cb8dcd2c38ba9ac.jpg_57w_57h_1c.png_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、登录校验流程： ###

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAZnJpZ2dseQ_size_20_color_FFFFFF_t_70_g_se_x_16][]

### 3.2、原理剖析： ###

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

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAZnJpZ2dseQ_size_20_color_FFFFFF_t_70_g_se_x_16 1][]

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

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

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

### 3.3、认证流程详解： ###

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAZnJpZ2dseQ_size_20_color_FFFFFF_t_70_g_se_x_16 2][]

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

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

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

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

### 3.4、思路分析 ###

**登录：**

①自定义登录接口

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

把用户信息存入redis中

②自定义UserDetailsService

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

**校验：**

①定义Jwt认证过滤器

获取token

解析token获取其中的userid

从redis中获取用户信息

存入SecurityContextHolder

# 四、搭建项目（这里只是准备工作，详细代码见Gitee） #

[spring\_security: springSecurity学习记录![favicon-9007bd527d8a7851c8330e783151df58.ico][]https://gitee.com/DZ\_QY/spring\_security.git][spring_security_ springSecurity_favicon-9007bd527d8a7851c8330e783151df58.ico_https_gitee.com_DZ_QY_spring_security.git]1、在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\}**。

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAZnJpZ2dseQ_size_20_color_FFFFFF_t_70_g_se_x_16 3][]

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

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

<1>定义SecurityConfig配置类，要求继承WebSecurityConfigurerAdapter（com/zhao/config/SecurityConfig.class）

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

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权限模型**：**基于角色的权限控制。这是目前最常被开发者使用也是相对易用、通用权限模型。** **】**

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAZnJpZ2dseQ_size_20_color_FFFFFF_t_70_g_se_x_16 4][]

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

[9f04ed3debf8620dea49a94f8cb8dcd2c38ba9ac.jpg_57w_57h_1c.png]: http://i2.hdslb.com/bfs/archive/9f04ed3debf8620dea49a94f8cb8dcd2c38ba9ac.jpg@57w_57h_1c.png
[SpringSecurity_-Spring Security_JWT_-B_Spring Security_bilibili_9f04ed3debf8620dea49a94f8cb8dcd2c38ba9ac.jpg_57w_57h_1c.png_https_www.bilibili.com_video_BV1mm4y1X7Hc_p_41_spm_id_from_333.337.header_right.history_list.click]: https://www.bilibili.com/video/BV1mm4y1X7Hc?p=41&spm_id_from=333.337.header_right.history_list.click
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAZnJpZ2dseQ_size_20_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/d5cd3676c6914a09bebed5b33280dbb6.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAZnJpZ2dseQ==,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAZnJpZ2dseQ_size_20_color_FFFFFF_t_70_g_se_x_16 1]: https://img-blog.csdnimg.cn/d9a8a34f4ab04e2086c3557a3e535e0b.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAZnJpZ2dseQ==,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAZnJpZ2dseQ_size_20_color_FFFFFF_t_70_g_se_x_16 2]: https://img-blog.csdnimg.cn/32e54536b2e54f8c8a71c1f263efffc8.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAZnJpZ2dseQ==,size_20,color_FFFFFF,t_70,g_se,x_16
[favicon-9007bd527d8a7851c8330e783151df58.ico]: https://assets.gitee.com/assets/favicon-9007bd527d8a7851c8330e783151df58.ico
[spring_security_ springSecurity_favicon-9007bd527d8a7851c8330e783151df58.ico_https_gitee.com_DZ_QY_spring_security.git]: https://gitee.com/DZ_QY/spring_security.git
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAZnJpZ2dseQ_size_20_color_FFFFFF_t_70_g_se_x_16 3]: https://img-blog.csdnimg.cn/9738307c47024f8aafad31573e3d94da.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAZnJpZ2dseQ==,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAZnJpZ2dseQ_size_20_color_FFFFFF_t_70_g_se_x_16 4]: https://img-blog.csdnimg.cn/c258bbaee2f6470baaa5dde064918248.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAZnJpZ2dseQ==,size_20,color_FFFFFF,t_70,g_se,x_16