SpringSecurity实现JWT认证与授权

SpringSecurity 是一个功能强大且高度可定制的身份验证和访问控制框架,它是保护基于 Spring 的应用程序的事实标准,其核心是一组过滤器链

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

认证:验证当前访问系统的是不是本系统的用户,并且要确认具体是哪个用户

授权:经过认证后判断当前用户是否有权限进行某个操作

一.准备工作

1.1 导入依赖

<!--web-->
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
</dependency>
​
<!-- spring test -->
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-test</artifactId>
   <scope>test</scope>
</dependency>
​
<!-- lombok -->
<dependency>
   <groupId>org.projectlombok</groupId>
   <artifactId>lombok</artifactId>
</dependency>
​
<!--spring security-->
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-security</artifactId>
</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.47</version>
</dependency>
​
<!-- jwt -->
<dependency>
   <groupId>io.jsonwebtoken</groupId>
   <artifactId>jjwt</artifactId>
   <version>0.9.0</version>
</dependency>
​
<!-- MySQL驱动 -->
<dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
   <scope>runtime</scope>
</dependency>
​
<!-- mybatis-plus -->
<dependency>
   <groupId>com.baomidou</groupId>
   <artifactId>mybatis-plus-boot-starter</artifactId>
   <version>3.5.2</version>
</dependency>

1.2 Redis相关

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

② FastJsonRedis工具类

/**
* 工具类,Redis使用FastJson序列化
* @param <T>
*/
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);
  }
}

③ RedisCache工具类

/**
* 封装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);
  }
}

1.3 JWT相关

/**
* JWT工具类
*/
public class JwtUtil {
​
   //有效期为
   public static final Long JWT_TTL = 60 * 60 * 1000L;// 60 * 60 *1000 一个小时
   //设置秘钥明文
   public static final String JWT_KEY = "handsomejunn";
   //签发者
   public static final String JWT_ISSUER = "junn";
​
   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(JwtUtil.JWT_ISSUER)     // 签发者
              .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();
  }
   
}

1.4 Web相关

① ResponseResult实体类

/**
* 统一响应体,便于前后端分离
* @param <T>
*/
@JsonInclude(JsonInclude.Include.NON_NULL)
public class ResponseResult<T> {
​
   // 状态码
   private Integer code;
​
   // 提示信息,如果有错误时,前端可以获取该字段进行提示
   private String msg;
​
   // 查询到的结果数据
   private T data;
​
   public ResponseResult(Integer code, String msg) {
       this.code = code;
       this.msg = msg;
  }
​
   public ResponseResult(Integer code, T data) {
       this.code = code;
       this.data = data;
  }
​
   public Integer getCode() {
       return code;
  }
​
   public void setCode(Integer code) {
       this.code = code;
  }
​
   public String getMsg() {
       return msg;
  }
​
   public void setMsg(String msg) {
       this.msg = msg;
  }
​
   public T getData() {
       return data;
  }
​
   public void setData(T data) {
       this.data = data;
  }
​
   public ResponseResult(Integer code, String msg, T data) {
       this.code = code;
       this.msg = msg;
       this.data = data;
  }
}

② WebUtils工具类

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

1.5 建表与实体类

① 用户表

