Security + Spring boot + jwt 多方式登录（图片验证码，手机验证码，邮箱验证码）
Security认证流程图
通过自定义UsernamePasswordAuthenticationFilter和BasicAuthenticationFilter 实现（验证码验证可以在UsernamePasswordAuthenticationFilter之前再加入一个Filter过滤器来处理）
使用原来的登录url （/login）
JWTLoginFilter
/**
* 自定义JWT登录过滤器
* 验证用户名密码正确后，生成一个token，并将token返回给客户端
* 该类继承自UsernamePasswordAuthenticationFilter，重写了其中的3个方法
* attemptAuthentication ：接收并解析用户凭证。
* successfulAuthentication ：用户成功登录后，这个方法会被调用，我们在这个方法里生成token。
* unsuccessfulAuthentication ： 认证失败，异常往外抛，让全局异常捕捉（当然你也可以判断异常类型，返回不同的code）
* @author cola
*/
public class JWTLoginFilter extends UsernamePasswordAuthenticationFilter {
private AuthenticationManager authenticationManager;
public JWTLoginFilter(AuthenticationManager authenticationManager) {
this.authenticationManager = authenticationManager;
}
// 尝试身份认证(接收并解析用户凭证)
@Override
public Authentication attemptAuthentication(HttpServletRequest req, HttpServletResponse res) throws AuthenticationException {
try {
SysLoginForm loginForm = new ObjectMapper().readValue(req.getInputStream(), SysLoginForm.class);
if(!ClassUtils.equalStringPropertyValue(LoginModeConstant.class,loginForm.getLoginMode())){
logger.error("未选择登录方式");
throw new AuthenticationServiceException("服务异常");
}
checkVerificationCode(loginForm);
return authenticationManager.authenticate(
new UsernamePasswordAuthenticationToken(
loginForm.getUsername(),
loginForm.getPassword(),
new ArrayList<>())
);
} catch (IOException | IllegalAccessException | InstantiationException e) {
throw new RuntimeException(e);
}
}
protected void checkVerificationCode(SysLoginForm loginForm) throws GalaxyException{
RedisUtils redisUtils = (RedisUtils) SpringContextUtils.getBean("redisUtils");
String key = null;
String value = null;
if(LoginModeConstant.PHONE_VERIFICATION_CODE.equals(loginForm.getLoginMode())){
key = RedisKeys.PHONE_VERIFICATION_LOGIN_PREFIX + loginForm.getPhone();
value = redisUtils.get(key);
if(StrUtil.isBlank(value) || !value.equals(loginForm.getPhoneVerificationCode())){
throw new AuthenticationServiceException("验证码错误");
}
}else if(LoginModeConstant.EMAIL_VERIFICATION_CODE.equals(loginForm.getLoginMode())){
key = RedisKeys.EMAIL_VERIFICATION_LOGIN_PREFIX + loginForm.getEmail();
value = redisUtils.get(key);
if(StrUtil.isBlank(value) || !value.equals(loginForm.getEmailVerificationCode())){
throw new AuthenticationServiceException("验证码错误");
}
}else {
key = RedisKeys.IMAGE_VERIFICATION_LOGIN_PREFIX + loginForm.getUuid();
value = redisUtils.get(RedisKeys.IMAGE_VERIFICATION_LOGIN_PREFIX + loginForm.getUuid());
if(StrUtil.isBlank(value) || !value.equals(loginForm.getImageVerificationCode())){
throw new AuthenticationServiceException("验证码错误");
}
}
redisUtils.delete(key);
}
// 认证成功(用户成功登录后，这个方法会被调用，我们在这个方法里生成token)
@Override
protected void successfulAuthentication(HttpServletRequest request,
HttpServletResponse response,
FilterChain chain,
Authentication auth) throws IOException, ServletException {
// builder the token
String token = null;
try {
Collection<? extends GrantedAuthority> authorities = auth.getAuthorities();
// 定义存放角色集合的对象
List roleList = new ArrayList<>();
for (GrantedAuthority grantedAuthority : authorities) {
roleList.add(grantedAuthority.getAuthority());
}
JwtConfig jwtConfig = (JwtConfig) SpringContextUtils.getBean("jwtConfig");
// 生成token start
Calendar calendar = Calendar.getInstance();
// 签发时间
Date now = calendar.getTime();
// 过期时间
Date time = new Date(now.getTime() + jwtConfig.getExpiration());
token = Jwts.builder()
.setSubject(auth.getName() + "-" + roleList)
.setIssuedAt(now)//签发时间
.setExpiration(time)//过期时间
.signWith(SignatureAlgorithm.HS256, jwtConfig.getSecret()) //采用什么算法是可以自己选择的，不一定非要采用HS512
.compact();
// 生成token end
// 登录成功后，返回token
TokenInfoDTO dto = new TokenInfoDTO();
dto.setToken(token);
dto.setUserName(auth.getName());
response.setCharacterEncoding("utf-8");
response.setContentType("application/json; charset=utf-8");
response.getWriter().write(JSON.toJSONString(DataResultUtil.success(dto)));
logger.debug("认证成功");
logger.debug("用户:" + auth.getName());
} catch (Exception e) {
logger.error("认证异常",e);
response.getWriter().write(JSON.toJSONString(DataResultUtil.error("网络异常")));
}
}
@Override
protected void unsuccessfulAuthentication(HttpServletRequest request, HttpServletResponse response, AuthenticationException authenticationException) throws IOException, ServletException {
logger.debug("认证失败");
logger.debug(authenticationException.getMessage());
response.setCharacterEncoding("utf-8");
response.setContentType("application/json; charset=utf-8");
response.getWriter().write(JSON.toJSONString(DataResultUtil.error(authenticationException.getMessage())));
}
}
Security 登录异常不能全局捕捉，通过 unsuccessfulAuthentication 捕捉并返回，其实在这个地方再往外抛异常好像是可以，一开始我是这样做的，后来也失效了。就改成这样了，功力不够啊，求大神解惑。
CustomAuthenticationProvider
/**
* 自定义身份认证验证组件
*
* @author
*/
public class CustomAuthenticationProvider implements AuthenticationProvider {
private UserDetailsService userDetailsService;
private BCryptPasswordEncoder bCryptPasswordEncoder;
public CustomAuthenticationProvider(UserDetailsService userDetailsService, BCryptPasswordEncoder bCryptPasswordEncoder){
this.userDetailsService = userDetailsService;
this.bCryptPasswordEncoder = bCryptPasswordEncoder;
}
/**
*执行与以下合同相同的身份验证
* {@link org.springframework.security.authentication.AuthenticationManager＃authenticate（Authentication）}
*。
*
* @param authentication 身份验证请求对象。
*
* @返回包含凭证的经过完全认证的对象。 可能会回来
* <code> null </ code>（如果<code> AuthenticationProvider </ code>无法支持）
* 对传递的<code> Authentication </ code>对象的身份验证。 在这种情况下，
* 支持所提供的下一个<code> AuthenticationProvider </ code>
* 将尝试<code> Authentication </ code>类。
*
* @throws AuthenticationException 如果身份验证失败。
*/
@Override
public Authentication authenticate(Authentication authentication) throws AuthenticationException {
// 获取认证的用户名 & 密码
String username = authentication.getName();
//明文密码
String password = authentication.getCredentials().toString();
// 认证逻辑
UserDetails userDetails = userDetailsService.loadUserByUsername(username);
if (null != userDetails) {
//密码比对
if (bCryptPasswordEncoder.matches(password, userDetails.getPassword())) {
//根据用户的名查询用户的权限
ArrayList<GrantedAuthority> authorities = new ArrayList<>();
Set<String> permissions = SecurityUserUtils.getUserPermissions(username);
if(CollUtil.isNotEmpty(permissions)) {
for (String permission : permissions) {
authorities.add(new GrantedAuthorityServiceImpl(permission));
}
}
return new UsernamePasswordAuthenticationToken(username, password, authorities);
} else {
throw new BadCredentialsException("密码错误");
}
} else {
throw new UsernameNotFoundException("用户不存在");
}
}
/**
* 是否可以提供输入类型的认证服务
* @param authentication
* @return
*/
@Override
public boolean supports(Class<?> authentication) {
return authentication.equals(UsernamePasswordAuthenticationToken.class);
}
}
UserDetailsServiceImpl
/**
* @author cola
* @version 1.0
**/
@Service("userDetailsServiceImpl")
public class UserDetailsServiceImpl implements UserDetailsService {
@Autowired
SysUserDao sysUserDao;
//根据 账号查询用户信息
@Override
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
//将来连接数据库根据账号查询用户信息
SysUserEntity sysUserEntity = sysUserDao.queryByUserName(username);
if(sysUserEntity == null){
//如果用户查不到，返回null，由provider来抛出异常
return null;
}
// 交给 CustomAuthenticationProvider 处理认证，这里先不查询权限标识
return User.withUsername(sysUserEntity.getUsername()).password(sysUserEntity.getPassword()).authorities(emptyList()).build();
}
}
LoginModeConstant
public class LoginModeConstant {
/**
* @author： cola
* @date： 2020/11/30 14:21
* @description：图片验证码
*/
public static final String PHONE_VERIFICATION_CODE = "PHONE_VERIFICATION_CODE";
/**
* @author： cola
* @date： 2020/11/30 14:21
* @description：手机验证码
*/
public static final String IMAGE_VERIFICATION_CODE = "IMAGE_VERIFICATION_CODE";
/**
* @author： cola
* @date： 2020/11/30 14:21
* @description：邮箱验证码
*/
public static final String EMAIL_VERIFICATION_CODE = "EMAIL_VERIFICATION_CODE";
}
JWTAuthenticationFilter
/**
* 自定义JWT认证过滤器
* 该类继承自BasicAuthenticationFilter，在doFilterInternal方法中，
* 从http头或参数 项读取token数据，然后用Jwts包提供的方法校验token的合法性。
* 如果校验通过，就认为这是一个取得授权的合法请求
* @author cola
*/
public class JWTAuthenticationFilter extends BasicAuthenticationFilter {
private static final Logger logger = LoggerFactory.getLogger(JWTAuthenticationFilter.class);
public JWTAuthenticationFilter(AuthenticationManager authenticationManager) {
super(authenticationManager);
}
@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException {
String token = request.getHeader("token");
if (StringUtil.isNullOrEmpty(token)) {
token = request.getParameter("token");
if(StringUtil.isNullOrEmpty(token)) {
chain.doFilter(request, response);
return;
}
}
UsernamePasswordAuthenticationToken authentication = getAuthentication(request, response);
SecurityContextHolder.getContext().setAuthentication(authentication);
chain.doFilter(request, response);
}
private UsernamePasswordAuthenticationToken getAuthentication(HttpServletRequest request, HttpServletResponse response) {
long start = System.currentTimeMillis();
String token = request.getHeader("token");
if (StringUtil.isNullOrEmpty(token)) {
token = request.getParameter("token");
if(StringUtil.isNullOrEmpty(token)) {
throw new TokenException("Token为空");
}
}
// parse the token.
String user = null;
try {
JwtConfig jwtConfig = (JwtConfig)SpringContextUtils.getBean("jwtConfig");
Claims claims = Jwts.parser().setSigningKey(jwtConfig.getSecret()).parseClaimsJws(token).getBody();
// token签发时间
long issuedAt = claims.getIssuedAt().getTime();
// 当前时间
long currentTimeMillis = System.currentTimeMillis();
// token过期时间
long expirationTime = claims.getExpiration().getTime();
// 1. 签发时间 < 当前时间 < (签发时间+((token过期时间-token签发时间)/2)) 不刷新token
// 2. (签发时间+((token过期时间-token签发时间)/2)) < 当前时间 < token过期时间 刷新token并返回给前端
// 3. tokne过期时间 < 当前时间 跳转登录，重新登录获取token
// 验证token时间有效性
if ((issuedAt + ((expirationTime - issuedAt) / 2)) < currentTimeMillis && currentTimeMillis < expirationTime) {
// 重新生成token start
Calendar calendar = Calendar.getInstance();
// 签发时间
Date now = calendar.getTime();
// 过期时间
Date time = new Date(now.getTime() + jwtConfig.getExpiration());
String refreshToken = Jwts.builder()
.setSubject(claims.getSubject())
.setIssuedAt(now)//签发时间
.setExpiration(time)//过期时间
.signWith(SignatureAlgorithm.HS256, jwtConfig.getSecret()) //采用什么算法是可以自己选择的，不一定非要采用HS512
.compact();
// 重新生成token end
// 主动刷新token，并返回给前端
response.addHeader("refreshToken", refreshToken);
}
long end = System.currentTimeMillis();
logger.debug("执行时间: {}", (end - start) + " 毫秒");
user = claims.getSubject();
if (user != null) {
String[] split = user.split("-")[1].split(",");
String userName = user.split("-")[0];
ArrayList<GrantedAuthority> authorities = new ArrayList<>();
for (String s : split) {
authorities.add(new GrantedAuthorityServiceImpl(s));
}
return new UsernamePasswordAuthenticationToken(userName, null, authorities);
}
} catch (ExpiredJwtException e) {
logger.error("Token已过期:",e);
throw new TokenException("Token已过期");
} catch (UnsupportedJwtException e) {
logger.error("Token格式错误:",e);
throw new TokenException("Token格式错误");
} catch (MalformedJwtException e) {
logger.error("Token没有被正确构造:",e);
throw new TokenException("Token没有被正确构造");
} catch (SignatureException e) {
logger.error("签名失败:",e);
throw new TokenException("签名失败");
} catch (IllegalArgumentException e) {
logger.error("非法参数异常:",e);
throw new TokenException("非法参数异常");
}
return null;
}
}
WebSecurityConfig
/**
* SpringSecurity的配置
* 通过SpringSecurity的配置，将JWTLoginFilter，JWTAuthenticationFilter组合在一起
* @author zhaoxinguo on 2017/9/13.
*/
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(securedEnabled = true)
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
/**
* 需要放行的URL
*/
@Value("#{'${auth.whitelist}'.split(',')}")
private String[] whitelist;
@Value("${auth.loginUrl}")
private String loginUrl;
@Value("${auth.logoutUrl}")
private String logoutUrl;
@Value("${auth.logoutSuccessUrl}")
private String logoutSuccessUrl;
@Autowired
private UserDetailsServiceImpl userDetailsService;
@Autowired
private CustomAccessDeniedHandler customAccessDeniedHandler;
@Autowired
private CustomLogoutSuccessHandler customLogoutSuccessHandler;
// 设置 HTTP 验证规则
@Override
protected void configure(HttpSecurity http) throws Exception {
LogoutConfigurer<HttpSecurity> httpSecurityLogoutConfigurer = http
.formLogin()
.loginProcessingUrl(loginUrl)
.and()
.cors()
.and()
.csrf().disable().sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
.and()
.authorizeRequests().antMatchers(whitelist).permitAll().anyRequest().authenticated() // 所有请求需要身份认证
.and()
// .exceptionHandling().authenticationEntryPoint(new Http401AuthenticationEntryPoint("Basic realm=\"MyApp\""))
// .and()
// .exceptionHandling().accessDeniedHandler(customAccessDeniedHandler) // 自定义访问失败处理器
// .and()
.addFilter(new JWTLoginFilter(authenticationManager()))
.addFilter(new JWTAuthenticationFilter(authenticationManager()))
.logout() // 默认注销行为为logout，可以通过下面的方式来修改
.logoutUrl(logoutUrl)
.logoutSuccessUrl(logoutSuccessUrl)// 设置注销成功后跳转页面，默认是跳转到登录页面;
// .logoutSuccessHandler(customLogoutSuccessHandler)
.permitAll();
}
// 该方法是登录的时候会进入
@Override
public void configure(AuthenticationManagerBuilder auth) throws Exception {
// 使用自定义身份验证组件
auth.authenticationProvider(new CustomAuthenticationProvider(userDetailsService, new BCryptPasswordEncoder()));
}
}
GrantedAuthorityServiceImpl
/**
* 权限类型，负责存储权限和角色
*
* @author cola
*/
public class GrantedAuthorityServiceImpl implements GrantedAuthority {
private String authority;
public GrantedAuthorityServiceImpl(String authority) {
this.authority = authority;
}
public void setAuthority(String authority) {
this.authority = authority;
}
@Override
public String getAuthority() {
return this.authority;
}
}
TokenException
public class TokenException extends RuntimeException {
private static final long serialVersionUID = 1L;
private String msg;
private String code = ResultEnum.UNAUTHORIZED.getValue();
public TokenException(String msg) {
super(msg);
this.msg = msg;
}
public TokenException(String msg, Throwable e) {
super(msg, e);
this.msg = msg;
}
public TokenException(String msg, String code) {
super(msg);
this.msg = msg;
this.code = code;
}
public TokenException(String msg, String code, Throwable e) {
super(msg, e);
this.msg = msg;
this.code = code;
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
public String getCode() {
return code;
}
public void setCode(String code) {
this.code = code;
}
}
配置信息
auth:
#白名单
whitelist: /v2/**,/swagger-ui.html,/swagger-resources/**,/doc.html,/webjars/**,/login,/captcha.jpg,/sms/login/code,/mail/login/code
#登录url
loginUrl: /login
#登出url
logoutUrl: /logout
#登出成功跳转url
logoutSuccessUrl: /login
其实实现很简单，复制代码，再修改一下报错就行（一些个性化的东西）jwt、redis集成可以自行百度。
jwt集成参考的是 springboot-springsecurity-jwt-demo
项目逻辑引用（jwt实现原理）
一: RestApi接口增加JWT认证功能
用户填入用户名密码后，与数据库里存储的用户信息进行比对，如果通过，则认证成功。传统的方法是在认证通过后，创建sesstion，并给客户端返回cookie。
现在我们采用JWT来处理用户名密码的认证。区别在于，认证通过后，服务器生成一个token，将token返回给客户端，客户端以后的所有请求都需要在http头中指定该token。
服务器接收的请求后，会对token的合法性进行验证。验证的内容包括：
内容是一个正确的JWT格式
检查签名
检查claims
检查权限
处理登录
创建一个类JWTLoginFilter，核心功能是在验证用户名密码正确后，生成一个token，并将token返回给客户端：
该类继承自UsernamePasswordAuthenticationFilter，重写了其中的2个方法：
attemptAuthentication ：接收并解析用户凭证。
successfulAuthentication ：用户成功登录后，这个方法会被调用，我们在这个方法里生成token。
二:授权验证
用户一旦登录成功后，会拿到token，后续的请求都会带着这个token，服务端会验证token的合法性。
创建JwtAuthenticationFilter类，我们在这个类中实现token的校验功能。
该类继承自BasicAuthenticationFilter，在doFilterInternal方法中，从http头的Authorization 项读取token数据，然后用Jwts包提供的方法校验token的合法性。
如果校验通过，就认为这是一个取得授权的合法请求。
三:SpringSecurity配置
通过SpringSecurity的配置，将上面的方法组合在一起。
这是标准的SpringSecurity配置内容，就不在详细说明。注意其中的
.addFilter(new JWTLoginFilter(authenticationManager()))
.addFilter(new JwtAuthenticationFilter(authenticationManager()))
这两行，将我们定义的JWT方法加入SpringSecurity的处理流程中。
扫一扫
745
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
