SpringSecurity认证流程详解和代码实现

朱雀 2024-03-17 12:29 42阅读 0赞

### 一、常见的登录校验流程 ###

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

常见的登录，主要就是要做认证和授权。

从上面可以看到，登录校验的过程（认证），主要就是围绕一个包含了用户信息的`token`来进行的。

至于授权的流程，也是由`SpringSecurity`来完成，下面会进行介绍。

### 二、SpringSecurity基础流程链 ###

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

`SpringSecurity`有很多过滤器，但是核心的过滤器主要有三个：

*  **UsernamePasswordAuthenticationFilter**：用户名密码认证过滤器。
    
    负责处理在登陆页面填写了用户名密码后的登陆请求。
 *  **ExceptionTranslationFilter**：异常转换过滤器。
    
    处理过滤器链中抛出的任何`AccessDeniedException`和`AuthenticationException` 。
 *  **FilterSecurityInterceptor**：负责权限校验的过滤器。

其它过滤器链的顺序如下：  
![在这里插入图片描述][f0ecf6bc2932478db48ec6d89cb44637.png]

### 三、SpringSecurity中基础认证流程 ###

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

第五步中的查询用户名的权限和密码，实际开发中基本是在数据库中进行查找。

其它相关概念：

*  **Authentication**接口: 它的实现类，表示当前访问系统的用户，封装了用户相关信息。
 *  **AuthenticationManager**接口：定义了认证`Authentication`的方法
 *  **UserDetailsService**接口：加载用户数据的核心接口。里面定义了一个根据用户名查询用户信息的方法。
    
     *  默认的实现类就是和上图一样在内存中查找，实际开发我们应自己定义实现类，覆盖默认的方式，把从内存中查询改为从数据库中查询。
 *  **UserDetails**接口：提供核心用户信息。通过`UserDetailsService`根据用户名获取处理的用户信息要封装成
    
    `UserDetails`对象返回。然后将这些信息封装到`Authentication`对象中。

### 四、代码实现 ###

这里是基于`SpringBoot`来进行实现的。

基础架构如下：  
![在这里插入图片描述][ce5f0c441ab54d718fc19f3fa59ca97e.jpeg]

#### 4.1 步骤 ####

要使用`SpringSecurity`实现登录校验，主要需要以下步骤：

##### 1）登录 #####

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

##### 2）校验 #####

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

> redis这里使用redisTemplate来进行操作，这部分配置在这里就不赘述了。

#### 4.2 准备工作 ####

##### 1）准备JWT操作工具类 #####

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

##### 2） 准备redis工具类 #####

熟悉`redisTemplate`操作的，不需要这个工具类也是没问题的。

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

##### 3）创建数据库表 #####

CREATE TABLE `sys_user` (
      `id` BIGINT(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
      `user_name` VARCHAR(64) NOT NULL DEFAULT 'NULL' COMMENT '用户名',
      `nick_name` VARCHAR(64) NOT NULL DEFAULT 'NULL' COMMENT '昵称',
      `password` VARCHAR(64) NOT NULL DEFAULT 'NULL' COMMENT '密码',
      `status` CHAR(1) DEFAULT '0' COMMENT '账号状态（0正常 1停用）',
      `email` VARCHAR(64) DEFAULT NULL COMMENT '邮箱',
      `phonenumber` VARCHAR(32) DEFAULT NULL COMMENT '手机号',
      `sex` CHAR(1) DEFAULT NULL COMMENT '用户性别（0男，1女，2未知）',
      `avatar` VARCHAR(128) DEFAULT NULL COMMENT '头像',
      `user_type` CHAR(1) NOT NULL DEFAULT '1' COMMENT '用户类型（0管理员，1普通用户）',
      `create_by` BIGINT(20) DEFAULT NULL COMMENT '创建人的用户id',
      `create_time` DATETIME DEFAULT NULL COMMENT '创建时间',
      `update_by` BIGINT(20) DEFAULT NULL COMMENT '更新人',
      `update_time` DATETIME DEFAULT NULL COMMENT '更新时间',
      `del_flag` INT(11) DEFAULT '0' COMMENT '删除标志（0代表未删除，1代表已删除）',
      PRIMARY KEY (`id`)
    ) ENGINE=INNODB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb4 COMMENT='用户表'

##### 4）导入MySQL和MyBatis-Plus的Maven坐标 #####

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

##### 5）准备用户表实体类 #####

import java.io.Serializable;
    import java.util.Date;
    
    /**
     * 用户(User)实体类
     */
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    @TableName(value = "sys_user")
    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;
    }

##### 6）application.yml配置MySQL地址 #####

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

