第一章简介

SpringSecurity https://spring.io/projects/spring-security#overview

1、概念

Spring家族当中，一个安全管理框架。

Shiro也是一个安全框架，提供了很多安全功能。Shiro比较老，旧的项目当中，可能还在使用。上手还挺简单。

在新项目当中，一线互联网大型项目，都是使用SpringSecurity 。

2、认证鉴权

一般的web项目当中，总会有登陆和鉴权的需求。但是大家一定要区分开。

认证：验证当前访问的用户是不是本系统中的用户。确定是哪一个具体的用户。
鉴权：经过认证，判断当前登陆用户有没有权限来执行某个操作。

所以说，安全框架SpringSecurity 当中，必定会有认证和鉴权的两大核心功能。

第二章入门

1、准备web项目

1.创建springboot web项目

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

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

    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.24</version>
    </dependency>

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

2.controller

@RestController
@RequestMapping("demo")
public class DemoController {

    @GetMapping("hello")
    public String hello(){
        return "hello SpringSecurity";
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6BBZ09wi-1665928556583)(C:/Users/LEGION/AppData/Roaming/Typora/typora-user-images/image-20221009104135209.png)]输入控制台默认的用户user和密码[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OccLTlHR-1665928556584)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221009104242662.png)]

3.自带退出

手输入logout

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MvC5sdvG-1665928556585)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221009104605867.png)][外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xKXktEjw-1665928556585)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221009104615791.png)]

第三章认证

1.web登陆流程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0RwbyndG-1665928556587)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221009233515993.png)]

项目改进：

1.自定义的登录页面

2.自定义security的用户名密码（数据库获取真实的用户名验证码）

3.自定义生成jwt,实现无状态登录，摆脱security的cookie/session

4.前端的请求头上携带jwt

5.鉴权操作

2.看源码

springsecurity 就是通过一些过滤器、拦截器，实现登陆鉴权的流程的

(1) security登录流程

springsecurity就是一个过滤器链，内置了关于springsecurity的16的过滤器。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rPvVlBOs-1665928556588)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221009233540662.png)]

注意：我只写出了几个核心过滤器，其他的如下图。

UsernamePasswordAuthenticationFilter：处理我们登陆页面输入的用户名和密码是否正确的过滤器。
ExceptionTranslationFilter：处理前面的几个过滤器中，有了问题，抛出错误，不让用户登录。
FilterSecurityInterceptor：经行一个权限校验的拦截器。

我们可以找到当前boot项目中的，所有有关security的过滤器链。

（2）认证流程细化，回头再看

看我如何debug UsernamePasswordAuthenticationFilter 运行机制

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-il3fGXwS-1665928556588)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221009151032476.png)]

3.自定义登录

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RGMZUAnr-1665928556589)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221009145437858.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-k18CGkqi-1665928556590)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221009153955763.png)]

一. 用户名和密码的这个过滤器默认使用后，用户登录后在页面存一个Cookie,而Session就保存在服务器的SecurityContextHolder中，由于之后我们做的是前后端分离的项目，所以这里我们需要自己写个Fliter去实现，调用prodivermanager auth方法然后生成一个无状态的用户登录模式，即jwt令牌

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FdvpSgEj-1665928556591)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221009153454276.png)]

二. 由于默认使用的是inMemory的实现类，则user肯定是内存中那个生成的，我们要利用数据库的用户的话，我们需要写个UserDetailManager的实现类去代替它，实现我们的需求

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KZVgFWQe-1665928556591)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221009155109070.png)]

三. 当前端访问某个区域时，获取前端的请求token，从token中获取userid，从redis中通过userid获取用户信息，然后保存在SecurityContextHolder

四. 这里补充一下jwt的相关知识

a.概念

JSON Web Token（JWT）是一个非常轻巧的规范。这个规范允许我们使用JWT在用户和服务器之间传递安全可靠的信息。无状态。

好处：不需要服务器端存session。

特点：可以呗看到，但是不能篡改，因为第三部分用了秘钥。

一个JWT实际上就是一个字符串，它由三部分组成，头部、载荷与签名。 asdf.asdf.asdf

头部（Header）

头部用于描述关于该JWT的最基本的信息，例如其类型以及签名所用的算法等。这也可以被表示成一个JSON对象。

{"typ":"JWT","alg":"HS256"}

在头部指明了签名算法是HS256算法。我们进行BASE64编码https://base64.us/，编码后的字符串如下：

eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9

载荷（playload）

载荷就是存放有效信息的地方。

定义一个payload:

{"sub":"1234567890","name":"itlils","admin":true,"age":18}

然后将其进行base64加密，得到Jwt的第二部分。

eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6Iml0bGlscyIsImFkbWluIjp0cnVlLCJhZ2UiOjE4fQ==

签证（signature）

jwt的第三部分是一个签证信息，这个签证信息由三部分组成：

header (base64后的)

payload (base64后的)

secret

这个部分需要base64加密后的header和base64加密后的payload使用.连接组成的字符串，然后通过header中声明的加密方式进行加盐secret组合加密，然后就构成了jwt的第三部分。

