浏览器模式下验证码存储策略
浏览器模式下，生成的短信验证码或者图形验证码是存在session里的，用户接收到验证码后携带过来做校验。
APP模式下验证码存储策略
在app场景下里是没有cookie信息的，请求里也就没有JSESSIONID，所以即使生成了验证码存在session里，你也接收到了验证码，但是没有JSEESIONID，校验你带过来的验证码时，会找不到对应的session，所以不能用session来存储验证码。
解决：在 生成 和 校验验证码的时候多带一个参数 ，设备id，生成验证码时，把生成的验证码和设备id一起存在外部存储里（数据库或redis里），校验的时候拿着设备id去找对应的验证码即可。
将验证码的存取策略代码抽取成接口，app和浏览器分别实现这个接口：
接口ValidateCodeRepository：
app的实现：
package com.imooc.security.app.validate.code.impl;
import java.util.concurrent.TimeUnit;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.ServletWebRequest;
import com.imooc.security.core.validate.code.ValidateCode;
import com.imooc.security.core.validate.code.ValidateCodeException;
import com.imooc.security.core.validate.code.ValidateCodeRepository;
import com.imooc.security.core.validate.code.ValidateCodeType;
/**
* redis验证码存取策略
* ClassName: RedisValidateCodeRepository
* @Description: redis验证码存取策略
* @author lihaoyang
* @date 2018年3月14日
*/
@Component
public class RedisValidateCodeRepository implements ValidateCodeRepository{
private Logger logger = LoggerFactory.getLogger(getClass());
@Autowired
private RedisTemplate<Object, Object> redisTemplate;
@Override
public void save(ServletWebRequest request, ValidateCode code, ValidateCodeType validateCodeType) {
String key = buildKey(request, validateCodeType);
logger.info("--------->redis存进去了一个新的key："+key+"，value："+code+"<-----------");
redisTemplate.opsForValue().set(key, code, 30, TimeUnit.MINUTES);
}
@Override
public ValidateCode get(ServletWebRequest request, ValidateCodeType validateCodeType) {
Object value = redisTemplate.opsForValue().get(buildKey(request, validateCodeType));
if(value == null){
return null;
}
return (ValidateCode) value;
}
@Override
public void remove(ServletWebRequest request, ValidateCodeType validateCodeType) {
String key = buildKey(request, validateCodeType);
logger.info("--------->redis删除了一个key："+key+"<-----------");
redisTemplate.delete(key);
}
/**
* 构建验证码在redis中的key
* @Description: 构建验证码在redis中的key
* @param @return
* @return String 验证码在redis中的key
* @throws
* @author lihaoyang
* @date 2018年3月14日
*/
private String buildKey(ServletWebRequest request , ValidateCodeType validateCodeType){
//获取设备id
String deviceId = request.getHeader("deviceId");
if(StringUtils.isBlank(deviceId)){
throw new ValidateCodeException("deviceId为空，请求头中未携带deviceId参数");
}
return "code:" + validateCodeType.toString().toLowerCase()+":"+deviceId;
}
}
application.properties里配置上redis：
#redis
# Redis数据库索引（默认为0）
spring.redis.database=0
# Redis服务器地址
spring.redis.host=127.0.0.1
# Redis服务器连接端口
spring.redis.port=6379
# Redis服务器连接密码（默认为空）
spring.redis.password=
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.pool.max-active=8
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.pool.max-wait=-1
# 连接池中的最大空闲连接
spring.redis.pool.max-idle=8
# 连接池中的最小空闲连接
spring.redis.pool.min-idle=0
# 连接超时时间（毫秒）
spring.redis.timeout=0
我是在windows上装了个redis，简单省事。
controller里生成验证码的地方，也换成了用 接口，具体的实现 看你引用app模块还是browser模块：
@GetMapping(SecurityConstants.DEFAULT_VALIDATE_CODE_URL_PREFIX+"/sms")
public void createSmsCode(HttpServletRequest request,HttpServletResponse response) throws Exception{
//调验证码生成接口方式
ValidateCode smsCode = smsCodeGenerator.generator(new ServletWebRequest(request));
/**
* 不能把验证码存在session了，调接口，app和browser不同实现
*/
// sessionStrategy.setAttribute(new ServletWebRequest(request), SESSION_KEY_SMS, smsCode);
validateCodeRepository.save(new ServletWebRequest(request) , smsCode, ValidateCodeType.SMS);
//获取手机号
String mobile = ServletRequestUtils.getRequiredStringParameter(request, "mobile");
//发送短信验证码
smsCodeSender.send(mobile, smsCode.getCode());
}
验证码过滤器也换了：
/**
* 短信验证码过滤器
* ClassName: ValidateCodeFilter
* @Description:
* 继承OncePerRequestFilter：spring提供的工具，保证过滤器每次只会被调用一次
* 实现 InitializingBean接口的目的：
* 在其他参数都组装完毕的时候，初始化需要拦截的urls的值
* @author lihaoyang
* @date 2018年3月2日
*/
public class SmsCodeFilter extends OncePerRequestFilter implements InitializingBean{
private Logger logger = LoggerFactory.getLogger(getClass());
//认证失败处理器
private AuthenticationFailureHandler authenticationFailureHandler;
//获取session工具类
private SessionStrategy sessionStrategy = new HttpSessionSessionStrategy();
private ValidateCodeRepository validateCodeRepository;
//需要拦截的url集合
private Set<String> urls = new HashSet<>();
//读取配置
private SecurityProperties securityProperties;
//spring工具类
private AntPathMatcher antPathMatcher = new AntPathMatcher();
/**
* 重写InitializingBean的方法，设置需要拦截的urls
*/
@Override
public void afterPropertiesSet() throws ServletException {
super.afterPropertiesSet();
//读取配置的拦截的urls
String[] configUrls = StringUtils.splitByWholeSeparatorPreserveAllTokens(securityProperties.getCode().getSms().getUrl(), ",");
//如果配置了需要验证码拦截的url，不判断，如果没有配置会空指针
if(configUrls != null && configUrls.length > 0){
for (String configUrl : configUrls) {
logger.info("ValidateCodeFilter.afterPropertiesSet()--->配置了验证码拦截接口:"+configUrl);
urls.add(configUrl);
}
}else{
logger.info("----->没有配置拦验证码拦截接口<-------");
}
//短信验证码登录一定拦截
urls.add(SecurityConstants.DEFAULT_LOGIN_PROCESSING_URL_MOBILE);
}
@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
throws ServletException, IOException {
//如果是 登录请求 则执行
// if(StringUtils.equals("/authentication/form", request.getRequestURI())
// &&StringUtils.equalsIgnoreCase(request.getMethod(), "post")){
// try {
// validate(new ServletWebRequest(request));
// } catch (ValidateCodeException e) {
// //调用错误处理器，最终调用自己的
// authenticationFailureHandler.onAuthenticationFailure(request, response, e);
// return ;//结束方法，不再调用过滤器链
// }
// }
/**
* 可配置的验证码校验
* 判断请求的url和配置的是否有匹配的，匹配上了就过滤
*/
boolean action = false;
for(String url:urls){
if(antPathMatcher.match(url, request.getRequestURI())){
action = true;
}
}
if(action){
try {
validate(new ServletWebRequest(request));
} catch (ValidateCodeException e) {
//调用错误处理器，最终调用自己的
authenticationFailureHandler.onAuthenticationFailure(request, response, e);
return ;//结束方法，不再调用过滤器链
}
}
//不是登录请求，调用其它过滤器链
filterChain.doFilter(request, response);
}
/**
* 校验验证码
* @Description: 校验验证码
* @param @param request
* @param @throws ServletRequestBindingException
* @return void
* @throws ValidateCodeException
* @author lihaoyang
* @date 2018年3月2日
*/
private void validate(ServletWebRequest request) throws ServletRequestBindingException {
//拿出session中的ImageCode对象
// ValidateCode smsCodeInSession = (ValidateCode) sessionStrategy.getAttribute(request, ValidateCodeController.SESSION_KEY_SMS);
//根据不同的存储策略调用不同的获取方式
ValidateCode validateCode = validateCodeRepository.get(request, ValidateCodeType.SMS);
//拿出请求中的验证码
String imageCodeInRequest = ServletRequestUtils.getStringParameter(request.getRequest(), SecurityConstants.DEFAULT_PARAMETER_NAME_CODE_SMS);
//校验
if(StringUtils.isBlank(imageCodeInRequest)){
throw new ValidateCodeException("验证码不能为空");
}
if(validateCode == null){
throw new ValidateCodeException("验证码不存在，请刷新验证码");
}
if(validateCode.isExpired()){
//从session移除过期的验证码
// sessionStrategy.removeAttribute(request, ValidateCodeController.SESSION_KEY_SMS);
validateCodeRepository.remove(request, ValidateCodeType.SMS);
throw new ValidateCodeException("验证码已过期，请刷新验证码");
}
if(!StringUtils.equalsIgnoreCase(validateCode.getCode(), imageCodeInRequest)){
throw new ValidateCodeException("验证码错误");
}
//验证通过，移除session中验证码
// sessionStrategy.removeAttribute(request, ValidateCodeController.SESSION_KEY_SMS);
validateCodeRepository.remove(request, ValidateCodeType.SMS);
}
public AuthenticationFailureHandler getAuthenticationFailureHandler() {
return authenticationFailureHandler;
}
public void setAuthenticationFailureHandler(AuthenticationFailureHandler authenticationFailureHandler) {
this.authenticationFailureHandler = authenticationFailureHandler;
}
public SecurityProperties getSecurityProperties() {
return securityProperties;
}
public void setSecurityProperties(SecurityProperties securityProperties) {
this.securityProperties = securityProperties;
}
public ValidateCodeRepository getValidateCodeRepository() {
return validateCodeRepository;
}
public void setValidateCodeRepository(ValidateCodeRepository validateCodeRepository) {
this.validateCodeRepository = validateCodeRepository;
}
}
注意SmsCodeFilter 这个类里，由于这个类不是由Spring管理的，所以这里边不能注入 ValidateCodeRepository ，只能将其作为成员变量，生成get、set，在new SmsCodeFilter 的类里，再注入ValidateCodeRepository为成员变量，再给SmsCodeFilter set进去
/**
* 资源服务器，和认证服务器在物理上可以在一起也可以分开
* ClassName: ImoocResourceServerConfig
* @Description: TODO
* @author lihaoyang
* @date 2018年3月13日
*/
@Configuration
@EnableResourceServer
public class ImoocResourceServerConfig extends ResourceServerConfigurerAdapter{
//自定义的登录成功后的处理器
@Autowired
private AuthenticationSuccessHandler imoocAuthenticationSuccessHandler;
//自定义的认证失败后的处理器
@Autowired
private AuthenticationFailureHandler imoocAuthenticationFailureHandler;
//读取用户配置的登录页配置
@Autowired
private SecurityProperties securityProperties;
@Autowired
private SmsCodeAuthenticationSecurityConfig smsCodeAuthenticationSecurityConfig;
@Autowired
private ValidateCodeRepository validateCodeRepository;
@Override
public void configure(HttpSecurity http) throws Exception {
//~~~-------------> 图片验证码过滤器 <------------------
ValidateCodeFilter validateCodeFilter = new ValidateCodeFilter();
validateCodeFilter.setValidateCodeRepository(validateCodeRepository);
//验证码过滤器中使用自己的错误处理
validateCodeFilter.setAuthenticationFailureHandler(imoocAuthenticationFailureHandler);
//配置的验证码过滤url
validateCodeFilter.setSecurityProperties(securityProperties);
validateCodeFilter.afterPropertiesSet();
//~~~-------------> 短信验证码过滤器 <------------------
SmsCodeFilter smsCodeFilter = new SmsCodeFilter();
smsCodeFilter.setValidateCodeRepository(validateCodeRepository);
//验证码过滤器中使用自己的错误处理
smsCodeFilter.setAuthenticationFailureHandler(imoocAuthenticationFailureHandler);
//配置的验证码过滤url
smsCodeFilter.setSecurityProperties(securityProperties);
smsCodeFilter.afterPropertiesSet();
http
.addFilterBefore(smsCodeFilter, UsernamePasswordAuthenticationFilter.class)
// .apply(imoocSocialSecurityConfig)//社交登录
// .and()
//把验证码过滤器加载登录过滤器前边
.addFilterBefore(validateCodeFilter, UsernamePasswordAuthenticationFilter.class)
//----------表单认证相关配置---------------
.formLogin()
.loginPage(SecurityConstants.DEFAULT_UNAUTHENTICATION_URL) //处理用户认证BrowserSecurityController
.loginProcessingUrl(SecurityConstants.DEFAULT_LOGIN_PROCESSING_URL_FORM)
.successHandler(imoocAuthenticationSuccessHandler)//自定义的认证后处理器
.failureHandler(imoocAuthenticationFailureHandler) //登录失败后的处理
.and()
//-----------授权相关的配置 ---------------------
.authorizeRequests()
// /authentication/require：处理登录，securityProperties.getBrowser().getLoginPage():用户配置的登录页
.antMatchers(SecurityConstants.DEFAULT_UNAUTHENTICATION_URL,
securityProperties.getBrowser().getLoginPage(),//放过登录页不过滤，否则报错
SecurityConstants.DEFAULT_LOGIN_PROCESSING_URL_MOBILE,
SecurityConstants.SESSION_INVALID_PAGE,
SecurityConstants.DEFAULT_VALIDATE_CODE_URL_PREFIX+"/*").permitAll() //验证码
.anyRequest() //任何请求
.authenticated() //都需要身份认证
.and()
.csrf().disable() //关闭csrf防护
.apply(smsCodeAuthenticationSecurityConfig);//把短信验证码配置应用上
}
}
启动demo项目，获取验证码，注意需要在请求头里带上设备id
生成验证码：
redis:
登录：
响应token：
登录成功，redis清除验证码
就能拿着token访问controller了：
{
"password": null,
"username": "13812349876",
"authorities":[
{
"authority": "ROLE_USER"
},
{
"authority": "admin"
}
],
"accountNonExpired": true,
"accountNonLocked": true,
"credentialsNonExpired": true,
"enabled": true,
"userId": "13812349876"
}
代码在github ：https://github.com/lhy1234/spring-security