##### 7）配置Mapper扫描 #####

主要是使用`@MapperScan`注解。

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

#### 4.3 核心代码实现 ####

##### 1）定义一个类，实现UserDetails接口，封装用户信息 #####

@Data
    @NoArgsConstructor
    @AllArgsConstructor
    public class LoginUser implements UserDetails {
        
    
        private User user;
    
        // 封装该用户拥有的权限信息，这里还只是讲认证，所以直接返回null跳过
        @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;
        }
    }

##### 2）创建类实现UserDetailsService接口 #####

主要是为了重写其中的方法，改为从数据库中查询用户信息，才更加符合实际开发需求。

@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(Objects.isNull(user)){
        
                throw new RuntimeException("用户名或密码错误");
            }
            //TODO 根据用户查询权限信息 添加到LoginUser中（这里到授权时才使用）
            
            //封装成UserDetails对象返回 
            return new LoginUser(user);
        }
    }

##### 3）密码加密存储 #####

实际开发中，用户密码一般不是明文存储在数据库中的。

`SpringSecurity`默认使用加密器`PasswordEncoder`，它要求数据库中的密码格式为：`{id}password` 。

`PasswordEncoder`会根据id去判断密码的加密方式。

但是通常都**不会采用**这种方式。所以就需要替换`PasswordEncoder`。

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

使用`BCryptPasswordEncoder`的方式如下：

把`BCryptPasswordEncoder`对象注入`Spring`容器，`SpringSecurity`就会用`PasswordEncoder`进行密码校验。

因此可以自定义`SpringSecurity`的配置类，这个配置类需要继承`WebSecurityConfigurerAdapter`。

/**
     * SpringSecurity配置类
     */
    @Configuration
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
        
    
        @Bean
        public PasswordEncoder passwordEncoder(){
        
            return new BCryptPasswordEncoder();
        }
    
    }

**拓展：**

数据库中的表的密码通常来说是密文存储，如果想在测试的时候方便一些，需要在密码前加`{noop}`。  
![在这里插入图片描述][973d0dde375d4230bb249e2e38954876.png]

像上图一样，就可以直接使用`123456`来进行登录了。

##### 4）登陆接口 #####

自定义登陆接口，让`SpringSecurity`对这个接口放行,让用户访问这个接口的时候不用登录也能访问。

在接口中我们通过`AuthenticationManager`的`authenticate`方法来进行用户认证,所以需要在`SecurityConfig`

中配置把`AuthenticationManager`注入容器。

认证成功的话要生成一个`jwt`，放入响应中返回。

为了让用户下回请求时能通过`jwt`识别出的是哪个用户，需要把用户信息存入`redis`，可以把用户`id`作为`key`。

*  **登录接口**

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

*  在`SecurityConfig`中注入`AuthenticationManager`

@Configuration
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
        
    
    
        @Bean
        public PasswordEncoder passwordEncoder(){
        
            return new BCryptPasswordEncoder();
        }
    
        @Override
        protected void configure(HttpSecurity http) throws Exception {
        
            http
                    //关闭csrf
                    .csrf().disable()
                    //不通过Session获取SecurityContext
                    .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                    .and()
                    .authorizeRequests()
                    // 对于登录接口 允许匿名访问
                    .antMatchers("/user/login").anonymous()
                    // 除上面外的所有请求全部需要鉴权认证
                    .anyRequest().authenticated();
        }
    
        @Bean
        @Override
        public AuthenticationManager authenticationManagerBean() throws Exception {
        
            return super.authenticationManagerBean();
        }
    }

*  在业务层进行认证操作

@Service
    public class LoginServiceImpl implements LoginServcie {
        
    
        @Autowired
        private AuthenticationManager authenticationManager;
        @Autowired
        private RedisCache redisCache;
    
        @Override
        public ResponseResult login(User user) {
        
            UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(user.getUserName(),user.getPassword());
            // 调用authenticate方法认证时
            // 会执行UserDetailsServiceImpl中的loadUserByUsername方法
            Authentication authenticate = authenticationManager.authenticate(authenticationToken);
            if(Objects.isNull(authenticate)){
        
                throw new RuntimeException("用户名或密码错误");
            }
            //使用userid生成token
            LoginUser loginUser = (LoginUser) authenticate.getPrincipal();
            String userId = loginUser.getUser().getId().toString();
            String jwt = JwtUtil.createJWT(userId);
            //authenticate存入redis
            redisCache.setCacheObject("login:"+userId,loginUser);
            //把token响应给前端
            HashMap<String,String> map = new HashMap<>();
            map.put("token",jwt);
            return new ResponseResult(200,"登陆成功",map);
        }
    }