hs256("eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6Iml0bGlscyIsImFkbWluIjp0cnVlLCJhZ2UiOjE4fQ==",secret)

将这三部分用.连接成一个完整的字符串,构成了最终的jwt:

JTdCJTIydHlwJTIyJTNBJTIySldUJTIyJTJDJTIyYWxnJTIyJTNBJTIySFMyNTYlMjIlN0Q=.JTdCJTIyc3ViJTIyJTNBJTIyMT

接下来来小测一下jwt

a.导入依赖

<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.0</version>
</dependency>

b.测试类

@SpringBootTest
public class JwtTest {
    @Test
    public void jwtGenerator(){
        JwtBuilder jwtBuilder = Jwts.builder()
                .setId("666")//设置id
                .setSubject("testJwt")//测试jwt
                .setIssuedAt(new Date())//签发日期
                .signWith(SignatureAlgorithm.HS256,"wxpnb");//第三部分的密钥:不要太短
        String jwt = jwtBuilder.compact();
        System.out.println(jwt);

    }
}

运行结果：

eyJhbGciOiJIUzI1NiJ9.eyJqdGkiOiI2NjYiLCJzdWIiOiJ0ZXN0Snd0IiwiaWF0IjoxNjY1MzE2MzAyfQ.krJjUTcgXT3CNvLtpeNKX2QcJpbfi3w8BIRPIwqhQA4

再次运行，会发现每次运行的结果是不一样的，因为我们的载荷中包含了时间。

验证base64 https://tool.oschina.net/encrypt?type=3

但是密钥可不能那么简单就解密出。我们也可在服务器内告诉它密钥的条件下然后解密出整个jwt

Claims wxpnb = Jwts.parser().setSigningKey("wxpnb").parseClaimsJws(jwt).getBody();
System.out.println(wxpnb);

运行结果：

{jti=666, sub=testJwt, iat=1665317594}

试着将token或签名秘钥篡改一下，会发现运行时就会报错，所以解析token也就是验证token.

注意：设置签名key必须和生成时一致

c.设置过期时间

@SpringBootTest
public class JwtTest {
    @Test
    public void jwtGenerator(){

        //过期时间
        Date date = new Date(System.currentTimeMillis() + 1000);

        JwtBuilder jwtBuilder = Jwts.builder()
                .setId("666")//设置id
                .setSubject("testJwt")//测试jwt
                .setIssuedAt(new Date())//签发日期
                .setExpiration(date)//设置过期时间
                .signWith(SignatureAlgorithm.HS256,"wxpnb");//第三部分的密钥:不要太短
        String jwt = jwtBuilder.compact();
        System.out.println(jwt);

        Claims wxpnb = Jwts.parser().setSigningKey("wxpnb").parseClaimsJws(jwt).getBody();
        System.out.println(wxpnb);

    }
}

由于令牌过期后面的解析jwt解析不了

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JqhMpfoJ-1665928556592)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221009202100216.png)]

利用.claim("变量名"，变量值)可以为jwt添加变量

4.项目准备

①添加依赖

        <!--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>

② 添加Redis相关配置

/**
 * Redis使用FastJson序列化
 *Java默认实现redis序列化是通过JDK的序列化策略。这种方式使用比较普遍，直接在项目中创建redis连接然后使用就可以了
 * @author wxp
 */
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);
    }
}

@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory factory){
        RedisTemplate<String,Object> template = new RedisTemplate<>();

        template.setConnectionFactory(factory);//redis去操作数据库的话需要拦截工厂

        //设置key的序列化方式
        template.setKeySerializer(RedisSerializer.string());
        //设置value的序列化方式
        template.setValueSerializer(RedisSerializer.json());
        //设置hash的key的序列化方式
        template.setHashKeySerializer(RedisSerializer.string());
        //设置hash的value的序列化方式
        template.setHashValueSerializer(RedisSerializer.json());

        //让template设置的这些参数生效
        template.afterPropertiesSet();
        return template;
    }

}

③ 响应类

统一返回结果

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

④工具类

jwt工具类：像前面的测试一样，生成jwt令牌

RedisCache：redis的相关配置和基础操作

WebUtils：对页面做出标准回应

public class JwtUtil {

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

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

    /**
     * 生成jwt
     * @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("wxp")     // 签发者
                .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();
    }


    /**
     * 生成加密后的秘钥 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();
    }


}

package com.wu.springsecuritydemo.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;

/**
 * @Author Wxp(麻瓜)
 * @Date 2022年10月09日 22:13
 **/
@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);
    }
}

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

⑤实体类

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable {
    private static final long serialVersionUID = 1L;
    
    /**
    * 主键
    */
    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;
}

5. 实现

数据库校验用户

自定义一个UserDetailsService的实现类,让SpringSecurity使用我们的实现类。从数据库中查询用户名和密码。

1.导入sql