DROP TABLE IF EXISTS `sys_user`;
CREATE TABLE `sys_user`  (
 `id` bigint NOT NULL 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 '2' 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 NULL DEFAULT NULL COMMENT '创建人的用户id',
 `create_time` datetime NULL DEFAULT NULL COMMENT '创建时间',
 `update_by` bigint NULL DEFAULT NULL COMMENT '更新人',
 `update_time` datetime NULL DEFAULT NULL COMMENT '更新时间',
 `del_flag` int NULL DEFAULT 0 COMMENT '删除标志(0代表未删除,1代表已删除)',
 PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 3 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci COMMENT = '用户表' ROW_FORMAT = Dynamic;
​
​
# 前两个用户密码123456,第三个123
INSERT INTO `sys_user` VALUES (1, 'user1', 'USER_01', '$2a$10$pxZ4kpvPIfDLQIlAY8ZmX.2sEKiDkhRh4WQTySfT1/juPHNP/DG.6', '0', '123@qq.com', NULL, '2', NULL, '1', NULL, '2023-01-07 14:53:41', NULL, NULL, 0);
INSERT INTO `sys_user` VALUES (2, 'user2', 'USER_02', '$2a$10$pxZ4kpvPIfDLQIlAY8ZmX.2sEKiDkhRh4WQTySfT1/juPHNP/DG.6', '0', '123@qq.com', NULL, '2', NULL, '1', NULL, '2023-01-07 14:53:41', NULL, NULL, 0);
INSERT INTO `sys_user` VALUES (3, 'admin', 'ADMIN_01', '$2a$10$jrhhSypDD1YbrI65MpZzHeRQj63Rfx1UgVgQy2P6cyYu.xIy.TzUG', '0', '123@qq.com', NULL, '1', NULL, '0', NULL, '2023-01-07 15:26:47', NULL, NULL, 0);

② User实体类

/**
* 用户表(User)实体类
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName(value = "sys_user")
public class User implements Serializable {
​
   // 若不指定serialVersionUID,
   // 当类文件变化而自动生成它也会发生变化,就会不一致而导致反序列化失败
   private static final long serialVersionUID = -40356785423868312L;
​
   // 主键
   @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;
}

③ DAO层

mybatis-plus

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

二.认证的实现

2.1 通过数据库校验用户

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

① 实现UserDetailsService接口

创建一个类实现UserDetailsService接口,重写其中的方法。根据用户名从数据库中查询用户信息,封装成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(Objects.isNull(user)){
           throw new RuntimeException("用户名不存在!");
      }
       //TODO 根据用户查询权限信息 添加到LoginUser中
​
       //封装成UserDetails对象返回
       return new LoginUser(user);
  }
}

② 实现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();
  }
​
   @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.2 使密码加密储存

默认使用的PasswordEncoder要求数据库中的密码格式为:{id}password 。它会根据id去判断密码的加密方式,如:{noop}123 123明文密码

我们一般使用SpringSecurity为我们提供的BCryptPasswordEncoder,它在数据库直接存加密后的密码

① SpringSecurity配置类

SpringSecurity 的配置类需要继承 WebSecurityConfigurerAdapter

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
   
   // 创建BCryptPasswordEncoder注入容器
   @Bean
   public PasswordEncoder passwordEncoder() {
       return new BCryptPasswordEncoder();
  }
   
}

2.3 登陆接口

@RestController
public class LoginController {
​
   @Autowired
   private LoginService loginService;
​
   @PostMapping("/user/login")
   public ResponseResult login(@RequestBody User user){
       return loginService.login(user);
  }
​
   @RequestMapping("/user/logout")
   public ResponseResult logout(){
       return loginService.logout();
  }
​
}

① 暴露用户认证方法

把authenticationManager管理接口类 注入容器,提供给 LoginServiceImpl 使用

其内定义了认证方法authenticate,它会调用 UserDetailsServiceImpl 获取用户,

最终通过authenticate方法的返回值判断认证成功与否

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
   
   @Bean
   @Override
   public AuthenticationManager authenticationManagerBean() throws Exception {
       return super.authenticationManagerBean();
  }
   
}

② 认证相关配置

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
​
   @Override
   protected void configure(HttpSecurity http) throws Exception {
       http
           // 关闭csrf防护,开启的话请求头需要携带csrf_token
          .csrf().disable()
           
           // 不通过Session获取SecurityContext
          .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
          .and()
​
           // 请求认证规则配置
          .authorizeRequests()
           
           // 允许匿名用户访问,不允许已登入用户访问
          .antMatchers("/user/login").anonymous()
           // 放行,不管有没有登入都能访问
          .antMatchers("/public").permitAll()
           // 除上面外的所有请求全部需要鉴权认证后才能访问,比如/hello
          .anyRequest().authenticated();
  }
​
}

③ 详细登录业务

认证成功之后生成一个jwt,放入响应中返回

并且为了让用户下回请求时能通过jwt识别出具体的是哪个用户,我们把id作为key将用户信息存入redis

@Service
public class LoginServiceImpl implements LoginService {
​
   @Autowired
   private AuthenticationManager authenticationManager;
​
   @Autowired
   private RedisCache redisCache;
​
   @Override
   public ResponseResult login(User user) {
       // 未认证状态,principal和credentials分别对应账号与密码
       // 若已认证,principal中存放loginUser实体类,见JwtAuthenticationTokenFilter
       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);
  }
​
}

2.4 Token校验过滤器

作用:获取每次请求中token以验证认证(登录)状态,避免高频访问mysql

① Token校验过滤器

用来获取每次请求头中的token,进而在Redis中获取对应用户实体类,并存入SecurityContextHolder

​
// 相比实现Filter接口,继承这个OncePer类能使该过滤器不会出错而执行多次
@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("用户未登录");
           filterChain.doFilter(request, response);
           return;
      }
​
       //存入SecurityContextHolder
       //TODO 获取权限信息封装到Authentication中
       /**
        * 3个参数这个构造方法里有个 super.setAuthenticated(true)
        * 来表示已认证,后面FilterSecurityInterceptor会识别
        */
       UsernamePasswordAuthenticationToken authenticationToken =
               new UsernamePasswordAuthenticationToken(loginUser, null, null);
       SecurityContextHolder.getContext().setAuthentication(authenticationToken);
​
       //放行
       filterChain.doFilter(request, response);
  }
}

