[Java知识库] 清晰搞懂Spring Security的登录认证

开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> Java知识库 -> 清晰搞懂Spring Security的登录认证 -> 正文阅读

[Java知识库]清晰搞懂Spring Security的登录认证

前言

在简单学习完成Redis之后，又进行了Spring Security的学习，这里学习的资源为三更草堂的SpringSecurity框架教程，讲得感觉还不错，推荐😁。

这里主要是对学习过程进行一个记录和总结，参考的仍然是三更草堂的笔记，但中间加上了自己的一些理解和看法以及一些遇到的问题总结，如果哪里有问题还请各位指点指点😻。

1、简介

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

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

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

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

2、登录认证

在这里主要介绍了使用Spring Security进行认证操作，授权并不会在这篇文章中过多涉及（其实并没有涉及），授权相关的内容在后面的文章《继认证后弄清Spring Security实现授权》之中。

一般来说，认证一般是用于登录时的一种操作，因此下面为使用Spring Security进行登录的一个简易流程图。

值得注意的是，这里会使用到JWT（JSON Web Token），由于之前有对它进行一定的学习和记录，这里就不过多赘述（虽然狗子我自己也有点忘记了得去看两眼），有兴趣的小伙伴可以自行前往《Spring Boot整合JWT》进行查看。

2.1、过滤器链

SpringSecurity的原理其实就是一个过滤器链，内部包含了提供各种功能的过滤器。而核心的过滤器主要为以下三个：

UsernamePasswordAuthenticationFilter:负责处理我们在登陆页面填写了用户名密码后的登陆请求。
ExceptionTranslationFilter：处理过滤器链中抛出的任何AccessDeniedException和AuthenticationException 。
FilterSecurityInterceptor：负责权限校验的过滤器。

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

2.2、认证流程

在认证过程中主要是以下接口发挥了重要作用：

Authentication 接口: 它的实现类，表示当前访问系统的用户，封装了用户相关信息；
AuthenticationManager 接口：定义了认证Authentication的方法；
UserDetailsService 接口：加载用户特定数据的核心接口。里面定义了一个根据用户名查询用户信息的方法；
UserDetails 接口：提供核心用户信息。通过UserDetailsService根据用户名获取处理的用户信息要封装成UserDetails对象返回，然后将这些信息封装到Authentication对象中。

2.3、大思路分析

注注注注意！！！在这里我砍掉了视频里的快速入门，那个觉得没有太大必要记录下来，当你完成第一步的时候随便写一个Hello接口就可以实现了，因此想了解的小伙伴直接过弯去视频查看。

在过了一遍视频和手敲了一遍之后，个人觉得很多地方还是很模糊，不太清晰，因此回过头来分析一波整体的一个思路并且记录在这里。

第一步，搭建基本环境。第一步我们肯定是得先搭建一个符合我们需求的一个Spring Boot项目对吧，在这里的话就需要搞定下面几个家常便饭。
- 数据库搭建和配置，这里包括了MySQL和Redis两个数据库；
- SpringBoot项目搭建，导入对应需要的坐标，完成yml文件配置和MVC三层架构的搭建；
- 工具类、部分配置类编写（其实这次也是一个合格的cv boy）；
第二步，自定义实现UserDetailsService接口，取代掉原本的接口实现类。这一块主要是让我们自己输入的账号密码能够访问我们自己的数据库中进行查询验证，我们总不能还用着Spring Security给我们的账号密码对吧（框架中不进行任何操作的时候会有一个随机的自生成的账号密码，没啥用，就让你香一下）
第三步，自定义登录接口，取代掉原有的登录接口。因为Spring Security自带了一个登录接口，但这个一般来说很难满足我们开发过程中特定的需求，因此我们就需要重新搞一个登录接口来谋权夺位。

3、撸袖开干

3.1、环境搭建

在环境搭建这一块主要是以代码块为主，因为这一块没有涉及到很多的新知识（默认新知识只有Spring Security😁），但是每一个代码内或外都会有或多或少的解释注明这一块是用来干哈子的。