DROP TABLE IF EXISTS `sys_user`;
CREATE TABLE `sys_user` (
  `id` bigint 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 DEFAULT NULL COMMENT '创建人的用户id',
  `create_time` datetime DEFAULT NULL COMMENT '创建时间',
  `update_by` bigint DEFAULT NULL COMMENT '更新人',
  `update_time` datetime DEFAULT NULL COMMENT '更新时间',
  `del_flag` int DEFAULT '0' COMMENT '删除标志（0代表未删除，1代表已删除）',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8 COMMENT='用户表';

-- ----------------------------
-- Records of sys_user
-- ----------------------------
INSERT INTO `sys_user` VALUES ('1', 'wxp', 'IT吴同学', '$2a$10$UNfN3sUdNmka5cxCmrWHf.EZs6yRTztTvwoLJWXGf6VjRz/ABJ9y2', '0', '123@qq.com', '13012345678', '0', 'a', '1', '1', '2022-08-20 18:52:41', '1', '2022-08-21 18:52:49', '0');

2.导入依赖

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.5.1</version>
</dependency>

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

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

3.dao层

@Mapper
public interface UserMapper extends BaseMapper<User> {
}

4.修改User实体类

类名上加@TableName(value = "sys_user") ,id字段上加 @TableId

5.启动类配置Mapper扫描

@MapperScan("com.wu.dao")

测试一下mapper就行

6.替换掉inMemor用户信息

接下来就说自定义接口从后往前做了，写个UserDetailManager的实现类去代替inMemory

仿造一下原有的
public class InMemoryUserDetailsManager implements UserDetailsManager, UserDetailsPasswordService

然后UserDetailsManager继承了UserDetailService，所以我们直接去实现它就行了
编写自定义：

在此之前，我们的方法返回的对象的类型为：UserDetails，所以我们写个LoginUser类实现了UserDetails的接口，然后我们增加user属性，在最后返回的时候 return new LoginUser(user)即可

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

@Service
public class UserDetailServiceImpl implements UserDetailsService {

    @Autowired
    private UserMapper userMapper;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        //根据用户名 获取 数据库中的系统用户
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.eq(User::getUserName,username); //查询条件
        User user = userMapper.selectOne(lambdaQueryWrapper);
        if(Objects.isNull(user)){
            throw new RuntimeException("用户名错误！");
        }
        //TODO 查询权限信息

        //返回UserDetails
        return new LoginUser(user);
    }
}

7.密码加密

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

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

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

之前我们学的是{密码}+加盐，然后md5,但是我们这次选择BCryptPasswordEncoder，它可以自动加盐且加密

创建加密的config类

@Configuration
public class SecurityConfig{

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

Test一下加密和原文匹配

@Test
public void testBcript(){
    String password1 = passwordEncoder.encode("wxp666");
    String password2 = passwordEncoder.encode("wxp666");
    System.out.println(password1);
    System.out.println(password2);

    //查看原文匹配
    System.out.println(passwordEncoder.matches("wxp666", password1));
    System.out.println(passwordEncoder.matches("wxp666", password2));
}//密码最好是4的倍数

$2a$10$u91MVfU/IHHIFT51FdBXDeRtgL4o2OV.PRBgU3Aohly0JV3wT50Pq
$2a$10$3d4QZDzAuVh0SDl364k2muI2mkkX5WjXAf8NrAzyRS/1nefZeFMIq
true
true

随便放入一个，输入密码wxp666也可以登陆成功

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zmLD5IAe-1665928556593)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221011203006307.png)].

过时问题：

首先，过时也能用，如果看着不爽，可以使用如下方法。

以前我们自定义类继承自 WebSecurityConfigurerAdapter 来配置我们的 Spring Security，我们主要是配置两个东西：

configure(HttpSecurity)
configure(WebSecurity)

前者主要是配置 Spring Security 中的过滤器链，后者则主要是配置一些路径放行规则。

现在在 WebSecurityConfigurerAdapter 的注释中，人家已经把意思说的很明白了：

以后如果想要配置过滤器链，可以通过自定义 SecurityFilterChainBean来实现。
以后如果想要配置 WebSecurity，可以通过 WebSecurityCustomizerBean来实现。

如

 @Bean
     public WebSecurityCustomizer webSecurityCustomizer() {
         return (web) -> web.ignoring().antMatchers("/images/**", "/js/**", "/webjars/**");
     }

	@Bean
    public  SecurityFilterChain securityFilterChain() {
        List&lt;Filter&gt; filters = new ArrayList&lt;&gt;();
        return new DefaultSecurityFilterChain(new AntPathRequestMatcher("/**"), filters);
    }

	//如果想好看,或者可以这样写
     @Bean
     public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
         http.authorizeRequests().antMatchers("/login").permitAll()
                 .antMatchers("/users/**", "/settings/**").hasAuthority("Admin")
                 .hasAnyAuthority("Admin", "Editor", "Salesperson")
                 .hasAnyAuthority("Admin", "Editor", "Salesperson", "Shipper")
                 .anyRequest().authenticated()
                 .and().formLogin()
                 .loginPage("/login")
                 .usernameParameter("email")
                 .permitAll()
                 .and()
                 .rememberMe().key("AbcdEfghIjklmNopQrsTuvXyz_0123456789")
                 .and()
                 .logout().permitAll();
  
         http.headers().frameOptions().sameOrigin();
  
         return http.build();
     }}   自定义登陆接口

我们先来对jwtUtil进行一顿测试

