SpringSecurity实战

​

0 简介

为什么写这篇博客呢，因为网络上关于SpringSecurity的内容不好找，官网很乱，所以在参考了官方文档，和b站三更草堂后，总结了一份文稿，也方便自己复习

废话不多说，正式开始

Spring Security是一个安全框架，众所周知要做好一个系统，首要考虑的就是系统的安全问题。

Spring Security隶属Spring，有SpringBoot之后，容易集成了

还有一个安全框架为Shiro,适合小项目，相比于Spring Security，shiro更容易上手，Spring Security比较适合用在中大型项目，更加的全面。

Spring Security如何保证系统安全呢？认证 + 授权

1 快速入门

在这里我们需要导入SpringSecurity的包，以及用户表(因为有用户才会涉及安全问题)

pom文件

<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>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>
</dependencies>

mysql建表语句

-- auto-generated definition
create table user
(
    username varchar(50)                  null,
    password varchar(1024)                null,
    user_id  bigint auto_increment
        primary key,
    constraint user_id
        unique (user_id)
);

简单Controller

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

    @Resource
    private UserService userService;

    @GetMapping("/getInfo")
    public User getUserInfo(@RequestParam("username") String username) {
        return userService.selectByName(username);
    }
}

现在访问localhost:8080/user/getInfo就会跳转到SpringSecurity自己预设的登陆界面，用户名为user密码在控制台上。
登陆后，才能访问。

2 SpringSecurity流程初识

其中就包含了核心：认证和授权
SpringSecurity的核心：本质上是一串过滤器链

最重要的有三个过滤器：

• UsernamePasswordAuthenticationFilter:负责认证验证用户名和密码，入门案例的登陆由其负责，后面就不用了
• ExceptionTranslationFilter:异常处理，出现异常，处理异常
• FilterSecurityInterceptor:负责校验权限不足的时候，进行拦截
  一共有15个过滤器，可以Debug查看
  

3 认证

3.1 认证流程：

基本概念：

• Authentication接口: 它的实现类，表示当前访问系统的用户，封装了用户相关信息。账号密码登陆用的是实现类UsernamePasswordAuthenticationToken

• AuthenticationManager接口：定义了认证Authentication的方法（项目里是直接用，AutoWired注入）

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

• UserDetails接口：提供核心用户信息。通过UserDetailsService根据用户名获取处理的用户信息要封装成UserDetails对象返回。然后将这些信息封装到Authentication对象中。(项目中可以实现一个LoginUser(实现UserDetails)来封装，然后登陆后，就创造一个LoginUser就行)

认证的步骤：

1. 用户前端提交用户名和密码（登陆信息）

2. 封装Authentication的对象。如果需要实现例如邮箱验证码登陆，可以先构造一个不带密码的构造器（未认证），认证成功后在构造一次（认证成功）

   // 未认证时使用的构造器（仅邮箱）
       public EmailCodeAuthenticationToken(String email) {
           super(null);
           this.principal = email;
           setAuthenticated(false); // 标记为未认证
       }
   
       // 认证成功后使用的构造器（用户信息和权限）
       public EmailCodeAuthenticationToken(Object principal, Collection<? extends GrantedAuthority> authorities) {
           super(authorities);
           this.principal = principal;
           super.setAuthenticated(true); // 标记为已认证
       }
   

3. manger调用authenticate方法，执行provider里面的authenticate方法

4. provider里面的方法调用Service的loadByUsername方法

5. loadByUsername可以查数据库

6. 默认的账号密码登陆，PassEncoder编码密码后，对比密码是否相同，相同就再构造一个认证成功，设置权限（上边代码的认证成功构造器）

7. 返回Authentication对象

8. 如果上一步返回了Authentication对象，就使用SecurityContextHolder.getContext().setAuthentication方法存储该对象。其它过滤器中会通过SecurityContextHolder来获取当前用户信息

3.2 JWT介绍