##### 5）认证过滤器 #####

自定义一个过滤器，这个过滤器会去获取请求头中的`token`，对`token`进行解析取出其中的`userId`。

使用`userId`去`redis`中获取对应的`LoginUser`对象。

最后封装`Authentication`对象存入`SecurityContextHolder`。

@Component
    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)) {
        
                //放行
                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
            //TODO 获取权限信息封装到Authentication中
            UsernamePasswordAuthenticationToken authenticationToken =
                    new UsernamePasswordAuthenticationToken(loginUser,null,null);
            SecurityContextHolder.getContext().setAuthentication(authenticationToken);
            //放行
            filterChain.doFilter(request, response);
        }
    }

再配置类中注入刚才的自定义过滤器，此过滤器才能生效。

@Configuration
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
        
    
    
        @Bean
        public PasswordEncoder passwordEncoder(){
        
            return new BCryptPasswordEncoder();
        }
    
    	// 注入位置
        @Autowired
        JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;
    
        @Override
        protected void configure(HttpSecurity http) throws Exception {
        
            http
                    //关闭csrf
                    .csrf().disable()
                    //不通过Session获取SecurityContext
                    .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                    .and()
                    .authorizeRequests()
                    // 对于登录接口 允许匿名访问
                    .antMatchers("/user/login").anonymous()
                    // 除上面外的所有请求全部需要鉴权认证
                    .anyRequest().authenticated();
    
            //把token校验过滤器添加到过滤器链中
            http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
        }
    
        @Bean
        @Override
        public AuthenticationManager authenticationManagerBean() throws Exception {
        
            return super.authenticationManagerBean();
        }
    }

##### 6）退出登陆 #####

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

@Service
    public class LoginServiceImpl implements LoginServcie {
        
    
        @Autowired
        private AuthenticationManager authenticationManager;
        @Autowired
        private RedisCache redisCache;
    
        // 登录业务
        @Override
        public ResponseResult login(User user) {
        
            UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(user.getUserName(),user.getPassword());
            Authentication authenticate = authenticationManager.authenticate(authenticationToken);
            if(Objects.isNull(authenticate)){
        
                throw new RuntimeException("用户名或密码错误");
            }
            //使用userid生成token
            LoginUser loginUser = (LoginUser) authenticate.getPrincipal();
            String userId = loginUser.getUser().getId().toString();
            String jwt = JwtUtil.createJWT(userId);
            //authenticate存入redis
            redisCache.setCacheObject("login:"+userId,loginUser);
            //把token响应给前端
            HashMap<String,String> map = new HashMap<>();
            map.put("token",jwt);
            return new ResponseResult(200,"登陆成功",map);
        }
    
        // 退出登录业务
        @Override
        public ResponseResult logout() {
        
            Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
            LoginUser loginUser = (LoginUser) authentication.getPrincipal();
            Long userid = loginUser.getUser().getId();
            redisCache.deleteObject("login:"+userid);
            return new ResponseResult(200,"退出成功");
        }
    }

### 五、自定义处理器 ###

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

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

`AuthenticationSuccessHandler`就是登录成功处理器。

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

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

在`SecurityConfig`类中配置认证成功处理器。

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

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

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

`AuthenticationFailureHandler`就是登录失败处理器。

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

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

在`SecurityConfig`类中配置认证失败处理器。

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

如果希望在认证失败或者是授权失败的情况下也能和我们的接口一样返回相同结构的`json`，这样可以让前端能对

响应进行统一的处理。

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

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

此时借助了一个工具类：

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

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

@Component
    public class LogoutSuccessHandler implements LogoutSuccessHandler {
        
        @Override
        public void onLogoutSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
        
            System.out.println("用户退出登录成功");
        }
    }

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

### 六、小节 ###

这就是`SpringSecurity`中基本的认证流程了。

下一篇介绍`SpringSecurity`中的授权流程。

[dac0d4d74d1848a681adf2c4a5ededcd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/93bbcf7331134bef860c4595d71e57c0.png
[e9202f870daa438aaacc63c8535d366b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/18dad8f6fc8e460cb562c9afdc383871.png
[f0ecf6bc2932478db48ec6d89cb44637.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/63a73e0b3c5f424b953b8aa1b75593f4.png
[34e8e71b6f0c405da9b84a0e5a0064b4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/12f843bc0035429da949d9a025a6f3fd.png
[ce5f0c441ab54d718fc19f3fa59ca97e.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/4a33bee6627a464ca788b7fb45a95f7f.png
[973d0dde375d4230bb249e2e38954876.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/41fa6ed07ed64057a4aa76776ffa1c91.png