public static void main(String[] args) throws Exception {
    String jwt = JwtUtil.createJWT("1");
    System.out.println(jwt);

    Claims claims = JwtUtil.parseJWT(jwt);
    System.out.println(claims);
}

eyJhbGciOiJIUzI1NiJ9.eyJqdGkiOiIyZjIwZjExZmZhOWQ0MTI3YTEzNDNjMTZjMzY5YzA4NSIsInN1YiI6IjEiLCJpc3MiOiJ3eHAiLCJpYXQiOjE2NjU0OTMyNTMsImV4cCI6MTY2NTQ5Njg1M30.6xC8rH0fDrqbyC7czvB65DQDcMDFVADgP7NOZzOlEto
{jti=2f20f11ffa9d4127a1343c16c369c085, sub=1, iss=wxp, iat=1665493253, exp=1665496853}

🔺 8.自定义登录接口

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RjmHDMxr-1665928556594)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221011215158055.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iujM6hCc-1665928556594)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221009145437858.png)]

(1) 自定义controller登录接口

在此之前先写好login的service和serviceImpl

@RestController
public class LoginController {

    @Autowired
    private LoginService loginService;

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

(2) 放行我们这自定义接口(WebSecurity内)

在securityConfig上添加上这个bean

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

    return http.build();
}

(3)使用ProvideManager的authenticate方法进行验证（这个方法的作用是是根据username和password来判断这个用户是否存在的）

(4) 自己生成jwt然后交给前端

(5) 系统用户相关的所有的信息放入Redis(原始是在context)

把原来框架的认证的方法和类放入Config中，等下拿出来ProvideManager内的authenticate直接用

@Autowired
private AuthenticationConfiguration authenticationConfiguration;

@Bean
public AuthenticationManager authenticationManager() throws Exception{
    AuthenticationManager authenticationManager = authenticationConfiguration.getAuthenticationManager();
    return authenticationManager;
}

403:请求被拦截 405:请求方式错误

LoginServiceImpl

@Service
public class LoginServiceImpl implements LoginService {

    @Autowired
    private AuthenticationManager authenticationManager; 

    @Autowired
    private RedisCache redisCache;
    @Override
    public ResponseResult login(User user) {
        //(3)使用ProvideManager的authenticate方法进行验证
        UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(user.getUserName(),user.getPassword());
        Authentication authenticate = authenticationManager.authenticate(authenticationToken);//需要参数类型为authentication,但是它是个接口，所以我们才会new一下它的子类
        //校验失败了
        if(Objects.isNull(authenticate)){
            throw new RuntimeException("你的用户名或密码错误！");
        }

        //(4) 自己生成jwt然后交给前端
        LoginUser loginUser   = (LoginUser)authenticate.getPrincipal();
        String userId = loginUser.getUser().getId().toString();
        String jwt = JwtUtil.createJWT(userId);
        Map<String,Object> map = new HashMap<>();
        map.put("token",jwt);

        //(5) 系统用户相关的所有的信息放入Redis(原始是在context)
        redisCache.setCacheObject("login:"+userId,loginUser);//生成key

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

接下来就是测试登录

主要是数据库的username 和 password写对，才能转化成正确的完全体authenication

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1YozlN5A-1665928556594)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221014131335287.png)]

9.认证过滤器

1.获取token

2.解析token

3.获取userid

4.封装Authentication

这里有个细节，就是我们要在第5步通过setAuthentication存入SecurityContextHolder，需要把loginUser封装成Authentication，需要用到Authentication的实现子类UsernamePasswordAuthenticationToken，这个方法有两参和三参

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iDzp8fx9-1665928556595)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221014144458924.png)]

之前我们用到这个方法的时候是进行登录过程中的使用ProvideManager的authenticate方法进行验证username,password

状态需要是未登录的，所以我们用得到才是二参的

而这次是利用需要把loginUser封装成Authentication然后存入上下文，所以它的状态是已登录的，所以我们用的三参

5.存入SecurityContextHolder

@Component
public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {

    @Autowired
    private RedisCache redisCache;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        //1.获取header的token
        String token = request.getHeader("token");
        if(!StringUtils.hasText(token)){
            //放行，让后面的过滤器执行 
            filterChain.doFilter(request,response);
            return;
        }

        //2.解析token
        String userId;
        try {
            Claims claims = JwtUtil.parseJWT(token);
            userId = claims.getSubject();//之前我们就是用userId作为Subject然后生成Token的
        } catch (Exception e) {
            throw new RuntimeException("token不合法!");
        }

        //3.获取userId,redis获取用户信息(根据key去redis内获取loginUser)
        LoginUser loginUser = redisCache.getCacheObject("login:"+userId);
        if(Objects.isNull(loginUser)){
            throw new RuntimeException("当前用户未登录!");
        }
        //4.封装Authentication,当然不能用接口去new,所以直接new它的实现子类
        UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(loginUser,null,null);//还没设置权限，先给空

        //5存入SecurityContextHolder
        SecurityContextHolder.getContext().setAuthentication(authenticationToken);

        //放行，让后面的过滤器执行
        filterChain.doFilter(request,response);

    }
}