可参考入门JWT
主要就是分三部分

• 头
• 荷载
• 签名

3.3 JWT&SpringSecurity整合的步骤

整合token之后，怎么用呢，怎么和SpringSecurity结合使用呢？
登陆：

1. 自定义登陆接口：

   调用ProviderManager的方法进行认证 如果认证通过生成jwt

   把用户信息存入redis中（思考:直接存jwt吗，不是，只存key:userid,value:LoginUser信息就行）

2. 自定义UserDetailsService：

   在这个实现类中去查询数据库

认证：
定义Jwt认证过滤器：

	获取token

	解析token获取其中的userid

	从redis中获取用户信息

	存入SecurityContextHolder

3.3.1 准备工作

pom文件

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

fastjson序列化

/**
 * Redis使用FastJson序列化
 */
public class FastJsonRedisSerializer<T> implements RedisSerializer<T>
{
 
    public static final Charset DEFAULT_CHARSET = StandardCharsets.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的配置文件（提供一个方便操作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;
    }
}

统一结果返回类

import com.fasterxml.jackson.annotation.JsonInclude;
@JsonInclude(JsonInclude.Include.NON_NULL)
@Data
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 ResponseResult(Integer code, String msg, T data) {
        this.code = code;
        this.msg = msg;
        this.data = data;
    }
}

JWT工具类

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

redis操作类

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

工具类：渲染字符串，就是设置好字符串，再返回给前端

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

用户实体类：用Mybatis-Plus可直接生成，domain，service，mapper

/**
 * 
 * @TableName user
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName(value ="user")
public class User implements Serializable {
    /**
     * 
     */
    @TableField(value = "username")
    private String username;

    /**
     * 
     */
    @TableField(value = "password")
    private String password;


    @TableField(exist = false)
    private static final long serialVersionUID = 1L;

}

3.3.2 核心代码实现

UserDetailService接口

创建一个实现UserDetailService接口
这里先实现认证，所以权限相关的先暂时不实现

/**
 * 用来鉴权
 */
@Service
public class UserDetailsServiceImpl implements UserDetailsService {
    @Resource
    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 UsernameNotFoundException("用户名或密码错误!!!");
        }
        // todo 查询对应的权限信息


        // 信息封装为UserDetails
        return new LoginUser(user);
    }
}

LoginServiceImpl

package com.pojiang.springsecuritytest.service.impl;

import cn.hutool.core.lang.hash.Hash;
import com.pojiang.springsecuritytest.domain.User;
import com.pojiang.springsecuritytest.domain.security.LoginUser;
import com.pojiang.springsecuritytest.service.LoginService;
import com.pojiang.springsecuritytest.utils.JwtUtil;
import com.pojiang.springsecuritytest.utils.RedisCache;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Service;

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

@Service
public class LoginServiceImpl implements LoginService {

    @Resource
    private AuthenticationManager authenticationManager;

    @Resource
    private RedisCache redisCache;

    @Override
    public String login(User user) {
        // principle:主体，代表用户或实体的唯一身份信息，如用户名、邮箱、手机号或用户ID等。
        // credential:安全凭证：用于验证用户身份的数据，如密码、验证码、JWT令牌等。
        UsernamePasswordAuthenticationToken authentication =
                new UsernamePasswordAuthenticationToken(user.getUsername(), user.getPassword());
        // 登陆的时候，就要使用SpringSecurity认证了
        // 会找UserDetailImpl的LoadByUserName方法
        Authentication authenticate = authenticationManager.authenticate(authentication);

        // 失败之后，给出提示
        if (Objects.isNull(authenticate)) {
            throw new RuntimeException("登陆失败：用户名或密码错误!!!");
        }

        // 认证通过，用userid生成一个jwt，jwt需要返回给用户
        LoginUser loginUser = (LoginUser) authenticate.getPrincipal();
        Long userId = loginUser.getUser().getUserId();
        // 把完整的用户信息存起来，也要存入到redis中
        redisCache.setCacheObject("user_id:" + userId, loginUser);
        return JwtUtil.createJWT(userId.toString());
    }  
}

