Spring Security构建Rest服务-1203-Spring Security OAuth开发APP认证框架之短信验证码登录

浏览器模式下验证码存储策略

浏览器模式下，生成的短信验证码或者图形验证码是存在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