实战篇：Security+JWT组合拳

Good morning, everyone!

之前我们已经说过用Shiro和JWT来实现身份认证和用户授权，今天我们再来说一下「Security和JWT」的组合拳。

简介

先赘述一下身份认证和用户授权：

用户认证(Authentication)：系统通过校验用户提供的用户名和密码来验证该用户是否为系统中的合法主体，即是否可以访问该系统;

用户授权(Authorization)：系统为用户分配不同的角色，以获取对应的权限，即验证该用户是否有权限执行该操作;

Web应用的安全性包括用户认证和用户授权两个部分，而Spring Security(以下简称Security)基于Spring框架，正好可以完整解决该问题。

它的真正强大之处在于它可以轻松扩展以满足自定义要求。

原理

Security可以看做是由一组filter过滤器链组成的权限认证。它的整个工作流程如下所示：

图中绿色认证方式是可以配置的，橘黄色和蓝色的位置不可更改：

  • FilterSecurityInterceptor：最后的过滤器，它会决定当前的请求可不可以访问Controller
  • ExceptionTranslationFilter：异常过滤器，接收到异常消息时会引导用户进行认证;

实战

项目准备

我们使用Spring Boot框架来集成。

1.pom文件引入的依赖

 
 
 
 
    
  
  
  
  
  1.  
    2. 
  
  
  
  
  2.     org.springframework.boot 
    3. 
  
  
  
  
  3.     spring-boot-starter 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5.  
    6. 
  
  
  
  
  6.  
    7. 
  
  
  
  
  7.     org.springframework.boot 
    8. 
  
  
  
  
  8.     spring-boot-starter-web 
    9. 
  
  
  
  
  9.      
    10. 
  
  
  
  
  10.          
    11. 
  
  
  
  
  11.             org.springframework.boot 
    12. 
  
  
  
  
  12.             spring-boot-starter-tomcat 
    13. 
  
  
  
  
  13.          
    14. 
  
  
  
  
  14.      
    15. 
  
  
  
  
  15.  
    16. 
  
  
  
  
  16.  
    17. 
  
  
  
  
  17.  
    18. 
  
  
  
  
  18.     org.springframework.boot 
    19. 
  
  
  
  
  19.     spring-boot-starter-undertow 
    20. 
  
  
  
  
  20.  
    21. 
  
  
  
  
  21.  
    22. 
  
  
  
  
  22.  
    23. 
  
  
  
  
  23.     mysql 
    24. 
  
  
  
  
  24.     mysql-connector-java 
    25. 
  
  
  
  
  25.  
    26. 
  
  
  
  
  26.  
    27. 
  
  
  
  
  27.  
    28. 
  
  
  
  
  28.     com.baomidou 
    29. 
  
  
  
  
  29.     mybatis-plus-boot-starter 
    30. 
  
  
  
  
  30.     3.4.0 
    31. 
  
  
  
  
  31.  
    32. 
  
  
  
  
  32.  
    33. 
  
  
  
  
  33.  
    34. 
  
  
  
  
  34.     org.projectlombok 
    35. 
  
  
  
  
  35.     lombok 
    36. 
  
  
  
  
  36.  
    37. 
  
  
  
  
  37.  
    38. 
  
  
  
  
  38.  
    39. 
  
  
  
  
  39.  
    40. 
  
  
  
  
  40.     com.alibaba 
    41. 
  
  
  
  
  41.     fastjson 
    42. 
  
  
  
  
  42.     1.2.74 
    43. 
  
  
  
  
  43.  
    44. 
  
  
  
  
  44.  
    45. 
  
  
  
  
  45.  
    46. 
  
  
  
  
  46.     joda-time 
    47. 
  
  
  
  
  47.     joda-time 
    48. 
  
  
  
  
  48.     2.10.6 
    49. 
  
  
  
  
  49.  
    50. 
  
  
  
  
  50.  
    51. 
  
  
  
  
  51.  
    52. 
  
  
  
  
  52.     org.springframework.boot 
    53. 
  
  
  
  
  53.     spring-boot-starter-test 
    54. 
  
  
  
  
  54.  
    55.