LoginUSer类

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

@Data
@AllArgsConstructor
@NoArgsConstructor
public class LoginUser implements UserDetails, Serializable {

    private static final long serialVersionUID = 1L;

    private User user;

    /**
     * @return 获取用户的权限集合（如角色、权限标识）。
     */
    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return null;
    }

    /**
     * @return 返回用户密码，供 Spring Security 进行凭证比对。
     */
    @Override
    public String getPassword() {
        return user.getPassword();
    }

    /**
     * @return 返回用户唯一标识
     */
    @Override
    public String getUsername() {
        return user.getUsername();
    }

    /**
     * @return 检查账户是否未过期（如付费用户是否到期）
     */
    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    /**
     * @return 是否没被封号，检查账户是否未被管理员或风控系统锁定
     * 可关联用户表中的 locked 字段
     */
    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    /**
     * @return 检查用户密码是否未过期
     */
    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    /**
     * @return 检查账户是否被激活（如邮箱验证后启用）。
     * 可关联用户表中的 enabled 字段。
     */
    @Override
    public boolean isEnabled() {
        return true;
    }
}

---

完成以上步骤后，可以试着登陆，user和控制台的密码，但是会报错：没有PassEncoder，可以先暂时把数据库修改一下加 {noop}

添加完之后，就可以登录成功了，因为这样这是为明文登陆了，不需要PassEncoder了

加密

但现实中不可能用明文存储密码，这时候我们需要替换PassWordEncoder,使用其加密后，虽然明文一样，但是每次加密结果不一样，因为会生成随机盐，注册的时候，也是存储密文

sysUser.setPassword(SecurityUtils.encryptPassword(registerBody.getPassword()));

我们一般使用SpringSecurity为我们提供的BCryptPasswordEncoder我们可以定义一个SpringSecurity的配置类，SpringSecurity要求这个配置类要继承WebSecurityConfigurerAdapter。

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Bean
    public PasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder();
    }
 
}

自定义登陆接口的实现

我们可以自己实现登陆接口(不是页面)，然后让SpringSecurity对这个接口放行，让用户访问这个接口的时候不需要登陆，也可访问

@RestController
public class LoginController {

    @Resource
    private LoginService loginService;

    @PostMapping("/user/login")
    public ResponseResult<User>  login(@RequestBody User user) {
        User login = loginService.login(user);
        return new ResponseResult<>(200, login);
    }
}

配置文件对接口放行

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

• anonymous():必须匿名，认证后不访问
• permitAll():允许所有请求，无论是否认证。
• authenticated():要求用户必须认证（登录）。
• denyAll():拒绝所有请求，无论是否认证。
• hasRole(“ROLE”) / hasAuthority(“AUTH”):要求用户拥有指定角色或权限。
• hasAnyRole(“ROLE1”, “ROLE2”) / hasAnyAuthority(“AUTH1”, “AUTH2”):要求用户拥有任意一个指定角色或权限。
• rememberMe():要求用户通过“记住我”功能认证。
• fullyAuthenticated():要求用户完全认证（非记住我登录）。

定义JWT认证过滤器

如果 JWT 认证成功，请求会直接进入后续流程，不会走到 UsernamePasswordAuthenticationFilter。
定义一个JWT认证过滤器来解析token,并存入SecurityContextHolder
步骤

• 获取token
• 解析出user_id
• 从redis获取用户信息
• 存入Security ContextHolder
• (todo 这里同样没有处理权限信息，鉴权后再加)