我们写的JwtAuthenticationTokenFilter需要放在其他拦截器的前面，那么就要有个顺序问题

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jBipnVZb-1665928556595)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221014145118097.png)]

然后在securityConfig中把自定义的认证过滤器放入过滤器链

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

    		//把jwtAuthenticationTokenFilter放在UsernamePasswordAuthenticationFilter之前
            http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);

    return http.build();
}

重新测试一下登录

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GmzQfy20-1665928556595)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221014150129318.png)].

获得Token:

eyJhbGciOiJIUzI1NiJ9.eyJqdGkiOiJlNDljODYzNWMxOTI0MDgwODc3OWYyNDMxNWJlM2I5ZiIsInN1YiI6IjEiLCJpc3MiOiJ3eHAiLCJpYXQiOjE2NjU3MzE2MTAsImV4cCI6MTY2NTczNTIxMH0.eEhGwPOIh8sm8YJVYbmQs-UmBf5GOsuB2dBtfm-v9Qc

测试一下普通资源

如果未登录就会被ExceptionlastionFilter给拦截

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gR25aiFP-1665928556596)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221014150548514.png)]

但是如果你带上Token的话就可以放行，try again!

遇到了解析token时候内部数据多传的情况，解决方法：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iJ6msxiy-1665928556596)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221014152357935.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-j5SqYCgx-1665928556596)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221014152541338.png)]

10.退出接口

看成登录的逆运算，多加的东西删除掉，但是我们不用全删除（redis,ContextHolder…）,我们只需删除Redis内相关信息即可

测试一下：

(1)登录：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VUgtlxoL-1665928556597)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221014154530804.png)]

(2) 利用token去访问demo/hello,可以成功访问

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ryhCDfx4-1665928556597)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221014154634959.png)]

(3)带着token退出

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bONZL7GB-1665928556598)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221014155133458.png)]

(4)你再用该token去访问demo/hello的话就不能访问了

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yQGRBmG8-1665928556598)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221014155235992.png)]

第四章授权

1.权限系统的作用

商城管理系统，普通用户登录可以创建订单等操作，但是不能删除商品。但是管理员可以删除商品信息，修改价格等。

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

我们不能只依赖前端去判断用户的权限来选择显示哪些菜单哪些按钮。因为黑客拿到高权限接口url,模拟访问！

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

2.授权基本流程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UeYchHNP-1665928556598)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221014161053765.png)]

那么我们怎么通过代码告诉这个拦截器这个用户是否具有相应的权限呢？

回想到之前的JwtAuthenticationTokenFilter内通过UsernamePasswordAuthenticationToken的三参方法把loginUser构建成一个完全体authentication然后放入到SecurityContextHolder,第三个参数其实就是权限信息(当时我i标记了)
//4.封装Authentication,当然不能用接口去new,所以直接new它的实现子类
       UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(loginUser,null,null);//还没设置权限，先给空
当然我们还有一处就是UserDetailServiceImpl

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PUF46xxW-1665928556598)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221014163614346.png)]

3.授权实现

(1)限制访问资源所需权限

SpringSecurity为我们提供了基于注解的权限控制方案，这也是我们项目中主要采用的方式。

我们可以使用注解去指定访问对应的资源所需的权限。

但是要使用它我们需要先开启相关配置。配置类SecurityConfig中。在方法运行前进行相应的校验

@EnableGlobalMethodSecurity(prePostEnabled = true)

2.在controller类上面或者接口方法上面前使用注解@PreAuthorize

@GetMapping("hello")
    @PreAuthorize("hasAuthority('test')")//有 ‘test’ 权限才可以被访问
    public String hello(){
        return "hello SpringSecurity";
    }

(2) 封装权限信息

a.loginUser实体内增加权限属性

    //权限信息
    private List<String> permissions;

b.在LoginUser的collection类型的getAuthorities中把permissions的所有权限封装为List返回出去

一般写法：

@Override
public Collection<? extends GrantedAuthority> getAuthorities() {

    List<SimpleGrantedAuthority>  list = new ArrayList<>();//权限集
    for (String permission : permissions) {
        SimpleGrantedAuthority simpleGrantedAuthority = new SimpleGrantedAuthority(permission);
        list.add(simpleGrantedAuthority);
    }
    return list;
}

lambda写法：

//lambda写法:
List<SimpleGrantedAuthority> collect = permissions.stream().map(SimpleGrantedAuthority::new).collect(Collectors.toList());

每过一个过滤器都需要执行一次gettAuthorities方法吗？时间性能分析下不妥

改进：直接把次数压缩到一次，还有用户对应Authority可能过多，所以我们需要通过停止序列化来达到高速
@JSONField(serialize = false)//不进行序列化，速度提升
List<SimpleGrantedAuthority> authorities;//!!!

@Override
public Collection<? extends GrantedAuthority> getAuthorities() {
   if(authorities!=null) return authorities;
   //lambda写法:
    authorities = permissions.stream().map(SimpleGrantedAuthority::new).collect(Collectors.toList());
    return authorities;
}
还有一点值得注意的是：你用了**@AllArgsConstructor全参构造器，但是在UserDetailSertviceImpl**的最后返回中只需要两个参数，所以我们需要写一些构造器
public LoginUser(User user, List<String> permissions) {
   this.user = user;
   this.permissions = permissions;
}

