SpringSecurity详解

港控/mmm° 2023-10-09 21:56 88阅读 0赞

#### SpringSecurity详解 ####

*  1 简介
 *  2 快速入门
 *  3 认证
 *   *  3.1 登录校验流程
     *  3.2 认证原理
     *   *  3.2.1 SpringSecurity完整流程
         *  3.2.2 认证流程详解 ☆
     *  3.3 编写代码
     *   *  3.3.1 思路分析
         *  3.3.2 准备工作
         *  3.3.3 实现
         *   *  3.3.3.1 数据库校验用户
             *  3.3.3.2 密码加密存储
             *  3.3.3.3 登录接口
             *  3.3.3.4 认证过滤器
             *  2.3.3.5 退出登录
 *  4 授权
 *   *  4.1 权限系统的作用
     *  4.2 授权基本流程
     *  4.3 授权实现
     *   *  4.3.1 限制访问资源所需权限
         *  4.3.2 封装权限信息
         *  4.3.3 从数据库查询权限信息
         *   *  4.3.3.1 RBAC权限模型
             *  4.3.3.2 准备工作
             *  4.3.3.3 代码实现
             *  4.3.3.4 测试
 *  5 自定义失败处理
 *  6 跨域
 *  7 拓展
 *   *  7.1 其它权限校验方法
     *  7.2 自定义权限校验方法
     *  7.3 基于配置的权限控制
     *  7.4 CSRF
     *  7.5 认证成功处理器
     *  7.6 认证失败处理器
     *  7.7 登出成功处理器

## 1 简介 ##

**Spring Security** 是 Spring 家族中的一个安全管理框架。相比与另外一个安全框架**Shiro**，它提供了更丰富的功能，社区资源也比Shiro丰富。

一般来说中大型的项目都是使用**SpringSecurity** 来做安全框架。小项目有Shiro的比较多，因为相比与SpringSecurity，Shiro的上手更加的简单。

一般Web应用的需要进行**认证**和**授权**。

**认证：验证当前访问系统的是否为系统的用户，并且要确认具体是哪个用户**

**授权：经过认证后判断当前用户是否有权限进行某个操作**

而**认证**和**授权**也是SpringSecurity作为安全框架的核心功能。

[SpringSecurity配套源码和资源传送门 免费下载][SpringSecurity_]

## 2 快速入门 ##

①导入依赖

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
    </dependencies>

②创建测试的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";
        }
    }

③引入springSecurity  
导入相应的依赖即可：

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

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

默认登录界面如下:  
![在这里插入图片描述][db7711bdde294b86952c5293a951164d.png]

登录密码如下：

![在这里插入图片描述][592589961a874bb89fb2b7dceae1f587.png]  
**必须登陆之后才能对接口进行访问。**

## 3 认证 ##

### 3.1 登录校验流程 ###

1.  携带`userName`和`password`访问登录接口
2.  将`userName`和`password`和数据中的数据进行比较
3.  如果正确，使用其生成一个`jwt`
4.  将生成的`jwt`返回给前端
5.  随后再访问其他请求时需要在Header中携带`token`
6.  访问其他请求时，获取其头中的`token`进行解析，获得`userId`
7.  根据`userId`获取用户权限信息
8.  有权限则允许其访问并后端响应信息给前端，没权限则滚蛋！  
    ![在这里插入图片描述][057e8297240d4e1d82ced1662de7286f.png]

### 3.2 认证原理 ###

#### 3.2.1 SpringSecurity完整流程 ####

SpringSecurity的原理其实就是一个过滤器链，内部包含了提供各种功能的过滤器。这里我们可以看看入门案例中的过滤器。  
![SpringSecurity过滤器链][SpringSecurity]  
**图中只展示了核心过滤器，其它的非核心过滤器并没有在图中展示。**

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

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

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

我们可以通过Debug查看当前系统中SpringSecurity过滤器链中有哪些过滤器及它们的顺序。

![SspringSecurity含有的过滤器][SspringSecurity]

#### 3.2.2 认证流程详解 ☆ ####

1.  前端提交`userName`和`password`参数请求后端
2.  后端接收到参数封装成`Authentication`对象，此时还没有权限信息
3.  调用`authenticate`方法进行认证
4.  再调用`DaoAuthenticationProvider`的`authenticate`方法进行认证
5.  再再调用`loadUserByUserName`方法查询用户信息，如果查询成功封装用户信息成`UserDetails`对象返回
6.  通过某些方法对比`UserDetails`中的密码与`Authentication`中的密码是否一致，一致则将用户权限信息set到`Authentication`对象中，并返回
7.  将`Authentication`对象存储到`SecurityContextHolder`中

**认证流程最最最最最核心的内容！**

只需看懂认证的大概流程，不用记忆！因为我们后期需要重写第5步到我们的数据库中查询，而不是到内存中查询，第7步封装到`SecurityContextHolder`中是因为在全局中我们可以随时取得到。

![在这里插入图片描述][b8af7eaa0ee94aa5af8b2cb5f9b038ff.png]

概念速查:

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

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

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

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

### 3.3 编写代码 ###

#### 3.3.1 思路分析 ####

**登录**

*  自定义登录接口
    
     *  调用ProviderManager实现类的方法进行认证，认证通过则生成jwt
     *  把用户信息存入redis中
 *  自定义UserDetailsService
    
     *  在这个实现类中去查询数据库

**校验**

*  定义Jwt认证过滤器
    
     *  获取token
     *  解析token获取其中的userId
     *  从redis中获取用户信息
     *  存入SecurityContextHolder

#### 3.3.2 准备工作 ####

①添加依赖

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.33</version>
    </dependency>
    
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt</artifactId>
        <version>0.9.0</version>
    </dependency>

② 添加Redis相关配置

Redis序列化

