Spring Security

最新推荐文章于 2024-06-30 10:23:22 发布

快乐的小三菊

最新推荐文章于 2024-06-30 10:23:22 发布

阅读量1.3k

点赞数 29

分类专栏： spring security 文章标签： spring

本文链接：https://blog.csdn.net/xhf852963/article/details/138115005

版权

spring security 专栏收录该内容

6 篇文章 2 订阅

订阅专栏

一、简介

Spring Security 的前身是 Acegi Security，在被收纳为 Spring 子项目后正式更名为 Spring Security。截止到目前为止，Spring Security 已经升级到 5.3.9 版本，不仅新增了原生 OAuth 框架，还支持更加现代化的密码加密方式。

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

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

一般 Web 应用的需要进行认证和授权。而认证和授权也是 SpringSecurity 作为安全框架的核心功能。

认证：验证当前访问系统的是不是本系统的用户，并且要确认具体是哪个用户。

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

二、快速入门

2.1 准备工作

我们我们搭建一个简答的 SpringBoot 工程，首先设置父工程添加依赖，如下：

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.0</version>
    </parent>
    <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>
    </dependencies>

然后创建启动类，代码如下：

@SpringBootApplication
public class Main {
    public static void main(String[] args) {
        SpringApplication.run(Main.class,args);
    }
}

最后创建一个测试用的 controller 类，代码如下

@RestController
public class HelloController {

    @RequestMapping("/hello")
    public String hello(){
        return "Hello World";
    }
}

启动测试，如下图，没有任何问题

2.1 引入 SpringSecurity

在 SpringBoot 项目中使用 SpringSecurity 我们只需要引入依赖即可实现入门案例。

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

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

只有登录成功之后才会跳转到我们的接口，如下图：

三、认证

3.1 登录校验流程

一个完整的登录校验流程如下图所示：

3.2 原理初探

想要知道如何实现自己的登陆流程就必须要先知道入门案例中 SpringSecurity 的流程。

3.2.1 SpringSecurity 完整流程

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

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

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

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

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

3.2.2 认证流程详解

前面我们已经了解了一个完整的 SpringSecurity 的流程，有负责认证、有负责异常处理、以及授权的拦截器。接下来我们要针对其中的一个点进行一个更详细的了解，先来了解下认证的流程内部究竟是如何实现的。

这个图不需要记忆，能看懂图就行。

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

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

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

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

1、默认案例中是使用 UsernamePasswordAuthenticationFilter 过滤器去实现认证的逻辑的，在它的内部还调用了其他的类来帮助它实现的。

2、用户在默认的登录页提交用户名和密码，点击提交就进行了一次登录认证，此时就会将用户名和密码提交给 UsernamePasswordAuthenticationFilter 过滤器。

3、在 UsernamePasswordAuthenticationFilter 中将用户名和密码封装成 Authentication 对象，这个时候最多只有用户名和密码，权限还没有。

4、将封装好的 Authentication 对象传递给 ProviderManager 类的 authenticate() 方法进行认证。主要是为了校验是否为系统的用户。

5、在 ProviderManager 类中调用 DaoAuthenticationProvider 的 authenticate() 方法进行认证，也是为了校验是否为系统的用户。

6、在 DaoAuthenticationProvider 类中调用 InMemoryUserDetailsManager 的 loadUserByUsername 方法查询用户，在这个方法的内部会根据用户名去查询对应的用户以及这个用户对应的权限信息。而 InMemoryUserDetailsManager 是在内存中查找。最后把查询到的用户信息和权限信息封装成 UserDetails 对象。

7、将封装好的 UserDetails 对象返回给 DaoAuthenticationProvider，在 DaoAuthenticationProvider 拿到这个 UserDetails 对象之后，会使用 PasswordEncoder 对比 UserDetails 中的密码和提交过来的 Authentication 对象中的密码是否一致，如果校验通过，就会把 UserDetails 中的权限信息设置到 Authentication 对象中。

8、最终把校验完的 Authentication 对象返回给 UsernamePasswordAuthenticationFilter。

9、如果第 8 步返回了 Authentication 对象，就会把这个对象存储到 SecurityContextHolder.getContext().setAuthentication 当中，其他的过滤器就会通过 SecurityContextHolder 来获取当前用户信息。