② 添加到过滤器链中

把该过滤器添加到 UsernamePasswordAuthenticationFilter 之前后,判断用户是否登录,只需判断携带token中的id在Redis中是否存在

也就是说,用户保持登录状态靠Redis实现了,而不用每次请求都查询mysql

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
   
   @Autowired
   private JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;
​
   @Override
   protected void configure(HttpSecurity http) throws Exception {
       // 把token校验过滤器添加到过滤器链中
       http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
  }
​
}

2.5 注销接口

① 登出业务

此时是已认证(登录)状态,登出请求先经过Token校验过滤器,把用户信息存入了 SecurityContextHolder

然后该函数再从中获取,并从Redis中删除,下一次请求Redis中获取不到,就实现登出了

@Service
public class LoginServiceImpl implements LoginService {
​
   @Autowired
   private AuthenticationManager authenticationManager;
​
   @Autowired
   private RedisCache redisCache;
​
​
   @Override
   public ResponseResult logout() {
       // 获取 SecurityContextHolder 中的用户id
       Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
       LoginUser loginUser = (LoginUser) authentication.getPrincipal();
       Long userid = loginUser.getUser().getId();
​
       // 删除Redis中的值
       redisCache.deleteObject("login:"+userid);
       return new ResponseResult(200,"登出成功");
  }
​
}

三.授权的实现

3.1 从数据库查询权限信息

① RBAC权限模型

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

image-20230111102657087

② 建表与实体类

加上之前的用户表,一共5张表