import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.serializer.SerializerFeature;
    import com.fasterxml.jackson.databind.JavaType;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.fasterxml.jackson.databind.type.TypeFactory;
    import org.springframework.data.redis.serializer.RedisSerializer;
    import org.springframework.data.redis.serializer.SerializationException;
    import com.alibaba.fastjson.parser.ParserConfig;
    import org.springframework.util.Assert;
    import java.nio.charset.Charset;
    
    /**
     * Redis使用FastJson序列化
     */
    public class FastJsonRedisSerializer<T> implements RedisSerializer<T>
    {
        
    
        public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
    
        private Class<T> clazz;
    
        static
        {
        
            ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
        }
    
        public FastJsonRedisSerializer(Class<T> clazz)
        {
        
            super();
            this.clazz = clazz;
        }
    
        @Override
        public byte[] serialize(T t) throws SerializationException
        {
        
            if (t == null)
            {
        
                return new byte[0];
            }
            return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
        }
    
        @Override
        public T deserialize(byte[] bytes) throws SerializationException
        {
        
            if (bytes == null || bytes.length <= 0)
            {
        
                return null;
            }
            String str = new String(bytes, DEFAULT_CHARSET);
    
            return JSON.parseObject(str, clazz);
        }
        protected JavaType getJavaType(Class<?> clazz)
        {
        
            return TypeFactory.defaultInstance().constructType(clazz);
        }
    }

RedisConfig.java

import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.data.redis.connection.RedisConnectionFactory;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    
    @Configuration
    public class RedisConfig {
        
    
        @Bean
        @SuppressWarnings(value = {
         "unchecked", "rawtypes" })
        public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory)
        {
        
            RedisTemplate<Object, Object> template = new RedisTemplate<>();
            template.setConnectionFactory(connectionFactory);
    
            FastJsonRedisSerializer serializer = new FastJsonRedisSerializer(Object.class);
    
            // 使用StringRedisSerializer来序列化和反序列化redis的key值
            template.setKeySerializer(new StringRedisSerializer());
            template.setValueSerializer(serializer);
    
            // Hash的key也采用StringRedisSerializer的序列化方式
            template.setHashKeySerializer(new StringRedisSerializer());
            template.setHashValueSerializer(serializer);
    
            template.afterPropertiesSet();
            return template;
        }
    }

③ResponseResult.java ----------响应类

import com.fasterxml.jackson.annotation.JsonInclude;
    @JsonInclude(JsonInclude.Include.NON_NULL)
    public class ResponseResult<T> {
        
        /**
         * 状态码
         */
        private Integer code;
        /**
         * 提示信息，如果有错误时，前端可以获取该字段进行提示
         */
        private String msg;
        /**
         * 查询到的结果数据，
         */
        private T data;
    
        public ResponseResult(Integer code, String msg) {
        
            this.code = code;
            this.msg = msg;
        }
    
        public ResponseResult(Integer code, T data) {
        
            this.code = code;
            this.data = data;
        }
    
        public Integer getCode() {
        
            return code;
        }
    
        public void setCode(Integer code) {
        
            this.code = code;
        }
    
        public String getMsg() {
        
            return msg;
        }
    
        public void setMsg(String msg) {
        
            this.msg = msg;
        }
    
        public T getData() {
        
            return data;
        }
    
        public void setData(T data) {
        
            this.data = data;
        }
    
        public ResponseResult(Integer code, String msg, T data) {
        
            this.code = code;
            this.msg = msg;
            this.data = data;
        }
    }

④工具类

JwtUtil.java----------JWT工具类

import io.jsonwebtoken.Claims;
    import io.jsonwebtoken.JwtBuilder;
    import io.jsonwebtoken.Jwts;
    import io.jsonwebtoken.SignatureAlgorithm;
    import javax.crypto.SecretKey;
    import javax.crypto.spec.SecretKeySpec;
    import java.util.Base64;
    import java.util.Date;
    import java.util.UUID;
    
    /**
     * JWT工具类
     */
    public class JwtUtil {
        
    
        //有效期为
        public static final Long JWT_TTL = 60 * 60 *1000L;// 60 * 60 *1000  一个小时
        //设置秘钥明文
        public static final String JWT_KEY = "cycyong";
    
        public static String getUUID(){
        
            String token = UUID.randomUUID().toString().replaceAll("-", "");
            return token;
        }
        
        /**
         * 生成jtw
         * @param subject token中要存放的数据（json格式）
         * @return
         */
        public static String createJWT(String subject) {
        
            JwtBuilder builder = getJwtBuilder(subject, null, getUUID());// 设置过期时间
            return builder.compact();
        }
    
        /**
         * 生成jtw
         * @param subject token中要存放的数据（json格式）
         * @param ttlMillis token超时时间
         * @return
         */
        public static String createJWT(String subject, Long ttlMillis) {
        
            JwtBuilder builder = getJwtBuilder(subject, ttlMillis, getUUID());// 设置过期时间
            return builder.compact();
        }
    
        private static JwtBuilder getJwtBuilder(String subject, Long ttlMillis, String uuid) {
        
            SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;
            SecretKey secretKey = generalKey();
            long nowMillis = System.currentTimeMillis();
            Date now = new Date(nowMillis);
            if(ttlMillis==null){
        
                ttlMillis=JwtUtil.JWT_TTL;
            }
            long expMillis = nowMillis + ttlMillis;
            Date expDate = new Date(expMillis);
            return Jwts.builder()
                    .setId(uuid)              //唯一的ID
                    .setSubject(subject)   // 主题  可以是JSON数据
                    .setIssuer("cyc")     // 签发者
                    .setIssuedAt(now)      // 签发时间
                    .signWith(signatureAlgorithm, secretKey) //使用HS256对称加密算法签名, 第二个参数为秘钥
                    .setExpiration(expDate);
        }
    
        /**
         * 创建token
         * @param id
         * @param subject
         * @param ttlMillis
         * @return
         */
        public static String createJWT(String id, String subject, Long ttlMillis) {
        
            JwtBuilder builder = getJwtBuilder(subject, ttlMillis, id);// 设置过期时间
            return builder.compact();
        }
    
        public static void main(String[] args) throws Exception {
        
            String token = "eyJhbGciOiJIUzI1NiJ9.eyJqdGkiOiJjYWM2ZDVhZi1mNjVlLTQ0MDAtYjcxMi0zYWEwOGIyOTIwYjQiLCJzdWIiOiJzZyIsImlzcyI6InNnIiwiaWF0IjoxNjM4MTA2NzEyLCJleHAiOjE2MzgxMTAzMTJ9.JVsSbkP94wuczb4QryQbAke3ysBDIL5ou8fWsbt_ebg";
            Claims claims = parseJWT(token);
            System.out.println(claims);
        }
    
        /**
         * 生成加密后的秘钥 secretKey
         * @return
         */
        public static SecretKey generalKey() {
        
            byte[] encodedKey = Base64.getDecoder().decode(JwtUtil.JWT_KEY);
            SecretKey key = new SecretKeySpec(encodedKey, 0, encodedKey.length, "AES");
            return key;
        }
        
        /**
         * 解析
         *
         * @param jwt
         * @return
         * @throws Exception
         */
        public static Claims parseJWT(String jwt) throws Exception {
        
            SecretKey secretKey = generalKey();
            return Jwts.parser()
                    .setSigningKey(secretKey)
                    .parseClaimsJws(jwt)
                    .getBody();
        }
    
    
    }