c.在JwtAuthenticationTokenFilter内补充

UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(loginUser,null,loginUser.getAuthorities());

d.UserDetailServiceImpl把之前的TODO先写死

@Service
public class UserDetailServiceImpl implements UserDetailsService {

    @Autowired
    private UserMapper userMapper;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        //根据用户名 获取 数据库中的系统用户
        LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        lambdaQueryWrapper.eq(User::getUserName,username); //查询条件
        User user = userMapper.selectOne(lambdaQueryWrapper);
        if(Objects.isNull(user)){
            throw new RuntimeException("用户名错误！");
        }
        //TODO 查询权限信息 之后再真实地去查数据库，现在先做一个假的权限
        List<String> list = new ArrayList<>(Arrays.asList("sayhello","delgoods"));


        //返回UserDetails
        return new LoginUser(user,list);
    }
}

e.DemoController

@RestController
@RequestMapping("demo")
public class DemoController {

    @GetMapping("hello")
    @PreAuthorize("hasAuthority('sayhello')")//有 ‘sayhello’ 权限才可以被访问
    public String hello(){
        return "hello SpringSecurity";
    }

    //每一个接口方法上都写死权限
}

测试一下

(1) 登录

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qqRfdW6N-1665928556599)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221015115936933.png)]

(2) 访问demo/hello

出现反序列化异常：

Caused by: com.fasterxml.jackson.databind.exc.MismatchedInputException: Cannot construct instance of `org.springframework.security.core.authority.SimpleGrantedAuthority` (although at least one Creator exists): cannot deserialize from Object value (no delegate- or property-based Creator)

在LoginUser的getAuthorities上添加@JsonIgnore，完美解决！

@Override
   @JsonIgnore
   public Collection<? extends GrantedAuthority> getAuthorities() {
       if(authorities!=null) return authorities;
       //lambda写法:
       authorities = permissions.stream().map(SimpleGrantedAuthority::new).collect(Collectors.toList());
       return authorities;
   }

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-P1TX43zR-1665928556599)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221015120815021.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sfg2J6YI-1665928556599)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221015115948964.png)]

(3) 退出登录

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jDl8sl5A-1665928556600)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221015120846366.png)]

(3)从数据库查询权限信息

之前我们的权限信息，比如说sayhello,delgoods都是假数据，那么接下来我们需要写的就是从数据库中真实地取出权限数据

a.RBAC模型-----5张表

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BJu6VCdC-1665928556600)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221015121647595.png)]

看完这个后就是设计表模型咯

/*sys_memnu表*/
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='菜单表';
/*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='角色表';
/*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;
/*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='用户表';
/*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;

ok!接下来我们插入一些数据：

首先是这个role表：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uvb4LEp5-1665928556600)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221015123407928.png)]

其次是这个sys_user_role表

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-o3QIq36O-1665928556601)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221015123858577.png)]

然后是这个menu表

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yu5WNOFe-1665928556601)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221015123843965.png)]

最后是这个sys_role_menu

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CIsWpHUd-1665928556601)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221015123947266.png)]

测试下数据库：

SELECT DISTINCT perms from sys_menu where id in (
	SELECT menu_id  from sys_role_menu where role_id in (
		SELECT role_id from sys_user_role  where user_id=1
	)
) and status='0'

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CIJ5F9Rn-1665928556602)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221015132922372.png)].

b.menu菜单类

@Data
@TableName(value="sys_menu")
@AllArgsConstructor
@NoArgsConstructor
@JsonInclude(JsonInclude.Include.NON_NULL)
public class Menu implements Serializable {
    private static final long serialVersionUID = 1L;
    
    @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;
}

c.创建MenuMapper

@Mapper
public interface MenuMapper extends BaseMapper<Menu> {

    List<String> selectPermsByUserId(Long userId);//查找权限

}

<select id="selectPermsByUserId" parameterType="long" resultType="java.lang.String">
    SELECT DISTINCT perms from sys_menu where id in (
        SELECT menu_id  from sys_role_menu where role_id in (
            SELECT role_id from sys_user_role  where user_id=#{userId}
        )
    ) and status='0'
</select>

//application.yml
mybatis-plus:
  mapper-locations: classpath*:/dao/**/*.xml

测试一下：

@Test
public void testMenu(){
    System.out.println(menuMapper.selectPermsByUserId(1L));
}

把UserDetailServiceImpl的loadUserByUsername内部的权限假数据换成我们的查询方法

//真实地去查数据库，提取权限
List<String> perms = menuMapper.selectPermsByUserId(user.getId());

把demo/hello的controller接口的PreAuthorize更改一下

@GetMapping("hello")
@PreAuthorize("hasAuthority('dev:code:pull')")
public String hello(){
    return "hello SpringSecurity";
}

运行：登录然后测试/demo/hello

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HCun3Va9-1665928556602)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221015142013854.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hHWGA8rv-1665928556603)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221015142038180.png)]

第五章自定义失败处理

类似于login的时候账号密码错误或者访问hello页面时没有dev:code:pull的权限，都会发生403拦截

