Spring Boot + Security + JWT 实现Token验证+多Provider——登录系统
首先呢就是需求：
1、账号、密码进行第一次登录，获得token，之后的每次请求都在请求头里加上这个token就不用带账号、密码或是session了。
2、用户有两种类型，具体表现在数据库中存用户信息时是分开两张表进行存储的。
为什么会分开存两张表呢，这个设计的时候是先设计的表结构，有分开的必要所以就分开存了，也没有想过之后Security 这块需要进行一些修改，但是分开存就分开存吧，Security 这块也不是很复杂。
maven就是这两：
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt</artifactId> <version>0.9.0</version> </dependency>
然后直接说代码吧，首先呢是实现dao层，这一层就不贴代码了，反正就是能根据用户名能返回用户信息就好了。
所以其实第一步是实现自己的安全模型：
这一步是实现UserDetails这个接口，其中我额外添加了用户类型、用户Id。其他的都是UserDetails接口必须实现的。
/** * 安全用户模型 * @author xuwang * Created on 2019/05/28 20:07 */ public class XWUserDetails implements UserDetails { //用户类型code public final static String USER_TYPE_CODE = "1"; //管理员类型code public final static String MANAGER_TYPE_CODE = "2"; //用户id private Integer userId; //用户名 private String username; //密码 private String password; //用户类型 private String userType; //用户角色表 private Collection<? extends GrantedAuthority> authorities; public XWUserDetails(Integer userId,String username, String password, String userType, Collection<? extends GrantedAuthority> authorities){ this.userId = userId; this.username = username; this.password = password; this.userType = userType; this.authorities = authorities; } /** * 获取权限列表 * @return Collection */ @Override public Collection<? extends GrantedAuthority> getAuthorities() { return authorities; } /** * 获取用户Id * @return String */ public Integer getUserId() { return userId; } /** * 获取用户类型 * @return String */ public String getUserType() { return userType; } /** * 获取密码 * @return String */ @Override public String getPassword() { return password; } /** * 获取用户名 * @return String */ @Override public String getUsername() { return username; } /** * 账号是否未过期 * @return boolean */ @Override public boolean isAccountNonExpired() { return true; } /** * 账号是否未锁定 * @return boolean */ @Override public boolean isAccountNonLocked() { return true; } /** * 凭证是否未过期 * @return boolean */ @Override public boolean isCredentialsNonExpired() { return true; } /** * 账号是否已启用 * @return boolean */ @Override public boolean isEnabled() { return true; }
第二步是实现两个UserDetailsService因为要从两张表里进行查询，所以我就实现了两个UserDetailsService
这一步呢，注入了dao层的东西，从数据库中查询出用户信息，构建XWUserDetails并返回。
/** * Manager专用的UserDetailsService * @author xuwang * Created on 2019/06/01 15:58 */ @Service("managerDetailsService") public class ManagerDetailsServiceImpl implements UserDetailsService { @Resource ScManagerMapper_Security scManagerMapper_security; @Resource ScRoleMapper_Security scRole_Mapper_security; /** * 根据用户名从数据库中获取XWUserDetails * @param username * @return UserDetails * @throws UsernameNotFoundException */ @Override public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException { //获取用户信息 ScManager user = scManagerMapper_security.findByUsername(username); //获取角色列表 List<String> roles = scRole_Mapper_security.findByUsername(username); if (user == null) { throw new UsernameNotFoundException(String.format("No user found with username '%s'.", username)); } else { return new XWUserDetails(user.getId(),user.getManagerName(), user.getLoginPass(),XWUserDetails.MANAGER_TYPE_CODE, roles.stream().map(SimpleGrantedAuthority::new).collect(Collectors.toList())); } } }
/** * User专用的UserDetailsService * @author xuwang * Created on 2019/06/01 15:58 */ @Service("userDetailsService") public class UserDetailsServiceImpl implements UserDetailsService { @Resource ScUserMapper_Security userMapper_security; @Resource ScRoleMapper_Security scRole_Mapper_security; /** * 根据用户名从数据库中获取XWUserDetails * @param username * @return UserDetails * @throws UsernameNotFoundException */ @Override public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException { //获取用户信息 ScUser user = userMapper_security.findByUsername(username); //获取角色列表 List<String> roles = scRole_Mapper_security.findByUsername(username); if (user == null) { throw new UsernameNotFoundException(String.format("No user found with username '%s'.", username)); } else { return new XWUserDetails(user.getId(),user.getName(),user.getPassword(), XWUserDetails.MANAGER_TYPE_CODE, roles.stream().map(SimpleGrantedAuthority::new).collect(Collectors.toList())); } } }
第三步，实现两个UsernamePasswordAuthenticationToken
这一步的话，其实单看不知道为什么实现两个类，但是注释里面我写了，然后真正的为什么，整体流程，到最后说吧。
/** * manager专用的UsernamePasswordAuthenticationToken * AuthenticationManager会遍历使用Provider的supports()方法,判断AuthenticationToken是不是自己想要的 * @author xuwang * Created on 2019/06/01 15:58 */ public class ManagerAuthenticationToken extends UsernamePasswordAuthenticationToken { public ManagerAuthenticationToken(Object principal, Object credentials) { super(principal, credentials); } }
/** * User专用的UsernamePasswordAuthenticationToken * AuthenticationManager会遍历使用Provider的supports()方法,判断AuthenticationToken是不是自己想要的 * @author xuwang * Created on 2019/06/01 15:58 */ public class UserAuthenticationToken extends UsernamePasswordAuthenticationToken { public UserAuthenticationToken(Object principal, Object credentials){ super(principal,credentials); } }
第四步，实现两个AuthenticationProvider
这个地方用到了上面的两个类，重点是supports()方法，这个方法是用来校验传进来的UsernamePasswordAuthenticationToken的，反正就代表着这个ManagerAuthenticationProvider就只适用于ManagerAuthenticationToken，另一个同理，具体也是最后说吧。
/** * Manager专用的AuthenticationProvider * 选择实现DaoAuthenticationProvider是因为比较方便且能用 * @author xuwang * Created on 2019/06/01 15:58 */ public class ManagerAuthenticationProvider extends DaoAuthenticationProvider { /** * 初始化 将使用Manager专用的userDetailsService * @param encoder * @param userDetailsService */ public ManagerAuthenticationProvider(PasswordEncoder encoder, UserDetailsService userDetailsService){ setPasswordEncoder(encoder); setUserDetailsService(userDetailsService); } @Override public void setPasswordEncoder(PasswordEncoder passwordEncoder) { super.setPasswordEncoder(passwordEncoder); } @Override public void setUserDetailsPasswordService(UserDetailsPasswordService userDetailsPasswordService) { super.setUserDetailsPasswordService(userDetailsPasswordService); } /** * 判断只有传入ManagerAuthenticationToken的时候才使用这个Provider * supports会在AuthenticationManager层被调用 * @param authentication * @return */ public boolean supports(Class<?> authentication) { return ManagerAuthenticationToken.class.isAssignableFrom(authentication); } }
/** * 实现User专用的AuthenticationProvider * 选择实现DaoAuthenticationProvider是因为比较方便且能用 * @author xuwang * Created on 2019/06/01 15:58 */ public class UserAuthenticationProvider extends DaoAuthenticationProvider { /** * 初始化 将使用User专用的userDetailsService * @param encoder * @param userDetailsService */ public UserAuthenticationProvider(PasswordEncoder encoder, UserDetailsService userDetailsService){ setPasswordEncoder(encoder); setUserDetailsService(userDetailsService); } @Override public void setPasswordEncoder(PasswordEncoder passwordEncoder) { super.setPasswordEncoder(passwordEncoder); } @Override public void setUserDetailsPasswordService(UserDetailsPasswordService userDetailsPasswordService) { super.setUserDetailsPasswordService(userDetailsPasswordService); } /** * 判断只有传入UserAuthenticationToken的时候才使用这个Provider * supports会在AuthenticationManager层被调用 * @param authentication * @return */ public boolean supports(Class<?> authentication) { return UserAuthenticationToken.class.isAssignableFrom(authentication); } }
第五步就是继承实现这个WebSecurityConfigurerAdapter
这一步呢，主要是将上面两个AuthenticationProvider加入到AuthenticationManager中，并向Spring中注入这个AuthenticationManager供Service在校验账号密码时使用。
同时还注入了一个PasswordEncoder，也是同样供Service层使用，反正就是其他地方能用就是了，就不用new了。
然后是configure方法，这个里面，具体就是Security 的配置了，为什么怎么写我就不说了，反正我这里实现了url的配置、Session的关闭、Filter的设置、设置验证失败权限不足自定义返回值。
其中Filter、和验证失败权限不足再看后面的代码吧，我也会贴上的。
关于AuthenticationManager，就是先用加密工具、和之前实现的UserDetailsService 构造两个DaoAuthenticationProvider，然后在configureGlobal()方法中添加这两个DaoAuthenticationProvider，最后authenticationManagerBean()方法进行注入。
/** * Security 配置 * @author xuwang * Created on 2019/06/01 15:58 */ @Configuration @EnableWebSecurity @EnableGlobalMethodSecurity(prePostEnabled = true) public class XWSecurityConfig extends WebSecurityConfigurerAdapter { @Autowired @Qualifier("userDetailsService") private UserDetailsService userDetailsService; @Autowired @Qualifier("managerDetailsService") private UserDetailsService managerDetailsService; @Resource private XWAuthenticationTokenFilter xwAuthenticationTokenFilter; @Resource private EntryPointUnauthorizedHandler entryPointUnauthorizedHandler; @Resource private RestAccessDeniedHandler restAccessDeniedHandler; /** * 注入UserAuthenticationProvider * @return */ @Bean("UserAuthenticationProvider") DaoAuthenticationProvider daoUserAuthenticationProvider(){ return new UserAuthenticationProvider(encoder(), userDetailsService); } /** * 注入ManagerAuthenticationProvider * @return */ @Bean("ManagerAuthenticationProvider") DaoAuthenticationProvider daoMangerAuthenticationProvider(){ return new ManagerAuthenticationProvider(encoder(), managerDetailsService); } /** * 向AuthenticationManager添加Provider * @return */ @Autowired public void configureGlobal(AuthenticationManagerBuilder auth){ auth.authenticationProvider(daoUserAuthenticationProvider()); auth.authenticationProvider(daoMangerAuthenticationProvider()); } @Autowired public void configureAuthentication(AuthenticationManagerBuilder authenticationManagerBuilder) throws Exception { authenticationManagerBuilder.userDetailsService(this.userDetailsService).passwordEncoder(passwordEncoder); } /** * 注入AuthenticationManager * @return */ @Bean public AuthenticationManager authenticationManagerBean() throws Exception { return super.authenticationManagerBean(); } /** * 注入PasswordEncoder * @return */ @Bean public PasswordEncoder encoder() { PasswordEncoder encoder = PasswordEncoderFactories.createDelegatingPasswordEncoder(); return encoder; } /** * 具体Security 配置 * @return */ @Override protected void configure(HttpSecurity http) throws Exception { http. csrf().disable().//默认开启，这里先显式关闭csrf sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS) //Spring Security永远不会创建HttpSession，它不会使用HttpSession来获取SecurityContext .and() .authorizeRequests() .antMatchers(HttpMethod.OPTIONS, "/**").permitAll() //任何用户任意方法可以访问/** .antMatchers("/base/login").permitAll() //任何用户可以访问/user/** .anyRequest().authenticated() //任何没有匹配上的其他的url请求，只需要用户被验证 .and() .headers().cacheControl(); http.addFilterBefore(xwAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class); http.exceptionHandling().authenticationEntryPoint(entryPointUnauthorizedHandler).accessDeniedHandler(restAccessDeniedHandler); } }
然后是上面的两个Handler
这个很简单，就是实现AccessDeniedHandler和AuthenticationEntryPoint就是了。
/** * 身份验证失败自定401返回值 * * @author xuwang * Created on 2019/05/29 16:10. */ @Component public class EntryPointUnauthorizedHandler implements AuthenticationEntryPoint { @Override public void commence(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AuthenticationException e) throws IOException, ServletException { httpServletResponse.setHeader("Access-Control-Allow-Origin", "*"); httpServletResponse.setStatus(401); } }
/** * 权限不足自定403返回值 * * @author xuwang * Created on 2019/05/29 16:10. */ @Component public class RestAccessDeniedHandler implements AccessDeniedHandler { @Override public void handle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AccessDeniedException e) throws IOException, ServletException { httpServletResponse.setHeader("Access-Control-Allow-Origin", "*"); httpServletResponse.setStatus(403); } }
再然后就是JWT这一块了。
首先是一个Token的工具类，里面有些什么东西直接看注释就好了。
/** * JWT工具类 * * @author xuwang * Created on 2019/05/28 20:16. */ @Component public class XWTokenUtil implements Serializable { /** * 密钥 */ private final String secret = "11111111"; /** * 从数据声明生成令牌 * * @param claims 数据声明 * @return 令牌 */ private String generateToken(Map<String, Object> claims) { //有效时间 Date expirationDate = new Date(System.currentTimeMillis() + 2592000L * 1000); return Jwts.builder().setClaims(claims).setExpiration(expirationDate).signWith(SignatureAlgorithm.HS512, secret).compact(); } /** * 从令牌中获取数据声明 * * @param token 令牌 * @return 数据声明 */ private Claims getClaimsFromToken(String token) { Claims claims; try { claims = Jwts.parser().setSigningKey(secret).parseClaimsJws(token).getBody(); } catch (Exception e) { claims = null; } return claims; } /** * 生成令牌 * * @param userDetails 用户 * @return 令牌 */ public String generateToken(UserDetails userDetails) { Map<String, Object> claims = new HashMap<>(2); claims.put("sub", userDetails.getUsername()); claims.put("userId", ((XWUserDetails)userDetails).getUserId()); claims.put("userType", ((XWUserDetails)userDetails).getUserType()); claims.put("created", new Date()); return generateToken(claims); } /** * 从令牌中获取用户名 * * @param token 令牌 * @return 用户名 */ public String getUsernameFromToken(String token) { String username; try { Claims claims = getClaimsFromToken(token); username = claims.getSubject(); } catch (Exception e) { username = null; } return username; } /** * 从令牌中获取用户类型 * * @param token 令牌 * @return 用户类型 */ public String getUserTypeFromToken(String token) { String userType; try { Claims claims = getClaimsFromToken(token); userType = (String) claims.get("userType"); } catch (Exception e) { userType = null; } return userType; } /** * 从令牌中获取用户Id * * @param token 令牌 * @return 用户Id */ public Integer getUserIdFromToken(String token) { Integer userId; try { Claims claims = getClaimsFromToken(token); userId = (Integer) claims.get("userId"); } catch (Exception e) { userId = null; } return userId; } /** * 判断令牌是否过期 * * @param token 令牌 * @return 是否过期 */ public Boolean isTokenExpired(String token) { try { Claims claims = getClaimsFromToken(token); Date expiration = claims.getExpiration(); return expiration.before(new Date()); } catch (Exception e) { return false; } } /** * 刷新令牌 * * @param token 原令牌 * @return 新令牌 */ public String refreshToken(String token) { String refreshedToken; try { Claims claims = getClaimsFromToken(token); claims.put("created", new Date()); refreshedToken = generateToken(claims); } catch (Exception e) { refreshedToken = null; } return refreshedToken; } /** * 验证令牌 * * @param token 令牌 * @param userDetails 用户 * @return 是否有效 */ public Boolean validateToken(String token, UserDetails userDetails) { XWUserDetails user = (xwUserDetails) userDetails; String username = getUsernameFromToken(token); return (username.equals(user.getUsername()) && !isTokenExpired(token)); } }
然后是Filter
这个Filter大家都知道请求发过来，会先进行这个Filter里面的方法，这里的逻辑也很简单，从Token中拿到身份信息，并进行验证，验证这里我写得比简单，可以再加逻辑。
UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
SecurityContextHolder.getContext().setAuthentication(authentication);
重点是这三行，这三行是什么意思呢，前面说了需求是第一次登录验证成功，以后发请求使用Token就好了，这三行之前的逻辑是在校验Token，从Token中获取用户信息，但系统中进行权限管理的是Spring Security，并没有使用Spring Security 进行验证啊，
所以需要做的就是这三行，这三行中的SecurityContextHolder就是:SecurityContextHolder是用来保存SecurityContext的。SecurityContext中含有当前正在访问系统的用户的详细信息，
实际就是使用用户信息构建authentication放到SecurityContextHolder就等于用户已经登录了，就不用再校验密码什么的了。
/** * JWT Filter * * @author xuwang * Created on 2019/05/29 16:10. */ @Component public class XWAuthenticationTokenFilter extends OncePerRequestFilter { @Resource ManagerDetailsServiceImpl managerDetailsService; @Resource UserDetailsServiceImpl userDetailsService; @Resource private XWTokenUtil xwTokenUtil; /** * 获取验证token中的身份信息 * @author xuwang */ @Override protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws ServletException, IOException { //从请求头中获取token String authHeader = request.getHeader("Authorization"); //token前缀 String tokenHead = "Bearer "; if (authHeader != null && authHeader.startsWith(tokenHead)) { //去掉token前缀 String authToken = authHeader.substring(tokenHead.length()); //从token中获取用户名 String username = XWTokenUtil.getUsernameFromToken(authToken); String userType = XWTokenUtil.getUserTypeFromToken(authToken); if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) { UserDetails userDetails = null; //根据从token中获取用户名从数据库中获取一个userDetails if(userType.equals(XWUserDetails.USER_TYPE_CODE)){ //普通用户 userDetails = userDetailsService.loadUserByUsername(username); }else if(userType.equals(XWUserDetails.MANAGER_TYPE_CODE)){ //管理员 userDetails = managerDetailsService.loadUserByUsername(username); } if (xwTokenUtil.validateToken(authToken, userDetails)) { //token中的用户信息和数据库中的用户信息对比成功后将用户信息加入SecurityContextHolder相当于登陆 UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities()); authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request)); SecurityContextHolder.getContext().setAuthentication(authentication); } } } chain.doFilter(request, response); } }
然后是用户登录的接口了，我直接贴Service层的代码吧
/** * @ClassName: loginServiceImpl * @ClassNameExplain: * @Description: 业务层实现类 * @author xuwang * @date 2019-05-31 16:15:46 */ @Service public class LoginServiceImpl implements ILoginService { static final Logger logger = LoggerFactory.getLogger(LoginServiceImpl.class); @Resource private AuthenticationManager authenticationManager; @Autowired @Qualifier("userDetailsService") private UserDetailsService userDetailsService; @Autowired @Qualifier("managerDetailsService") private UserDetailsService managerDetailsService; @Resource private XWTokenUtil xwTokenUtil; @Override public LoginVO login(LoginIO loginIO) throws Exception { //不同的用户类型使用不同的登陆方式 String token = ""; UserDetails userDetails = null; if(loginIO.getType().equals(XWUserDetails.USER_TYPE_CODE)){ //登录 login(new UserAuthenticationToken(loginIO.getUserName(), loginIO.getPassword())); userDetails = userDetailsService.loadUserByUsername(loginIO.getUserName()); token = xwTokenUtil.generateToken(userDetails); logger.info("user[{}]登陆成功",loginIO.getUserName()); }else if(loginIO.getType().equals(XWUserDetails.MANAGER_TYPE_CODE)){ login(new ManagerAuthenticationToken(loginIO.getUserName(), loginIO.getPassword())); userDetails = managerDetailsService.loadUserByUsername(loginIO.getUserName()); token = xwUtil.generateToken(userDetails); logger.info("manager[{}]登陆成功",loginIO.getUserName()); }else { logger.error("type[{}]参数错误",loginIO.getType()); //type参数错误 throw new BusinessException(ExceptionConstants.PARAM_INVALID_CODE, ExceptionConstants.PARAM_INVALID_MSG); } LoginVO loginVO = new LoginVO(); loginVO.setToken(token); loginVO.setUserId(((XWUserDetails)userDetails).getUserId()); return loginVO == null ? new LoginVO() : loginVO; } /** * 校验账号密码并进行登陆 * @param upToken */ private void login(UsernamePasswordAuthenticationToken upToken){ //验证 Authentication authentication = authenticationManager.authenticate(upToken); //将用户信息保存到SecurityContextHolder=登陆 SecurityContextHolder.getContext().setAuthentication(authentication); } }
这个Service解释一下就是：
loginIO能接收到用户信息:账号UserName、密码Password、类型Type之类的，然后使用AuthenticationManager 进行校验，再使用SecurityContextHolder进行登录操作(上面解释过了)，最后返回Token(xwTokenUtil工具类生成的)和用户Id。
最后解释一下其中的流程，已经我为什么这么去实现吧。
从Service中我们可以看到，登录时使用的是先使用账号密码构建了一个UsernamePasswordAuthenticationToken，我这里构建的是UserAuthenticationToken、ManagerAuthenticationToken，不过影响不大，都是它的子类，AuthenticationManager的authenticate将接受一个UsernamePasswordAuthenticationToken来进行验证，最后才登录。
上面的相当于Security的登录使用流程。
然后解释一下前面的那些所有的疑惑，在Service中使用AuthenticationManager的authenticate()方法进行校验的时候，实际上是会把UsernamePasswordAuthenticationToken传递给Provider进行校验的，Provider里呢又让Service去校验的。这是类和类之间的关系，然后还有实际代码关系是，AuthenticationManager中会有一个Provider列表，进行校验的时候会遍历使用每一个Provider的supports()方法，这个supports()方法将校验传进来的UsernamePasswordAuthenticationToken是自己想要的UsernamePasswordAuthenticationToken吗，如果是的话就使用这个Provider进行校验。所以我实现了UserAuthenticationToken、ManagerAuthenticationToken，还实现了ManagerAuthenticationProvider、UserAuthenticationProvider以及其中的supports()方法，这样authenticationManager.authenticate(new UserAuthenticationToken)就会使用UserAuthenticationProvider中的UserDetailsServiceImpl去校验了。ManagerAuthenticationToken同理。
上面的我自己是觉得写得是比较清晰了。如果实在是看不明白，或者其实是我还是写得太烂了，可以自己跟一下代码，就从AuthenticationManager.authenticate()方法跟进去就好了，
具体跟代码的时候要注意，AuthenticationManager的默认实现是ProviderManager，所以其实看到的是ProviderManager的authenticate()方法
图中：
1. 获取到Authentication的类信息
2. 得到Provider列表的迭代器
3.进行遍历
4.调用Provider的supports()方法
所以我重写了两个provider和其中supports()方法，和两个AuthenticationToken。
然后其实这个东西并不算是太复杂，自己去用和学习的时候，最好还是先实现，然后在慢慢跟代码，去猜去思考其中的流程，就好了。
最后是为什么要这样去写代码、去注入、用这个方式进行加密、以及token中存放的信息、loginIo得设置等等的，这些都是可以任意更改的，无需纠结太多，根据根据个人习惯和当时的业务改就好了，至于到底怎样才是最好的，我也没太认真的去思考过，毕竟加班的时候只能先实现功能了，至于为什么在写这个博客的时候还不去思考的原因就是。。。因为这些并不是重点