3.3 提出问题

如何修改默认的认证流程来实现我们自己的认证流程呢？在我们实际的这种前后端分离的项目当中，要求传过来用户名和密码之后去查询数据库，然后生成一个 token 响应给前端就可以了。

3.3.1 思路分析

针对于查询数据库，只需要替换 InMemoryUserDetailsManager 类，自己去实现 UserDetailsService 接口即可。

如果验证通过了，就需要生成一个 token 响应给前端，默认情况下，认证通过是返回到 UsernamePasswordAuthenticationFilter 过滤器里面，但是我们无法在这个类里面进行返回 token 的操作，我们可以自己定义一套 controller ，当用户提交的时候，用户名和密码就提交到我们自己的 controller 当中，然后在 controller 当中去调用 ProviderManager 类的 authenticate() 方法即可，此时的流程图如下所示：

认证不能只考虑登录，还需要考虑校验，就是登录成功之后，如何再去判断是否登录呢？此时我们就需要自己定义一个过滤器，前端如果登录完成之后会获取到 token，再访问其他接口的时候携带 token 即可，如下图：

但是，这里面是有一个问题，在 jwt 认证过滤器中获取到了 userid 后怎么获取到完整的用户信息？我们可以使用 redis 来存储用户信息，减轻数据库的压力。即当用户登录成功之后，用 userid 作为 key，用户信息作为 value 存入到 redis 中。jwt 认证过滤器就可以通过 userid 从 redis 中获取到用户信息了

3.3.2 思路分析总结

登录：

1、自定义登录接口：调用 ProviderManager 的方法进行认证如果认证通过生成 jwt 把用户信息存入 redis 中。

2、自定义 UserDetailsService：在这个实现类中去查询数据库。

校验：

1、定义 Jwt 认证过滤器：获取 token，解析 token 获取其中的 userid，从 redis 中获取用户信息，存入 SecurityContextHolder 中。

3.3.3 准备工作

1、添加依赖，pom.xml 如下所示：

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

2、创建 Redis 基于 FastJson 的序列化器，代码如下：

package com.spring.util;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.fasterxml.jackson.databind.JavaType;
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 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);
    }
}

3、创建 Redis 相关的一些配置类，避免看上去出现乱码问题，代码如下：

package com.spring.config;

import com.spring.util.FastJsonRedisSerializer;
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;
    }
}

4、创建一个专门用于响应给前端的实体类，代码如下：

package com.spring.entity;

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

5、创建一个 jwt 的工具类，代码如下：

package com.spring.util;

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;

public class JwtUtil {
    // 有效期为
    public static final Long JWT_TTL = 60 * 60 * 1000L;// 60 * 60 *1000 一个小时
    //设置秘钥明文
    public static final String JWT_KEY = "sangeng";

    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("sg") // 签发者
                .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();
    }
}

6、创建 Redis 的工具类，里面对 Template 方法进行了进一步的封装，代码如下：

package com.spring.util;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.BoundSetOperations;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;

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

7、创建 WebUtils 工具类，后面会往响应中写入一些数据，代码如下：

package com.spring.util;

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

8、创建用户的实体类，代码如下：

package com.spring.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

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.4 解决问题

3.4.1 数据库校验用户

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

1、我们先创建一个用户表，建表语句如下：

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

然后随便的向里面插入一条数据，用于我们后续的测试，如下图：

2、引入 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>

3、配置数据库信息，application.yml 内容如下所示：

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

4、定义 Mapper 接口，代码如下：

package com.spring.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.spring.entity.User;

public interface UserMapper extends BaseMapper<User> {
}

5、修改 User 实体类，在类名上加 @TableName(value = "sys_user") ，id 字段上加 @TableId，如下图：

6、配置 Mapper 扫描，如下图：

7、测试我们配置的 mybatisplus 是否好用，添加 junit 依赖，如下：

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

编写测试代码进行测试，如下：

package com.spring;

import com.spring.entity.User;
import com.spring.mapper.UserMapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

@SpringBootTest
public class MapperTest {