RedisCache.java----------redis工具类

import java.util.*;
    import java.util.concurrent.TimeUnit;
    
    @SuppressWarnings(value = {
         "unchecked", "rawtypes" })
    @Component
    public class RedisCache
    {
        
        @Autowired
        public RedisTemplate redisTemplate;
    
        /**
         * 缓存基本的对象，Integer、String、实体类等
         *
         * @param key 缓存的键值
         * @param value 缓存的值
         */
        public <T> void setCacheObject(final String key, final T value)
        {
        
            redisTemplate.opsForValue().set(key, value);
        }
    
        /**
         * 缓存基本的对象，Integer、String、实体类等
         *
         * @param key 缓存的键值
         * @param value 缓存的值
         * @param timeout 时间
         * @param timeUnit 时间颗粒度
         */
        public <T> void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit)
        {
        
            redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
        }
    
        /**
         * 设置有效时间
         *
         * @param key Redis键
         * @param timeout 超时时间
         * @return true=设置成功；false=设置失败
         */
        public boolean expire(final String key, final long timeout)
        {
        
            return expire(key, timeout, TimeUnit.SECONDS);
        }
    
        /**
         * 设置有效时间
         *
         * @param key Redis键
         * @param timeout 超时时间
         * @param unit 时间单位
         * @return true=设置成功；false=设置失败
         */
        public boolean expire(final String key, final long timeout, final TimeUnit unit)
        {
        
            return redisTemplate.expire(key, timeout, unit);
        }
    
        /**
         * 获得缓存的基本对象。
         *
         * @param key 缓存键值
         * @return 缓存键值对应的数据
         */
        public <T> T getCacheObject(final String key)
        {
        
            ValueOperations<String, T> operation = redisTemplate.opsForValue();
            return operation.get(key);
        }
    
        /**
         * 删除单个对象
         *
         * @param key
         */
        public boolean deleteObject(final String key)
        {
        
            return redisTemplate.delete(key);
        }
    
        /**
         * 删除集合对象
         *
         * @param collection 多个对象
         * @return
         */
        public long deleteObject(final Collection collection)
        {
        
            return redisTemplate.delete(collection);
        }
    
        /**
         * 缓存List数据
         *
         * @param key 缓存的键值
         * @param dataList 待缓存的List数据
         * @return 缓存的对象
         */
        public <T> long setCacheList(final String key, final List<T> dataList)
        {
        
            Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
            return count == null ? 0 : count;
        }
    
        /**
         * 获得缓存的list对象
         *
         * @param key 缓存的键值
         * @return 缓存键值对应的数据
         */
        public <T> List<T> getCacheList(final String key)
        {
        
            return redisTemplate.opsForList().range(key, 0, -1);
        }
    
        /**
         * 缓存Set
         *
         * @param key 缓存键值
         * @param dataSet 缓存的数据
         * @return 缓存数据的对象
         */
        public <T> BoundSetOperations<String, T> setCacheSet(final String key, final Set<T> dataSet)
        {
        
            BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);
            Iterator<T> it = dataSet.iterator();
            while (it.hasNext())
            {
        
                setOperation.add(it.next());
            }
            return setOperation;
        }
    
        /**
         * 获得缓存的set
         *
         * @param key
         * @return
         */
        public <T> Set<T> getCacheSet(final String key)
        {
        
            return redisTemplate.opsForSet().members(key);
        }
    
        /**
         * 缓存Map
         *
         * @param key
         * @param dataMap
         */
        public <T> void setCacheMap(final String key, final Map<String, T> dataMap)
        {
        
            if (dataMap != null) {
        
                redisTemplate.opsForHash().putAll(key, dataMap);
            }
        }
    
        /**
         * 获得缓存的Map
         *
         * @param key
         * @return
         */
        public <T> Map<String, T> getCacheMap(final String key)
        {
        
            return redisTemplate.opsForHash().entries(key);
        }
    
        /**
         * 往Hash中存入数据
         *
         * @param key Redis键
         * @param hKey Hash键
         * @param value 值
         */
        public <T> void setCacheMapValue(final String key, final String hKey, final T value)
        {
        
            redisTemplate.opsForHash().put(key, hKey, value);
        }
    
        /**
         * 获取Hash中的数据
         *
         * @param key Redis键
         * @param hKey Hash键
         * @return Hash中的对象
         */
        public <T> T getCacheMapValue(final String key, final String hKey)
        {
        
            HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();
            return opsForHash.get(key, hKey);
        }
    
        /**
         * 删除Hash中的数据
         * 
         * @param key
         * @param hkey
         */
        public void delCacheMapValue(final String key, final String hkey)
        {
        
            HashOperations hashOperations = redisTemplate.opsForHash();
            hashOperations.delete(key, hkey);
        }
    
        /**
         * 获取多个Hash中的数据
         *
         * @param key Redis键
         * @param hKeys Hash键集合
         * @return Hash对象集合
         */
        public <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys)
        {
        
            return redisTemplate.opsForHash().multiGet(key, hKeys);
        }
    
        /**
         * 获得缓存的基本对象列表
         *
         * @param pattern 字符串前缀
         * @return 对象列表
         */
        public Collection<String> keys(final String pattern)
        {
        
            return redisTemplate.keys(pattern);
        }
    }

WebUtils.java

