来人！教我实现Springboot+Jwt+SpringSecurity实现认证请求

悠悠 2022-12-04 12:59 130阅读 0赞

# 前言 #

近排因为项目原因，承接了甲方大佬的系统，其它的还好，熊某还是比较注重权限的部分，毕竟我这方面还是毕竟薄弱，发现用的是JWT+SpringSecurity的认证方式，就好好学习下，顺便写下自己的笔记！

> SpringSecurity官方文档:[https://www.springcloud.cc/spring-security-zhcn.html\#jc][https_www.springcloud.cc_spring-security-zhcn.html_jc]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODE2ODk0Nw_size_16_color_FFFFFF_t_70_pic_center]

# 认证流程 #

开始前我们还是要了解下总体流程是什么样的：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODE2ODk0Nw_size_16_color_FFFFFF_t_70_pic_center 1]  
看起来不太难，那就让我们动手做吧！

# 表结构 #

我们一共需要3张表，分别是用户表、角色表、用户角色关联表

-- 角色用户关联表
    CREATE TABLE `role_user`  (
      `user_id` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '用户ID',
      `role_id` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '角色ID'
    ) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
    
    -- 角色表
    CREATE TABLE `sys_role`  (
      `id` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '角色ID',
      `role_name` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '角色名称',
      `role_permissions` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '角色权限',
      `create_date` datetime(0) NULL DEFAULT NULL COMMENT '创建时间',
      `create_by` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '创建人',
      `update_date` datetime(0) NULL DEFAULT NULL COMMENT '修改时间',
      `update_by` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '修改日期',
      PRIMARY KEY (`id`) USING BTREE
    ) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
    
    -- 用户表
    CREATE TABLE `sys_user`  (
      `id` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '用户ID',
      `user_account` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '用户名',
      `user_password` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '用户密码',
      `user_name` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '用户昵称',
      `user_email` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '电子邮箱',
      `user_phone` int(11) NULL DEFAULT NULL COMMENT '电话号码',
      `create_date` datetime(0) NULL DEFAULT NULL COMMENT '创建时间',
      `create_by` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '创建人',
      `update_date` datetime(0) NULL DEFAULT NULL COMMENT '修改时间',
      `update_by` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '修改日期',
      PRIMARY KEY (`id`) USING BTREE
    ) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

# 构建项目 #

这个我就不细说，相信大家都很熟悉这个步骤。

> 注意，我这里用的框架是SpringSecurity+Springboot+MyBatis-Plus

一般来说，构建项目并且启动后，访问接口的话都会出现SpringSecurity默认的登陆方式，如下图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODE2ODk0Nw_size_16_color_FFFFFF_t_70_pic_center 2]  
账号是user，密码是控制台生成的：  
![在这里插入图片描述][20200909110846294.png_pic_center]  
这只是一个简单的页面，在业务场景下肯定不会用这种啦，一般都是我们自己设定的登陆界面，和登陆方式。

# 设置安全管理器 #

我们通过继承**WebSecurityConfigurerAdapter**来自定义我们的安全管理器，上代码！

@EnableWebSecurity
    @Configuration
    public class WebSecurityConfig extends WebSecurityConfigurerAdapter { 
    
        @Autowired
        SuccessHandler successHandler;
        @Autowired
        FailedHandler failedHandler;
    
        // 为了安全需要，我这里添加了密码编码器，详情可以到SpringSecurity的文档里看
        @Bean
        public BCryptPasswordEncoder passwordEncoder(){ 
            return new BCryptPasswordEncoder();
        }
    
        @Override
        protected void configure(HttpSecurity http) throws Exception { 
            http
                    .authorizeRequests()
                    // 除了/authentication/**, /auth/**, /js/**, /css/**的url外，其它的路径都需要执行认证
                    .antMatchers("/authentication/**", "/auth/**", "/js/**", "/css/**").permitAll()
                    .anyRequest().authenticated()
                    .and()
                    .formLogin()
                    // 登陆请求
                    .loginProcessingUrl("/authentication/form")
                    // 登陆成功后的操作
                    .successHandler(successHandler)
                    // 登陆失败的操作
                    .failureHandler(failedHandler)
                    .and()
                    // 我这里关闭CSRF处理
                    .csrf().disable()
                    // 因为我们使用的是JWT来进行认证，所以不需要session，这里就设置成永不创建HttpSession
                    .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                    .and()
                    // 添加JWT过滤器
                    .addFilter(new PhotoUsernamePasswordFilter(authenticationManager()))
                    // 基于http请求
                    .httpBasic();
        }
    }

# 自定义获取认证信息 #