@Component
public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {

    @Resource
    private RedisCache redisCache;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        //获取token
        String token = request.getHeader("token");
        if (StringUtils.isEmpty(token)) {
            // 放行
            filterChain.doFilter(request, response);
            return;
        }
        //解析token
        String userId;
        try {
            Claims claims = JwtUtil.parseJWT(token);
            userId = claims.getSubject();
        } catch (Exception e) {
            throw new RuntimeException("Token非法！！！");
        }
        //得到用户信息
        String redisKey = "user_id:" + userId;
        LoginUser loginUser = redisCache.getCacheObject(redisKey);
        if (Objects.isNull(loginUser)) {
            throw new RuntimeException("用户未登陆！！！");
        }
        //存入SecurityContextHolder

        //TODO 获取权限信息封装到Authentication中
        // 每一次都需要存一下，因为HTTP是无状态的，不存就忘记了
        UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(loginUser,null,null);
        SecurityContextHolder.getContext().setAuthentication(authenticationToken);

        // 放行
        filterChain.doFilter(request,response);

    }
}

将过滤器配置到容器中

package com.pojiang.springsecuritytest.config;

import com.pojiang.springsecuritytest.filter.JwtAuthenticationTokenFilter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

import javax.annotation.Resource;

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {


    @Resource
    private 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()
//                .antMatchers("/user/getInfo").anonymous()

                // 除上面外的所有请求全部需要鉴权认证
                .anyRequest().authenticated();


        // 配置jwtToken过滤器,在UsernamePasswordAuthenticationFilter之前
        http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
    }

    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }

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

登出/退出登陆

本质上就是删除redis的信息

@Service
public class LoginServiceImpl implements LoginService {

    @Resource
    private AuthenticationManager authenticationManager;

    @Resource
    private RedisCache redisCache;

    @Override
    public boolean logOut() {
        //token不用删除，或者无法删除，只能等待自己过期
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        if (Objects.isNull(authentication)) {
            throw new RuntimeException("退出登陆失败！！！");
        }
        //删除redis
        LoginUser principal = (LoginUser) authentication.getPrincipal();
        redisCache.deleteObject("user_id:" + principal.getUser().getUserId());
        return true;
    }
}

4 授权

作用：不同的用户可以使用不同的功能

4.1 授权的基本流程

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

所以我们在项目中只需要把当前登录用户的权限信息也存入Authentication

然后设置我们的资源所需要的权限即可。

• UserDetailsServiceImpl中，查询出权限信息
• 在认证过滤器中，可以获取到权限，和authenticationToken一起放到SecurityContextHolder中

4.2 设置权限（实际应从数据库中查询）

注解实现方式和配置实现方式，注解使用简单方便

开启注解

@EnableGlobalMethodSecurity(prePostEnabled = true)

设置权限

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

    @Resource
    private UserService userService;

    @GetMapping("/getInfo")
    @PreAuthorize("hasRole('ADMIN')")
    public User getUserInfo(@RequestParam("username") String username) {
        return userService.selectByName(username);
    }
}

4.3 封装权限信息

这里可以先写死权限信息，后面需要从数据库中查询
也是针对前面的两个todo

• UserDetailsServiceImpl中，查询出权限信息
• 在认证过滤器中，可以获取到权限，和authenticationToken一起放到SecurityContextHolder中

UserDetailsServiceImpl

/**
 * 用来鉴权
 */
@Service
public class UserDetailsServiceImpl implements UserDetailsService {
    @Resource
    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 UsernameNotFoundException("用户名或密码错误!!!");
        }

        // todo 查询对应的权限信息
        List<String> permissions = new ArrayList<>(Arrays.asList("ADMIN", "TEST"));
        // 信息封装为UserDetails
        return new LoginUser(user, permissions, null);
    }
}

注意：这里一定要设置LoginUser
加一个permissions列表，来存储我们的权限信息
但是其实系统拿到权限是根据
public Collection<? extends GrantedAuthority> getAuthorities() 方法来得到的
我们只需要将permissions转换为GrantedAuthority的实现类即可

