SpringBoot+Spring Security+JWT（三更草堂）

三更草堂的视频地址：B站三更草堂Up主的SpringSecurity课程

一、简介

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

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

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

• 认证：验证当前访问系统的是不是本系统的用户，并且要确认具体是哪个用户
• 授权：经过认证后判断当前用户是否有权限进行某个操作

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

二、快速入门

2.1 准备工作

我们先要搭建一个简单的SpringBoot工程

1. 设置父工程添加依赖

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.3</version>
        <relativePath/> <!-- lookup parent from repository -->
    </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>

2. 创建启动类

@SpringBootApplication
public class SpringSecurityJwtApplication {
   

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

3. 创建Controller

@RestController
public class HelloController {
   

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

2.2 引入SpringSecurity

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

<!--引入spring security场景启动器-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

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

必须登陆之后才能对接口进行访问。

• 初始账号名：user

• 初始密码：随机生成（看控制台）
  

• 默认退出接口：/logout

三、认证

3.1 登陆校验流程

3.2 原理初探

3.2.1 SpringSecurity完整流程

SpringSecurity的原理其实就是一个过滤器链，内部包含了提供各种功能的过滤器。这里我们可以看看入门案例中的过滤器。

图中只展示了核心过滤器，其它的非核心过滤器并没有在图中展示。

• UsernamePasswordAuthenticationFilter：（负责认证）负责处理我们在登陆页面填写了用户名密码后的登陆请求。入门案例的认证工作主要有它负责。
• ExceptionTranslationFilter：处理过滤器链中抛出的任何AccessDeniedException和AuthenticationException。
• FilterSecuritylnterceptor：负责权限校验的过滤器。

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

3.2.2 认证流程详解

概念速查:

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

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

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

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

3.3 解决问题

3.3.1 思路分析

1. 登录

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

   ②自定义UserDetailsService：在这个实现类中去查询数据库（这里使用假数据测试）

2. 校验:

   ①定义Jwt认证过滤器

   ​ 获取token

   ​ 解析token：获取其中的userid，根据userid从redis中获取用户信息存入SecurityContextHolder中，然后其他的过滤器会从SecurityContextHolder中获取用户信息

3.3.2 准备工作

1. 添加依赖

        <!--JWT-->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.1</version>
        </dependency>
        <!--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.79</version>
        </dependency>

2. 添加Redis相关配置

用于Redis序列化的工具类：FastJsonRedisSerializer（依赖包 com.alibaba.fastjson.support.spring 中已存在）

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.parser.ParserConfig;
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 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);
    }
}

Redis配置类：RedisConfig

import com.alibaba.fastjson.support.spring.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;

/**
 * RedisConfig配置类
 */
@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;
    }
}

3. 响应结果类

import com.fasterxml.jackson.annotation.JsonInclude;

/**
 * 响应结果类
 *
 * @param <T>
 */
@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;
    }
}

4. 工具类

JWT工具类

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.JwtBuilder;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

import javax.crypto.