3.1.1、数据库

1、MySQL数据库搭建。因为这里只是用作学习Spring Security的，所以数据库中一个表足以满足它的欲望了，因此只有一个用户表。

CREATE DATABASE IF NOT EXISTS db_security;

-- ----------------------------
-- Table structure for sys_user
-- ----------------------------
DROP TABLE IF EXISTS `sys_user`;
CREATE TABLE `sys_user`  (
  `id` bigint(0) NOT NULL AUTO_INCREMENT COMMENT '主键',
  `user_name` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL DEFAULT 'NULL' COMMENT '用户名',
  `nick_name` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL DEFAULT 'NULL' COMMENT '昵称',
  `password` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL DEFAULT 'NULL' COMMENT '密码',
  `status` char(1) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT '0' COMMENT '账号状态（0正常 1停用）',
  `email` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '邮箱',
  `phonenumber` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '手机号',
  `sex` char(1) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '用户性别（0男，1女，2未知）',
  `avatar` varchar(128) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '头像',
  `user_type` char(1) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL DEFAULT '1' COMMENT '用户类型（0管理员，1普通用户）',
  `create_by` bigint(0) NULL DEFAULT NULL COMMENT '创建人的用户id',
  `create_time` datetime(0) NULL DEFAULT NULL COMMENT '创建时间',
  `update_by` bigint(0) NULL DEFAULT NULL COMMENT '更新人',
  `update_time` datetime(0) NULL DEFAULT NULL COMMENT '更新时间',
  `del_flag` int(0) NULL DEFAULT 0 COMMENT '删除标志（0代表未删除，1代表已删除）',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 2 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci COMMENT = '用户表' ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of sys_user
-- ----------------------------
INSERT INTO `sys_user` VALUES (1, 'xbaozi', '陈宝子', '$2a$10$WCD7xp6lxrS.PvGmL86nhuFHMKJTc58Sh0dG1EQw0zSHjlLFyFvde', '0', NULL, NULL, NULL, NULL, '1', NULL, NULL, NULL, NULL, 0);

2、Redis搭建。如果是第一次使用Redis的话介绍太长了，虽然也有写到Redis的安装配置，但是没有上传上来还躺在我的电脑里，所以大家直接去搜一下就可以啦。

3.1.2、项目搭建

1、相关依赖导入。这里主要导入一些基本依赖和数据库以及Spring Security涉及到的依赖。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.6</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>top.xbaoziplus</groupId>
    <artifactId>security</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>security</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <!--SpringBoot Web服务-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--MyBatis-plus-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.3</version>
        </dependency>
        <!--MySQL数据库-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <!--Lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <!--springboot单元测试-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--SpringSecurity启动器-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        <!--SpringSecurity测试-->
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--druid数据库连接池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.2.11</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.33</version>
        </dependency>
        <!--jwt依赖-->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.1</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
            <!--解决Maven插件启动报错-->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.22.2</version>
                <configuration>
                    <skipTests>true</skipTests>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

2、yml配置文件。配置数据库的基本连接信息。

# 指定端口号
server:
  port: 8080

# 配置数据源
spring:
  application:
    name: security
  # 数据库连接池配置
  datasource:
    druid:
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://localhost:3306/db_security?useUnicode=true&characterEncoding=utf-8&useSSL=false
      username: root
      password: 123456
  # Redis配置
  redis:
	# 这是我的虚拟机IP
	host: 192.168.150.100
    port: 6379
    password: 123456
    # 操作0号数据库，默认有16个数据库
    database: 0
    jedis:
      pool:
        max-active: 8 # 最大连接数
        max-wait: 1ms # 连接池最大阻塞等待时间
        max-idle: 4   # 连接池中的最大空闲连接
        min-idle: 0   # 连接池中的最小空闲连接
  cache:
    redis:
      time-to-live: 1800000 # 设置数据过期时间为半小时（ms）

3、实体类。因为数据库只有一个表，因此我们只需要与之对应上就可以了。

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

4、mapper编写。因为这里使用的是MP，所以我们直接继承BaseMapper就搞定了。

@Repository
public interface UserMapper extends BaseMapper<User> {

}

5、service编写。分别编写接口和实现类的代码，这里还是MP的常规操作。

public interface UserService extends IService<User> {

}

------ 下面的在 impl 包里面 ------

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {

}

6、controller编写。这里主要就是UserController和一个简单的hello接口用作后续测试使用。

@RestController
public class HelloController {

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

--- 两个不一样的文件 ---

@RestController
@RequestMapping("/user")
@Slf4j
public class UserController {

    @Autowired
    private UserService loginService;

    @PostMapping("/login")
    public Result login(@RequestBody User user){
        log.info("登录的用户为{}", user);
        return loginService.login(user);
    }
}

3.1.3、工具类、部分配置类

1、Redis配置类。主要是对Redis默认的序列化器进行一个更换。

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

2、JWT工具类。这里就不过多的介绍啦，有兴趣的可以读一下。需要注意的就是自己更换密钥的时候，因为用到的是Base64.getDecoder()，只允许A~Z、 a~z、 0~9这些字符，如果需要用到特殊字符的话则需要换成Base64.getMimeDecoder()。（Ctrl+F 搜一下就知道在哪啦）

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

    public static String getUUID() {
        String token = UUID.randomUUID().toString().replaceAll("-", "");
        return token;
    }

    /**
     * 生成jtw
     * @param subject token中要存放的数据（json格式）
     */
    public static String createJWT(String subject) {
        JwtBuilder builder = getJwtBuilder(subject, null, getUUID());// 设置过期时间
        return builder.compact();
    }

    /**
     * 生成jwt
     * @param subject   token中要存放的数据（json格式）
     * @param ttlMillis token超时时间
     */
    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
     */
    public static String createJWT(String id, String subject, Long ttlMillis) {
        JwtBuilder builder = getJwtBuilder(subject, ttlMillis, id);// 设置过期时间
        return builder.compact();
    }

    /**
     * 生成加密后的秘钥 secretKey
     */
    public static SecretKey generalKey() {
        byte[] encodedKey = Base64.getDecoder().decode(JwtUtil.JWT_KEY);
        SecretKey key = new SecretKeySpec(encodedKey, 0, encodedKey.length, "AES");
        return key;
    }

    /**
     * 解析
     * @throws Exception
     */
    public static Claims parseJWT(String jwt) throws Exception {
        SecretKey secretKey = generalKey();
        return Jwts.parser()
                .setSigningKey(secretKey)
                .parseClaimsJws(jwt)
                .getBody();
    }
}

3、Redis工具类。这里主要是对Redis操作进行了进一步的封装，简化了操作和提高代码重用，感兴趣的同样可以自行读一下，毕竟狗子我也是cv之后再重新读的😁。

@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 多个对象
     */
    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);
    }
}