-- ----------------------------
-- Table structure for sys_menu
-- ----------------------------
DROP TABLE IF EXISTS `sys_menu`;
CREATE TABLE `sys_menu`  (
 `id` bigint NOT NULL AUTO_INCREMENT,
 `menu_name` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL DEFAULT 'NULL' COMMENT '菜单名',
 `path` varchar(200) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '路由地址',
 `component` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '组件路径',
 `visible` char(1) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT '0' COMMENT '菜单状态(0显示 1隐藏)',
 `status` char(1) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT '0' COMMENT '菜单状态(0正常 1停用)',
 `perms` varchar(100) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '权限标识',
 `icon` varchar(100) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT '#' COMMENT '菜单图标',
 `create_by` bigint NULL DEFAULT NULL,
 `create_time` datetime NULL DEFAULT NULL,
 `update_by` bigint NULL DEFAULT NULL,
 `update_time` datetime NULL DEFAULT NULL,
 `del_flag` int NULL DEFAULT 0 COMMENT '是否删除(0未删除 1已删除)',
 `remark` varchar(500) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '备注',
 PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 2 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci COMMENT = '菜单表' ROW_FORMAT = Dynamic;
​
INSERT INTO `sys_menu` VALUES (1, '添加用户', 'user', 'sys/user/add', '0', '0', 'sys:user:add', '#', NULL, NULL, NULL, NULL, 0, NULL);
INSERT INTO `sys_menu` VALUES (2, '查看用户列表', 'user', 'sys/user/list', '0', '0', 'sys:user:list', '#', NULL, NULL, NULL, NULL, 0, NULL);
INSERT INTO `sys_menu` VALUES (3, '删除用户', 'user', 'sys/user/delete', '0', '0', 'sys:user:delete', '#', NULL, NULL, NULL, NULL, 0, NULL);
​
-- ----------------------------
-- Table structure for sys_role
-- ----------------------------
DROP TABLE IF EXISTS `sys_role`;
CREATE TABLE `sys_role`  (
 `id` bigint NOT NULL AUTO_INCREMENT,
 `name` varchar(128) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL,
 `role_key` varchar(100) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '角色权限字符串',
 `status` char(1) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT '0' COMMENT '角色状态(0正常 1停用)',
 `del_flag` int NULL DEFAULT 0 COMMENT 'del_flag',
 `create_by` bigint NULL DEFAULT NULL,
 `create_time` datetime NULL DEFAULT NULL,
 `update_by` bigint NULL DEFAULT NULL,
 `update_time` datetime NULL DEFAULT NULL,
 `remark` varchar(500) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '备注',
 PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 3 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci COMMENT = '角色表' ROW_FORMAT = Dynamic;
​
INSERT INTO `sys_role` VALUES (1, 'Admin', 'admin', '0', 0, NULL, NULL, NULL, NULL, NULL);
INSERT INTO `sys_role` VALUES (2, 'User', 'user', '0', 0, NULL, NULL, NULL, NULL, NULL);
​
-- ----------------------------
-- Table structure for sys_role_menu
-- ----------------------------
DROP TABLE IF EXISTS `sys_role_menu`;
CREATE TABLE `sys_role_menu`  (
 `role_id` bigint NOT NULL AUTO_INCREMENT COMMENT '角色ID',
 `menu_id` bigint NOT NULL DEFAULT 0 COMMENT '菜单id',
 PRIMARY KEY (`role_id`, `menu_id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 2 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;
​
INSERT INTO `sys_role_menu` VALUES (1, 1);
INSERT INTO `sys_role_menu` VALUES (1, 2);
INSERT INTO `sys_role_menu` VALUES (1, 3);
​
-- ----------------------------
-- Table structure for sys_user_role
-- ----------------------------
DROP TABLE IF EXISTS `sys_user_role`;
CREATE TABLE `sys_user_role`  (
 `user_id` bigint NOT NULL AUTO_INCREMENT COMMENT '用户id',
 `role_id` bigint NOT NULL DEFAULT 0 COMMENT '角色id',
 PRIMARY KEY (`user_id`, `role_id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;
​
INSERT INTO `sys_user_role` VALUES (3, 1);
/**
* 菜单表(Menu,也是权限表)实体类
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName(value = "sys_menu")
@JsonInclude(JsonInclude.Include.NON_NULL)
public class Menu implements Serializable {
   private static final long serialVersionUID = -54979041104113736L;
​
   @TableId
   private Long id;
   /**
    * 菜单名
    */
   private String menuName;
   /**
    * 路由地址
    */
   private String path;
   /**
    * 组件路径
    */
   private String component;
   /**
    * 菜单状态(0显示 1隐藏)
    */
   private String visible;
   /**
    * 菜单状态(0正常 1停用)
    */
   private String status;
   /**
    * 权限标识
    */
   private String perms;
   /**
    * 菜单图标
    */
   private String icon;
​
   private Long createBy;
​
   private Date createTime;
​
   private Long updateBy;
​
   private Date updateTime;
   /**
    * 是否删除(0未删除 1已删除)
    */
   private Integer delFlag;
   /**
    * 备注
    */
   private String remark;
}

③ 查询权限信息

根据用户id去查询到其所对应的权限信息(字符串集合)

@Mapper
public interface MenuMapper extends BaseMapper<Menu> {
​
   List<String> selectPermsByUserId(Long userid);
​
}
<?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.permission.mapper.MenuMapper">
​
   <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>

在application.yml中配置mapperXML文件的位置

mybatis-plus:
  mapper-locations: classpath*:/mapper/**/*.xml

修改UserDetailsServiceImpl类中方法,调用该mapper的方法查询权限信息封装到LoginUser对象中即可

@Service
public class UserDetailsServiceImpl implements UserDetailsService {
​
   @Autowired
   private UserMapper userMapper;
​
   @Autowired
   private MenuMapper menuMapper;
​
   @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("用户名不存在!");
      }
​
       //根据用户查询权限信息 添加到LoginUser中
       List<String> permissionKeyList =  menuMapper.selectPermsByUserId(user.getId());
​
       //封装成UserDetails对象返回
       return new LoginUser(user, permissionKeyList);
  }
}

3.2 封装权限信息

上面查询到的权限信息是字符串集合,方便我们序列化后储存到Redis

但要在Security框架使用,我们还需要将其转化为 List<SimpleGrantedAuthority>,封装到UserDetails中返回

修改LoginUser实体类

@Data
@NoArgsConstructor
@AllArgsConstructor
public class LoginUser implements UserDetails {
​
   // 存储用户信息
   private User user;
   // 存储权限信息(字符串集合)
   private List<String> permissions;
   // 存储SpringSecurity所需要的权限信息的集合,作为成员变量方便多次调用
   // 存到Redis时不进行序列化,不然会报错,反序列化后通过permissions得到即可
   @JSONField(serialize = false)
   private List<SimpleGrantedAuthority> authorities;
   
   // 自定义有参构造,因为不需要构造authorities
   public LoginUser(User user, List<String> permissions) {
       this.user = user;
       this.permissions = permissions;
  }
​
   /**
    * 把权限字符串集合转化成authorities
    */
   @Override
   public Collection<? extends GrantedAuthority> getAuthorities() {
       if (authorities != null) {
           return authorities;
      }
       // (函数式编程)把permissions中String类型的权限信息封装成SimpleGrantedAuthority对象
       authorities = permissions.stream()
              .map(SimpleGrantedAuthority::new)
              .collect(Collectors.toList());
       return authorities;
  }
   
  ... (其他方法不变)
   
}

3.3 开启基于注解的权限控制功能

① EnableGlobalMethodSecurity注解

SpringSecurity为我们提供了基于注解的权限控制方案,这也是我们项目中主要采用的方式。我们可以使用注解去指定访问对应的资源所需的权限。

但是要使用它我们需要在WebSecurityConfigurerAdapter子类先开启相关配置

@EnableGlobalMethodSecurity(prePostEnabled = true)

② PreAuthorize注解

@RestController
public class UserController {
​
  ...
​
   @RequestMapping("/sys")
   @PreAuthorize("hasAuthority('sys:user:list')")
   public String system(){
       return "system";
  }
​
}

四.自定义失败处理

(也是异常处理)

我们希望在认证失败或者是授权失败的情况下也能和我们的接口一样返回相同结构的json,这样可以让前端能对响应进行统一的处理

{
   "code": 403,
   "msg": "权限不足"
}

4.1 Security异常处理机制

认证或者授权的过程中出现了异常会被ExceptionTranslationFilter捕获,在ExceptionTranslationFilter中会去判断是认证失败还是授权失败出现的异常

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

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

所以如果我们需要自定义异常处理,我们只需要自定义AuthenticationEntryPoint和AccessDeniedHandler的实现类,然后配置给SpringSecurity即可

4.2 认证失败处理类

当用户没有携带有效凭证时,转交到这里进行处理

@Component
public class JwtAuthenticationEntryPoint implements AuthenticationEntryPoint {
​
   @Override
   public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
       ResponseResult result = new ResponseResult(HttpStatus.UNAUTHORIZED.value(), "认证失败请重新登录");
       // 使用fastjson
       String json = JSON.toJSONString(result);
       // 将字符串渲染到客户端,并指定响应格式
       WebUtils.renderString(response, json);
  }
​
}