import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    
    public class WebUtils
    {
        
        /**
         * 将字符串渲染到客户端
         * 
         * @param response 渲染对象
         * @param string 待渲染的字符串
         * @return null
         */
        public static String renderString(HttpServletResponse response, String string) {
        
            try
            {
        
                response.setStatus(200);
                response.setContentType("application/json");
                response.setCharacterEncoding("utf-8");
                response.getWriter().print(string);
            }
            catch (IOException e)
            {
        
                e.printStackTrace();
            }
            return null;
        }
    }

⑤User.java---------------实体类

import java.io.Serializable;
    import java.util.Date;
    
    /**
     * 用户表(User)实体类
     */
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class User implements Serializable {
        
        private static final long serialVersionUID = -40356785423868312L;
        
        /**
        * 主键
        */
        private Long id;
        /**
        * 用户名
        */
        private String userName;
        /**
        * 昵称
        */
        private String nickName;
        /**
        * 密码
        */
        private String password;
        /**
        * 账号状态（0正常 1停用）
        */
        private String status;
        /**
        * 邮箱
        */
        private String email;
        /**
        * 手机号
        */
        private String phonenumber;
        /**
        * 用户性别（0男，1女，2未知）
        */
        private String sex;
        /**
        * 头像
        */
        private String avatar;
        /**
        * 用户类型（0管理员，1普通用户）
        */
        private String userType;
        /**
        * 创建人的用户id
        */
        private Long createBy;
        /**
        * 创建时间
        */
        private Date createTime;
        /**
        * 更新人
        */
        private Long updateBy;
        /**
        * 更新时间
        */
        private Date updateTime;
        /**
        * 删除标志（0代表未删除，1代表已删除）
        */
        private Integer delFlag;
    }

#### 3.3.3 实现 ####

##### 3.3.3.1 数据库校验用户 #####

从之前的分析我们可以知道，我们可以自定义一个UserDetailsService,让SpringSecurity使用我们的UserDetailsService。我们自己的UserDetailsService可以从数据库中查询用户名和密码。  
**准备工作**

① 创建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='用户表'

② 引入MybatisPuls和mysql驱动的依赖

<dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.4.3</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>

③ 配置数据库信息

spring:
      datasource:
        url: jdbc:mysql://localhost:3306/security?characterEncoding=utf-8&serverTimezone=UTC
        username: root
        password: root
        driver-class-name: com.mysql.cj.jdbc.Driver

④ 定义Mapper接口

public interface UserMapper extends BaseMapper<User> {
        
    }

⑤ 修改User实体类

**类名上加@TableName(value = “sys\_user”) ,id字段上加 @TableId**

⑥ 配置Mapper扫描

@SpringBootApplication
    @MapperScan("com.cycyong.mapper")
    public class SimpleSecurityApplication {
        
        public static void main(String[] args) {
        
            ConfigurableApplicationContext run = SpringApplication.run(SimpleSecurityApplication.class);
        }
    }

⑦ 测试MP是否能正常使用

@Autowired
        private UserMapper userMapper;
        
        @Test
        void contextLoads() {
        
            User user = userMapper.selectById(1);
            System.out.println(user);
        }

**核心代码实现**

创建一个类实现UserDetailsService接口，重写其中的方法。更加用户名从数据库中查询用户信息

@Service
    public class UserDetailsServiceImpl implements UserDetailsService {
        
    
        @Autowired
        private UserMapper userMapper;
    
        @Override
        public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        
            // 1.根据用户名查询用户信息
            LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
            wrapper.eq(User::getUserName,username);
            User user = userMapper.selectOne(wrapper);
            // 2.如果查询不到数据就通过抛出异常来给出提示
            if(Objects.isNull(user)){
        
                throw new RuntimeException("用户名或密码错误");
            }
            //TODO 3.根据用户查询权限信息 添加到LoginUser中
            
            // 4.封装成UserDetails对象返回 
            return new LoginUser(user);
        }
    }

因为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;
        }
    }

注意：如果要测试，需要往用户表中写入用户数据，并且如果你想让用户的密码是明文存储，需要在密码前加`{noop}` 例如下图所示：  
![在这里插入图片描述][0b7b8ad7a78743d084e6e0a6b5db6f99.png]

这样登陆的时候就可以用cycyong作为用户名，1234作为密码来登陆测试了。

postman测试截图：成功返回`token`

![在这里插入图片描述][d261e46f25254348ab03d0b2d5cb45b6.png]

##### 3.3.3.2 密码加密存储 #####

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

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

我们一般使用SpringSecurity为我们提供的`BCryptPasswordEncoder`

我们只需要使用把`BCryptPasswordEncoder`对象注入Spring容器中，SpringSecurity就会使用该PasswordEncoder来进行密码校验

我们可以定义一个SpringSecurity的配置类，SpringSecurity要求这个配置类要继承`WebSecurityConfigurerAdapter`**(注意此方法已经过时，但是我这里接下来的所有关于这个配置仍然按旧版进行配置，在文末我会给出全新的配置方式，更简单，更简洁)**

@Configuration
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
        
    
        @Bean
        // 使用官方推荐的BCrypt加密密码，也就是md5加随机盐
        public PasswordEncoder passwordEncoder(){
        
            return new BCryptPasswordEncoder();
        }
    }

##### 3.3.3.3 登录接口 #####

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

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

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

@RestController
    public class LoginController {
        
    
        @Autowired
        private LoginServcie loginServcie;
    
        @PostMapping("/user/login")
        public ResponseResult login(@RequestBody User user){
        
            return loginServcie.login(user);
        }
    }

@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
        //注入AuthenticationManager 
        public AuthenticationManager authenticationManagerBean() throws Exception {
        
            return super.authenticationManagerBean();
        }
    }

@Service
    public class LoginServiceImpl implements LoginServcie {
        
    
        @Autowired
        private AuthenticationManager authenticationManager;
        @Autowired
        private RedisCache redisCache;
    
        @Override
        public ResponseResult login(User user) {
        
        	// 1.authenticationManager authenticate进行用户验证
            UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(user.getUserName(),user.getPassword());
            Authentication authenticate = authenticationManager.authenticate(authenticationToken);
            // 2.认证没有通过，给出对应的错误信息
            if(Objects.isNull(authenticate)){
        
                throw new RuntimeException("用户名或密码错误");
            }
            // 3.认证通过，使用userId生成一个Jwt并存入ResponseResult返回
            //使用userId生成token
            LoginUser loginUser = (LoginUser) authenticate.getPrincipal();
            String userId = loginUser.getUser().getId().toString();
            String jwt = JwtUtil.createJWT(userId);
           // 4.authenticate存入redis（完整用户信息存入redis）
            redisCache.setCacheObject("login:"+userId,loginUser);
            // 5.把token响应给前端
            HashMap<String,String> map = new HashMap<>();
            map.put("token",jwt);
            return new ResponseResult(200,"登陆成功",map);
        }
    }