4、fastjson对Redis工具类的配置。这里有一个问题就是不要使用高版本的fastjson依赖，因为高版本的好像是已经将ParserConfig.getGlobalInstance().setAutoTypeSupport(true);去除了，从而后面导致报错。

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

到这里问题不大的话应该你的idea就是下面图片里面的结构啦（因为我是已经敲完代码再做的笔记，所以空的很多地方是因为我盖住了）

3.2、实现UserDetailsService接口

这个是和视频中的顺序是一样的，原本是在考虑着按照流程图来先写登录接口再写这一块比对账号密码细节的，但是最终还是决定按照视频的顺序来。

因为最核心的其实就是在这一块，在接口中有一个loadUserByUsername方法需要我们进行重写，这个就是在数据库中拿数据出来对比而不是使用Spring Security自生成的随机的账号密码进行对比，可能也会更直观一点。

3.2.1、具体实现

1、大致实现步骤

注入UserMapper。因为这里需要操作数据库，因此我们需要引入登录时需要的Mapper对数据进行操作；
使用 MP 获取用户数据，若查询不到则抛出异常
注意的是loadUserByUsername方法返回的数据类型为UserDetails，因此需要将查询到的数据封装到该数据类型中

@Service
public class UserDetailsServiceImpl implements UserDetailsService {