我们要的是返回信息，比如ResponseResult

我们之前在springboot中一般是用的@controllerAdvise配合exceptionHandler进行配置全局的[异常处理]

但是springSecurity的ExceptionTranslationFilter可以用来处理全局异常，这里我将使用这个

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RBB55V6o-1665928556603)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221015143003887.png)]

认证失败：它会封装AuthenticationException，然后调用AuthenticationEntryPoint的commence方法处理
授权失败：它会封装AccessDeniedException，然后调用AccessDeniedHandler的handle方法处理

我们怎么办？

自定义这两个类的异常处理机制的实现类，配置到SpringSecurity。

(1) AuthenticationEntryPointImpl,实现了原来方法的实现AuthenticationEntryPoint，重写内部的方法commence，

然后自定义处理我们页面返回信息，这里用到之前导入的WebUtil,作用是response.write···

@Component
public class AuthenticationEntryPointImpl implements AuthenticationEntryPoint {
    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
        //给前端ResponseResult的json字符串
     ResponseResult responseResult = new ResponseResult(HttpStatus.UNAUTHORIZED.value(), "登录认证失败,请重新登录!");
        String json = JSON.toJSONString(responseResult);
        WebUtils.renderString(response,json);
    }
}

(2)AccessDeniedHandlerImpl也和上面的类似

@Component
public class AccessDeniedHandlerImpl implements AccessDeniedHandler {
    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) throws IOException, ServletException {
        //给前端ResponseResult的json字符串
        ResponseResult responseResult = new ResponseResult(HttpStatus.FORBIDDEN.value(), "用户权限不足!");
        String json = JSON.toJSONString(responseResult);
        WebUtils.renderString(response,json);
    }
}

那我们写了两个自定义的异常出实现类(已经放到ioc中)，那SpringSecurity怎么知道且用上呢？

SecurityConfig从ioc把他们拿出来然后进行配置

@Autowired
private AuthenticationEntryPointImpl authenticationEntryPoint;

@Autowired
private AccessDeniedHandlerImpl accessDeniedHandler;

//SecurityFilterChain内部
//告诉security怎么处理异常
http.exceptionHandling().authenticationEntryPoint(authenticationEntryPoint).accessDeniedHandler(accessDeniedHandler);

测试一下：

1.登录异常

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JywlzYXK-1665928556604)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221015150351610.png)]

2.权限异常

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GlaZ8vBk-1665928556604)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221015150738512.png)].

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Nh8QG8al-1665928556605)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221015150845318.png)]

第六章跨域

1.概念

面试：

1什么是跨域问题：浏览器的同源策略，导致不能向其他域名发送异步请求。

2同源策略：具有相同的协议（protocol），主机（host）和端口号（port）

页面： http://192.168.1.1:8080/search 商品搜索页面

https://192.168.1.1:8080/search?name=手表 ----->no 协议不一样

http://192.168.1.2:8080/search ------------->no 主机ip不一样

http://192.168.1.1:8081/goods/add ------------->no 端口号不一样

http://192.168.1.1:8080/goods/add -------------> YES

出于浏览器的同源策略限制。同源策略（Sameoriginpolicy）是一种约定，它是浏览器最核心也最基本的安全功能，如果缺少了同源策略，则浏览器的正常功能可能都会受到影响。可以说Web是构建在同源策略基础之上的，浏览器只是针对同源策略的一种实现。同源策略会阻止一个域的javascript脚本和另外一个域的内容进行交互。所谓同源（即指在同一个域）就是两个页面具有相同的协议（protocol），主机（host）和端口号（port）

跨域问题：浏览器的同源策略限制。会报错。

如果跨域调用，会出现如下错误：

No ‘Access-Control-Allow-Origin’ header is present on the requested resource. Origin ‘http://localhost:9100’ is therefore not allowed access. The response had HTTP status code 400.

由于我们采用的是前后端分离的编程方式，前端和后端必定存在跨域问题。解决跨域问题可以采用CORS

2.CORS简介

CORS:跨域资源共享

条件：IE10以上

本质：请求头增加一个参数，开启跨域请求。

CORS 是一个 W3C 标准，全称是"跨域资源共享"（Cross-origin resource sharing）。CORS需要浏览器和服务器同时支持。目前，所有浏览器都支持该功能，IE 浏览器不能低于 IE10。它允许浏览器向跨源服务器，发出 XMLHttpRequest 请求，从而克服了 AJAX 只能同源使用的限制。整个 CORS 通信过程，都是浏览器自动完成，不需要用户参与。对于开发者来说，CORS 通信与同源的 AJAX 通信没有差别，代码完全一样。浏览器一旦发现 AJAX 请求跨源，就会自动添加一些附加的头信息，有时还会多出一次附加的请求，但用户不会有感觉。因此，实现 CORS 通信的关键是服务器。只要服务器实现了 CORS 接口，就可以跨源通信。

请求过程如下图:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ytk7cnma-1665928556605)(C:%5CUsers%5CLEGION%5CAppData%5CRoaming%5CTypora%5Ctypora-user-images%5Cimage-20221015152057013.png)]Preflight Request：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-woL5saDd-1665928556605)(C:%5CUsers%5CLEGION%5CAppData%5CRoaming%5CTypora%5Ctypora-user-images%5Cimage-20221015152114684.png)]