    @Autowired
    UserMapper userMapper;

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

可以看到，没有任何问题，如下图：

3.4.2 核心代码实现

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

package com.spring.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.spring.entity.User;
import com.spring.mapper.UserMapper;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.Objects;

@Service
public class UserDetailsServiceImpl implements UserDetailsService {

    @Resource
    UserMapper userMapper;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {

        // 根据用户名查询用户信息
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("user_name",username);
        User user = userMapper.selectOne(queryWrapper);

        // 如果查询不到数据就通过抛出异常给出提示
        if(Objects.isNull(user)){
            throw new RuntimeException();
        }
        // 封装成 UserDetails 对象返回
        return new LoginUser(user);
    }
}

因为 UserDetailsService 方法的返回值是 UserDetails 类型，所以需要定义一个类，实现该接口，把用户信息封装在其中。代码如下：

package com.spring.service.impl;

import com.spring.entity.User;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;

import java.util.Collection;

@Data
@AllArgsConstructor
@NoArgsConstructor
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;
    }
}

接下来进行测试，首先确保数据库表里面有一条数据，如下图：

在浏览器访问 http://localhost:8080/hello，会自动跳转到 login 的登录页面，输入用户名和密码之后，发现登录不成功，报错信息如下：

如果想让用户的密码是明文存储，需要在密码前加 {noop}。如下：

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

3.4.3 密码加密存储

上面的这种方式是将密码明文存储的，在实际项目中我们不会把密码明文存储在数据库中，默认使用的 PasswordEncoder 要求数据库中的密码格式为：{id}password，它会根据 id 去判断密码的加密方式。但是我们一般不会采用这种方式。所以就需要替换 PasswordEncoder。

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

我们可以定义一个 SpringSecurity 的配置类，SpringSecurity 要求这个配置类要继承 WebSecurityConfigurerAdapter。代码如下：

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {

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

BCryptPasswordEncoder 类提供了两个关键的方法，一个是对明文密码的加密，另外一个是判断明文密码和加密之后的密码是否匹配，测试的方法代码如下：

    @Test
    public void testPasswordEncoder(){
        PasswordEncoder p = new BCryptPasswordEncoder();

        // 对密码进行加密
        // $2a$10$vOUFt/rotkr.TZwRTziL1egPx8o3OAjn7nbfem8Z.bPHgAZ/yGCyK
        String encode1 = p.encode("1234");

        // $2a$10$d3mxXkCYjBFrQICVVos/P.BK.rp13/HUFxjpL.EULyoLs9nWSaaPO
        String encode2 = p.encode("1234");

        System.out.println(encode1);
        System.out.println(encode2);

        // 判断明文密码和加密之后的密码是否匹配
        boolean matches = p.matches("1234", "$2a$10$vOUFt/rotkr.TZwRTziL1egPx8o3OAjn7nbfem8Z.bPHgAZ/yGCyK");
        System.out.println(matches);

        boolean matches2 = p.matches("1234", "$2a$10$d3mxXkCYjBFrQICVVos/P.BK.rp13/HUFxjpL.EULyoLs9nWSaaPO");
        System.out.println(matches2);

    }
}

我们将生成的加密之后的密码粘贴到数据库中之后，再进行登录测试，可以发现，直接就登录成功了。

3.4.4 jwt 简述

在我们设计的自定义接口当中，当认证通过了就会生成 jwt，接下来我们稍微介绍下 jwt，在我们前面创建的工具类 JwtUtil 中，提供了生成 token 和解析 token 的方法，调用方式如下：