    @Autowired
    private UserMapper userMapper;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        //根据用户名查询用户信息
        LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(User::getUserName,username);
        User user = userMapper.selectOne(wrapper);
        //如果查询不到数据就通过抛出异常来给出提示
        if(ObjectUtils.isEmpty(user)){
            throw new RuntimeException("用户名或密码错误");
        }
        //封装成UserDetails对象返回，其中LoginUser为UserDetails的实现类
        return new LoginUser(user);
    }
}

2、为实现loadUserByUsername方法实现 UserDetails接口。仔细翻看我们会发现UserDetails其实只是一个接口，因此我们需要自定义一个实现类来实现该接口从而达到我们的需求。

@Data
@NoArgsConstructor
@AllArgsConstructor
public class LoginUser implements UserDetails {
	/** 使用构造方法初始化 */
    private User user;

    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return null;
    }

    @Override
    public String getPassword() {
        return user.getPassword();
    }

    @Override
    public String getUsername() {
        return user.getUserName();
    }

    /** 下面的方法暂时全部都让他们返回true */
    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    @Override
    public boolean isEnabled() {
        return true;
    }
}

3、初见成效。这时其实我们就可以利用自带的登录界面和接口，输入账号密码和数据库中数据对比进行登录了。

但是如果要测试，并且如果想让用户的密码是明文存储，需要在密码前加{noop}，如密码为1234，那在数据库中的数据就得为{noop}1234，这与默认使用的PasswordEncoder有关。

3.2.2、密码问题解决

通过上面的测试我们发现，这框架是个什么玩意，密码都搞这么麻烦，而且我们实际项目中也不会将密码明文存储在数据库中对吧，这要是让哪个老六拿到手自己岂不是成大怨种了，因此我们要改进！

在Spring Security中默认使用的PasswordEncoder要求数据库中的密码格式为{id}password，框架会根据前面的id去判断密码的加密模式，我们上面的{noop}1234也是属于这种格式，其中的noop就标明着这个密码是以明文的形式进行存储的，就会直接使用后面的1234当作密码。

而一般我们会使用Spring Security为我们提供的BCryptPasswordEncoder，其操作也很简单，我们只需要把BCryptPasswordEncoder对象注入Spring容器中计科，Spring Security就会使用我们自定义的PasswordEncoder进行密码校验。

那怎么将其加入到Spring容器中呢？我们可以定义一个SpringSecurity的配置类，SpringSecurity要求这个配置类要继承WebSecurityConfigurerAdapter。

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    /**
     * 将BCryptPasswordEncoder加入到容器中
     **/
    @Bean
    public PasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder();
    }
}

这里可以用测试类对BCryptPasswordEncoder进行测试，并且拿到我们密码加密之后的密文，值得注意的是，即使是同一个密码，两次加密出来的密文很有可能并不是相同的，这是因为该加密方式会添加一个随机盐一起进行加密。

@Test
public void testBCryptPasswordEncoder() {
    BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
    String encode = passwordEncoder.encode("1234");
    String encode2 = passwordEncoder.encode("123456");
    boolean matches = passwordEncoder.matches("1234", "$2a$10$WCD7xp6lxrS.PvGmL86nhuFHMKJTc58Sh0dG1EQw0zSHjlLFyFvde");
    System.out.println(encode);
    System.out.println(encode2);
    System.out.println(matches);
}

3.2.3、小疑问解决

问题所在： 在编写这一块内容的时候其实是有一个疑问在脑子里面的，因为这里的方法是根据用户名来进行查询的，且只有一个方法，那么如果用户名重复了该怎么办呢，这可是会抛异常的。