为了不让每次查询权限的时候都要做上述转换，我们可以缓存一下
设置一个对象为
@JSONField(serialize = false)
private List<GrantedAuthority> authorities;
因为要将用户信息存到redis中，需要序列化，但我们没必要序列化authorities只需要序列化permissions即可
使用：FastJSON 注解，标记该字段不参与序列化

@Data
@AllArgsConstructor
@NoArgsConstructor
public class LoginUser implements UserDetails, Serializable {

    private static final long serialVersionUID = 1L;

    private User user;

    private List<String> permissions;


    //需要存入到redis中，需要序列化，这里加注解，防止序列化，不存到redis中，存permissions就行了
    @JSONField(serialize = false)
    private List<GrantedAuthority> authorities;

    /**
     * @return 获取用户的权限集合（如角色、权限标识）。
     */
    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        if (authorities != null) {
            return authorities;
        }
        //将permissions中的String转换成GrantedAuthority
        authorities = permissions.stream()
                .map(SimpleGrantedAuthority::new)
                .collect(Collectors.toList());
        return authorities;
    }

    /**
     * @return 返回用户密码，供 Spring Security 进行凭证比对。
     */
    @Override
    public String getPassword() {
        return user.getPassword();
    }

    /**
     * @return 返回用户唯一标识
     */
    @Override
    public String getUsername() {
        return user.getUsername();
    }

    /**
     * @return 检查账户是否未过期（如付费用户是否到期）
     */
    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    /**
     * @return 是否没被封号，检查账户是否未被管理员或风控系统锁定
     * 可关联用户表中的 locked 字段
     */
    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    /**
     * @return 检查用户密码是否未过期
     */
    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    /**
     * @return 检查账户是否被激活（如邮箱验证后启用）。
     * 可关联用户表中的 enabled 字段。
     */
    @Override
    public boolean isEnabled() {
        return true;
    }
}

修改认证过滤器

@Component
public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {

    @Resource
    private RedisCache redisCache;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        //获取token
        String token = request.getHeader("token");
        if (StringUtils.isEmpty(token)) {
            // 放行
            filterChain.doFilter(request, response);
            return;
        }
        //解析token
        String userId;
        try {
            Claims claims = JwtUtil.parseJWT(token);
            userId = claims.getSubject();
        } catch (Exception e) {
            throw new RuntimeException("Token非法！！！");
        }
        //得到用户信息
        String redisKey = "user_id:" + userId;
        LoginUser loginUser = redisCache.getCacheObject(redisKey);
        if (Objects.isNull(loginUser)) {
            throw new RuntimeException("用户未登陆！！！");
        }
        //存入SecurityContextHolder

        //TODO 获取权限信息封装到Authentication中
      
      	//加上权限信息
        UsernamePasswordAuthenticationToken authenticationToken = new 
          UsernamePasswordAuthenticationToken(loginUser, null, loginUser.getAuthorities());
        SecurityContextHolder.getContext().setAuthentication(authenticationToken);
        filterChain.doFilter(request, response);

    }
}

4.4 最终版（从数据库中查询数据）

4.4.1 RBAC模型

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

想象一个图书馆，有读者和管理员，他们的权限肯定不一样，这就去要鉴权了
我们可以先设置两个表 用户表和menu权限表

这样一个用户会有很多权限，一个权限也可以分给多个用户，多对多，比较复杂。

如何改进
我们可以设置一些，例如 管理员,读者角色，然后每个角色有一些权限，真正的张三 李四使用的时候，分配给他管理员或读者身份即可
所以，我们需要 用户表 用户角色表 角色权限表 权限表

假如系统已经完成，新用户在进来的时候，只需要分配角色即可

4.4.2 准备工作

这里参考的是RUOYI开源框架的设计
注意：这里并没有sys_user,因为最开始的时候，建立了user表，直接用user表即可

/*Table structure for table `sys_menu` */
 
DROP TABLE IF EXISTS `sys_menu`;
 