public static void main(String[] args) throws Exception {

	// 创建 token 的第一种方式，只对数据进行加密
	// eyJhbGciOiJIUzI1NiJ9.eyJqdGkiOiI2NGQ5NzUyMDA2NDk0ZmRjYTM2NjYzNmM1ZThjZDIzNyIsInN1YiI6IjEyMzQiLCJpc3MiOiJzZyIsImlhdCI6MTcxMzQwNDM0MywiZXhwIjoxNzEzNDA3OTQzfQ.OogiA2gcSIwqKvZWs331gF2-EpcG2rqFwnkplpKwtZQ
	String jwt1 = createJWT("1234");
	System.out.println(jwt1);

	// 创建 token 的第二种方式，对数据加密的同时也设置了 token 的过期时间
	// eyJhbGciOiJIUzI1NiJ9.eyJqdGkiOiIyMzI5OGI3ZDk3ODg0NThhYjM4OGViZjlkZjgyMzRhYSIsInN1YiI6IjEyMzQiLCJpc3MiOiJzZyIsImlhdCI6MTcxMzQwNDM0NCwiZXhwIjoxNzEzNDA0NjQ0fQ.9yY66ANkDp4vdh2zREutPdnQy02HzQS2nS2UTZHSa8w
	String jwt2 = createJWT("1234", 300000l);
	System.out.println(jwt2);

	// 创建 token 的第三种方式，对 id 和数据及逆行加密，也设置了 token 的过期时间
	// eyJhbGciOiJIUzI1NiJ9.eyJqdGkiOiIxIiwic3ViIjoiMTIzNCIsImlzcyI6InNnIiwiaWF0IjoxNzEzNDA0MzQ0LCJleHAiOjE3MTM0MDczNDR9.6X3EF-oBHYI-78Jmw3V9fDoYacEnkunFUOcZqNmA8yk
	String jwt3 = createJWT("1", "1234", 3000000l);
	System.out.println(jwt3);

	// 对 token 进行解密操作
	String token = "eyJhbGciOiJIUzI1NiJ9.eyJqdGkiOiIxIiwic3ViIjoiMTIzNCIsImlzcyI6InNnIiwiaWF0IjoxNzEzNDA0MzQ0LCJleHAiOjE3MTM0MDczNDR9.6X3EF-oBHYI-78Jmw3V9fDoYacEnkunFUOcZqNmA8yk";
	Claims claims = parseJWT(token);
	System.out.println(claims.getSubject());
}

3.4.5 登录接口

首先我们创建一个自定义登陆接口，代码如下：

@RestController
public class LoginController {

    @Autowired
    LoginService loginService;

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

然后让 SpringSecurity 对这个接口放行，让用户访问这个接口的时候不用登录也能访问。重写 SecurityConfig 配置类的 configure 方法，代码如下：

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

由于我们在接口中是通过 AuthenticationManager 的 authenticate 方法来进行用户认证，所以还需要在 SecurityConfig 中配置，把 AuthenticationManager 注入容器。如下：

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

最后也是最重要的是编写 LoginService 层的代码，如下：

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

@Service
public class LoginServiceImpl implements LoginService {

    @Autowired
    AuthenticationManager authenticationManager;

    @Autowired
    RedisCache redisCache;

    @Override
    public ResponseResult login(User user) {
        // 第一步：使用 AuthenticationManager 类的 authenticate 方法进行用户认证
        UsernamePasswordAuthenticationToken u = new UsernamePasswordAuthenticationToken(user.getUserName(),user.getPassword());
        Authentication authenticate = authenticationManager.authenticate(u);// 需要传入一个 Authentication 接口的实现类，我们使用 UsernamePasswordAuthenticationToken
        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 响应给前端
        Map<String,Object> map = new HashMap<>();
        map.put("token",jwt);

        return new ResponseResult(200,"登录成功",map);
    }
}

接下来进行测试，记得启动你的 redis，使用 postman 发送 post 请求，如下，访问成功了。

3.4.6 认证过滤器

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

新创建一个 JwtAuthenticationTokenFilter 类，代码如下：

@Component
public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {

    @Autowired
    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
        Claims claims = null;
        try {
            claims = JwtUtil.parseJWT(token);
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
        String userid = claims.getSubject();

        // 第三步：从 redis 中获取数据
        LoginUser loginUser = redisCache.getCacheObject("login:"+userid);
        if(Objects.isNull(loginUser)){
            throw new RuntimeException("用户未登录");
        }

        // 第四步：将信息封装到 SecurityContextHolder 中
        // 获取权限信息封装到 Authentication 中后续再实现
        UsernamePasswordAuthenticationToken u = new UsernamePasswordAuthenticationToken(loginUser,null,null);
        SecurityContextHolder.getContext().setAuthentication(u);

        // 第五步：放行
        filterChain.doFilter(request,response);
    }
}

然后把我们创建的认证过滤器添加到过滤器链的最开始的位置，修改 SecurityConfig 的 configure 方法，如下图：

接下来使用 debug 的方式启动，在我们 JwtAuthenticationTokenFilter 类中打上断点，首先使用 postman 访问 http://localhost:8080/user/login，此时断点中 token 的值为空，如下图：

接下来访问 http://localhost:8080/hello，也是不可以访问的，如下图：

如果在请求头中添加上面我们生成的 token 信息，再试下，如下图，可以看到，访问成功了，证明当携带 token 时请求就被放行了

3.4.7 退出登录

我们只需要获取 SecurityContextHolder 中的认证信息，删除 redis 中对应的数据即可。首先在 LoginController 中添加退出的方法，代码如下：

@RestController
public class LoginController {

