• SpringSecurity学习 - 认证和授权

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

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

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

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

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

    我所学习的正是,认证和授权和流程。

    另外默认SpringBoot、Redis会调用。

    1.简单入门Demo

    新建一个SpringBoot工程。这是使用的依赖。

    1. 	<dependency>
    2. 			<groupId>org.springframework.bootgroupId>
    3. 			<artifactId>spring-boot-starter-securityartifactId>
    4. 		dependency>
    5. 		<dependency>
    6. 			<groupId>org.springframework.bootgroupId>
    7. 			<artifactId>spring-boot-starter-webartifactId>
    8. 		dependency>
    9.  
    10. 		<dependency>
    11. 			<groupId>org.springframework.bootgroupId>
    12. 			<artifactId>spring-boot-starter-testartifactId>
    13. 			<scope>testscope>
    14. 		dependency>
    15.  
    17.         	<dependency>
    18. 			<groupId>org.springframework.bootgroupId>
    19. 			<artifactId>spring-boot-starter-data-redisartifactId>
    20. 		dependency>
    21. 		<dependency>
    22. 			<groupId>com.baomidougroupId>
    23. 			<artifactId>mybatis-plus-boot-starterartifactId>
    24. 			<version>3.5.3.1version>
    25. 		dependency>
    26. 		<dependency>
    27. 			<groupId>mysqlgroupId>
    28. 			<artifactId>mysql-connector-javaartifactId>
    29. 		dependency>
    30. 		<dependency>
    31. 			<groupId>org.projectlombokgroupId>
    32. 			<artifactId>lombokartifactId>
    33. 		dependency>
    34. 		<dependency>
    35. 			<groupId>com.alibabagroupId>
    36. 			<artifactId>fastjsonartifactId>
    37. 			<version>1.2.58version>
    38. 		dependency>
    39. 		<dependency>
    40. 			<groupId>com.fasterxml.jackson.datatypegroupId>
    41. 			<artifactId>jackson-datatype-jdk8artifactId>
    42. 		dependency>
    43. 		<dependency>
    44. 			<groupId>io.jsonwebtokengroupId>
    45. 			<artifactId>jjwtartifactId>
    46. 			<version>0.9.1version>
    47. 		dependency>
    48. 		<dependency>
    49. 			<groupId>org.apache.commonsgroupId>
    50. 			<artifactId>commons-pool2artifactId>
    51. 		dependency>
    52. 		
    53. 		
    54. 		<dependency>
    55. 			<groupId>javax.xml.bindgroupId>
    56. 			<artifactId>jaxb-apiartifactId>
    57. 			<version>2.3.0version>
    58. 		dependency>
    59. 		<dependency>
    60. 			<groupId>com.sun.xml.bindgroupId>
    61. 			<artifactId>jaxb-implartifactId>
    62. 			<version>2.3.0version>
    63. 		dependency>
    64. 		<dependency>
    65. 			<groupId>com.sun.xml.bindgroupId>
    66. 			<artifactId>jaxb-coreartifactId>
    67. 			<version>2.3.0version>
    68. 		dependency>
    69. 		<dependency>
    70. 			<groupId>javax.activationgroupId>
    71. 			<artifactId>activationartifactId>
    72. 			<version>1.1.1version>
    73. 		dependency>

    启动之后，访问localhost:8888, 出现一下页面代表SpringSecurity生效了。

     此时我们发现控制台生成：

     我们向登录表单输入，这段密码和用户名user,即可登录通过。

     2.认证

    2.1 登录校验流程

     当然，我们实际情况，可能会加一个redis做缓存,登录之后，用用户id -> 用户信息，存储到redis中。

    这样我们登录之后，解析token，就是从redis查询。

    2.2 SpringSecurity验证流程

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

    UsernamePasswordAuthenticationFilter:负责处理我们在登陆页面填写了用户名密码后的登陆请求。入门案例的认证工作主要有它负责。

    ExceptionTranslationFilter：处理过滤器链中抛出的任何AccessDeniedException和AuthenticationException 。

    FilterSecurityInterceptor：负责权限校验的过滤器。

    2.3 认证流程详解

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

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

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

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

    2.4 思路分析

    1. ...,在现在前后端分离项目，我们肯定是要自定义登录接口，不能用SpringSecurity的登录页面；

    2. UserDetailService 是在内存中查找比较用户输入的用户名和密码，那我们需要是需要查询数据库比对的。

    2.5 问题解决

    2.5.0 前提

    user.sql

    1. DROP TABLE IF EXISTS `user`;
    2. CREATE TABLE `user` (
    3.   `id` bigint NOT NULL COMMENT '主键',
    4.   `user_name` varchar(64) NOT NULL DEFAULT 'NULL' COMMENT '用户名',
    5.   `nick_name` varchar(64) NOT NULL DEFAULT 'NULL' COMMENT '昵称',
    6.   `password` varchar(64) NOT NULL DEFAULT 'NULL' COMMENT '密码',
    7.   `status` char(1) DEFAULT '0' COMMENT '账号状态（0正常 1停用）',
    8.   `email` varchar(64) DEFAULT NULL COMMENT '邮箱',
    9.   `phonenumber` varchar(32) DEFAULT NULL COMMENT '手机号',
    10.   `sex` char(1) DEFAULT NULL COMMENT '用户性别（0男，1女，2未知）',
    11.   `avatar` varchar(128) DEFAULT NULL COMMENT '头像',
    12.   `user_type` char(1) NOT NULL DEFAULT '1' COMMENT '用户类型（0管理员，1普通用户）',
    13.   `create_by` bigint DEFAULT NULL COMMENT '创建人的用户id',
    14.   `create_time` datetime DEFAULT NULL COMMENT '创建时间',
    15.   `update_by` bigint DEFAULT NULL COMMENT '更新人',
    16.   `update_time` datetime DEFAULT NULL COMMENT '更新时间',
    17.   `del_flag` int DEFAULT '0' COMMENT '删除标志（0代表未删除，1代表已删除）',
    18.   PRIMARY KEY (`id`)
    19. ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='用户表';

     application.yaml 中数据库配置

    1. spring:
    2.   datasource:
    3.     url: jdbc:mysql://localhost:3306/test?characterEncoding=utf-8&serverTimezone=UTC
    4.     username: root
    5.     password: root
    6.     driver-class-name: com.mysql.cj.jdbc.Driver

    UserMapper

    1. @Mapper
    2. public interface UserMapper extends BaseMapper {
    3. }

    User

    1. @Data
    2. @AllArgsConstructor
    3. @NoArgsConstructor
    4. @TableName(value = "user")
    5. public class User {
    6.  
    7.     /**
    8.      * 主键
    9.      */
    10.     @TableId
    11.     private Long id;
    12.     /**
    13.      * 用户名
    14.      */
    15.     private String userName;
    16.     /**
    17.      * 昵称
    18.      */
    19.     private String nickName;
    20.     /**
    21.      * 密码
    22.      */
    23.     private String password;
    24.     /**
    25.      * 账号状态（0正常 1停用）
    26.      */
    27.     private String status;
    28.     /**
    29.      * 邮箱
    30.      */
    31.     private String email;
    32.     /**
    33.      * 手机号
    34.      */
    35.     private String phonenumber;
    36.     /**
    37.      * 用户性别（0男，1女，2未知）
    38.      */
    39.     private String sex;
    40.     /**
    41.      * 头像
    42.      */
    43.     private String avatar;
    44.     /**
    45.      * 用户类型（0管理员，1普通用户）
    46.      */
    47.     private String userType;
    48.     /**
    49.      * 创建人的用户id
    50.      */
    51.     private Long createBy;
    52.     /**
    53.      * 创建时间
    54.      */
    55.     private Date createTime;
    56.     /**
    57.      * 更新人
    58.      */
    59.     private Long updateBy;
    60.     /**
    61.      * 更新时间
    62.      */
    63.     private Date updateTime;
    64.     /**
    65.      * 删除标志（0代表未删除，1代表已删除）
    66.      */
    67.     private Integer delFlag;
    68. }

    UserDetailServiceImpl

    1. @Data
    2. @NoArgsConstructor
    3. @AllArgsConstructor
    4. public class UserDetailsImpl implements UserDetails {
    5.  
    6.     private User user;
    7.  
    8.     //private List authList;
    9.     //
    10.     //@JSONField(serialize = false)
    11.     //private List authorities;  // SimpleGrantedAuthority对象不支持序列化，无法存入redis
    12.     //
    13.     //
    14.     //public UserDetailsImpl(User user, List authList) { // 将对应的权限字符串列表传入
    15.     //    this.user = user;
    16.     //    this.authList = authList;
    17.     //}
    18.     //
    19.  
    20.  
    21.     @Override
    22.     public Collectionextends GrantedAuthority> getAuthorities() {
    23.          初始化之后，我们后续其他拦截器，也会获取; 没必要多次初始化；
    24.         //if(authorities != null){
    25.         //    return authorities;
    26.         //}else{
    27.         //    authorities = new ArrayList<>();
    28.         //}
    29.         //
    30.          第一次登录，封装UserDetails对象,初始化权限列表
    31.         //for (String auth : authList) {
    32.         //    SimpleGrantedAuthority simpleGrantedAuthority = new SimpleGrantedAuthority(auth);
    33.         //    authorities.add(simpleGrantedAuthority); // 对，默认是个空的
    34.         //}
    35.         //return authorities;
    36.         
    37.         return null;
    38.     }
    39.  
    40.     @Override
    41.     public String getPassword() {
    42.         return user.getPassword();
    43.     }
    44.  
    45.     @Override
    46.     public String getUsername() {
    47.         return user.getUserName();
    48.     }
    49.  
    50.     @Override
    51.     public boolean isAccountNonExpired() {  // 下面bool值，全部响应为true,UserDetail对象返回校验过程中，会因为没权限报错
    52.         return true;
    53.     }
    54.  
    55.     @Override
    56.     public boolean isAccountNonLocked() {
    57.         return true;
    58.     }
    59.  
    60.     @Override
    61.     public boolean isCredentialsNonExpired() {
    62.         return true;
    63.     }
    64.  
    65.     @Override
    66.     public boolean isEnabled() {
    67.         return true;
    68.     }
    69. }

    RedisConfig : redis配置类

    1. @Configuration
    2. public class RedisConfig {
    3.  
    4.     @Bean
    5.     @SuppressWarnings(value = { "unchecked", "rawtypes" })
    6.     public RedisTemplate redisTemplate(RedisConnectionFactory connectionFactory)
    7.     {
    8.         RedisTemplate template = new RedisTemplate<>();
    9.         template.setConnectionFactory(connectionFactory);
    10.  
    11.         FastJsonRedisSerializer serializer = new FastJsonRedisSerializer(Object.class);
    12.  
    13.         // 使用StringRedisSerializer来序列化和反序列化redis的key值
    14.         template.setKeySerializer(new StringRedisSerializer());
    15.         template.setValueSerializer(serializer);
    16.  
    17.         // Hash的key也采用StringRedisSerializer的序列化方式
    18.         template.setHashKeySerializer(new StringRedisSerializer());
    19.         template.setHashValueSerializer(serializer);
    20.  
    21.         template.afterPropertiesSet();
    22.         return template;
    23.     }
    24. }

     Result : 后端统一封装响应

    1. @Data
    2. @AllArgsConstructor
    3. @NoArgsConstructor
    4. public class Result {
    5.  
    6.     private T data;
    7.     private String mes;
    8.     private Integer code;
    9.  
    10.     public Result(String mes, Integer _code) {
    11.     }
    12.  
    13.  
    14.     public static  Result success(T data){
    15.         return new Result(data,"操作成功",200);
    16.     }
    17.  
    18.     public  static  Result success(String _mes){
    19.         return new Result(_mes,200);
    20.     }
    21.  
    22.     public static  Result error(String _mes,Integer _code){
    23.         return new Result(_mes,_code);
    24.     }
    25. }

     JwtUtil 工具类

    1. /**
    2.  * JWT工具类
    3.  */
    4. public class JwtUtil {
    5.  
    6.     //有效期为
    7.     public static final Long JWT_TTL = 60 * 60 *1000L;// 60 * 60 *1000  一个小时
    8.     //设置秘钥明文
    9.     public static final String JWT_KEY = "sangeng";
    10.  
    11.     public static String getUUID(){
    12.         String token = UUID.randomUUID().toString().replaceAll("-", "");
    13.         return token;
    14.     }
    15.     
    16.     /**
    17.      * 生成jtw
    18.      * @param subject token中要存放的数据（json格式）
    19.      * @return
    20.      */
    21.     public static String createJWT(String subject) {
    22.         JwtBuilder builder = getJwtBuilder(subject, null, getUUID());// 设置过期时间
    23.         return builder.compact();
    24.     }
    25.  
    26.     /**
    27.      * 生成jtw
    28.      * @param subject token中要存放的数据（json格式）
    29.      * @param ttlMillis token超时时间
    30.      * @return
    31.      */
    32.     public static String createJWT(String subject, Long ttlMillis) {
    33.         JwtBuilder builder = getJwtBuilder(subject, ttlMillis, getUUID());// 设置过期时间
    34.         return builder.compact();
    35.     }
    36.  
    37.     private static JwtBuilder getJwtBuilder(String subject, Long ttlMillis, String uuid) {
    38.         SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;
    39.         SecretKey secretKey = generalKey();
    40.         long nowMillis = System.currentTimeMillis();
    41.         Date now = new Date(nowMillis);
    42.         if(ttlMillis==null){
    43.             ttlMillis=JwtUtil.JWT_TTL;
    44.         }
    45.         long expMillis = nowMillis + ttlMillis;
    46.         Date expDate = new Date(expMillis);
    47.         return Jwts.builder()
    48.                 .setId(uuid)              //唯一的ID
    49.                 .setSubject(subject)   // 主题  可以是JSON数据
    50.                 .setIssuer("sg")     // 签发者
    51.                 .setIssuedAt(now)      // 签发时间
    52.                 .signWith(signatureAlgorithm, secretKey) //使用HS256对称加密算法签名, 第二个参数为秘钥
    53.                 .setExpiration(expDate);
    54.     }
    55.  
    56.     /**
    57.      * 创建token
    58.      * @param id
    59.      * @param subject
    60.      * @param ttlMillis
    61.      * @return
    62.      */
    63.     public static String createJWT(String id, String subject, Long ttlMillis) {
    64.         JwtBuilder builder = getJwtBuilder(subject, ttlMillis, id);// 设置过期时间
    65.         return builder.compact();
    66.     }
    67.  
    68.     public static void main(String[] args) throws Exception {
    69. //        String jwt = createJWT("2123");
    70.         Claims claims = parseJWT("eyJhbGciOiJIUzI1NiJ9.eyJqdGkiOiIyOTY2ZGE3NGYyZGM0ZDAxOGU1OWYwNjBkYmZkMjZhMSIsInN1YiI6IjIiLCJpc3MiOiJzZyIsImlhdCI6MTYzOTk2MjU1MCwiZXhwIjoxNjM5OTY2MTUwfQ.NluqZnyJ0gHz-2wBIari2r3XpPp06UMn4JS2sWHILs0");
    71.         String subject = claims.getSubject();
    72.         System.out.println(subject);
    73. //        System.out.println(claims);
    74.     }
    75.  
    76.     /**
    77.      * 生成加密后的秘钥 secretKey
    78.      * @return
    79.      */
    80.     public static SecretKey generalKey() {
    81.         byte[] encodedKey = Base64.getDecoder().decode(JwtUtil.JWT_KEY);
    82.         SecretKey key = new SecretKeySpec(encodedKey, 0, encodedKey.length, "AES");
    83.         return key;
    84.     }
    85.     
    86.     /**
    87.      * 解析
    88.      *
    89.      * @param jwt
    90.      * @return
    91.      * @throws Exception
    92.      */
    93.     public static Claims parseJWT(String jwt) throws Exception {
    94.         SecretKey secretKey = generalKey();
    95.         return Jwts.parser()
    96.                 .setSigningKey(secretKey)
    97.                 .parseClaimsJws(jwt)
    98.                 .getBody();
    99.     }
    100.  
    101.  
    102. }
    FastJsonRedisSerializer 
    1. public class FastJsonRedisSerializer implements RedisSerializer
    2. {
    3.  
    4.     public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
    5.  
    6.     private Class clazz;
    7.  
    8.     static
    9.     {
    10.         ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
    11.     }
    12.  
    13.     public FastJsonRedisSerializer(Class clazz)
    14.     {
    15.         super();
    16.         this.clazz = clazz;
    17.     }
    18.  
    19.     @Override
    20.     public byte[] serialize(T t) throws SerializationException
    21.     {
    22.         if (t == null)
    23.         {
    24.             return new byte[0];
    25.         }
    26.         return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
    27.     }
    28.  
    29.     @Override
    30.     public T deserialize(byte[] bytes) throws SerializationException
    31.     {
    32.         if (bytes == null || bytes.length <= 0)
    33.         {
    34.             return null;
    35.         }
    36.         String str = new String(bytes, DEFAULT_CHARSET);
    37.  
    38.         return JSON.parseObject(str, clazz);
    39.     }
    40.  
    41.  
    42.     protected JavaType getJavaType(Class clazz)
    43.     {
    44.         return TypeFactory.defaultInstance().constructType(clazz);
    45.     }
    46. }

    2.5.1 自定义UserDetailService

    我们自定义UserDatailService 实现UserDatailService接口，注入到spring容器中，这样就会在SpringSecurity的认证流程中调用我们自定义的实现类。

    1. @Service
    2. public class UserDetailServiceImpl extends ServiceImpl< UserMapper, User> implements UserDetailsService {
    3.  
    4.     @Override
    5.     public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
    6.         // 用用户名查询对应User
    7.         LambdaQueryWrapper queryWrapper = new LambdaQueryWrapper<>();
    8.         queryWrapper.eq(User::getUserName,username);
    9.         // 判断是否空
    10.         User user = this.getOne(queryWrapper);
    11.         if(user == null){
    12.             throw new RuntimeException("用户名或密码错误");
    13.         }
    14.         // 将查询到user封装到自定义UserDeatail中
    15.       return new UserDetailsImpl(user);
    16.     }
    17. }

    我们看下图，我们输入的用户名和密码，最终会传入UserDetailService 对象，加载loadUserByUsername 方法，返回UserDtail对象。返回过程中，会与UserDetail中的password和username进行比对,不同则报错。

    注意：如果要测试，需要往用户表中写入用户数据，并且如果你想让用户的密码是明文存储，需要在密码前加{noop}。例如 : 数据库中,username:sg, password: {noop}1234

    这样登陆的时候就可以用sg作为用户名，1234作为密码来登陆了。

    2.5.2 密码加密存储

    在实际中项目中，我一般不会明文存储，而是采用PasswordEncoder加密的方式;

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

    我们只需要使用把BCryptPasswordEncoder对象注入Spring容器中，SpringSecurity就会使用该PasswordEncoder来进行密码校验

    1. @Configuration
    2. public class SecurityConfig extends WebSecurityConfigurerAdapter {
    3.  
    4.  
    5.     @Bean
    6.     public PasswordEncoder passwordEncoder(){
    7.         return new BCryptPasswordEncoder();
    8.     }
    9.  
    10. }

    2.5.3 自定义登录接口

    • 接下我们需要自定义登陆接口，然后让SpringSecurity对这个接口放行,让用户访问这个接口的时候不用登录也能访问。
    • 在接口中我们通过AuthenticationManager的authenticate方法来进行用户认证,所以需要在SecurityConfig中配置把AuthenticationManager注入容器。
    • 认证成功的话要生成一个jwt，放入响应中返回。并且为了让用户下回请求时能通过jwt识别出具体的是哪个用户，我们需要把用户信息存入redis，可以把用户id作为key。

    UserController 

    1. @RestController
    2. @RequestMapping("/user")
    3. public class UserController {
    4.  
    5.     @Autowired
    6.     private UserService userService;
    7.  
    8.     @PostMapping("/login")
    9.     Result login(@RequestBody User user){
    10.      return   userService.login(user);
    11.     }
    12.  
    13. }
    1. public interface UserService extends IService {
    2.     Result login(User user);
    3. }
    1. @Service
    2. public class UserServiceImpl extends ServiceImpl implements UserService {
    3.  
    4.     @Autowired
    5.     private AuthenticationManager authenticationManager;
    6.  
    7.     @Autowired
    8.     private RedisTemplate redisTemplate;
    9.  
    10.  
    11.  
    12.     @Override
    13.     public Result login(User user) {
    14.         //  AuthenticationManager authenticationManager 进行认证
    15.         UsernamePasswordAuthenticationToken authenticationToken =
    16.                 new UsernamePasswordAuthenticationToken(user.getUserName(), user.getPassword());
    17.         Authentication authenticate = authenticationManager.authenticate(authenticationToken);
    18.         // 如果认证通过、给出对应提示
    19.         if(Objects.isNull(authenticate)){
    20.             throw new RuntimeException("登录失败");
    21.         }
    22.         // 认证通过使用userid生成jwt
    23.         UserDetailsImpl udi = (UserDetailsImpl) authenticate.getPrincipal();
    24.         String userId = udi.getUser().getId().toString();
    25.         String token = JwtUtil.createJWT(userId);
    26.         HashMap map = new HashMap<>();
    27.         map.put("token",token);
    28.         // 把完整用户信息存入redis
    29.         redisTemplate.opsForValue().set("login:" +userId,udi);
    30.        return Result.success(map,"登录成功");
    31.     }
    32.  
    33.  
    34. }

    SpringSecurityConfig

    1. @Configuration
    2. public class SecurityConfig extends WebSecurityConfigurerAdapter {
    3.  
    4.  
    5.     @Bean
    6.     public PasswordEncoder passwordEncoder(){
    7.         return new BCryptPasswordEncoder();
    8.     }
    9.  
    10.     @Override
    11.     protected void configure(HttpSecurity http) throws Exception {
    12.         http
    13.                 //关闭csrf
    14.                 .csrf().disable()
    15.                 //不通过Session获取SecurityContext
    16.                 .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
    17.                 .and()
    18.                 .authorizeRequests()
    19.                 // 对于登录接口 允许匿名访问
    20.                 .antMatchers("/user/login").anonymous()
    21.                 // 除上面外的所有请求全部需要鉴权认证
    22.                 .anyRequest().authenticated();
    23.     }
    24.  
    25.     @Bean
    26.     @Override
    27.     public AuthenticationManager authenticationManagerBean() throws Exception {
    28.         return super.authenticationManagerBean();
    29.     }
    30. }
    1. spring:
    2.   # mysql配置
    3.   datasource:
    4.     url: jdbc:mysql://localhost:3306/test?characterEncoding=utf-8&serverTimezone=UTC
    5.     username: root
    6.     password: 123456
    7.     driver-class-name: com.mysql.cj.jdbc.Driver
    8.  
    9.   # redis配置
    10.   redis:
    11.     # 默认0库
    12.     database: 0
    13.     #连接超时时间
    14.     timeout: 10000ms
    15.     port: 6379
    16.     host: 192.168.213.136
    17.     lettuce:
    18.       pool:
    19.         # 设置最大连接数
    20.         max-active: 1024
    21.         # 最大阻塞时间
    22.         max-wait: 10000ms
    23.         # 最大空间连接,默认8
    24.         max-idle: 200
    25.         # 最小空间连接,默认5
    26.         min-idle: 5
    27. server:
    28.   port: 8888

     2.5.4 自定义jwt过滤器

    以下跨域设置,postman测试是完全没有问题的。但是，我们是为了前后端分离，会有问题。

    当登录之后，携带token的请求头，被jwt过滤器捕获解析之后，获得userId,用userId将从redis拿出UserDetailImpl封装到 SecurityContextHolder.getContext()中,被SpringSecurity过滤链捕获到，证明没有问题，因此放行访问资源。

    1. /**
    2.  * jwt过滤器
    3.  *
    4.  * @author: qhx20040819
    5.  * @date: 2023-09-09 21:27
    6.  **/
    7. @Component
    8. public class JwtFilter extends OncePerRequestFilter {
    9.  
    10.  
    11.     @Autowired
    12.     private RedisTemplate redisTemplate;
    13.  
    14.     @Override
    15.     protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
    16.         // 设置跨域
    17.         response.setHeader("Access-Control-Allow-Origin", request.getHeader("Origin")); // 修改携带cookie,PS
    18.         response.setHeader("Access-Control-Allow-Methods", "GET,POST,DELETE,PUT");
    19.         response.setHeader("Access-Control-Allow-Headers", "Authorization,content-type"); // PS
    20.         // 预检请求缓存时间（秒），即在这个时间内相同的预检请求不再发送，直接使用缓存结果。
    21.         response.setHeader("Access-Control-Max-Age", "3600");
    22.  
    23.         //获取token
    24.         String authorization = request.getHeader("Authorization");
    25.         if(StringUtils.isEmpty(authorization)){
    26.             filterChain.doFilter(request,response);
    27.             return;
    28.         }
    29.         String token = authorization.substring(6);
    30.         //解析token
    31.         String userid;
    32.         try {
    33.             Claims claims = JwtUtil.parseJWT(token);
    34.             userid = claims.getSubject();
    35.         } catch (Exception e) {
    36.             e.printStackTrace();
    37.             throw new RuntimeException("token非法");
    38.         }
    39.         //从redis中获取用户信息
    40.         String redisKey = "login:" + userid;
    41.         UserDetailsImpl  udi = (UserDetailsImpl) redisTemplate.opsForValue().get(redisKey);
    42.  
    43.         if(Objects.isNull(udi)){
    44.             throw new RuntimeException("用户未登录");
    45.         }
    46.         //存入SecurityContextHolder
    47.         //获取权限信息封装到Authentication中
    48.         UsernamePasswordAuthenticationToken authenticationToken =           // 现在权限字段是null
    49.                 new UsernamePasswordAuthenticationToken(udi,null,udi.getAuthorities());
    50.         SecurityContextHolder.getContext().setAuthentication(authenticationToken);
    51.         //放行
    52.         filterChain.doFilter(request, response);
    53.     }
    54. }

    3.授权

    3.1 授权流程

    在SpringSecurity中，会使用默认FiterSecuritInterceptor来进行权限校验，而它又是从SpringSecurityContex中Authentication，来获取其中的权限信息。判断当前用户是否拥有访问当前资源权限。

    因此，我们只需要将权限信息存储到Authentication中即可，设置资源的访问权限。

    3.2 问题解决

    3.2.1 相关配置

    用注解开启相关配置。

    @EnableGlobalMethodSecurity(prePostEnabled = true)

     在相应的资源上开启访问权限管控。

    1.   @RequestMapping("/hello")
    2.     @PreAuthorize("hasAnyAuthority('test')") // 限制访问权限字段
    3.     public String hello(){
    4.         return "hello";
    5.     }

    3.2.2 封装权限字段

    我们之前UserDetailServiceImpl中loadUserByUsername()中，返回的UserDetailImpl对象，我们之前创建时，并没传入权限字段，我们先自定义权限字段模拟用户权限列表。

    1. @Service
    2. public class UserDetailServiceImpl extends ServiceImpl< UserMapper, User> implements UserDetailsService {
    3.  
    4.     @Override
    5.     public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
    6.         // 用用户名查询对应User
    7.         LambdaQueryWrapper queryWrapper = new LambdaQueryWrapper<>();
    8.         queryWrapper.eq(User::getUserName,username);
    9.         // 判断是否空
    10.         User user = this.getOne(queryWrapper);
    11.         if(user == null){
    12.             throw new RuntimeException("用户名或密码错误");
    13.         }
    14.  
    15.         List authlist = new ArrayList<>(); // 暂且封装这样权限字段
    16.         authlist.add("test");
    17.         authlist.add("test0");
    18.  
    19.         return new UserDetailsImpl(user,authlist);
    20.     }
    21. }

    相应的UserDetailImpl中也需要修改，seucrity过滤器链是从getAuthorities()方法中来获取用户权限字段的。

    1. @Data
    2. @NoArgsConstructor
    3. @AllArgsConstructor
    4. public class UserDetailsImpl implements UserDetails {
    5.  
    6.     private User user;
    7.  
    8.     private List authList;
    9.  
    10.     @JSONField(serialize = false)
    11.     private List authorities;  // SimpleGrantedAuthority对象不支持序列化，无法存入redis
    12.  
    13.  
    14.     public UserDetailsImpl(User user, List authList) { // 将对应的权限字符串列表传入
    15.         this.user = user;
    16.         this.authList = authList;
    17.     }
    18.  
    19.  
    20.  
    21.     @Override
    22.     public Collectionextends GrantedAuthority> getAuthorities() {
    23.         // 初始化之后，我们后续其他拦截器，也会获取; 没必要多次初始化；
    24.         if(authorities != null){
    25.             return authorities;
    26.         }else{
    27.             authorities = new ArrayList<>();
    28.         }
    29.  
    30.         // 第一次登录，封装UserDetails对象,初始化权限列表
    31.         for (String auth : authList) {
    32.             SimpleGrantedAuthority simpleGrantedAuthority = new SimpleGrantedAuthority(auth);
    33.             authorities.add(simpleGrantedAuthority); // 对，默认是个空的
    34.         }
    35.         return authorities;
    36.  
    37.     }
    38.  
    39.     @Override
    40.     public String getPassword() {
    41.         return user.getPassword();
    42.     }
    43.  
    44.     @Override
    45.     public String getUsername() {
    46.         return user.getUserName();
    47.     }
    48.  
    49.     @Override
    50.     public boolean isAccountNonExpired() {
    51.         return true;
    52.     }
    53.  
    54.     @Override
    55.     public boolean isAccountNonLocked() {
    56.         return true;
    57.     }
    58.  
    59.     @Override
    60.     public boolean isCredentialsNonExpired() {
    61.         return true;
    62.     }
    63.  
    64.     @Override
    65.     public boolean isEnabled() {
    66.         return true;
    67.     }
    68. }

    这是拿着携带token去请求，能访问成功。

     3.2.3 数据库查询权限字段

    就是我们真实的权限应该封装在数据库中。

    3.2.3.1 RBAC权限模型

    一个用户，可以对应多个角色；一个角色，可以对应多个用户；

    一个角色，可以拥有多个权限字段； 一个权限字段，可以被多个角色所拥有;

     3.2.3.2 准备工作
    1.  
    2.  
    3. USE `test`;
    4.  
    5. /*Table structure for table `menu` */
    6.  
    7. DROP TABLE IF EXISTS `menu`;
    8.  
    9. CREATE TABLE `menu` (
    10.   `id` bigint(20) NOT NULL AUTO_INCREMENT,
    11.   `menu_name` varchar(64) NOT NULL DEFAULT 'NULL' COMMENT '菜单名',
    12.   `path` varchar(200) DEFAULT NULL COMMENT '路由地址',
    13.   `component` varchar(255) DEFAULT NULL COMMENT '组件路径',
    14.   `visible` char(1) DEFAULT '0' COMMENT '菜单状态（0显示 1隐藏）',
    15.   `status` char(1) DEFAULT '0' COMMENT '菜单状态（0正常 1停用）',
    16.   `perms` varchar(100) DEFAULT NULL COMMENT '权限标识',
    17.   `icon` varchar(100) DEFAULT '#' COMMENT '菜单图标',
    18.   `create_by` bigint(20) DEFAULT NULL,
    19.   `create_time` datetime DEFAULT NULL,
    20.   `update_by` bigint(20) DEFAULT NULL,
    21.   `update_time` datetime DEFAULT NULL,
    22.   `del_flag` int(11) DEFAULT '0' COMMENT '是否删除（0未删除 1已删除）',
    23.   `remark` varchar(500) DEFAULT NULL COMMENT '备注',
    24.   PRIMARY KEY (`id`)
    25. ) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb4 COMMENT='菜单表';
    26.  
    27. /*Table structure for table `role` */
    28.  
    29. DROP TABLE IF EXISTS `role`;
    30.  
    31. CREATE TABLE `role` (
    32.   `id` bigint(20) NOT NULL AUTO_INCREMENT,
    33.   `name` varchar(128) DEFAULT NULL,
    34.   `role_key` varchar(100) DEFAULT NULL COMMENT '角色权限字符串',
    35.   `status` char(1) DEFAULT '0' COMMENT '角色状态（0正常 1停用）',
    36.   `del_flag` int(1) DEFAULT '0' COMMENT 'del_flag',
    37.   `create_by` bigint(200) DEFAULT NULL,
    38.   `create_time` datetime DEFAULT NULL,
    39.   `update_by` bigint(200) DEFAULT NULL,
    40.   `update_time` datetime DEFAULT NULL,
    41.   `remark` varchar(500) DEFAULT NULL COMMENT '备注',
    42.   PRIMARY KEY (`id`)
    43. ) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8mb4 COMMENT='角色表';
    44.  
    45. /*Table structure for table `role_menu` */
    46.  
    47. DROP TABLE IF EXISTS `role_menu`;
    48.  
    49. CREATE TABLE `role_menu` (
    50.   `role_id` bigint(200) NOT NULL AUTO_INCREMENT COMMENT '角色ID',
    51.   `menu_id` bigint(200) NOT NULL DEFAULT '0' COMMENT '菜单id',
    52.   PRIMARY KEY (`role_id`,`menu_id`)
    53. ) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb4;
    54.  
    55. /*Table structure for table `user` */
    56.  
    57. DROP TABLE IF EXISTS `user`;
    58.  
    59. CREATE TABLE `user` (
    60.   `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
    61.   `user_name` varchar(64) NOT NULL DEFAULT 'NULL' COMMENT '用户名',
    62.   `nick_name` varchar(64) NOT NULL DEFAULT 'NULL' COMMENT '昵称',
    63.   `password` varchar(64) NOT NULL DEFAULT 'NULL' COMMENT '密码',
    64.   `status` char(1) DEFAULT '0' COMMENT '账号状态（0正常 1停用）',
    65.   `email` varchar(64) DEFAULT NULL COMMENT '邮箱',
    66.   `phonenumber` varchar(32) DEFAULT NULL COMMENT '手机号',
    67.   `sex` char(1) DEFAULT NULL COMMENT '用户性别（0男，1女，2未知）',
    68.   `avatar` varchar(128) DEFAULT NULL COMMENT '头像',
    69.   `user_type` char(1) NOT NULL DEFAULT '1' COMMENT '用户类型（0管理员，1普通用户）',
    70.   `create_by` bigint(20) DEFAULT NULL COMMENT '创建人的用户id',
    71.   `create_time` datetime DEFAULT NULL COMMENT '创建时间',
    72.   `update_by` bigint(20) DEFAULT NULL COMMENT '更新人',
    73.   `update_time` datetime DEFAULT NULL COMMENT '更新时间',
    74.   `del_flag` int(11) DEFAULT '0' COMMENT '删除标志（0代表未删除，1代表已删除）',
    75.   PRIMARY KEY (`id`)
    76. ) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8mb4 COMMENT='用户表';
    77.  
    78. /*Table structure for table `user_role` */
    79.  
    80. DROP TABLE IF EXISTS `user_role`;
    81.  
    82. CREATE TABLE `user_role` (
    83.   `user_id` bigint(200) NOT NULL AUTO_INCREMENT COMMENT '用户id',
    84.   `role_id` bigint(200) NOT NULL DEFAULT '0' COMMENT '角色id',
    85.   PRIMARY KEY (`user_id`,`role_id`)
    86. ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
    1. SELECT 
    2. 	DISTINCT m.`perms`
    3. FROM
    4. 	user_role ur
    5. 	LEFT JOIN `role` r ON ur.`role_id` = r.`id`
    6. 	LEFT JOIN `role_menu` rm ON ur.`role_id` = rm.`role_id`
    7. 	LEFT JOIN `menu` m ON m.`id` = rm.`menu_id`
    8. WHERE
    9. 	user_id = 2
    10. 	AND r.`status` = 0
    11. 	AND m.`status` = 0
    1. @TableName(value="menu")
    2. @Data
    3. @AllArgsConstructor
    4. @NoArgsConstructor
    5. @JsonInclude(JsonInclude.Include.NON_NULL)
    6. public class Menu implements Serializable {
    7.     private static final long serialVersionUID = -54979041104113736L;
    8.  
    9.     @TableId
    10.     private Long id;
    11.     /**
    12.      * 菜单名
    13.      */
    14.     private String menuName;
    15.     /**
    16.      * 路由地址
    17.      */
    18.     private String path;
    19.     /**
    20.      * 组件路径
    21.      */
    22.     private String component;
    23.     /**
    24.      * 菜单状态（0显示 1隐藏）
    25.      */
    26.     private String visible;
    27.     /**
    28.      * 菜单状态（0正常 1停用）
    29.      */
    30.     private String status;
    31.     /**
    32.      * 权限标识
    33.      */
    34.     private String perms;
    35.     /**
    36.      * 菜单图标
    37.      */
    38.     private String icon;
    39.  
    40.     private Long createBy;
    41.  
    42.     private Date createTime;
    43.  
    44.     private Long updateBy;
    45.  
    46.     private Date updateTime;
    47.     /**
    48.      * 是否删除（0未删除 1已删除）
    49.      */
    50.     private Integer delFlag;
    51.     /**
    52.      * 备注
    53.      */
    54.     private String remark;
    55. }
    3.2.3.3 代码实现
    1. @Mapper
    2. public interface MenuMapper extends BaseMapper {
    3.  
    4.      List selectPermsByUserId(Long userId);
    5. }
    1. "1.0" encoding="UTF-8"?>
    2. mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    3. <mapper namespace="com.qhx.springsecuritydemo.mapper.MenuMapper">
    4.     <select id="selectPermsByUserId" resultType="java.lang.String">
    5.         SELECT
    6.             m.perms
    7.         FROM
    8.             `user_role` as ur
    9.                 LEFT JOIN `role` as r on ur.role_id = r.id
    10.                 LEFT JOIN `role_menu` as rm on ur.role_id = rm.role_id
    11.                 LEFT JOIN `menu` as m on rm.menu_id = m.id
    12.         WHERE
    13.             ur.`user_id` = #{userId} AND r.`status`=0 and m.`status`=0;
    14.     select>
    15.  
    16.  
    17. mapper>

     修改UserDetailServiceImpl。

    1. @Service
    2. public class UserDetailServiceImpl extends ServiceImpl< UserMapper, User> implements UserDetailsService {
    3.  
    4.  @Autowired
    5.     private MenuMapper menuMapper;
    6.  
    7.     @Override
    8.     public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
    9.         // 用用户名查询对应User
    10.         LambdaQueryWrapper queryWrapper = new LambdaQueryWrapper<>();
    11.         queryWrapper.eq(User::getUserName,username);
    12.         // 判断是否空
    13.         User user = this.getOne(queryWrapper);
    14.         if(user == null){
    15.             throw new RuntimeException("用户名或密码错误");
    16.         }
    17.  
    18.         List authList = menuMapper.selectPermsByUserId(user.getId());
    19.  
    20.         return new UserDetailsImpl(user,authlist);
    21.     }
    22. }

    4.异常处理

    4.1 SpringSecurity异常处理

    我们发现，就算我们登录输入的用户名和错误的：

    1.SpringSecurity没有抛出异常 2.也有没有相关响应提示信息；

    我是并不希望这样，因此要添加自定义异常处理器：

    1. /**
    2.  * 授权异常处理器
    3.  **/
    4. @Component
    5. public class AccessDeniedHandlerImpl implements AccessDeniedHandler {
    6.     @Override
    7.     public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) throws IOException, ServletException {
    8.  
    9.         Result result = Result.error("权限不足", 403);
    10.         String jsonResult = JSON.toJSONString(result);
    11.  
    12.         response.setStatus(200);
    13.         response.setContentType("application/json");
    14.         response.getWriter().write(jsonResult);
    15.  
    16.     }
    17. }
    1. /**
    2.  * 认证异常处理器
    3.  **/
    4. @Component
    5. public class AuthenticationEntryPointImpl  implements AuthenticationEntryPoint {
    6.  
    7.     @Override
    8.     public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
    9.  
    10.         Result result = Result.error("您认证错误/请检查你的用户名或密码是否正确", 401);
    11.         String jsonResult = JSON.toJSONString(result);
    12.  
    13.         response.setStatus(200);
    14.         response.setContentType("application/json");
    15.         response.getWriter().write(jsonResult);
    16.  
    17.     }
    18. }

     在SecurityConfig配置中引入

    1. @Configuration
    2. @EnableGlobalMethodSecurity(prePostEnabled = true)
    3. public class SecurityConfig extends WebSecurityConfigurerAdapter {
    4.  
    5.     @Autowired
    6.     private JwtFilter jwtFilter;
    7.  
    8.  
    9.     @Bean
    10.     public PasswordEncoder passwordEncoder(){
    11.         return new BCryptPasswordEncoder();
    12.     }
    13.  
    14.     @Autowired
    15.     private AccessDeniedHandlerImpl accessDeniedHandler;
    16.     @Autowired
    17.     private AuthenticationEntryPoint authenticationEntryPoint;
    18.  
    19.     @Override
    20.     protected void configure(HttpSecurity http) throws Exception {
    21.         http
    22.                 //关闭csrf
    23.                 .csrf().disable()
    24.                 //不通过Session获取SecurityContext
    25.                 .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
    26.                 .and()
    27.                 .authorizeRequests()
    28.                 // 对于登录接口 允许匿名访问
    29.                 .antMatchers("/user/login").anonymous()
    30.                 // 除上面外的所有请求全部需要鉴权认证
    31.                 .anyRequest().authenticated();
    32.  
    33.         // 添加自定义token过滤器到链中
    34.         http.addFilterBefore(jwtFilter, UsernamePasswordAuthenticationFilter.class);
    35.  
    36.         // 添加自定义异常处理器
    37.         http.exceptionHandling().accessDeniedHandler(accessDeniedHandler)
    38.                 .authenticationEntryPoint(authenticationEntryPoint);
    39.     }
    40.  
    41.     @Bean
    42.     @Override
    43.     public AuthenticationManager authenticationManagerBean() throws Exception {
    44.         return super.authenticationManagerBean();
    45.     }
    46. }

    4.2 自定义异常处理

    上面除了我们SpringSecurity异常，那么还有一些其他异常，我们不希望每次捕获，并手动抛出，因此可以转化为自定义异常，用SpringBoot的全局异常处理器捕获并且抛出；

    5. 跨域

    我们现在是用postman测试，但是未来项目涉及到前后端分离项目交互的，都伴随着跨域的问题。

    后端能接受到前端原生request对象,response对象,都涉及到跨域的问题。

    SpringSecurity解决跨域

    SringMvc解决跨域

    1. @Configuration
    2. public class CorsConfig implements WebMvcConfigurer {
    3.  
    4.     @Override
    5.     public void addCorsMappings(CorsRegistry registry) {
    6.       // 设置允许跨域的路径
    7.         registry.addMapping("/**")
    8.                 // 设置允许跨域请求的域名
    9.                 .allowedOriginPatterns("*")
    10.                 // 是否允许cookie
    11.                 .allowCredentials(true)
    12.                 // 设置允许的请求方式
    13.                 .allowedMethods("GET", "POST", "DELETE", "PUT")
    14.                 // 设置允许的header属性
    15.                 .allowedHeaders("*")
    16.                 // 跨域允许时间
    17.                 .maxAge(3600);
    18.     }
    19. }

    自定义jwt过滤器解决跨域 

  • 相关阅读:
    tf.data.Dataset多个输入无法正确解包
    znai： 使用Markdown编写Java文档系统
    MS SQL Server 删除重复行数据
    2022牛客蔚来杯第一场
    华为再次入选2022年Gartner® SIEM魔力象限
    职场：“工作”的理解
    工欲善其事，必先利其器-使用vscode搭建go语言开发环境
    艾奇软件怎么下载安装?
    哈希函数2：用于哈希表的存储和扩容
    SpringCloud——负载均衡——Ribbon
  • 原文地址：https://blog.csdn.net/Qhx20040819/article/details/132888748