CREATE TABLE `sys_menu` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
 
  `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=utf8 COMMENT='菜单表';
 
/*Table structure for table `sys_role` */
 
DROP TABLE IF EXISTS `sys_role`;
 
CREATE TABLE `sys_role` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `name` varchar(128) DEFAULT NULL,
  `role_key` varchar(100) DEFAULT NULL COMMENT '角色权限字符串',
  `status` char(1) DEFAULT '0' COMMENT '角色状态（0正常 1停用）',
  `del_flag` int(1) DEFAULT '0' COMMENT 'del_flag',
  `create_by` bigint(200) DEFAULT NULL,
  `create_time` datetime DEFAULT NULL,
  `update_by` bigint(200) DEFAULT NULL,
  `update_time` datetime DEFAULT NULL,
  `remark` varchar(500) DEFAULT NULL COMMENT '备注',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8 COMMENT='角色表';
 
/*Table structure for table `sys_role_menu` */
 
DROP TABLE IF EXISTS `sys_role_menu`;
 
CREATE TABLE `sys_role_menu` (
  `role_id` bigint(200) NOT NULL AUTO_INCREMENT COMMENT '角色ID',
  `menu_id` bigint(200) NOT NULL DEFAULT '0' COMMENT '菜单id',
  PRIMARY KEY (`role_id`,`menu_id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
  
DROP TABLE IF EXISTS `sys_user_role`;
 