    @Autowired
    LoginService loginService;

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

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

然后在 LoginServiceImpl 中实现退出的方法，代码如下：

@Service
public class LoginServiceImpl implements LoginService {

    @Autowired
    AuthenticationManager authenticationManager;

    @Autowired
    RedisCache redisCache;

    @Override
    public ResponseResult login(User user) {
        // 第一步：使用 AuthenticationManager 类的 authenticate 方法进行用户认证
        UsernamePasswordAuthenticationToken u = new UsernamePasswordAuthenticationToken(user.getUserName(),user.getPassword());
        Authentication authenticate = authenticationManager.authenticate(u);// 需要传入一个 Authentication 接口的实现类，我们使用 UsernamePasswordAuthenticationToken
        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 响应给前端
        Map<String,Object> map = new HashMap<>();
        map.put("token",jwt);

        return new ResponseResult(200,"登录成功",map);
    }

    @Override
    public ResponseResult logout() {
        // 第一步：在 SecurityContextHolder 中获取用户的信息
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        LoginUser loginUser = (LoginUser) authentication.getPrincipal();
        Long userid = loginUser.getUser().getId();

        // 第二步：删除 redis 中的 key
        redisCache.deleteObject("login:"+userid);
        return new ResponseResult(200,"退出成功");
    }
}

接下来进行测试，首先调用登录的方法获取 token，然后调用登出的方法，如下图：

然后携带 token 调用 /hello 的方法，返回的信息如下，可以看到，无法正常访问了。

四、授权

4.1 权限系统的作用

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

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

我们不能只依赖前端去判断用户的权限来选择显示哪些菜单哪些按钮。因为如果只是这样，如果有人知道了对应功能的接口地址就可以不通过前端，直接去发送请求来实现相关功能操作。

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

4.2 授权基本流程

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

所以我们在项目中只需要把当前登录用户的权限信息也存入 Authentication。然后设置我们的资源所需要的权限即可。

4.3 授权实现

4.3.1 限制访问资源所需权限

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

但是要使用它我们需要先开启相关配置，首先在我们的配置类中添加如下的注解：

@EnableGlobalMethodSecurity(prePostEnabled = true)

然后就可以使用对应的注解：@PreAuthorize，如下：

@RestController
public class HelloController {

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

4.3.2 封装权限信息

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

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

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

@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;
    }
    // 第二步：创建一个 GrantedAuthority 类型的集合来 存储 SpringSecurity 所需要的权限信息集合
    // 此处不需要序列化存储，否则会出问题
    @JSONField(serialize = false)
    List<GrantedAuthority> authorities;