问题思考结果： 在查询了许多前辈们的博文之后，虽然没有找到很明确的答案，但是根据这些博文结合自己的思考得出了以下理解。即loadUserByUsername方法中的用户名只是Spring Security的一个叫法，这其实就是用户的账号，框架认为大家的账号都是叫做username而已，大家的账号总不能是相同的对吧，有些系统用的是手机号、有些系统用的是ID、有些系统用的是某些特殊标识，我们只需要在方法内部的查询操作中对应上就行，并不是强制要求我们必须要有username这一字段或必须账号就是username。

当然这只是一些个人理解，如果有哪里出入，还请各位指出。

3.3、自定义登录接口

在上一步测试的时候我们能够很明显的感受到Spring Security给我们自带了一个出厂登录接口，但是它一定是符合我们需求的接口吗？所以我们就需要自定义一个自己的登录接口。

3.3.1、编写登录接口。

编写controller，定义登录接口。

@RestController
@RequestMapping("/user")
@Slf4j
public class UserController {

    @Autowired
    private UserService loginService;

    @PostMapping("/login")
    public Result<Map<String, String>> login(@RequestBody User user){
        log.info("登录的用户为{}", user);
        return loginService.login(user);
    }
}

3.3.2、编写登录具体逻辑。

1、这一部分主要是在service层中去实现，这里的话主要是有以下几个步骤。

UserService中先定义好方法；
获取认证入口AuthenticationManager；
- 因为Spring Security中并没有将AuthenticationManager加入到容器中，所以我们需要手动将其加到Spring容器中再进行注入。
通过AuthenticationManager的authenticate方法来进行用户认证；
- authenticate方法需要传递一个Authentication类型的参数，而该类型是一个接口，因此使用该接口的实现类UsernamePasswordAuthenticationToken对用户登录信息进行封装。
判断是否验证成功决定是否抛异常
在认证信息authenticate中获取登录成功后的用户信息；
- 通过debug调试我们会发现获取的用户信息都存放在authenticate的Principal中，因此我们只需要获取该属性然后进行强转，就可以获得需要的用户数据了。
使用userId生成token；
userId用作key，将用户信息存入redis；
把token响应给前端，我这里使用到了Map。

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {

    /** 获取认证入口 */
    @Autowired
    private AuthenticationManager authenticationManager;

    @Autowired
    private RedisCache redisCache;

    @Override
    public Result<Map<String, String>> login(User user) {
        // 在没认证之前principal, credentials两个参数分别存放用户名和密码
        UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(user.getUserName(),user.getPassword());
        // 通过AuthenticationManager的authenticate方法来进行用户认证
        Authentication authenticate = authenticationManager.authenticate(authenticationToken);
        // 判断是否验证成功
        if(Objects.isNull(authenticate)){
            throw new RuntimeException("用户名或密码错误");
        }
        // 在认证信息authenticate中获取登录成功后的用户信息
        LoginUser loginUser = (LoginUser) authenticate.getPrincipal();
        // 使用userid生成token
        String userId = loginUser.getUser().getId().toString();
        String jwt = JwtUtil.createJWT(userId);
        // userId用作key，将用户信息存入redis，并设置30分钟过期
        redisCache.setCacheObject("login:" + userId, loginUser, 30, TimeUnit.MINUTES);
        // 把token响应给前端
        HashMap<String,String> map = new HashMap<>();
        map.put("token",jwt);
        return Result.success(map, "登录成功");
    }
}

2、将AuthenticationManager接入到Spring容器中。在上面service实现的时候有说到，Spring Security并没有将AuthenticationManager加入到容器中，因此我们需要手动将其加到Spring容器中再进行注入，这里同样借助SecurityConfig配置类重写authenticationManagerBean方法生成Bean。

代码在下面配置放行时一起，毕竟都是在同一个配置类中