因为我们是通过查询数据库的数据来验证我们的登录信息，所以我们可以通过实现**UserDetailsService**接口中的 **loadUserByUsername(String s)** 来从一个JDBC数据源获得认证信息。

@Service
    public class PhotoUserDetail implements UserDetailsService { 
        @Autowired
        RoleUserService roleUserService;
    
    
        @Override
        public UserDetails loadUserByUsername(String s) throws UsernameNotFoundException { 
            // 获取用户以及用户所具有的权限信息
            UserInfo userInfo = roleUserService.getUserInfo(s);
            return userDetails(userInfo);
        }
    
        private UserDetails userDetails(UserInfo userInfo) { 
            Set<String> creditList = new HashSet<>();
            if(StringUtils.notEmpty(userInfo.getPermissionsList()) && StringUtils.notEmpty(userInfo.getRoleList())){ 
                // 我这里把角色名和权限字符都存放起来
                creditList.addAll(userInfo.getPermissionsList());
                creditList.addAll(userInfo.getRoleList());
            }
            Collection<? extends GrantedAuthority> collection = AuthorityUtils.createAuthorityList(creditList.toArray(new String[0]));
            // 将用户账号和密码以及权限存放到User对象
            return new User(userInfo.getSysUser().getUserAccount(), userInfo.getSysUser().getUserPassword(),  collection);
        }
    }

这里有必要提醒一下，User类是SpringSecurity用来存放用户登陆信息的类，如果不想用User类，可以通过实现**UserDetails**接口。

# 校验成功处理器 #

校验信息成功后我们需要返回一个token给客户端，看看代码!

@Component
    public class SuccessHandler extends SavedRequestAwareAuthenticationSuccessHandler { 
    
        @Override
        public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws ServletException, IOException { 
            String userName = ((User)authentication.getPrincipal()).getUsername();
            Collection<? extends GrantedAuthority> authoritiesList = authentication.getAuthorities();
            List<String> permissionList = new ArrayList<>();
            authoritiesList.stream().forEach(t -> { 
                permissionList.add(((GrantedAuthority) t).getAuthority());
            });
            SaveUserInfo saveUserInfo = new SaveUserInfo();
            saveUserInfo.setRoleList(permissionList);
            saveUserInfo.setUserAccount(userName);
            String token = JwtUtils.generateToke(saveUserInfo);
            ResponseUtils.out(response, AjaxResult.success(token));
        }
    }

这里发下JwtUtils和SaveUserInfo的代码

public class JwtUtils { 
    
        public static String generateToke(SaveUserInfo saveUserInfo) { 
            Algorithm algorithm = Algorithm.HMAC256(JwtConstants.ISSUER);
            JWTCreator.Builder jwtBuilder = JWT.create()
                    .withClaim("userAccount", saveUserInfo.getUserAccount())
                    .withClaim("roleList", saveUserInfo.getRoleList())
                    .withIssuer(JwtConstants.PUBLISHPEPLE)
                    .withIssuedAt(new Date())
                    .withExpiresAt(new Date(JwtConstants.EXPIRE_DATE));
            return jwtBuilder.sign(algorithm);
        }
    
        public static SaveUserInfo parseJWT(String token) { 
            JWTVerifier jwtVerifier = JWT.require(Algorithm.HMAC256(JwtConstants.ISSUER)).withIssuer(JwtConstants.PUBLISHPEPLE).build();
            DecodedJWT jwt =  jwtVerifier.verify(token);
            SaveUserInfo saveUserInfo = new SaveUserInfo();
            saveUserInfo.setRoleList(jwt.getClaim("roleList").asList(String.class));
            saveUserInfo.setUserAccount(jwt.getClaim("userAccount").asString());
            return saveUserInfo;
        }
    
    }

public class SaveUserInfo { 
    
        private String userAccount;
        private List<String> roleList;
    
        public String getUserAccount() { 
            return userAccount;
        }
    
        public void setUserAccount(String userAccount) { 
            this.userAccount = userAccount;
        }
    
        public List<String> getRoleList() { 
            return roleList;
        }
    
        public void setRoleList(List<String> roleList) { 
            this.roleList = roleList;
        }
    }

# 校验失败处理器 #

@Component
    public class FailedHandler extends SimpleUrlAuthenticationFailureHandler { 
    
        @Override
        public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) throws IOException, ServletException { 
            if(exception instanceof UsernameNotFoundException){ 
                ResponseUtils.out(response, AjaxResult.error("用户名不存在"));
            }else if(exception instanceof BadCredentialsException){ 
                ResponseUtils.out(response, AjaxResult.error("用户或密码输入错误"));
            }else{ 
                ResponseUtils.out(response, AjaxResult.error());
            }
        }
    }