    // 第三步：重写获取权限信息的方法
    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        if(authorities != null){
            return authorities;
        }
        authorities = new ArrayList<>();
        // 把 permissions 中字符串类型的权限信息转换成 GrantedAuthority 对象存入到 authorities 中
        for (String permission :permissions){
            GrantedAuthority g = new SimpleGrantedAuthority(permission);
            authorities.add(g);
        }
        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 中了。我们写死权限进行测试，后面我们再从数据库中查询权限信息。代码如下：

最后在 JwtAuthenticationTokenFilter 类中，将权限信息封装到 Authentication 中，如下图：

接下来进行测试，启动工程，先登录，然后携带 token 去访问 hello 接口，如下图，可以正常访问。

接下来将 test 改成 test2 再进行测试，可以看到，权限校验没有通过。

4.3.3 从数据库查询权限信息

4.3.3.1 RBAC 权限模型

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

4.3.3.2 准备工作

首先执行下面的 sql 脚本，创建相关的表并插入几条测试数据，如下：

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;
INSERT INTO `sg_security`.`sys_user` (`id`, `user_name`, `nick_name`, `password`, `status`, `email`, `phonenumber`, `sex`, `avatar`, `user_type`, `create_by`, `create_time`, `update_by`, `update_time`, `del_flag`) VALUES ('1', 'zhangsan', 'zhangsan', '$10$vOUFt/rotkr.TZwRTziL1egPx8o3OAjn7nbfem8Z.bPHgAZ/yGCyK', '0', NULL, NULL, NULL, NULL, '1', NULL, NULL, NULL, NULL, '0');
INSERT INTO `sg_security`.`sys_user_role` (`user_id`, `role_id`) VALUES ('1', '1');
INSERT INTO `sg_security`.`sys_role` (`id`, `name`, `role_key`, `status`, `del_flag`, `create_by`, `create_time`, `update_by`, `update_time`, `remark`) VALUES ('1', 'CEO', 'ceo', '0', '0', NULL, NULL, NULL, NULL, NULL);
INSERT INTO `sg_security`.`sys_role` (`id`, `name`, `role_key`, `status`, `del_flag`, `create_by`, `create_time`, `update_by`, `update_time`, `remark`) VALUES ('2', 'Coder', 'coder', '0', '0', NULL, NULL, NULL, NULL, NULL);
INSERT INTO `sg_security`.`sys_role_menu` (`role_id`, `menu_id`) VALUES ('1', '1');
INSERT INTO `sg_security`.`sys_role_menu` (`role_id`, `menu_id`) VALUES ('1', '2');
INSERT INTO `sg_security`.`sys_menu` (`id`, `menu_name`, `path`, `component`, `visible`, `status`, `perms`, `icon`, `create_by`, `create_time`, `update_by`, `update_time`, `del_flag`, `remark`) VALUES ('1', '部门管理', 'dept', 'system/dept/index', '0', '0', 'system:dept:list', '#', NULL, NULL, NULL, NULL, '0', NULL);
INSERT INTO `sg_security`.`sys_menu` (`id`, `menu_name`, `path`, `component`, `visible`, `status`, `perms`, `icon`, `create_by`, `create_time`, `update_by`, `update_time`, `del_flag`, `remark`) VALUES ('2', '测试', 'test', 'system/text/index', '0', '0', 'system:test:list', '#', NULL, NULL, NULL, NULL, '0', NULL);

我们此次需要使用的查询的 sql 语句如下，可以根据 userid 查询具体的权限，如下，其中 userid 先写 1，后续再使用变量替换。

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

创建 menu 的实体类，因为我们只用到了这个实体类，其他的实体类没有用到

/**
 * 菜单表(Menu)实体类
 */
@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 代码实现

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

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

在 resources 目录下创建 mapper 文件，并创建 MenuMapper 文件，内容如下：

<?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.spring.mapper.MenuMapper">
    <select id="selectPermsByUserId" resultType="java.lang.String">
        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>

在 application.yml 中配置 mapperXML 文件的位置，如下：

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

然后我们可以在 UserDetailsServiceImpl 中去调用该 mapper 的方法查询权限信息封装到 LoginUser 对象中即可。别忘了注入依赖，如下：

修改 controller 中的权限信息，如下：

启动工程进行测试，先进行登录操作，然后携带 token 去访问 hello 方法，可以看到，没有什么问题，可以正常访问，如下图：

五、自定义失败处理

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

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

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

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

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

5.1 权限异常的实现类

创建权限异常的自定义实现类，代码如下：

@Component
public class AccessDeniedHandlerImpl implements AccessDeniedHandler {

    // 三个参数：请求对象、响应对象、异常对象
    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException e) throws IOException, ServletException {
        // 处理异常，无论任何形似的异常都返回指定格式的异常数据
        ResponseResult result = new ResponseResult(HttpStatus.FORBIDDEN.value(),"权限不足");

        // 将返回的数据转换成 json 格式
        String json = JSON.toJSONString(result);
        // 将 json 格式的数据封装到 response 中
        WebUtils.renderString(response,json);
    }
}

5.2 认证异常的实现类

创建认证异常的自定义实现类，代码如下：

@Component
public class AuthenticationEntryPointImpl implements AuthenticationEntryPoint {