4.3 无权访问处理类

@Component
public class JwtAccessDeniedHandler implements AccessDeniedHandler {
​
   @Override
   public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) throws IOException, ServletException {
       ResponseResult result = new ResponseResult(HttpStatus.FORBIDDEN.value(), "权限不足");
       String json = JSON.toJSONString(result);
       WebUtils.renderString(response, json);
  }
​
}

4.4 配置到配置类

@EnableGlobalMethodSecurity(prePostEnabled = true)
@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
​
   @Autowired
   private AuthenticationEntryPoint authenticationEntryPoint;
​
   @Autowired
   private AccessDeniedHandler accessDeniedHandler;
​
  ...
       
​
   @Override
   protected void configure(HttpSecurity http) throws Exception {
      ...
       // 配置异常处理器
       http.exceptionHandling()
               // 认证失败处理器
              .authenticationEntryPoint(authenticationEntryPoint)
               // 无权访问处理器
              .accessDeniedHandler(accessDeniedHandler);
  }
}

五.跨域问题解决

5.1 跨域问题

浏览器出于安全的考虑,使用 XMLHttpRequest对象发起 HTTP请求时必须遵守同源策略,否则就是跨域的HTTP请求,默认情况下是被禁止的

同源策略要求协议、域名、端口号都完全一致才能正常进行通信,postman不存在跨域问题