代码比较简单，就不一一诉说了。顺便把ResponseUtils和AjaxResult的代码也上了。  
需要引入gson依赖：

<dependency>
                <groupId>com.google.code.gson</groupId>
                <artifactId>gson</artifactId>
                <version>2.8.5</version>
    </dependency>

public class ResponseUtils { 
    
        public static void out(HttpServletResponse response, Map<String, Object> outMap){ 
            ServletOutputStream outputStream = null;
            try { 
                response.setCharacterEncoding("UTF-8");
                response.setContentType("application/json;charset=UTF-8");
                outputStream = response.getOutputStream();
                outputStream.write(new Gson().toJson(outMap).getBytes());
            } catch (IOException e) { 
                e.printStackTrace();
            }finally { 
                try { 
                    outputStream.flush();
                    outputStream.close();
                } catch (IOException e) { 
                    e.printStackTrace();
                }
            }
        }
    
    }

public class AjaxResult extends HashMap<String, Object>
    { 
        private static final long serialVersionUID = 1L;
    
        /** 状态码 */
        public static final String CODE_TAG = "code";
    
        /** 返回内容 */
        public static final String MSG_TAG = "msg";
    
        /** 数据对象 */
        public static final String DATA_TAG = "data";
    
        /** * 初始化一个新创建的 AjaxResult 对象，使其表示一个空消息。 */
        public AjaxResult()
        { 
        }
    
        /** * 初始化一个新创建的 AjaxResult 对象 * * @param code 状态码 * @param msg 返回内容 */
        public AjaxResult(int code, String msg)
        { 
            super.put(CODE_TAG, code);
            super.put(MSG_TAG, msg);
        }
    
        /** * 初始化一个新创建的 AjaxResult 对象 * * @param code 状态码 * @param msg 返回内容 * @param data 数据对象 */
        public AjaxResult(int code, String msg, Object data)
        { 
            super.put(CODE_TAG, code);
            super.put(MSG_TAG, msg);
            if (Objects.nonNull(data))
            { 
                super.put(DATA_TAG, data);
            }
        }
    
        /** * 返回成功消息 * * @return 成功消息 */
        public static AjaxResult success()
        { 
            return AjaxResult.success("操作成功");
        }
    
        /** * 返回成功数据 * * @return 成功消息 */
        public static AjaxResult success(Object data)
        { 
            return AjaxResult.success("操作成功", data);
        }
    
        /** * 返回成功消息 * * @param msg 返回内容 * @return 成功消息 */
        public static AjaxResult success(String msg)
        { 
            return AjaxResult.success(msg, null);
        }
    
        /** * 返回成功消息 * * @param msg 返回内容 * @param data 数据对象 * @return 成功消息 */
        public static AjaxResult success(String msg, Object data)
        { 
            return new AjaxResult(ResponseEnum.SUCCESS.code, msg, data);
        }
    
        /** * 返回错误消息 * * @return */
        public static AjaxResult error()
        { 
            return AjaxResult.error("操作失败");
        }
    
        /** * 返回错误消息 * * @param msg 返回内容 * @return 警告消息 */
        public static AjaxResult error(String msg)
        { 
            return AjaxResult.error(msg, null);
        }
    
        /** * 返回错误消息 * * @param msg 返回内容 * @param data 数据对象 * @return 警告消息 */
        public static AjaxResult error(String msg, Object data)
        { 
            return new AjaxResult(ResponseEnum.FAILED.code, msg, data);
        }
    
        /** * 返回错误消息 * * @param code 状态码 * @param msg 返回内容 * @return 警告消息 */
        public static AjaxResult error(int code, String msg)
        { 
            return new AjaxResult(code, msg, null);
        }
    }

# 自定义过滤器 #

因为我们使用的JWT编码成的token，因此需要自定义一个过滤器来进行解析。

public class PhotoUsernamePasswordFilter extends BasicAuthenticationFilter { 
    
        public PhotoUsernamePasswordFilter(AuthenticationManager authenticationManager) { 
            super(authenticationManager);
        }
    
        @Override
        protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException { 
            // 获取请求头的Authorization
            String header = request.getHeader("Authorization");
            if(Strings.isNotBlank(header)){ 
                String token = header.split(" ")[1];
                try{ 
                    UsernamePasswordAuthenticationToken authentication = getToken(token, response);
                    SecurityContextHolder.getContext().setAuthentication(authentication);
                }catch (Exception e){ 
                    e.printStackTrace();
                }
            }else { 
                chain.doFilter(request, response);
                return;
            }
            chain.doFilter(request, response);
        }
    