2.application.yml配置

 
 
 
 
    
  
  
  
  
  1. spring: 
    2. 
  
  
  
  
  2.   application: 
    3. 
  
  
  
  
  3.     name: securityjwt 
    4. 
  
  
  
  
  4.   datasource: 
    5. 
  
  
  
  
  5.     driver-class-name: com.mysql.cj.jdbc.Driver 
    6. 
  
  
  
  
  6.     url: jdbc:mysql://127.0.0.1:3306/cheetah?characterEncoding=utf-8&useSSL=false&serverTimezone=UTC 
    7. 
  
  
  
  
  7.     username: root 
    8. 
  
  
  
  
  8.     password: 123456 
    9. 
  
  
  
  
  9.  
    10. 
  
  
  
  
  10. server: 
    11. 
  
  
  
  
  11.   port: 8080 
    12. 
  
  
  
  
  12.  
    13. 
  
  
  
  
  13. mybatis: 
    14. 
  
  
  
  
  14.   mapper-locations: classpath:mapper/*.xml 
    15. 
  
  
  
  
  15.   type-aliases-package: com.itcheetah.securityjwt.entity 
    16. 
  
  
  
  
  16.   configuration: 
    17. 
  
  
  
  
  17.     map-underscore-to-camel-case: true 
    18. 
  
  
  
  
  18.  
    19. 
  
  
  
  
  19. rsa: 
    20. 
  
  
  
  
  20.   key: 
    21. 
  
  
  
  
  21.     pubKeyFile: C:\Users\Desktop\jwt\id_key_rsa.pub 
    22. 
  
  
  
  
  22.     priKeyFile: C:\Users\Desktop\jwt\id_key_rsa 
    23.

3.SQL文件

 
 
 
 
    
  
  
  
  
  1. /** 
    2. 
  
  
  
  
  2. * sys_user_info 
    3. 
  
  
  
  
  3. **/ 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5. SET NAMES utf8mb4; 
    6. 
  
  
  
  
  6. SET FOREIGN_KEY_CHECKS = 0; 
    7. 
  
  
  
  
  7.  
    8. 
  
  
  
  
  8. -- ---------------------------- 
    9. 
  
  
  
  
  9. -- Table structure for sys_user_info 
    10. 
  
  
  
  
  10. -- ---------------------------- 
    11. 
  
  
  
  
  11. DROP TABLE IF EXISTS `sys_user_info`; 
    12. 
  
  
  
  
  12. CREATE TABLE `sys_user_info`  ( 
    13. 
  
  
  
  
  13.   `id` bigint(20) NOT NULL AUTO_INCREMENT, 
    14. 
  
  
  
  
  14.   `username` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL, 
    15. 
  
  
  
  
  15.   `password` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL, 
    16. 
  
  
  
  
  16.   PRIMARY KEY (`id`) USING BTREE 
    17. 
  
  
  
  
  17. ) ENGINE = InnoDB AUTO_INCREMENT = 3 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic; 
    18. 
  
  
  
  
  18.  
    19. 
  
  
  
  
  19. SET FOREIGN_KEY_CHECKS = 1; 
    20. 
  
  
  
  
  20.  
    21. 
  
  
  
  
  21.  
    22. 
  
  
  
  
  22. /** 
    23. 
  
  
  
  
  23. * product_info 
    24. 
  
  
  
  
  24. **/ 
    25. 
  
  
  
  
  25.  
    26. 
  
  
  
  
  26. SET NAMES utf8mb4; 
    27. 
  
  
  
  
  27. SET FOREIGN_KEY_CHECKS = 0; 
    28. 
  
  
  
  
  28.  
    29. 
  
  
  
  
  29. -- ---------------------------- 
    30. 
  
  
  
  
  30. -- Table structure for product_info 
    31. 
  
  
  
  
  31. -- ---------------------------- 
    32. 
  
  
  
  
  32. DROP TABLE IF EXISTS `product_info`; 
    33. 
  
  
  
  
  33. CREATE TABLE `product_info`  ( 
    34. 
  
  
  
  
  34.   `id` bigint(20) NOT NULL AUTO_INCREMENT, 
    35. 
  
  
  
  
  35.   `name` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL, 
    36. 
  
  
  
  
  36.   `price` decimal(10, 4) NULL DEFAULT NULL, 
    37. 
  
  
  
  
  37.   `create_date` datetime(0) NULL DEFAULT NULL, 
    38. 
  
  
  
  
  38.   `update_date` datetime(0) NULL DEFAULT NULL, 
    39. 
  
  
  
  
  39.   PRIMARY KEY (`id`) USING BTREE 
    40. 
  
  
  
  
  40. ) ENGINE = InnoDB AUTO_INCREMENT = 4 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic; 
    41. 
  
  
  
  
  41.  
    42. 
  
  
  
  
  42. SET FOREIGN_KEY_CHECKS = 1; 
    43.