然后服务器端给我们返回一个PreflightResponse

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FYF2k7WC-1665928556606)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221015152202082.png)]

在controller层加上@CrossOrigin即可

3.开启跨域请求

(1) 先对SpringBoot配置，运行跨域请求

@Configuration
public class CorsConfig implements WebMvcConfigurer {//WebMvcConfigurer用于配置全局的SpringMVC的相关属性

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

(2) 开启SpringSecurity的跨域访问

由于我们的资源都会收到SpringSecurity的保护，所以想要跨域访问还要让SpringSecurity运行跨域访问

//在SecurityConfig的SecurityFilterChain内添加
//允许跨域
http.cors();

第七章拓展

1.所有自带权限校验方法

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

debug看一下相关内部代码

(1) hasAuthority

	private boolean hasAnyAuthorityName(String prefix, String... roles) { //接口要求的权限 pull123
		Set<String> roleSet = getAuthoritySet();    //获取登录人的所有权限 pull push
		for (String role : roles) {
			String defaultedRole = getRoleWithDefaultPrefix(prefix, role);
			if (roleSet.contains(defaultedRole)) {
				return true;
			}
		}
		return false;
	}

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

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

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

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

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

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

2.自定义权限校验方法

我们也可以定义自己的权限校验方法，在@PreAuthorize注解中使用我们的方法。

@Component("ex")//bean对象的名称
public class ExpressionRoot {
    public boolean hasAuthority(String authority){
        //1.获取当前用户的权限
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        LoginUser loginUser = (LoginUser) authentication.getPrincipal();
        List<String> permissions = loginUser.getPermissions();//直接拿permissions，不用去getAuthorities拿collection
        //2.判断权限内是否有接口的访问权限
        return permissions.contains(authority);
    }
}

在SPEL表达式中使用 @ex相当于获取容器中bean的名字未ex的对象。然后再调用这个对象的hasAuthority方法

@RestController
@RequestMapping("demo")
public class DemoController {

    @GetMapping("hello")
    //@PreAuthorize("hasAuthority('dev:code:pull')")
    @PreAuthorize("@ex.hasAuthority('dev:code:pull')")
    public String hello(){
        return "hello SpringSecurity";
    }

}

Test一下：记得先登录！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-14IApVWM-1665928556606)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221015170014036.png)]

3.基于配置的权限控制

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iwPuafde-1665928556606)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221015170625707.png)]

4.CSRF

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IJ80w8Na-1665928556607)(C:\Users\LEGION\AppData\Roaming\Typora\typora-user-images\image-20221015170825237.png)]

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

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

6.认证失败处理器

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

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

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

@Configuration
public class SecurityConfig {
        @Autowired
    private AuthenticationSuccessHandler successHandler;

    @Autowired
    private AuthenticationFailureHandler failureHandler;
	@Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
            
                http.formLogin()
//                配置认证成功处理器
                .successHandler(successHandler)
//                配置认证失败处理器
                .failureHandler(failureHandler);
        http.authorizeRequests().anyRequest().authenticated();
        return http.build();
    }
}

7.登出成功处理器

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

@Configuration
public class SecurityConfig {
    @Autowired
    private AuthenticationSuccessHandler successHandler;

    @Autowired
    private AuthenticationFailureHandler failureHandler;

    @Autowired
    private LogoutSuccessHandler logoutSuccessHandler;
@Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
          http.formLogin()
//                配置认证成功处理器
                .successHandler(successHandler)
//                配置认证失败处理器
                .failureHandler(failureHandler);

        http.logout()
                //配置注销成功处理器
                .logoutSuccessHandler(logoutSuccessHandler);

        http.authorizeRequests().anyRequest().au
            thenticated();
    }
}

本文含有隐藏内容，请开通VIP 后查看

SpringSecurity快速入门！读这一篇就够了！

第一章 简介

1、概念

2、认证 鉴权

第二章 入门

1、准备web项目

1.创建springboot web项目

2.controller

3.自带退出

第三章 认证

1.web登陆流程

2.看源码

3.自定义登录

4.项目准备

5. 实现

1.导入sql

2.导入依赖

3.dao层

4.修改User实体类

5.启动类配置Mapper扫描

6.替换掉inMemor用户信息

7.密码加密

🔺 8.自定义登录接口

9.认证过滤器

10.退出接口

第四章 授权

1.权限系统的作用

2.授权基本流程

3.授权实现

(1)限制访问资源所需权限

(2) 封装权限信息

(3)从数据库查询权限信息

第五章 自定义失败处理

第六章 跨域

1.概念

2.CORS简介

3.开启跨域请求

第七章 拓展

1.所有自带权限校验方法

2.自定义权限校验方法

3.基于配置的权限控制

4.CSRF

6.认证失败处理器

7.登出成功处理器

网站公告

今日签到

热门文章

最新发布

第一章简介

2、认证鉴权

第二章入门

第三章认证

第四章授权

第五章自定义失败处理

第六章跨域

第七章拓展