3、放行登录接口。大家可能会发现，当我们随便进入一个接口的时候，如/hello，请求都会被拦截下来，这是因为Spring Security底层就是一条过滤器链，默认是对所有接口进行拦截，因此我们就需要让框架对我们自定义的接口放行，让用户在不登录的情况下也能够访问登录接口。

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
   /** 这里使用了数组当作下方可变参数列表的参数 */
    private String[]  matchers = new String[]{
       "/user/login"
   };
    
    /**
     * 将BCryptPasswordEncoder加入到容器中
     **/
    @Bean
    public PasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder();
    }

    /**
     * 将认证入口AuthenticationManager注入容器中用于用户认证
     **/
    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }

    /**
     * 配置SpringSecurity对需要放行的接口放行
     **/
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                //关闭csrf
                .csrf().disable()
                //不通过Session获取SecurityContext
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                .authorizeRequests()
                // 对于登录接口 允许匿名访问，下面注释的是视频中的使用方式
                //.antMatchers("/user/login").anonymous()
            	.antMatchers(matchers).anonymous()
                // 除上面外的所有请求全部需要鉴权认证
                .anyRequest().authenticated();
    }
}

3.3.3、Bug跑起来。

这个时候我们就可以真正意义上使用自己的接口，调用自己的数据库进行登录操作啦，这里使用Postman进行测试（如果有自己的页面可以加入前端界面进行协调）。

大家伙记得记得你们的redis要先跑起来！！！

3.4、认证过滤器

3.4.1、思路分析

为什么这里我们还需要一个认证过滤器在这里呢？

是因为前面我们实现的只是简单的登录操作，但是总会有一些大聪明企图在未登录的情况下访问我们不给他访问的东西，因此我们就需要编写一个登录状态的一个认证拦截器对为登录的用户进行拦截，这就类似于初学过滤器写的登录拦截器中判断session是否存在一样。

该过滤器会去获取请求头中的token，对token进行解析取出其中的userId。使用userId去redis中获取对应的LoginUser对象。然后封装Authentication对象存入SecurityContextHolder。但是我们还需要思考一个问题，那就是Spring Security是存在自己的一套过滤器链的（可以回头看目录中的2.1、过滤器链），那么我们这个过滤器应该放在过滤器链中的哪个位置呢？

答案是应该放在UsernamePasswordAuthenticationFilter的前面。这是因为我们的登录接口是在这里被调用的，当过滤器链走到这里的时候就证明是开始获取账号密码的时候了，很显然我们目前只需要验证用户是否登录，获取账户密码的意义不大，因此需要放到他的前面去。

3.4.2、具体实现

主要流程有如下几步：

定义过滤器并将其加入Spring容器中，因为后面需要将其插入到过滤器链中；
获取请求头中的token数据；
判断请求头中是否携带token数据，若没有携带有两种可能：
- 用户需要登录，正在访问登录接口准备账号密码登录；
- 用户未登录或登录过期，导致无token或token已过期；
解析token数据，从中拿到userId；
从Redis中获取用户数据，若Redis中无数据则证明登录已过期，抛异常提示；
将用户数据存入SecurityContextHolder：
- 因为这里是认证，是假设已经登录之后的状态，所以参数列表分别为用户数据，空，鉴权信息；
- 如果是前面的还未登录状态，参数列表则为账号和密码两个参数；
将过滤器插入至过滤器链中。

@Component
@Slf4j
public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {

    @Autowired
    private RedisCache redisCache;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        //获取token
        String token = request.getHeader("token");
        if (!StringUtils.hasText(token)) {
            log.info("无token");
            //放行
            filterChain.doFilter(request, response);
            return;
        }
        //解析token
        String userId;
        try {
            Claims claims = JwtUtil.parseJWT(token);
            userId = claims.getSubject();
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("token非法");
        }
        //从redis中获取用户信息
        String redisKey = "login:" + userId;
        LoginUser loginUser = redisCache.getCacheObject(redisKey);
        if(Objects.isNull(loginUser)){
            throw new RuntimeException("账号登录已超时，请重新登录");
        }
        //存入SecurityContextHolder
        UsernamePasswordAuthenticationToken authenticationToken =
                new UsernamePasswordAuthenticationToken(loginUser,null,null);
        SecurityContextHolder.getContext().setAuthentication(authenticationToken);
        //放行
        filterChain.doFilter(request, response);
    }
}