引入依赖

 
 
 
 
    
  
  
  
  
  1.  
    2. 
  
  
  
  
  2.     org.springframework.boot 
    3. 
  
  
  
  
  3.     spring-boot-starter-security 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5.  
    6. 
  
  
  
  
  6.  
    7. 
  
  
  
  
  7.  
    8. 
  
  
  
  
  8.     io.jsonwebtoken 
    9. 
  
  
  
  
  9.     jjwt 
    10. 
  
  
  
  
  10.     0.9.1 
    11. 
  
  
  
  
  11.  
    12.

引入之后启动项目，会有如图所示：

其中用户名为user，密码为上图中的字符串。

SecurityConfig类

 
 
 
 
    
  
  
  
  
  1. //开启全局方法安全性 
    2. 
  
  
  
  
  2. @EnableGlobalMethodSecurity(prePostEnabled=true, securedEnabled=true) 
    3. 
  
  
  
  
  3. public class SecurityConfig extends WebSecurityConfigurerAdapter { 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5.     //认证失败处理类 
    6. 
  
  
  
  
  6.     @Autowired 
    7. 
  
  
  
  
  7.     private AuthenticationEntryPointImpl unauthorizedHandler; 
    8. 
  
  
  
  
  8.  
    9. 
  
  
  
  
  9.     //提供公钥私钥的配置类 
    10. 
  
  
  
  
  10.     @Autowired 
    11. 
  
  
  
  
  11.     private RsaKeyProperties prop; 
    12. 
  
  
  
  
  12.  
    13. 
  
  
  
  
  13.     @Autowired 
    14. 
  
  
  
  
  14.     private UserInfoService userInfoService; 
    15. 
  
  
  
  
  15.      
    16. 
  
  
  
  
  16.     @Override 
    17. 
  
  
  
  
  17.     protected void configure(HttpSecurity httpSecurity) throws Exception { 
    18. 
  
  
  
  
  18.         httpSecurity 
    19. 
  
  
  
  
  19.                 // CSRF禁用，因为不使用session 
    20. 
  
  
  
  
  20.                 .csrf().disable() 
    21. 
  
  
  
  
  21.                 // 认证失败处理类 
    22. 
  
  
  
  
  22.                 .exceptionHandling().authenticationEntryPoint(unauthorizedHandler).and() 
    23. 
  
  
  
  
  23.                 // 基于token，所以不需要session 
    24. 
  
  
  
  
  24.                 .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS).and() 
    25. 
  
  
  
  
  25.                 // 过滤请求 
    26. 
  
  
  
  
  26.                 .authorizeRequests() 
    27. 
  
  
  
  
  27.                 .antMatchers( 
    28. 
  
  
  
  
  28.                         HttpMethod.GET, 
    29. 
  
  
  
  
  29.                         "/*.html", 
    30. 
  
  
  
  
  30.                         "/**/*.html", 
    31. 
  
  
  
  
  31.                         "/**/*.css", 
    32. 
  
  
  
  
  32.                         "/**/*.js" 
    33. 
  
  
  
  
  33.                 ).permitAll() 
    34. 
  
  
  
  
  34.                 // 除上面外的所有请求全部需要鉴权认证 
    35. 
  
  
  
  
  35.                 .anyRequest().authenticated() 
    36. 
  
  
  
  
  36.                 .and() 
    37. 
  
  
  
  
  37.                 .headers().frameOptions().disable(); 
    38. 
  
  
  
  
  38.         // 添加JWT filter 
    39. 
  
  
  
  
  39.         httpSecurity.addFilter(new TokenLoginFilter(super.authenticationManager(), prop)) 
    40. 
  
  
  
  
  40.                 .addFilter(new TokenVerifyFilter(super.authenticationManager(), prop)); 
    41. 
  
  
  
  
  41.     } 
    42. 
  
  
  
  
  42.  
    43. 
  
  
  
  
  43.     //指定认证对象的来源 
    44. 
  
  
  
  
  44.     public void configure(AuthenticationManagerBuilder auth) throws Exception { 
    45. 
  
  
  
  
  45.          
    46. 
  
  
  
  
  46.         auth.userDetailsService(userInfoService) 
    47. 
  
  
  
  
  47.         //从前端传递过来的密码就会被加密，所以从数据库 
    48. 
  
  
  
  
  48.         //查询到的密码必须是经过加密的，而这个过程都是 
    49. 
  
  
  
  
  49.         //在用户注册的时候进行加密的。 
    50. 
  
  
  
  
  50.         .passwordEncoder(passwordEncoder()); 
    51. 
  
  
  
  
  51.     } 
    52. 
  
  
  
  
  52.  
    53. 
  
  
  
  
  53.     //密码加密 
    54. 
  
  
  
  
  54.     @Bean 
    55. 
  
  
  
  
  55.     public BCryptPasswordEncoder passwordEncoder(){ 
    56. 
  
  
  
  
  56.         return new BCryptPasswordEncoder(); 
    57. 
  
  
  
  
  57.     } 
    58. 
  
  
  
  
  58. } 
    59.