但是前后端分离项目,前端项目和后端项目一般都不是同源的,所以肯定会存在跨域请求的问题

所以我们就要处理一下,让前端能进行跨域请求

5.2 SpringMVC开启跨域

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

5.3 SpringSecurity开启跨域

@EnableGlobalMethodSecurity(prePostEnabled = true)
@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
​
...
​
   @Override
   protected void configure(HttpSecurity http) throws Exception {
      ...
           
       //允许跨域
       http.cors();
  }
​
}

六.自定义权限控制

6.1 其他权限校验方法

我们前面都是使用@PreAuthorize注解,然后在在其中使用的是hasAuthority方法进行校验

hasAuthority方法实际是执行到了SecurityExpressionRoot的hasAuthority,

它内部其实是调用authentication的getAuthorities方法获取用户的权限列表。然后判断我们存入的方法参数数据是否在权限列表中

SpringSecurity还为我们提供了其它方法例如:hasAnyAuthority,hasRole,hasAnyRole等

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

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

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

6.2 自定义权限校验方法

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

@Component("exr")
public class MyExpressionRoot {
​
   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);
  }
}

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

//   @PreAuthorize("hasAuthority('system:dept:list')")
@PreAuthorize("@exr.hasAuthority('system:dept:list')")

6.3 基于配置的权限控制

我们也可以在配置类中使用使用配置的方式对资源进行权限控制

@Override
protected void configure(HttpSecurity http) throws Exception {
   http
      ...
       
       // 基于配置的权限控制
      .antMatchers("/sys").hasAuthority("sys:user:list")
​
}

七.跨站请求伪造

CSRF(Cross-site request forgery),是web常见的攻击之一

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

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

@Override
protected void configure(HttpSecurity http) throws Exception {
   http
       // 关闭csrf防护
      .csrf().disable()
}

八.自定义处理器

可用于另一套认证方案

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

8.1 认证成功处理器

实现AuthenticationSuccessHandler接口

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

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

8.2 认证失败处理器

实现AuthenticationFailureHandler接口

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

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

8.3 注销成功处理器

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

参考资料:https://www.bilibili.com/video/BV1mm4y1X7Hc/

© 版权声明
THE END
喜欢就支持一下吧
点赞0
分享
评论 抢沙发
墨初的头像-墨初小屋

昵称

取消
昵称表情代码图片