        private UsernamePasswordAuthenticationToken getToken(String token, HttpServletResponse response){ 
            String accountName = null;
            List<GrantedAuthority> grantedAuthorityList = new ArrayList<>();
            try{ 
                // 解析请求头的Authorization中的token
                SaveUserInfo saveUserInfo = JwtUtils.parseJWT(token);
                accountName = saveUserInfo.getUserAccount();
                List<String> permissionsList = saveUserInfo.getRoleList();
                permissionsList.stream().forEach(t -> { 
                    grantedAuthorityList.add(new SimpleGrantedAuthority(t));
                });
            }catch (ExpiredJwtException e){ 
                ResponseUtils.out(response, AjaxResult.error(401,"登录已失效，请重新登录"));
            }catch (Exception e){ 
                ResponseUtils.out(response, AjaxResult.error(500,"解析token失败"));
            }
            if(Strings.isNotBlank(accountName)){ 
                User principal = new User(accountName, "", grantedAuthorityList);
                return new UsernamePasswordAuthenticationToken(principal, null, grantedAuthorityList);
            }
            return null;
        }
    }

用户发起的请求都会通过这个过滤器，过滤器通过请求消息携带的token来获得用户的信息和权限。

# 测试 #

代码都写好了，接下来我们测试一下，因为我们需要用户，因此添加用户就不进行校验了。

@RequestMapping("/auth/user")
    @RestController
    @Transactional(rollbackFor = Exception.class)
    public class AuthController { 
    
        @Autowired
        SysUserService sysUserService;
    
        @PostMapping
        public AjaxResult addUser(@RequestBody SysUser sysUser){ 
            sysUser.setCreateDate(new Date());
            sysUser.setId(UuidUtils.randomUUid());
            sysUser.setUserPassword(new BCryptPasswordEncoder().encode(sysUser.getUserPassword()));
            sysUserService.save(sysUser);
            return AjaxResult.success();
        }
    }

上面提到过，/auth/\*\*匹对的url不进行校验，因此/auth/user自然不会进行安全校验。这里也准备了一个查询用户的接口，测试是否通过。

@RestController
    @RequestMapping("sysUser")
    public class SysUserController extends ApiController { 
        /** * 服务对象 */
        @Resource
        private SysUserService sysUserService;
    
        /** * 分页查询所有数据 * * @param page 分页对象 * @param sysUser 查询实体 * @return 所有数据 */
        @GetMapping
        public R selectAll(Page<SysUser> page, SysUser sysUser) { 
            return success(this.sysUserService.page(page, new QueryWrapper<>(sysUser)));
        }
    }

我这里用PostMan进行测试  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODE2ODk0Nw_size_16_color_FFFFFF_t_70_pic_center 3]  
![在这里插入图片描述][20200909165755341.png_pic_center]  
然后我们试下能不能访问查询用户接口  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODE2ODk0Nw_size_16_color_FFFFFF_t_70_pic_center 4]  
显然不能，登陆后再试下。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODE2ODk0Nw_size_16_color_FFFFFF_t_70_pic_center 5]  
登陆成功返回的就是token，我们把它放到请求头。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODE2ODk0Nw_size_16_color_FFFFFF_t_70_pic_center 6]  
可以进行访问了。

# 结尾 #

SpringSecurity的简单使用就到这里了，其实弄起来也不是特别复杂，当然还有很多的功能，熊某这篇文章还没对权限进行认证，后面会另外开一篇，就这样啦。

最后说一句，各位喜欢的话可以点个赞哦。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODE2ODk0Nw_size_16_color_FFFFFF_t_70]

[https_www.springcloud.cc_spring-security-zhcn.html_jc]: https://www.springcloud.cc/spring-security-zhcn.html#jc
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODE2ODk0Nw_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/48dc71a344b64477a5f85aa727ace6f1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODE2ODk0Nw_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/19eecf6b663844bf87a83ff60348b889.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODE2ODk0Nw_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/479bb93b97a04e028a14da6df46e4f18.png
[20200909110846294.png_pic_center]: /images/20221123/56eb38897b194d4dabdea6763be53977.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODE2ODk0Nw_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221123/cd08ba7caea94c8fb1dc5c400c744219.png
[20200909165755341.png_pic_center]: /images/20221123/0ffbb3db731a478dba76215c7a432588.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODE2ODk0Nw_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221123/6525a954654849cf98c471a572503d46.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODE2ODk0Nw_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221123/c390bfea4047445fb58bd66c89338367.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODE2ODk0Nw_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221123/bc35fd73a5aa49c1b897d4a4ab0e57ec.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODE2ODk0Nw_size_16_color_FFFFFF_t_70]: /images/20221123/ded3bc5eee8d4ea1a749cb78da0f45fe.png