注意一个问题：

1.  用户验证通过，`loginUser`对象是在`authenticate`的`Principal`里面!!!  
    ![在这里插入图片描述][b2afe019553341d486f0c0fd7cacc747.png]

##### 3.3.3.4 认证过滤器 #####

我们需要自定义一个过滤器，这个过滤器会去获取请求头中的token，对token进行解析取出其中的`userId`。这是为了取出`userId`去数据库查询该用户具有权限，即授权做准备！！！

方法步骤：

1.  使用`userId`去redis中获取对应的LoginUser对象。
2.  然后封装`Authentication`对象存入`SecurityContextHolder`

JwtAuthenticationTokenFilter.java

@Component
    public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {
        
        @Autowired
        private RedisCache redisCache;
    
        @Override
        protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        
            // 1.获取token
            String token = request.getHeader("token");
            // 2.如果为空，则放行返回
            if (!StringUtils.hasText(token)) {
        
                // 放行，后面还有其他的过滤器会判断异常
                filterChain.doFilter(request, response);
                //这里是为了过滤器链回来后不执行下去
                return;
            }
            // 3.如果不为空，则解析token
            String userId;
            try {
        
                Claims claims = JwtUtil.parseJWT(token);
                userId = claims.getSubject();
            } catch (Exception e) {
        
                e.printStackTrace();
                throw new RuntimeException("token非法");
            }
            // 4.解析成功，从redis中获取用户信息
            String redisKey = "login:" + userId;
            LoginUser loginUser = redisCache.getCacheObject(redisKey);
            if(Objects.isNull(loginUser)){
        
                throw new RuntimeException("用户未登录");
            }
    
            // 5.将用户信息存入SecurityContextHolder
            //TODO 获取权限信息封装到Authentication中
             UsernamePasswordAuthenticationToken authenticationToken =
             new UsernamePasswordAuthenticationToken(loginUser,null,null);
            SecurityContextHolder.getContext().setAuthentication(authenticationToken);
            //放行
            filterChain.doFilter(request, response);
        }
    }

这里注意几个问题：

1.  解析`token`成功之后，`userId`是藏在`claims`对象中的`sub`中

![在这里插入图片描述][a19d8350a7d746f8a9863c68f36a7456.png]

1.  放在redis中的key值为`login:id`,里面存着用户信息`lpgonUser`对象，包含用户的权限信息。

##### 2.3.3.5 退出登录 #####

我们只需要定义一个登出接口，然后获取`SecurityContextHolder`中的认证信息，删除redis中对应的`redisKey`即可。

LoginController.java

@RequestMapping("/user/logout")
        public ResponseResult logout(){
        
            return loginService.logout();
        }

LoginService.java

ResponseResult logout();

LoginServiceImpl.java

@Override
    public ResponseResult logout() {
        
        // 1.获取SecurityContextHolder中的用户Id
        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,"注销成功！");
    }

测试成功登录和登出！

成功登录！

![在这里插入图片描述][6b5273f80a924e47818f1dfb0ade8c33.png]

--------------------

成功登出！

![在这里插入图片描述][2a298c992a83409d9e69461f121de8f4.png]

--------------------

登出之后不能再用该`token`访问页面了！！！

## 4 授权 ##

### 4.1 权限系统的作用 ###

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

总结起来就是**不同的用户可以使用不同的功能**。这就是权限系统要去实现的效果。

有的同学就会问了，那我直接在系统界面显示不同角色要实现的功能不就行了嘛？我的回答是NO NO NO！还是上面的例子，如果我是普通学生的角色，不怀好意的得到删除书籍的接口地址，那我有可能将图书馆的所有图书信息全部删除了，**这是非常不安全的**。

有句话说得好：**前端防君子，后端防小人**。因此我们需要在前后端都加上防护，确保万无一失。

### 4.2 授权基本流程 ###

在SpringSecurity中，会使用默认的FilterSecurityInterceptor来进行权限校验。在FilterSecurityInterceptor中会从`SecurityContextHolder`获取其中的`Authentication`，然后获取其中的权限信息。当前用户是否拥有访问当前资源所需的权限。

所以我们在项目中只需要把当前登录用户的权限信息也存入`Authentication`。

然后设置我们的资源所需要的权限即可。

### 4.3 授权实现 ###

#### 4.3.1 限制访问资源所需权限 ####

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

在SecurityConfig.java添加启动全局安全配置。

@EnableGlobalMethodSecurity(prePostEnabled = true)

然后就可以使用对应的注解。  
`@PreAuthorize`:顾名思义，使用前必须授权！！！

`hasAuthority('test')`:顾名思义，需要有test权限才能访问！！！

HelloController.java

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

#### 4.3.2 封装权限信息 ####

我们前面在写UserDetailsServiceImpl的时候说过，在查询出用户后还要获取对应的权限信息，封装到UserDetails中返回。

我们先直接把权限信息写死封装到UserDetails中进行测试。

我们之前定义了UserDetails的实现类`LoginUser`，想要让其能封装权限信息就要对其进行修改。

LoginUser.java