    // 三个参数：请求对象、响应对象、异常对象
    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException e) throws IOException, ServletException {
        // 处理异常，无论任何形似的异常都返回指定格式的异常数据
        ResponseResult result = new ResponseResult(HttpStatus.UNAUTHORIZED.value(),"认证失败请重新登录");

        // 将返回的数据转换成 json 格式
        String json = JSON.toJSONString(result);
        // 将 json 格式的数据封装到 response 中
        WebUtils.renderString(response,json);
    }
}

5.3 配置给 SpringSecurity

在 SecurityConfig 配置类中，注入我们刚刚实现的两个异常处理实现类，如下：

5.4 测试

启动工程，不携带 token 直接访问 hello 方法，如下图，可以看到。返回值为我们自定义异常里面的信息。

修改 helloController 的权限，如下图：

启动工程，登录，获取 token，然后访问 hello 方法，如下图，可以看到，返回的是我们想要的数据。

六、跨域

6.1 什么是跨域

浏览器出于安全的考虑，使用 XMLHttpRequest 对象发起 HTTP 请求时必须遵守同源策略，否则就是跨域的 HTTP 请求，默认情况下是被禁止的。向我们前几个章节使用的 postman 调用就不存在跨域问题，因为它只是个工具，不是浏览器。

同源策略要求源相同才能正常进行通信，即协议、域名、端口号都完全一致。

前后端分离项目，前端项目和后端项目一般都不是同源的，所以肯定会存在跨域请求的问题，所以我们就要处理一下，让前端能进行跨域请求。

6.2 配置跨域

1、首先需要对 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);
    }
}

2、然后开启 SpringSecurtity 的跨域请求，由于我们的资源都会受到 SpringSecurity 的保护，所以想要跨域访问还要让 SpringSecurity 运行跨域访问，修改 SecurityConfig 类的 configure 方法，添加支持跨域访问，如下图：

6.3 测试

首先下载一个前端工程，下载地址在这，下载完成后按照 README.md 里面的步骤下载依赖并启动前端工程，如下图：

首先测试不配置支持跨域请求，登录上面的页面，反馈信息如下图：

接下来配置支持跨域请求，登录上面的页面，反馈信息如下：

七、遗留小问题

7.1 其他权限校验方法

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

hasAuthority 方法实际是执行到了 SecurityExpressionRoot 的 hasAuthority，大家只要断点调试既可知道它内部的校验原理。

它内部其实是调用 authentication 的 getAuthorities 方法获取用户的权限列表。然后判断我们存入的方法参数数据在权限列表中。

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 注解中使用我们的方法。首先创建一个自定义的实现类，并创建一个权限校验的方法，代码如下：

@Component("xhfEx")
public class XhfExpressionRoot {

    public final boolean hasAuthority(String authority) {
        // 1、获取当前用户的权限
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        LoginUser loginUser = (LoginUser) authentication.getPrincipal();
        List<String> aList = loginUser.getPermissions();

        // 2、判断用户权限集合中是否存在authority
        return aList.contains(authority);
    }
}

然后在 SPEL 表达式中使用 @xhfEx 相当于获取容器中 bean 的名字为 xhfEx 的对象。然后再调用这个对象的 hasAuthority 方法，如下代码：

@RestController
public class HelloController {

    @RequestMapping("/hello")
    @PreAuthorize("@xhfEx.hasAuthority('system:dept:list')")
    public String hello(){
        return "Hello World";
    }
}

7.3 基于配置的权限控制

我们也可以在配置类中使用使用配置的方式对资源进行权限控制。修改 SecurityConfig 类的 configure 方法，如下图：

7.4 CSRF

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

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

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

所以 SpringSecurity 不用开启 CSRF，如下图：

7.5 认证成功处理器

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

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

@Component
public class SGSuccessHandler 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 SGFailureHandler 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 SGLogoutSuccessHandler 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();
	}
}