• Mall脚手架总结（一）——SpringSecurity实现鉴权认证

    前言

            在结束理论知识的学习后，荔枝开始项目学习，这个系列文章将围绕荔枝学习mall项目过程中总结的知识点来梳理。本篇文章主要涉及如何整合Spring Security和JWT实现鉴权认证的功能！希望能帮助到一起学习mall项目的小伙伴~~~

    文章目录

    前言

    一、JWT和Spring Security的整合知识点

    1.1 JWTtoken的生成流程

    1.1.1 什么是CSRF：

    1.1.2 为什么需要JWT 

    1.1.3 JWTtoken的生成流程 

    1.2 UserDetails接口

    1.3 CollUtil类

    1.4 PasswordEncoder接口

    1.5 为什么要实现Serializable接口

    总结

    一、JWT和Spring Security的整合知识点

    这部分会根据mall_learning中的后台用户管理实现类来做系统的梳理学习，目的主要是弄清楚JWT token的生成流程以及相应的类的使用。首先我们来看一下该实现类的demo:

    1. package com.crj.crj_mall_learning.service.impl;
    2.  
    3. import cn.hutool.core.collection.CollUtil;
    4. import com.crj.crj_mall_learning.utils.JwtTokenUtil;
    5. import com.crj.crj_mall_learning.domain.AdminUserDetails;
    6. import com.crj.crj_mall_learning.domain.UmsResource;
    7. import com.crj.crj_mall_learning.service.UmsAdminService;
    8. import lombok.extern.slf4j.Slf4j;
    9. import org.springframework.beans.factory.annotation.Autowired;
    10. import org.springframework.security.authentication.BadCredentialsException;
    11. import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
    12. import org.springframework.security.core.AuthenticationException;
    13. import org.springframework.security.core.context.SecurityContextHolder;
    14. import org.springframework.security.core.userdetails.UserDetails;
    15. import org.springframework.security.crypto.password.PasswordEncoder;
    16. import org.springframework.stereotype.Service;
    17.  
    18. import javax.annotation.PostConstruct;
    19. import java.util.ArrayList;
    20. import java.util.List;
    21. import java.util.stream.Collectors;
    22.  
    23. /**
    24.  * @auther lzddl
    25.  * @description 后台用户管理Service实现类
    26.  */
    27. @Slf4j
    28. @Service
    29. public class UmsAdminServiceImpl implements UmsAdminService {
    30.     /**
    31.      * 存放默认用户信息
    32.      */
    33.     private List adminUserDetailsList = new ArrayList<>();
    34.     /**
    35.      * 存放默认资源信息
    36.      */
    37.     private List resourceList = new ArrayList<>();
    38.     @Autowired
    39.     private JwtTokenUtil jwtTokenUtil;
    40.  
    41.     //spring security中的一种对密码的编译方法
    42.     @Autowired
    43.     private PasswordEncoder passwordEncoder;
    44.  
    45.     // Spring IOC容器的初始化中就会执行该init方法
    46.     @PostConstruct
    47.     private void init(){
    48.         adminUserDetailsList.add(AdminUserDetails.builder()
    49.                 .username("admin")
    50.                 .password(passwordEncoder.encode("123456"))
    51.                 .authorityList(CollUtil.toList("brand:create","brand:update","brand:delete","brand:list","brand:listAll"))
    52.                 .build());
    53.         adminUserDetailsList.add(AdminUserDetails.builder()
    54.                 .username("lzddl")
    55.                 .password(passwordEncoder.encode("123456"))
    56.                 .authorityList(CollUtil.toList("brand:listAll"))
    57.                 .build());
    58.         resourceList.add(UmsResource.builder()
    59.                 .id(1L)
    60.                 .name("brand:create")
    61.                 .url("/brand/create")
    62.                 .build());
    63.         resourceList.add(UmsResource.builder()
    64.                 .id(2L)
    65.                 .name("brand:update")
    66.                 .url("/brand/update/**")
    67.                 .build());
    68.         resourceList.add(UmsResource.builder()
    69.                 .id(3L)
    70.                 .name("brand:delete")
    71.                 .url("/brand/delete/**")
    72.                 .build());
    73.         resourceList.add(UmsResource.builder()
    74.                 .id(4L)
    75.                 .name("brand:list")
    76.                 .url("/brand/list")
    77.                 .build());
    78.         resourceList.add(UmsResource.builder()
    79.                 .id(5L)
    80.                 .name("brand:listAll")
    81.                 .url("/brand/listAll")
    82.                 .build());
    83.     }
    84.     @Override
    85.     public AdminUserDetails getAdminByUsername(String username) {
    86.         //在存放默认用户对象的集合中来查找指定的用户信息，如果有就返回符合条件的第一条数据；
    87.         // 如果没有就会返回一个null
    88.         List findList = adminUserDetailsList.stream().filter(item -> item.getUsername().equals(username)).collect(Collectors.toList());
    89.         if(CollUtil.isNotEmpty(findList)){
    90.             return findList.get(0);
    91.         }
    92.         return null;
    93.     }
    94.  
    95.     @Override
    96.     public List getResourceList() {
    97.         return resourceList;
    98.     }
    99.  
    100.     @Override
    101.     public String login(String username, String password) {
    102.         String token = null;
    103.         try {
    104.             //这里的UserDetails是Spring Security中的一个接口，该接口实现仅仅存储用户的信息，后续会将该接口提供的用户信息封装到认证对象Authentication中去
    105.             UserDetails userDetails = getAdminByUsername(username);
    106.             if(userDetails==null){
    107.                 return token;
    108.             }
    109.             if (!passwordEncoder.matches(password, userDetails.getPassword())) {
    110.                 throw new BadCredentialsException("密码不正确");
    111.             }
    112.             UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
    113.             SecurityContextHolder.getContext().setAuthentication(authentication);
    114.             token = jwtTokenUtil.generateToken(userDetails);
    115.         } catch (AuthenticationException e) {
    116.             log.warn("登录异常:{}", e.getMessage());
    117.         }
    118.         return token;
    119.     }
    120. }

    1.1 JWTtoken的生成流程

            在正式了解整个认证鉴权的流程之前，我们首先需要弄清楚为什么需要使用JWT！在以往的前后端半分离的项目中我们经常使用会话来实现token值的缓存，由于前后端没有涉及过多的跨域操作，因此也就不会采用JWT来保证跨域请求的安全。那为什么跨域请求中需要采用JWT来认证授权呢？

    1.1.1 什么是CSRF：

    跨站请求伪造（Cross-site request forgery），也被称为 one-click attack 或者session riding，通常缩写为 CSRF 或者 XSRF，是一种挟制用户在当前已登录的Web应用程序上执行非本意的操作的攻击方法。

    1.1.2 为什么需要JWT 

            JWT的token值主要是由三部分组成的：header.payload.signature。该token是用户访问正规网站会拿到的并缓存在用户浏览器的localStorage本地缓存里面。header里面是加密算法的信息，里面放type=jwt，alg(加密算法)=HS512；payload里面存放的是用户名、token的创建时间和过期时间；signature通过使用head中定义的加密算法和后端已经设置好的加密密钥，将head+payload这两部分加密生成一个signature签名，最终拼接所有密钥数据加起来生成一个JWT令牌也就是token。由于JWT的token存在用户浏览器的localStorage本地缓存里面，下次这个用户发送请求给网站的后台时，就会把这个JWT发给正规网站的后台进行安全性校验，而不会向之前那种模式那样使用到cookie。这就可以避免用户在浏览网站的时候被恶意链接获取到cookies，从而绕开网站的安全性校验而导致用户的信息被窃取或造成其它损失。

    1.1.3 JWTtoken的生成流程 

    首先用户通过后端提供的校验授权的接口来执行登录的操作，这部分的功能主要有两个：校验和授权。首先当用户第一次登录的时候会根据账号和密码来获得JWT生成的token，在上面的介绍中我们已经知晓该token值的功能。

    首次登录

            首先用户根据账号和密码进行校验，在Spring Security中我们可以选择在初始化接口实现类的时候就将符合条件的用户信息加载在一个UserDetails对象构成的列表中，并根据默认要求对密码采用passwordEncoder类方法进行encode。因此我们在校验密码的正误的时候也需要采用该类方法对用户输入的密码进行比较。完成身份校验后才会开始生成token，首先需要将用户信息对象UserDetails和用户的访问权限列表交给UsernamePasswordAuthenticationToken对象的构造方法构造一个UsernamePasswordAuthenticationToken对象，之后会交给一个SecurityContextHolder来管理该用户的信息，最后才会调用你自定义的token工具类生成JWT token值。

    1. //用户校验完成，获取一个UsernamePasswordAuthenticationToken对象
    2. UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
    3. //将UsernamePasswordAuthenticationToken对象交给SecurityContextHolder，表示用户已经通过身份验证，这一步是为了让SpringSecurity知晓用户对象是谁及其权限，并判断该用户是否有相应的访问资源的权限
    4. SecurityContextHolder.getContext().setAuthentication(authentication);
    5. //获取token
    6. token = jwtTokenUtil.generateToken(userDetails);
    token生成的具体流程

            在下面的demo中使用了一个map对象来设置主题信息，并在重载方法中通过setClaims方法来实现主题信息的声明，后续可以根据UserDetails对象的getSubject()方法来获得用户名。这个UserDetails对象的获取其实就是根据用户输入的用户名在已经缓存的用户信息List中找到对应的用户信息对象。

    1. /**
    2.      * 根据负载生成JWT的token
    3.      */
    4.     private String generateToken(Map claims) {
    5.         return Jwts.builder()
    6.                 .setClaims(claims) // 设置JWT的声明（claims），即要在JWT中存储的信息。这个参数是一个Map，表示JWT的payload部分。
    7.                 .setExpiration(generateExpirationDate()) //过期时间
    8.                 .signWith(SignatureAlgorithm.HS512, secret) //根据后台设置的密钥来生成签名
    9.                 .compact();   //构建并返回最终的JWT字符串
    10.     }
    11. /**
    12.      * 根据用户信息生成token
    13.      */
    14.     public String generateToken(UserDetails userDetails) {
    15.         Map claims = new HashMap<>();
    16.         claims.put(CLAIM_KEY_USERNAME, userDetails.getUsername());
    17.         claims.put(CLAIM_KEY_CREATED, new Date());
    18.         return generateToken(claims);
    19.     }

            拿到token后用户每次调用接口都在http的headert中添加一个叫Authorization的头，值为WT的token，后台程序通过对Authorization头中信息的解码及数字签名校验来获取其中的用户信息，从而实现认证和授权。 

    授权

            在上文中我们已经弄清楚了整个JWT的token令牌生成的流程了，接下来我们需要搞清楚如何整合Spring Security完成用户权限的授权。首先同样的我们事先需要获取到所有用户的权限以及信息，这部分内容并不是现在我们的重点。前面我们知道我们需要把用户信息存在一个个UserDetails对象，当用户成功登录时，UserDetails对象会被封装成Authentication对象，并且设置到Spring Security的安全上下文中（通常是SecurityContextHolder），以便在后续的请求中进行鉴权和授权。首先我们需要弄清楚Spring Security的配置类：

    1. /**
    2.  * @auther lzddl
    3.  * @description SpringSecurity的配置
    4.  */
    5. @Configuration
    6. @EnableWebSecurity
    7. @EnableGlobalMethodSecurity(prePostEnabled=true)
    8. public class SecurityConfig {
    9.     @Autowired
    10.     private RestfulAccessDeniedHandler restfulAccessDeniedHandler;
    11.     @Autowired
    12.     private RestAuthenticationEntryPoint restAuthenticationEntryPoint;
    13.     @Autowired
    14.     private IgnoreUrlsConfig ignoreUrlsConfig;
    15.  
    16.     @Bean
    17.     SecurityFilterChain filterChain(HttpSecurity httpSecurity) throws Exception {
    18.         ExpressionUrlAuthorizationConfigurer.ExpressionInterceptUrlRegistry registry = httpSecurity
    19.                 .authorizeRequests();
    20.         //不需要保护的资源路径允许访问
    21.         for (String url : ignoreUrlsConfig.getUrls()) {
    22.             registry.antMatchers(url).permitAll();
    23.         }
    24.         //允许跨域请求的OPTIONS请求，这是因为在跨域访问的正式请求发送前会发送一个Option请求，我们要开启跨域访问就必须允许所有的option请求
    25.         registry.antMatchers(HttpMethod.OPTIONS)
    26.                 .permitAll();
    27.         httpSecurity.csrf()// 由于使用的是JWT，我们这里不需要csrf
    28.                 .disable()
    29.                 .sessionManagement()// 基于token，所以不需要session，下面设置session为无状态的
    30.                 .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
    31.                 .and()
    32.                 .authorizeRequests()
    33.                 .anyRequest()// 除上面外的所有请求全部需要鉴权认证
    34.                 .authenticated();
    35.         // 禁用缓存
    36.         httpSecurity.headers().cacheControl();
    37.         // 添加JWT filter
    38.         httpSecurity.addFilterBefore(jwtAuthenticationTokenFilter(), UsernamePasswordAuthenticationFilter.class);
    39.         //添加自定义未授权和未登录结果返回
    40.         httpSecurity.exceptionHandling()
    41.                 .accessDeniedHandler(restfulAccessDeniedHandler)
    42.                 .authenticationEntryPoint(restAuthenticationEntryPoint);
    43.         return httpSecurity.build();
    44.     }
    45.  
    46.     @Bean
    47.     public PasswordEncoder passwordEncoder() {
    48.         return new BCryptPasswordEncoder();
    49.     }
    50.  
    51.     @Bean
    52.     public JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter(){
    53.         return new JwtAuthenticationTokenFilter();
    54.     }
    55.  
    56. }

            我们需要使用SecurityFilterChain来配置相关的操作，首先我们需要获取到httpSecurity对象，然后配置相应的访问路径白名单、允许跨域的Option请求、禁用csrf和session、开启除白名单外的鉴权认证功能、禁用缓存并添加JWT过滤器、添加自定义未授权和未登录结果返回。以上就是我们需要整合SpringSecurity的内容。其中鉴权部分我们需要注意的是JwtAuthenticationTokenFilter 部分，因为我们在配置类中开启了将filter放置在登录验证的功能前，因此这个功能其实就是为我们提供一个可以通过token记住用户态的功能。

    1. /**
    2.  * @auther lzddl
    3.  * @description JWT登录授权过滤器
    4.  */
    5. public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {
    6.     private static final Logger LOGGER = LoggerFactory.getLogger(JwtAuthenticationTokenFilter.class);
    7.  
    8.     @Autowired
    9.     private UserDetailsService userDetailsService;
    10.  
    11.     @Autowired
    12.     private JwtTokenUtil jwtTokenUtil;
    13.     @Value("${jwt.tokenHeader}")
    14.     private String tokenHeader;
    15.     @Value("${jwt.tokenHead}")
    16.     private String tokenHead;
    17.  
    18.     @Override
    19.     protected void doFilterInternal(HttpServletRequest request,
    20.                                     HttpServletResponse response,
    21.                                     FilterChain chain) throws ServletException, IOException {
    22.         String authHeader = request.getHeader(this.tokenHeader);
    23.         if (authHeader != null && authHeader.startsWith(this.tokenHead)) {
    24. //            获取token
    25.             String authToken = authHeader.substring(this.tokenHead.length());// The part after "Bearer "
    26. //            根据token获取用户名
    27.             String username = jwtTokenUtil.getUserNameFromToken(authToken);
    28.             LOGGER.info("checking username:{}", username);
    29.             //若有，则获取用户信息并创建authentication对象
    30.             if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
    31.                 UserDetails userDetails = this.userDetailsService.loadUserByUsername(username);
    32.                 if (jwtTokenUtil.validateToken(authToken, userDetails)) {
    33.                     UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
    34.                     authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
    35.                     LOGGER.info("authenticated user:{}", username);
    36.                     SecurityContextHolder.getContext().setAuthentication(authentication);
    37.                 }
    38.             }
    39.         }
    40.         chain.doFilter(request, response);
    41.     }
    42. }

    真正的授权其实在用户信息对象的加载过程中就完成了！ 

    当然了接口也需要使用@PreAuthorize注解来定义接口需要的权限，在配置类中我们还要@EnableGlobalMethodSecurity(prePostEnabled=true)注解来开启方法级的安全性！

    1.2 UserDetails接口

            该接口和UsernamePasswordAuthenticationToken类其实都是Spring Security中core包下管理。该接口定义了一个用户信息管理的api，要想使用该接口，我们需要自定义实现一个实现类在Spring Security中按照我们自定义的来动态权限配置列表，这里荔枝将其命名为AdminUserDetails类。

    1. /**
    2.  * @auther lzddl
    3.  * @description SpringSecurity用户信息封装类
    4.  */
    5. @Data
    6. @EqualsAndHashCode(callSuper = false)
    7. @Builder
    8. public class AdminUserDetails implements UserDetails {
    9.     private String username;
    10.     private String password;
    11.     private List authorityList;
    12.     @Override
    13.     public Collectionextends GrantedAuthority> getAuthorities() {
    14.         return this.authorityList.stream().map(SimpleGrantedAuthority::new).collect(Collectors.toList());
    15.     }
    16.  
    17.     @Override
    18.     public String getPassword() {
    19.         return this.password;
    20.     }
    21.  
    22.     @Override
    23.     public String getUsername() {
    24.         return this.username;
    25.     }
    26.     @Override
    27.     public boolean isAccountNonExpired() {
    28.         return true;
    29.     }
    30.     @Override
    31.     public boolean isAccountNonLocked() {
    32.         return true;
    33.     }
    34.     @Override
    35.     public boolean isCredentialsNonExpired() {
    36.         return true;
    37.     }
    38.     @Override
    39.     public boolean isEnabled() {
    40.         return true;
    41.     }
    42. }

            this.authorityList.stream()是将authorityList列表对象转化成一个Stream方便我们操作集合对象，map()定义了authorityList中的每个字符串对象到SimpleGrantedAuthority 对象的映射关系！SimpleGrantedAuthority 是Spring Security提供的一个实现了GrantedAuthority 接口的简单权限授予类，它表示用户的权限。最后就是借助collect将SimpleGrantedAuthority 对象收集在一个List对象中。也就是说，这个List包含了用户具有的权限，可以被Spring Security用于进行身份验证和授权。

    1.3 CollUtil类

    CollUtil类是Hutool插件中有关集合操作的工具类，里面封装了大量的操作集合数据的方法。

    中文文档：https://www.hutool.cn/docs/#/

    API手册：https://apidoc.gitee.com/dromara/hutool/

    1.4 PasswordEncoder接口

    该接口是一个密码解析器，一般用来加密。Spring Security 要求容器中必须有 PasswordEncoder 实例，因此我们在用户的信息中必须使用该解析器来对密码进行解析。

    1. //
    2. // Source code recreated from a .class file by IntelliJ IDEA
    3. // (powered by FernFlower decompiler)
    4. //
    5.  
    6. package org.springframework.security.crypto.password;
    7.  
    8. public interface PasswordEncoder {
    9.     String encode(CharSequence rawPassword);
    10.  
    11.     boolean matches(CharSequence rawPassword, String encodedPassword);
    12.  
    13.     default boolean upgradeEncoding(String encodedPassword) {
    14.         return false;
    15.     }
    16. }

     当然了该接口有很多实现类，我们可以创建该接口的实现类对象来指定加密的规则。但是如果我们使用的是@AutoWired注解的方式来将接口进行依赖注入，那么默认使用加密算法BCrypt。如果要修改加密算法，我们可以在配置类声明bean对象的时候修改：

    1. /**
    2.  * @auther lzddl
    3.  * @description SpringSecurity的配置
    4.  */
    5. @Configuration
    6. @EnableWebSecurity
    7. @EnableGlobalMethodSecurity(prePostEnabled=true)
    8. public class SecurityConfig {
    9.     @Autowired
    10.     private RestfulAccessDeniedHandler restfulAccessDeniedHandler;
    11.     @Autowired
    12.     private RestAuthenticationEntryPoint restAuthenticationEntryPoint;
    13.     @Autowired
    14.     private IgnoreUrlsConfig ignoreUrlsConfig;
    15.  
    16.     @Bean
    17.     SecurityFilterChain filterChain(HttpSecurity httpSecurity) throws Exception {
    18.         ......
    19.     }
    20.  
    21.     @Bean
    22.     public PasswordEncoder passwordEncoder() {
    23.         //使用MD4加密算法
    24.         return new Md4PasswordEncoder();
    25.     }
    26.  
    27.     @Bean
    28.     public JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter(){
    29.         return new JwtAuthenticationTokenFilter();
    30.     }
    31.  
    32. }

    1.5 为什么要实现Serializable接口

    说起Serializable接口，我们一定会提到的一个名词就是序列化，那么什么是序列化呢？

            Serializable接口是一个语义级别的一个接口，属于Java的io包中定义的接口，该接口没有定义任何的方法，只有实现了该接口的类才会有序列化和反序列化的状态。序列化和反序列化时Java在执行底层的IO读写操作，也就是实现对象数据和文件字节流转化的时候，告诉JVM的一种方式。实现了Serializable接口的类可以被ObjectOutputStream转换为字节流，同时也可以通过ObjectInputStream再将其解析为对象。

    可序列化是一个可以被继承的状态。同时为了保证不可序列化类的子类被序列化，子类必须有一个无参的构造方法

    serialVersionUID

            序列化运行时与每个可序列化类关联一个版本号，称为serialVersionUlD。在反序列化期间使用它来验证序列化对象的发送方和接收方已经为该对象加载了类与序列化兼容。类的一个类对象的serialVersionUlD与相应发送方的serialVersionUlD不同时会导致在反序列化时抛出异常InvalidclassException。所以我们在实现Serializable接口的时候，一般还会要去尽量显示地定义serialVersionUID就比如：

    private static final long serialVersionUID = 1L;

     记住一定要是final类型的！

    总结

            在正式开发项目中我个人认为可能鉴权这部分的功能会更加复杂一点，因为脚手架只是一个快速让我们接触上手的内容，因此这部分token拼接和请求头的生成其实是在Swagger中手动输入的哈哈哈。然后最重要的还是要弄清楚整个整合的流程，需要自定义的配置以及相应的鉴权流程，当然了JWTtoken的结构也是比较重要的！

    今朝已然成为过去，明日依然向往未来！我是荔枝，在技术成长之路上与您相伴~~~

    如果博文对您有帮助的话，可以给荔枝一键三连嘿，您的支持和鼓励是荔枝最大的动力！

    如果博文内容有误，也欢迎各位大佬在下方评论区批评指正！！！

  • 相关阅读:
    spring security auth2.0实现
    基于JSP的动漫论坛
    手搓哈希表、列表、队列，只为了用C语言快速求解华容道游戏，我不是大佬，只是一个游戏算法爱好者
    金融领域：怎么保持电力系统连续供应？
    web基础学习
    【完美世界】战王之殇特别篇定档，11月3日播，云曦受辱石昊杀红眼了
    Bean实例化的三级缓存
    Go 内存泄漏，pprof 够用了吗？
    基于hexo框架快速从0到1搭建个人博客----文章一键发布（五）
    python构造函数使print输出不同颜色的文本
  • 原文地址：https://blog.csdn.net/qq_62706049/article/details/133624782