「拦截规则」

  • anyRequest：匹配所有请求路径
  • access：SpringEl表达式结果为true时可以访问
  • anonymous：匿名可以访问
  • `denyAll：用户不能访问
  • fullyAuthenticated：用户完全认证可以访问(非remember-me下自动登录)
  • hasAnyAuthority：如果有参数，参数表示权限，则其中任何一个权限可以访问
  • hasAnyRole：如果有参数，参数表示角色，则其中任何一个角色可以访问
  • hasAuthority：如果有参数，参数表示权限，则其权限可以访问
  • hasIpAddress：如果有参数，参数表示IP地址，如果用户IP和参数匹配，则可以访问
  • hasRole：如果有参数，参数表示角色，则其角色可以访问
  • permitAll：用户可以任意访问
  • rememberMe：允许通过remember-me登录的用户访问
  • authenticated：用户登录后可访问

认证失败处理类

 
 
 
 
    
  
  
  
  
  1. /** 
    2. 
  
  
  
  
  2.  *  返回未授权 
    3. 
  
  
  
  
  3.  */ 
    4. 
  
  
  
  
  4. @Component 
    5. 
  
  
  
  
  5. public class AuthenticationEntryPointImpl implements AuthenticationEntryPoint, Serializable { 
    6. 
  
  
  
  
  6.  
    7. 
  
  
  
  
  7.     private static final long serialVersionUID = -8970718410437077606L; 
    8. 
  
  
  
  
  8.  
    9. 
  
  
  
  
  9.     @Override 
    10. 
  
  
  
  
  10.     public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException e) 
    11. 
  
  
  
  
  11.             throws IOException { 
    12. 
  
  
  
  
  12.         int code = HttpStatus.UNAUTHORIZED; 
    13. 
  
  
  
  
  13.         String msg = "认证失败，无法访问系统资源，请先登陆"; 
    14. 
  
  
  
  
  14.         ServletUtils.renderString(response, JSON.toJSONString(AjaxResult.error(code, msg))); 
    15. 
  
  
  
  
  15.     } 
    16. 
  
  
  
  
  16. } 
    17.

认证流程

自定义认证过滤器

 
 
 
 
    
  
  
  
  
  1. public class TokenLoginFilter extends UsernamePasswordAuthenticationFilter { 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3.     private AuthenticationManager authenticationManager; 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5.     private RsaKeyProperties prop; 
    6. 
  
  
  
  
  6.  
    7. 
  
  
  
  
  7.     public TokenLoginFilter(AuthenticationManager authenticationManager, RsaKeyProperties prop) { 
    8. 
  
  
  
  
  8.         this.authenticationManager = authenticationManager; 
    9. 
  
  
  
  
  9.         this.prop = prop; 
    10. 
  
  
  
  
  10.     } 
    11. 
  
  
  
  
  11.  
    12. 
  
  
  
  
  12.     /** 
    13. 
  
  
  
  
  13.      * @author cheetah 
    14. 
  
  
  
  
  14.      * @description 登陆验证 
    15. 
  
  
  
  
  15.      * @date 2021/6/28 16:17 
    16. 
  
  
  
  
  16.      * @Param [request, response] 
    17. 
  
  
  
  
  17.      * @return org.springframework.security.core.Authentication 
    18. 
  
  
  
  
  18.      **/ 
    19. 
  
  
  
  
  19.     public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException { 
    20. 
  
  
  
  
  20.         try { 
    21. 
  
  
  
  
  21.             UserPojo sysUser = new ObjectMapper().readValue(request.getInputStream(), UserPojo.class); 
    22. 
  
  
  
  
  22.             UsernamePasswordAuthenticationToken authRequest = new UsernamePasswordAuthenticationToken(sysUser.getUsername(), sysUser.getPassword()); 
    23. 
  
  
  
  
  23.             return authenticationManager.authenticate(authRequest); 
    24. 
  
  
  
  
  24.         }catch (Exception e){ 
    25. 
  
  
  
  
  25.             try { 
    26. 
  
  
  
  
  26.                 response.setContentType("application/json;charset=utf-8"); 
    27. 
  
  
  
  
  27.                 response.setStatus(HttpServletResponse.SC_UNAUTHORIZED); 
    28. 
  
  
  
  
  28.                 PrintWriter out = response.getWriter(); 
    29. 
  
  
  
  
  29.                 Map resultMap = new HashMap(); 
    30. 
  
  
  
  
  30.                 resultMap.put("code", HttpServletResponse.SC_UNAUTHORIZED); 
    31. 
  
  
  
  
  31.                 resultMap.put("msg", "用户名或密码错误！"); 
    32. 
  
  
  
  
  32.                 out.write(new ObjectMapper().writeValueAsString(resultMap)); 
    33. 
  
  
  
  
  33.                 out.flush(); 
    34. 
  
  
  
  
  34.                 out.close(); 
    35. 
  
  
  
  
  35.             }catch (Exception outEx){ 
    36. 
  
  
  
  
  36.                 outEx.printStackTrace(); 
    37. 
  
  
  
  
  37.             } 
    38. 
  
  
  
  
  38.             throw new RuntimeException(e); 
    39. 
  
  
  
  
  39.         } 
    40. 
  
  
  
  
  40.     } 
    41. 
  
  
  
  
  41.  
    42. 
  
  
  
  
  42.  
    43. 
  
  
  
  
  43.     /** 
    44. 
  
  
  
  
  44.      * @author cheetah 
    45. 
  
  
  
  
  45.      * @description 登陆成功回调 
    46. 
  
  
  
  
  46.      * @date 2021/6/28 16:17 
    47. 
  
  
  
  
  47.      * @Param [request, response, chain, authResult] 
    48. 
  
  
  
  
  48.      * @return void 
    49. 
  
  
  
  
  49.      **/ 
    50. 
  
  
  
  
  50.     public void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain, Authentication authResult) throws IOException, ServletException { 
    51. 
  
  
  
  
  51.         UserPojo user = new UserPojo(); 
    52. 
  
  
  
  
  52.         user.setUsername(authResult.getName()); 
    53. 
  
  
  
  
  53.         user.setRoles((List)authResult.getAuthorities()); 
    54. 
  
  
  
  
  54.         //通过私钥进行加密：token有效期一天 
    55. 
  
  
  
  
  55.         String token = JwtUtils.generateTokenExpireInMinutes(user, prop.getPrivateKey(), 24 * 60); 
    56. 
  
  
  
  
  56.         response.addHeader("Authorization", "Bearer "+token); 
    57. 
  
  
  
  
  57.         try { 
    58. 
  
  
  
  
  58.             response.setContentType("application/json;charset=utf-8"); 
    59. 
  
  
  
  
  59.             response.setStatus(HttpServletResponse.SC_OK); 
    60. 
  
  
  
  
  60.             PrintWriter out = response.getWriter(); 
    61. 
  
  
  
  
  61.             Map resultMap = new HashMap(); 
    62. 
  
  
  
  
  62.             resultMap.put("code", HttpServletResponse.SC_OK); 
    63. 
  
  
  
  
  63.             resultMap.put("msg", "认证通过！"); 
    64. 
  
  
  
  
  64.             resultMap.put("token", token); 
    65. 
  
  
  
  
  65.             out.write(new ObjectMapper().writeValueAsString(resultMap)); 
    66. 
  
  
  
  
  66.             out.flush(); 
    67. 
  
  
  
  
  67.             out.close(); 
    68. 
  
  
  
  
  68.         }catch (Exception outEx){ 
    69. 
  
  
  
  
  69.             outEx.printStackTrace(); 
    70. 
  
  
  
  
  70.         } 
    71. 
  
  
  
  
  71.     } 
    72. 
  
  
  
  
  72. } 
    73.

流程

Security默认登录路径为/login，当我们调用该接口时，它会调用上边的attemptAuthentication方法;图片图片图片图片所以我们要自定义UserInfoService继承UserDetailsService实现loadUserByUsername方法;

所以我们要自定义UserInfoService继承UserDetailsService实现loadUserByUsername方法；

 
 
 
 
    
  
  
  
  
  1. public interface UserInfoService extends UserDetailsService { 
    2. 
  
  
  
  
  2.  
    3. 
  
  
  
  
  3. } 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5. @Service 
    6. 
  
  
  
  
  6. @Transactional 
    7. 
  
  
  
  
  7. public class UserInfoServiceImpl implements UserInfoService { 
    8. 
  
  
  
  
  8.  
    9. 
  
  
  
  
  9.     @Autowired 
    10. 
  
  
  
  
  10.     private SysUserInfoMapper userInfoMapper; 
    11. 
  
  
  
  
  11.  
    12. 
  
  
  
  
  12.     @Override 
    13. 
  
  
  
  
  13.     public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException { 
    14. 
  
  
  
  
  14.         UserPojo user = userInfoMapper.queryByUserName(username); 
    15. 
  
  
  
  
  15.         return user; 
    16. 
  
  
  
  
  16.     } 
    17. 
  
  
  
  
  17. } 
    18.

其中的loadUserByUsername返回的是UserDetails类型，所以UserPojo继承UserDetails类

 
 
 
 
    
  
  
  
  
  1. @Data 
    2. 
  
  
  
  
  2. public class UserPojo implements UserDetails { 
    3. 
  
  
  
  
  3.  
    4. 
  
  
  
  
  4.     private Integer id; 
    5. 
  
  
  
  
  5.  
    6. 
  
  
  
  
  6.     private String username; 
    7. 
  
  
  
  
  7.  
    8. 
  
  
  
  
  8.     private String password; 
    9. 
  
  
  
  
  9.  
    10. 
  
  
  
  
  10.     private Integer status; 
    11. 
  
  
  
  
  11.  
    12. 
  
  
  
  
  12.     private List roles; 
    13. 
  
  
  
  
  13.  
    14. 
  
  
  
  
  14.     @JsonIgnore 
    15. 
  
  
  
  
  15.     @Override 
    16. 
  
  
  
  
  16.     public Collection getAuthorities() { 
    17. 
  
  
  
  
  17.         //理想型返回 admin 权限，可自已处理这块 
    18. 
  
  
  
  
  18.         List auth = new ArrayList<>(); 
    19. 
  
  
  
  
  19.         auth.add(new SimpleGrantedAuthority("ADMIN")); 
    20. 
  
  
  
  
  20.         return auth; 
    21. 
  
  
  
  
  21.     } 
    22. 
  
  
  
  
  22.  
    23. 
  
  
  
  
  23.     @Override 
    24. 
  
  
  
  
  24.     public String getPassword() { 
    25. 
  
  
  
  
  25.         return this.password; 
    26. 
  
  
  
  
  26.     } 
    27. 
  
  
  
  
  27.  
    28. 
  
  
  
  
  28.     @Override 
    29. 
  
  
  
  
  29.     public String getUsername() { 
    30. 
  
  
  
  
  30.         return this.username; 
    31. 
  
  
  
  
  31.     } 
    32. 
  
  
  
  
  32.  
    33. 
  
  
  
  
  33.     /** 
    34. 
  
  
  
  
  34.      * 账户是否过期 
    35. 
  
  
  
  
  35.      **/ 
    36. 
  
  
  
  
  36.     @JsonIgnore 
    37. 
  
  
  
  
  37.     @Override 
    38. 
  
  
  
  
  38.     public boolean isAccountNonExpired() { 
    39. 
  
  
  
  
  39.         return true; 
    40. 
  
  
  
  
  40.     } 
    41. 
  
  
  
  
  41.  
    42. 
  
  
  
  
  42.     /** 
    43. 
  
  
  
  
  43.      * 是否禁用 
    44. 
  
  
  
  
  44.      */ 
    45. 
  
  
  
  
  45.     @JsonIgnore 
    46. 
  
  
  
  
  46.     @Override 
    47. 
  
  
  
  
  47.     public boolean isAccountNonLocked() { 
    48. 
  
  
  
  
  48.         return true; 
    49. 
  
  
  
  
  49.     } 
    50. 
  
  
  
  
  50.  
    51. 
  
  
  
  
  51.     /** 
    52. 
  
  
  
  
  52.      * 密码是否过期 
    53. 
  
  
  
  
  53.      */ 
    54. 
  
  
  
  
  54.     @JsonIgnore 
    55. 
  
  
  
  
  55.     @Override 
    56. 
  
  
  
  
  56.     public boolean isCredentialsNonExpired() { 
    57. 
  
  
  
  
  57.         return true; 
    58. 
  
  
  
  
  58.     } 
    59. 
  
  
  
  
  59.  
    60. 
  
  
  
  
  60.     /** 
    61. 
  
  
  
  
  61.      * 是否启用 
    62. 
  
  
  
  
  62.      */ 
    63. 
  
  
  
  
  63.     @JsonIgnore 
    64. 
  
  
  
  
  64.     @Override 
    65. 
  
  
  
  
  65.     public boolean isEnabled() { 
    66. 
  
  
  
  
  66.         return true; 
    67. 
  
  
  
  
  67.     } 
    68. 
  
  
  
  
  68. } 
    69.

当认证通过之后会在SecurityContext中设置Authentication对象，回调调用successfulAuthentication方法返回token信息，

整体流程图如下

鉴权流程

自定义token过滤器

 
 
 
 
    
  
  
  
  
  1. public class TokenVerifyFilter extends BasicAuthenticationFilter { 
    2. 
  
  
  
  
  2.     private RsaKeyProperties prop; 
    3. 
  
  
  
  
  3.  
    4. 
  
  
  
  
  4.     public TokenVerifyFilter(AuthenticationManager authenticationManager, RsaKeyProperties prop) { 
    5. 
  
  
  
  
  5.         super(authenticationManager); 
    6. 
  
  
  
  
  6.         this.prop = prop; 
    7. 
  
  
  
  
  7.     } 
    8. 
  
  
  
  
  8.  
    9. 
  
  
  
  
  9.     public void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException { 
    10. 
  
  
  
  
  10.         String header = request.getHeader("Authorization"); 
    11. 
  
  
  
  
  11.         if (header == null || !header.startsWith("Bearer ")) { 
    12. 
  
  
  
  
  12.             //如果携带错误的token，则给用户提示请登录！ 
    13. 
  
  
  
  
  13.             chain.doFilter(request, response); 
    14. 
  
  
  
  
  14.         } else { 
    15. 
  
  
  
  
  15.             //如果携带了正确格式的token要先得到token 
    16. 
  
  
  
  
  16.             String token = header.replace("Bearer ", ""); 
    17. 
  
  
  
  
  17.             //通过公钥进行解密：验证tken是否正确 
    18. 
  
  
  
  
  18.             Payload payload = JwtUtils.getInfoFromToken(token, prop.getPublicKey(), UserPojo.class); 
    19. 
  
  
  
  
  19.             UserPojo user = payload.getUserInfo(); 
    20. 
  
  
  
  
  20.             if(user!=null){ 
    21. 
  
  
  
  
  21.                 UsernamePasswordAuthenticationToken authResult = new UsernamePasswordAuthenticationToken(user.getUsername(), null, user.getAuthorities()); 
    22. 
  
  
  
  
  22.                 //将认证信息存到安全上下文中 
    23. 
  
  
  
  
  23.                 SecurityContextHolder.getContext().setAuthentication(authResult); 
    24. 
  
  
  
  
  24.                 chain.doFilter(request, response); 
    25. 
  
  
  
  
  25.             } 
    26. 
  
  
  
  
  26.         } 
    27. 
  
  
  
  
  27.     } 
    28. 
  
  
  
  
  28. } 
    29.

当我们访问时需要在header中携带token信息

本文转载自微信公众号「阿Q说代码」，可以通过以下二维码关注。转载本文请联系阿Q说代码公众号。

分享文章：实战篇：Security+JWT组合拳
转载注明：http://www.shufengxianlan.com/qtweb/news9/428759.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网页设计公司知识

各行业网站

商城网站建设　　 　成都做商城网站　　 　上海济桢教育　　 　外贸网站建设　　 　腾讯云虚拟主机　　 　网站制作价格　　 　SSL证书　　 　成都封阳台　　 　成都网站制作　　 　南充护栏钻孔机　　 　崇州湖霆科技　　 　成都网站制作　　 　橡塑保温管　　 　成都木托盘　　 　成都光华机房服务器托管　　 　内江做网站　　 　固迪佳新材料　　 　成都网创优客　　 　瑞捷酒店用品　　 　成都IDC机房托管