CREATE TABLE `sys_user_role` (
  `user_id` bigint(200) NOT NULL AUTO_INCREMENT COMMENT '用户id',
  `role_id` bigint(200) NOT NULL DEFAULT '0' COMMENT '角色id',
  PRIMARY KEY (`user_id`,`role_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

思考一下，我们想用这些表来干什么？
当然是根据用户的ID来查看他的权限了，那么接下来肯定就是使用多表查询了

# 多表查询的语句
SELECT DISTINCT m.`perms`
FROM sys_user_role ur
         LEFT JOIN `sys_role` r ON ur.`role_id` = r.`id`
         LEFT JOIN `sys_role_menu` rm ON ur.`role_id` = rm.`role_id`
         LEFT JOIN `sys_menu` m ON m.`id` = rm.`menu_id`
WHERE user_id = 1
  AND r.`status` = 0
  AND m.`status` = 0

4.4.3 代码实现

因为我们需要得到权限，权限在menu里面，所以只需要menu实体类即可
MP自动生成

/**
 * 菜单表
 * @TableName sys_menu
 */
@TableName(value ="sys_menu")
@Data
@AllArgsConstructor
@NoArgsConstructor
public class SysMenu implements Serializable {
    /**
     * 
     */
    @TableId(value = "id", type = IdType.AUTO)
    private Long id;

    /**
     * 路由地址
     */
    @TableField(value = "path")
    private String path;

    /**
     * 组件路径
     */
    @TableField(value = "component")
    private String component;

    /**
     * 菜单状态（0显示 1隐藏）
     */
    @TableField(value = "visible")
    private String visible;

    /**
     * 菜单状态（0正常 1停用）
     */
    @TableField(value = "status")
    private String status;

    /**
     * 权限标识
     */
    @TableField(value = "perms")
    private String perms;

    /**
     * 菜单图标
     */
    @TableField(value = "icon")
    private String icon;

    /**
     * 
     */
    @TableField(value = "create_by")
    private Long createBy;

    /**
     * 
     */
    @TableField(value = "create_time")
    private Date createTime;

    /**
     * 
     */
    @TableField(value = "update_by")
    private Long updateBy;

    /**
     * 
     */
    @TableField(value = "update_time")
    private Date updateTime;

    /**
     * 是否删除（0未删除 1已删除）
     */
    @TableField(value = "del_flag")
    private Integer delFlag;

    /**
     * 备注
     */
    @TableField(value = "remark")
    private String remark;

    @TableField(exist = false)
    private static final long serialVersionUID = 1L;
}

mapper

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.pojiang.springsecuritytest.mapper.SysMenuMapper">

    <resultMap id="BaseResultMap" type="com.pojiang.springsecuritytest.domain.SysMenu">
        <id property="id" column="id" jdbcType="BIGINT"/>
        <result property="path" column="path" jdbcType="VARCHAR"/>
        <result property="component" column="component" jdbcType="VARCHAR"/>
        <result property="visible" column="visible" jdbcType="CHAR"/>
        <result property="status" column="status" jdbcType="CHAR"/>
        <result property="perms" column="perms" jdbcType="VARCHAR"/>
        <result property="icon" column="icon" jdbcType="VARCHAR"/>
        <result property="createBy" column="create_by" jdbcType="BIGINT"/>
        <result property="createTime" column="create_time" jdbcType="TIMESTAMP"/>
        <result property="updateBy" column="update_by" jdbcType="BIGINT"/>
        <result property="updateTime" column="update_time" jdbcType="TIMESTAMP"/>
        <result property="delFlag" column="del_flag" jdbcType="INTEGER"/>
        <result property="remark" column="remark" jdbcType="VARCHAR"/>
    </resultMap>

    <sql id="Base_Column_List">
        id
        ,`path`,component,
        visible,status,perms,
        icon,create_by,create_time,
        update_by,update_time,del_flag,
        remark
    </sql>
    <select id="selectPermsByUserId" resultType="java.lang.String">
        SELECT
            DISTINCT m.`perms`
        FROM
            sys_user_role ur
                LEFT JOIN `sys_role` r ON ur.`role_id` = r.`id`
                LEFT JOIN `sys_role_menu` rm ON ur.`role_id` = rm.`role_id`
                LEFT JOIN `sys_menu` m ON m.`id` = rm.`menu_id`
        WHERE
            user_id = #{userid}
          AND r.`status` = 0
          AND m.`status` = 0
    </select>
</mapper>

/**
* @author liheng
* @description 针对表【sys_menu(菜单表)】的数据库操作Mapper
* @createDate 2025-04-08 23:04:23
* @Entity com.pojiang.springsecuritytest.domain.SysMenu
*/
public interface SysMenuMapper extends BaseMapper<SysMenu> {
    List<String> selectPermsByUserId(Long id);
}

修改UserDetailsServiceImpl将写死的权限改为从数据库中获取

/**
 * 用来鉴权
 */
@Service
public class UserDetailsServiceImpl implements UserDetailsService {
    @Resource
    private UserMapper userMapper;

    @Resource
    private SysMenuMapper sysMenuMapper;

    @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 UsernameNotFoundException("用户名或密码错误!!!");
        }

        // todo 查询对应的权限信息
        List<String> permissions = sysMenuMapper.selectPermsByUserId(user.getUserId());
        // 信息封装为UserDetails
        return new LoginUser(user, permissions, null);
    }
}

5 异常格式统一

现在如果校验失败或者认证失败后，返回默认的错误信息，为了保证统一性，我们全部将他们变成前文的ResponseResult

根据前文大家已经知道出现异常会让ExceptionTranslationFilter处理

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

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

我们只需要实现我们只需要自定义AuthenticationEntryPoint和AccessDeniedHandler然后配置给SpringSecurity即可。

认证失败

/**
 * 认证失败，处理
 */
@Component
public class AuthenticationEntryPointImpl implements AuthenticationEntryPoint {
    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
        // 处理认证失败的异常
        ResponseResult res = new ResponseResult(HttpStatus.HTTP_FORBIDDEN, "用户认证失败");
        String resJson = JSONUtil.toJsonStr(res);
        WebUtils.renderString(response, resJson);
    }
}

授权失败

/**
 * 处理授权失败
 */
@Component
public class AccessDeniedHandlerImpl implements AccessDeniedHandler {
    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) throws IOException, ServletException {
        // 处理认证失败的异常
        ResponseResult res = new ResponseResult(HttpStatus.HTTP_FORBIDDEN, "用户权限不足");
        String resJson = JSONUtil.toJsonStr(res);
        WebUtils.renderString(response, resJson);
    }
}

配置SecurityConfig

@Autowired
private AuthenticationEntryPoint authenticationEntryPoint;
 
@Autowired
private AccessDeniedHandler accessDeniedHandler;


http.exceptionHandling().authenticationEntryPoint(authenticationEntryPoint).
        accessDeniedHandler(accessDeniedHandler);

认证失败：密码错误，没带token
授权失败：没权限

6 跨域

现在一般都是前后端分离项目，都会涉及到跨域的问题，用postman不会有跨域问题。
为了解决跨域
我们需要：

• Spring配置
• Security配置

spring配置

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

security配置

@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();
 
    //添加过滤器
    http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
 
    //配置异常处理器
    http.exceptionHandling()
            //配置认证失败处理器
            .authenticationEntryPoint(authenticationEntryPoint)
            .accessDeniedHandler(accessDeniedHandler);
 
    //允许跨域
    // 在这里允许跨域
    http.cors();
}

7 其他

7.1 权限校验

前面用的是：hasAuthority

还有：

• hasAnyAuthority: 多选的权限
• hasRole: 要求有对应的角色才可以访问，但是它内部会把我们传入的参数拼接上 ROLE_ 后再去比较。所以这种情况下要用用户对应的权限也要有 ROLE_ 这个前缀才可以。
• hasAnyRole: 多选的角色拼接

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

@Component("ex")
public class PJExpressionRoot {
 
    public boolean hasAuthority(String authority){
        //获取当前用户的权限
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        LoginUser loginUser = (LoginUser) authentication.getPrincipal();
        List<String> permissions = loginUser.getPermissions();
        //判断用户权限集合中是否存在authority
        return permissions.contains(authority);
    }
}

7.2 基于配置的权限校验

除了注解，我们还可以通过配置的方式来进行权限控制

@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("/testCors").hasAuthority("system:dept:list222")
            // 除上面外的所有请求全部需要鉴权认证
            .anyRequest().authenticated();
 
    //添加过滤器
    http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
 
    //配置异常处理器
    http.exceptionHandling()
            //配置认证失败处理器
            .authenticationEntryPoint(authenticationEntryPoint)
            .accessDeniedHandler(accessDeniedHandler);
 
    //允许跨域
    http.cors();
}

7.3 CSRF

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

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

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

我们自己生成的TOKEN就有保护的作用，所以我们需要关闭CSRF，因为不关闭还是会去校验

protected void configure(HttpSecurity http) throws Exception {
        http
                //关闭csrf
                .csrf().disable()

7.4 认证成功/失败处理器(不常用)

注意： 如果 JWT 过滤器拦截了请求并处理了认证，表单登录的 successHandler 就不会被触发

所以，不常用

认证成功处理器

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

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

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

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

认证失败处理器

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

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

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

java

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

7.5 登出成功处理器

当登出成功后，也可以进行后续处理
注意：登出成功处理器会在JwtAuthenticationTokenFilter处理器之前执行，SecurityContextHolder要想获取就不行了，因为这次的http请求的SecurityContextHolder还没有被赋值

package com.pojiang.springsecuritytest.security.filter;

import com.pojiang.springsecuritytest.domain.security.LoginUser;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.web.authentication.logout.LogoutSuccessHandler;
import org.springframework.stereotype.Component;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Component
public class PjLogoutSuccessHandler implements LogoutSuccessHandler {
    @Override
    public void onLogoutSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
        // 登出成功，发生什么:删除token
        //LoginUser user = (LoginUser) SecurityContextHolder.getContext().getAuthentication();
        //System.out.println(user.getUsername() + "用户登出成功");
        System.out.println("用户登出成功");
    }
}

设置登出的接口

http.logout().logoutUrl("/user/logout").logoutSuccessHandler(logoutSuccessHandler);