@Data
    @NoArgsConstructor
    public class LoginUser implements UserDetails {
        
    
        private User user;
        //存储权限信息
        private List<String> permissions;
        // 不会被序列化进流当中
        //存储SpringSecurity所需要的权限信息的集合
        @JSONField(serialize = false)
        private List<SimpleGrantedAuthority> authorities;
    
    
        public LoginUser(User user,List<String> permissions){
        
            this.user = user;
            this.permissions = permissions;
        }
    
        // ctrl+alt+点击
        @Override
        public Collection<? extends GrantedAuthority> getAuthorities() {
        
            // 如果
            if(authorities!=null)
                return authorities;
            //把permissions中字符串类型的权限信息转换成GrantedAuthority对象存入authorities中
            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 UserDetailServiceImpl implements UserDetailsService {
        
    
        @Autowired
        private UserMapper userMapper;
    
        @Autowired
        private MenuMapper menuMapper;
    
        @Override
        public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        
            //根据用户名查询用户信息
            System.out.println(username);
            LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
            wrapper.eq(User::getUserName,username);
            User user = userMapper.selectOne(wrapper);
            //如果查询不到数据就通过抛出异常来给出提示
            if(Objects.isNull(user)){
        
                throw new RuntimeException("用户名或密码错误.....");
            }
            //TODO 根据用户查询权限信息 添加到LoginUser中
            List<String> list = new ArrayList<>(Arrays.asList("test"));
            return new LoginUser(user,list);
        }
    }

#### 4.3.3 从数据库查询权限信息 ####

##### 4.3.3.1 RBAC权限模型 #####

RBAC权限模型（Role-Based Access Control）即：基于角色的权限控制。这是目前最常被开发者使用也是相对易用、通用权限模型。  
![在这里插入图片描述][733769b8ac1b4e628f8b46e7e03e9c0e.png]

##### 4.3.3.2 准备工作 #####

SQL语句

CREATE DATABASE /*!32312 IF NOT EXISTS*/`security` /*!40100 DEFAULT CHARACTER SET utf8mb4 */;
    
    USE `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;

查询用户权限信息

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 = 2
    	AND r.`status` = 0
    	AND m.`status` = 0

package com.cycyong.domain;
    import com.baomidou.mybatisplus.annotation.TableId;
    import com.baomidou.mybatisplus.annotation.TableName;
    import com.fasterxml.jackson.annotation.JsonInclude;
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    import java.io.Serializable;
    import java.util.Date;
    
    @TableName(value="sys_menu")
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    @JsonInclude(JsonInclude.Include.NON_NULL)
    public class Menu implements Serializable {
        
    
        private static final long serialVersionUID = -54979041104113736L;
        
        @TableId
        private Long id;
        /**
        * 菜单名
        */
        private String menuName;
        /**
        * 路由地址
        */
        private String path;
        /**
        * 组件路径
        */
        private String component;
        /**
        * 菜单状态（0显示 1隐藏）
        */
        private String visible;
        /**
        * 菜单状态（0正常 1停用）
        */
        private String status;
        /**
        * 权限标识
        */
        private String perms;
        /**
        * 菜单图标
        */
        private String icon;
        
        private Long createBy;
        
        private Date createTime;
        
        private Long updateBy;
        
        private Date updateTime;
        /**
        * 是否删除（0未删除 1已删除）
        */
        private Integer delFlag;
        /**
        * 备注
        */
        private String remark;
    }

##### 4.3.3.3 代码实现 #####

然后我们可以在UserDetailsServiceImpl中去调用该mapper的方法查询权限信息封装到LoginUser对象中即可。

我们只需要根据用户id去查询到其所对应的权限信息即可。  
所以我们可以先定义个mapper，其中提供一个方法可以根据userid查询权限信息。

MenuMapper.java

@Repository // 代表持久层
    public interface MenuMapper extends BaseMapper<Menu> {
        
        List<String> selectPermsByUserId(Long id);
    }

MenuMapper.xml

<?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.cycyong.mapper.MenuMapper">
        <select id="selectPermsByUserId" resultType="java.lang.String">
            select
                distinct (m.perms)
            from
                security.sys_user_role ur
                    left join security.sys_role r on ur.role_id = r.id
                    left join security.sys_role_menu rm on rm.role_id = r.id
                    left join security.sys_menu m on m.id = rm.menu_id
            where
                ur.user_id = #{id} and
                r.status = 0 and
                m.status = 0
        </select>
    </mapper>

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

spring:
      datasource:
        url: jdbc:mysql://localhost:3306/security?characterEncoding=utf-8&serverTimezone=UTC
        username: root
        password: jianjian123456
        driver-class-name: com.mysql.cj.jdbc.Driver
    
      redis:
        host: localhost
        port: 6379
    mybatis-plus:
      mapper-locations: classpath*:/mapper/**/*.xml

然后我们可以在UserDetailsServiceImpl中去调用该mapper的方法查询权限信息`perms`封装到`LoginUser`中即可。

@Service
    public class UserDetailServiceImpl implements UserDetailsService {
        
    
        @Autowired
        private UserMapper userMapper;
    
        @Autowired
        private MenuMapper menuMapper;
    
        @Override
        public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        
            //根据用户名查询用户信息
            System.out.println(username);
            LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
            wrapper.eq(User::getUserName,username);
            User user = userMapper.selectOne(wrapper);
            //如果查询不到数据就通过抛出异常来给出提示
            if(Objects.isNull(user)){
        
                throw new RuntimeException("用户名或密码错误.....");
            }
            //TODO 根据用户查询权限信息 添加到LoginUser中
            List<String> perms = menuMapper.selectPermsByUserId(user.getId());
            //封装成UserDetails对象返回
            return new LoginUser(user,perms);
        }
    }

##### 4.3.3.4 测试 #####

我们定义了两个用户`cycyong`和`zxc`

zxc的权限：

![在这里插入图片描述][f5f2921ef81646028cdbc6892daf41b9.png]

cycyong的权限：

![在这里插入图片描述][3a05a4478f5b4c7ebab9288b84d8b9f3.png]

HelloController.java

@RestController
    public class HelloController {
        
        @RequestMapping("/hello")
    	@PreAuthorize("hasAuthority('system:emp:list')")
        public String hello(){
        
            return "员工列表";
        }
    }

我们在controller规定了`/hello`只能有`system:emp:list`才能进入，所以zxc不能访问，cycyong可以访问！！！

cycyong携带token访问：可以访问！！！

![在这里插入图片描述][9662be06cfdf46e1be4375ab8a6570dd.png]  
zxc携带token访问：403Forbidden！！！  
![在这里插入图片描述][9831dc109469471699ec14ec458ec1b6.png]

## 5 自定义失败处理 ##

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

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

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

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

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

① 自定义实现类

AccessDeniedHandlerImpl.java

@Component
    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);
        }
    }

AuthenticationEntryPointImpl.java

@Component
    public class AuthenticationEntryPointImpl implements AuthenticationEntryPoint {
        
        @Override
        public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
        
            // 处理认证异常
            ResponseResult result = new ResponseResult(HttpStatus.UNAUTHORIZED.value(),"认证失败,请重新登录");
            String jsonString = JSON.toJSONString(result);
            WebUtils.renderString(response,jsonString);
        }
    }

② 配置给SpringSecurity  
第一步：注入对应的处理器

@Autowired
    private AuthenticationEntryPoint authenticationEntryPoint;
    
    @Autowired
    private AccessDeniedHandler accessDeniedHandler;

然后我们可以使用HttpSecurity对象的方法去配置。

http.exceptionHandling()
    .authenticationEntryPoint(authenticationEntryPoint)
    .accessDeniedHandler(accessDeniedHandler);

③ 测试  
还是上一节测试的例子：zxc没有`/hello`访问的权限，仍然携带`token`去访问`/hello`

得到我们设置的`code`和`msg`。

![在这里插入图片描述][206f13b5fc6d47508f91749c2558783e.png]  
不携带`token`访问，则得到我们预料的结果！！！  
![在这里插入图片描述][a8d26540fd984a169d627813e7226894.png]

## 6 跨域 ##

浏览器出于安全的考虑，使用 XMLHttpRequest对象发起 HTTP请求时必须遵守同源策略，否则就是跨域的HTTP请求，默认情况下是被禁止的。 同源策略要求源相同才能正常进行通信，即协议、域名、端口号都完全一致。

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

所以我们就要处理一下，让前端能进行跨域请求。

①先对SpringBoot配置，允许跨域请求

@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);
        }
    }

②开启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("/hello").hasAuthority("system:dept:list")
                // 除上面外的所有请求全部需要鉴权认证
                .anyRequest().authenticated();
        //把token校验过滤器添加到过滤器链中
        http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
        http.exceptionHandling().authenticationEntryPoint(authenticationEntryPoint).accessDeniedHandler(accessDeniedHandler);
    
        // 允许跨域
        http.cors();
    }

## 7 拓展 ##

### 7.1 其它权限校验方法 ###

我们前面都是使用`@PreAuthorize`注解，然后在在其中使用的是`hasAuthority`方法进行校验。SpringSecurity还为我们提供了其它方法例如：`hasAnyAuthority`，`hasRole`，`hasAnyRole`等。

我们先不着急了解其他方法，而先去理解`hasAuthority`的源码是怎么执行的！

我们打上断点进行调试！  
① 实际上是调用了`hasAnyAuthority`方法，并传入`preflx`和`authorities`

![在这里插入图片描述][db046c611a604180b7b5a3919b067bb1.png]

② 再调用了`hasAnyAuthorityName`方法，里面的`getAuthoritySet`获取用户的权限信息

private boolean hasAnyAuthorityName(String prefix, String... roles) {
        
    	Set<String> roleSet = getAuthoritySet();
    	for (String role : roles) {
        
    		// 添加前缀
    		String defaultedRole = getRoleWithDefaultPrefix(prefix, role);
    		if (roleSet.contains(defaultedRole)) {
        
    			return true;
    		}
    	}
    	return false;
    }

`getAuthoritySet`方法内部

![在这里插入图片描述][321d1e47f39f4a0ba3964bb90f6d65bc.png]

③ `hasAnyAuthorityName`方法用用户所拥有的权限逐一判断是否拥有访问接口要求的权限，如果接口要求的权限信息都有，则返回true，否则返回false！

![在这里插入图片描述][e0167d5bc67546e49af5d31b4cefe369.png]

了解完`hasAuthority`的源码实现之后，其他方法也容易理解！！！

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

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

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

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

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

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

### 7.2 自定义权限校验方法 ###

我们也可以定义自己的权限校验方法，在`@PreAuthorize`注解中使用我们的方法。这里举的例子是同时要求的权限才能访问！

HelloController.java

@RestController
    public class HelloController {
        
    
        @RequestMapping("/hello")
    //    @PreAuthorize("hasAuthority('system:emp:list')")
        @PreAuthorize("@ex.hasAuthorities('system:emp:list','system:dept:list')")
        public String hello(){
        
            return "员工列表";
        }
    }

hasAuthorities.java

@Component("ex")
    public class cycExpressionRoot {
        
        /**
         * 检查是否含有对应的权限
         * @param authorities 要求的权限
         * @return boolean
         */
        public boolean hasAuthorities(String ...authorities){
        
            // 获取当前用户的权限
            Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
            LoginUser loginUser = (LoginUser) authentication.getPrincipal();
            List<String> permissions = loginUser.getPermissions();
            for (String authority : authorities) {
        
                if (!permissions.contains(authority)) {
        
                    return false;
                }
            }
            // 判断当前用户权限中是否存在要求的权限String
            return true;
        }
    }

### 7.3 基于配置的权限控制 ###

我们也可以在配置类中使用使用配置的方式对资源进行权限控制。

@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").hasAuthority("system:dept:list111111111")
                // 除上面外的所有请求全部需要鉴权认证
                .anyRequest().authenticated();
    
        //添加过滤器
        http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
    
        //配置异常处理器
        http.exceptionHandling()
                //配置认证失败处理器
                .authenticationEntryPoint(authenticationEntryPoint)
                .accessDeniedHandler(accessDeniedHandler);
    
        //允许跨域
        http.cors();
    }

### 7.4 CSRF ###

CSRF是指跨站请求伪造（Cross-site request forgery），是web常见的攻击之一。

参考大佬博客：https://blog.csdn.net/freeking101/article/details/86537087

SpringSecurity去防止CSRF攻击的方式就是通过csrf\_token。后端会生成一个csrf\_token，前端发起请求的时候需要携带这个csrf\_token,后端会有过滤器进行校验，如果没有携带或者是伪造的就不允许访问。

我们可以发现CSRF攻击依靠的是cookie中所携带的认证信息。但是在前后端分离的项目中我们的认证信息其实是token，而token并不是存储中cookie中，并且需要前端代码去把token设置到请求头中才可以，所以CSRF攻击也就不用担心了。

### 7.5 认证成功处理器 ###

实际上在UsernamePasswordAuthenticationFilter进行登录认证的时候，如果登录成功了是会调用AuthenticationSuccessHandler的方法进行认证成功后的处理的。AuthenticationSuccessHandler就是登录成功处理器。

我们也可以自己去自定义成功处理器进行成功后的相应处理。

@Component
    public class CYCSuccessHandler implements AuthenticationSuccessHandler {
        
        
        @Override
        public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
        
            System.out.println("认证成功！！！");
        }
    }

@Configuration
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
        
    
        @Autowired
        private AuthenticationSuccessHandler successHandler;
    
        @Override
        protected void configure(HttpSecurity http) throws Exception {
        
            http.formLogin().successHandler(successHandler);
    
            http.authorizeRequests().anyRequest().authenticated();
        }
    }

### 7.6 认证失败处理器 ###

实际上在UsernamePasswordAuthenticationFilter进行登录认证的时候，如果认证失败了是会调用AuthenticationFailureHandler的方法进行认证失败后的处理的。AuthenticationFailureHandler就是登录失败处理器。

我们也可以自己去自定义失败处理器进行失败后的相应处理。

@Component
    public class CYCFailureHandler implements AuthenticationFailureHandler {
        
        @Override
        public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) throws IOException, ServletException {
        
            System.out.println("认证失败了");
        }
    }

@Configuration
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
        
    
        @Autowired
        private AuthenticationSuccessHandler successHandler;
    
        @Autowired
        private AuthenticationFailureHandler failureHandler;
    
        @Override
        protected void configure(HttpSecurity http) throws Exception {
        
            http.formLogin()
    //                配置认证成功处理器
                    .successHandler(successHandler)
    //                配置认证失败处理器
                    .failureHandler(failureHandler);
    
            http.authorizeRequests().anyRequest().authenticated();
        }
    }

### 7.7 登出成功处理器 ###

@Component
    public class CYCLogoutSuccessHandler implements LogoutSuccessHandler {
        
        @Override
        public void onLogoutSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
        
            System.out.println("注销成功");
        }
    }

@Configuration
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
        
    
        @Autowired
        private AuthenticationSuccessHandler successHandler;
    
        @Autowired
        private AuthenticationFailureHandler failureHandler;
    
        @Autowired
        private LogoutSuccessHandler logoutSuccessHandler;
    
        @Override
        protected void configure(HttpSecurity http) throws Exception {
        
            http.formLogin()
    //                配置认证成功处理器
                    .successHandler(successHandler)
    //                配置认证失败处理器
                    .failureHandler(failureHandler);
    
            http.logout()
                    //配置注销成功处理器
                    .logoutSuccessHandler(logoutSuccessHandler);
    
            http.authorizeRequests().anyRequest().authenticated();
        }
    }

[SpringSecurity_]: https://download.csdn.net/download/cycyong/87769378
[db7711bdde294b86952c5293a951164d.png]: https://img-blog.csdnimg.cn/db7711bdde294b86952c5293a951164d.png
[592589961a874bb89fb2b7dceae1f587.png]: https://img-blog.csdnimg.cn/592589961a874bb89fb2b7dceae1f587.png
[057e8297240d4e1d82ced1662de7286f.png]: https://img-blog.csdnimg.cn/057e8297240d4e1d82ced1662de7286f.png
[SpringSecurity]: https://img-blog.csdnimg.cn/cc496aeb57cf4b938ef2e7a672ad6f1b.png
[SspringSecurity]: https://img-blog.csdnimg.cn/3c59c63dcb044e2d86c6075bb51a30d1.png
[b8af7eaa0ee94aa5af8b2cb5f9b038ff.png]: https://img-blog.csdnimg.cn/b8af7eaa0ee94aa5af8b2cb5f9b038ff.png
[0b7b8ad7a78743d084e6e0a6b5db6f99.png]: https://img-blog.csdnimg.cn/0b7b8ad7a78743d084e6e0a6b5db6f99.png
[d261e46f25254348ab03d0b2d5cb45b6.png]: https://img-blog.csdnimg.cn/d261e46f25254348ab03d0b2d5cb45b6.png
[b2afe019553341d486f0c0fd7cacc747.png]: https://img-blog.csdnimg.cn/b2afe019553341d486f0c0fd7cacc747.png
[a19d8350a7d746f8a9863c68f36a7456.png]: https://img-blog.csdnimg.cn/a19d8350a7d746f8a9863c68f36a7456.png
[6b5273f80a924e47818f1dfb0ade8c33.png]: https://img-blog.csdnimg.cn/6b5273f80a924e47818f1dfb0ade8c33.png
[2a298c992a83409d9e69461f121de8f4.png]: https://img-blog.csdnimg.cn/2a298c992a83409d9e69461f121de8f4.png
[733769b8ac1b4e628f8b46e7e03e9c0e.png]: https://img-blog.csdnimg.cn/733769b8ac1b4e628f8b46e7e03e9c0e.png
[f5f2921ef81646028cdbc6892daf41b9.png]: https://img-blog.csdnimg.cn/f5f2921ef81646028cdbc6892daf41b9.png
[3a05a4478f5b4c7ebab9288b84d8b9f3.png]: https://img-blog.csdnimg.cn/3a05a4478f5b4c7ebab9288b84d8b9f3.png
[9662be06cfdf46e1be4375ab8a6570dd.png]: https://img-blog.csdnimg.cn/9662be06cfdf46e1be4375ab8a6570dd.png
[9831dc109469471699ec14ec458ec1b6.png]: https://img-blog.csdnimg.cn/9831dc109469471699ec14ec458ec1b6.png
[206f13b5fc6d47508f91749c2558783e.png]: https://img-blog.csdnimg.cn/206f13b5fc6d47508f91749c2558783e.png
[a8d26540fd984a169d627813e7226894.png]: https://img-blog.csdnimg.cn/a8d26540fd984a169d627813e7226894.png
[db046c611a604180b7b5a3919b067bb1.png]: https://img-blog.csdnimg.cn/db046c611a604180b7b5a3919b067bb1.png
[321d1e47f39f4a0ba3964bb90f6d65bc.png]: https://img-blog.csdnimg.cn/321d1e47f39f4a0ba3964bb90f6d65bc.png
[e0167d5bc67546e49af5d31b4cefe369.png]: https://img-blog.csdnimg.cn/e0167d5bc67546e49af5d31b4cefe369.png