这里对没有获取到token数据时为什么要放行的原因进行一个个人理解体会的记录。

从2.1、过滤器链中的解释我们可以看到主要作用的有三个过滤器（图片已经贴到这里），其中可以简单的理解为第一个用于登录的、第二个用于异常捕获的、第三个则是从SecurityContextHolder中获取数据来鉴权。

这时我们应该可以大致的感受出来为什么可以放行而不是抛异常了，放行是为了可能需要后面的登录操作，不用担心有老六偷溜绕过认证是因为有第三个过滤器的存在。

因为如果是已登录的状态会在上面自定义的过滤器中将用户信息（内包含鉴权信息）存放至SecurityContextHolder中去，如果在该过滤器中没能成功从中拿到数据，那就证明该用户这次操作并不是登录操作，而是真正需要拦截的老六操作，因此就会在FilterSecurityInterceptor过滤器中抛出异常。

而加上return的目的是为了避免在过滤器链往回执行的时候执行自定义过滤器中的后面逻辑，因为这是无用操作。

到这里其实还没有结束，因为我们还需要将自定义过滤器添加到过滤器链中，更准确的说是将自定义过滤器添加至UsernamePasswordAuthenticationFilter过滤器的前面，当然这一操作Spring Security帮我们封装好了对应的方法，要不然要这框架有何用！

我们直接在SecurityConfig配置类中将自定义过滤器注入，并在configure方法中将其插入到指定位置。
为了突出修改的地方，这里将部分前面已经配置的方法进行了隐藏去除。

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Autowired
    private JwtAuthenticationTokenFilter authenticationTokenFilter;

    /**
     * 配置SpringSecurity对需要放行的接口放行
     **/
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                //关闭csrf
                .csrf().disable()
                //不通过Session获取SecurityContext
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                .authorizeRequests()
                // 对于登录接口 允许匿名访问，其中的antMatchers可以传递一个数组
                .antMatchers("/user/login").anonymous()
                // 除上面外的所有请求全部需要鉴权认证
                .anyRequest().authenticated();
        // 参数列表分别为需要插入的过滤器和标识过滤器的字节码
        http.addFilterBefore(authenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
    }
}

3.4.3、试当老六

首先我们在不登录的情况下访问/hello接口，可以发现是访问不了的

然后我们再尝试一下登录生成token，将token数据加入到请求头中之后再进行访问。（token错误的我就不演示了哈，感兴趣的小伙伴自己可以测试一下）

3.5、退出登录

既然登录都搞了，登出怎么说也得来一手搞一条龙服务对吧。

主要步骤如下：

从SecurityContextHolder中获取认证信息。因为在访问退出接口的时候，肯定是已经登录了且是经过了自定义的过滤器，因此在SecurityContextHolder中是已经存放了该登录用户的基本数据信息，这样我们就是可以获取得到的。
根据获取到的用户数据获取useId进行key的拼接，并从Redis中删除指定key的值，即删除该用户已登录的标识

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {

    @Autowired
    private RedisCache redisCache;

    @Override
    public Result<String> logout() {
        // 从SecurityContextHolder中获取认证信息
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        // 判空，避免登录已过期导致异常
        if (ObjectUtils.isEmpty(authentication)) {
            return Result.fail("登录已过期，退出登录失败");
        }
        // 从认证信息中获取登录用户数据
        LoginUser loginUser = (LoginUser) authentication.getPrincipal();
        // 从登录用户数据中获取userId
        Long userId = loginUser.getUser().getId();
        // 从redis中将该用户的值删除
        redisCache.deleteObject("login:" + userId);
        return Result.success("退出登录成功");
    }
}