使用shiro完成短信验证码登录

    过了4个月才写第二篇，相当之懒。项目里需要做一个短信验证码的登录，这里使用了shiro。

      1.首先是subject:与服务器交互的主体就是subject(用户)，获得subject的方式

    

        Subject subject = SecurityUtils.getSubject();

   可以在项目的任何地方使用。

     2.UsernamePasswordToken（令牌）,用来验证用户名、密码的登录方式，如果需要其他方式认证登录，可以自定义token，继承UsernamePasswordToken类，自定义realm进行实现。

 

   3.realm:继承AuthorizingRealm，实质上就是与数据库的连接，里面实现2个方法

    

/**
 * 为当限前登录的用户授予角色和权限
 */
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {

    return null;
}

/**
 * 验证当前登录的用户
 */
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
   return null;
}

   上面是角色和权限的验证，下面是token的验证，即登录验证。

  4.调用的方法:

//登录
subject.login(token);

 5.逻辑:⑴接收前端jsp或html传来的手机号和短信验证码,放到token中

String mobile = request.getParameter("mobile");
String code = request.getParameter("code");
UsernamePasswordToken token = new UsernamePasswordToken(mobile, code);

           ⑵调用登录方法：subject.login(token);

           ⑶realm里用当前手机号去查找用户表里是否有当前手机号的用户，没找到或验证码不对则手动抛出异常

  6.登录接口

  

    /**
     * 用户登录
     * */
    @RequestMapping("login")
    @ResponseBody
    public String test(HttpServletRequest request, HttpServletResponse response, HttpSession session, Model model){
          //这句是用来与前端h5进行调试时用的，调试时会有一个ajax跨域的问题
//        response.setHeader("Access-Control-Allow-Origin", "*");
        String mobile = request.getParameter("mobile");
        String code = request.getParameter("code");
        ActivityVO activityVO = new ActivityVO();
        JsonMapper jsonMapper = new JsonMapper();
        //主体,当前状态为没有认证的状态“未认证”
        Subject subject = SecurityUtils.getSubject();
        //创建令牌，将手机号和验证码丢进去
        UsernamePasswordToken token = new UsernamePasswordToken(mobile, code);
        //设置rememberMe为true
        token.setRememberMe(true);
        UserUser user;
        try {
            //登录
            subject.login(token);
            //登录成功，则认证成功，rememberMe和这个认证的状态是互斥的
            if (subject.isAuthenticated()){
                //获得session
                Session subjectSession = subject.getSession();
                //去数据里查找当前用户
                user = icUserUserService.findUserUserByMobile(mobile);
                //将用户存于session中
                subjectSession.setAttribute(CustomActConstans.userSession,user);
            }
            activityVO.setCode(1);
            activityVO.setMsg("登录成功!");
            return jsonMapper.toJson(activityVO);
        } catch (UnknownAccountException ex) {// 用户名没有找到。
            activityVO.setCode(-1);
            activityVO.setMsg("账号不存在!");
            return jsonMapper.toJson(activityVO);
        } catch (IncorrectCredentialsException ex) {// 用户名密码不匹配。
            activityVO.setCode(-2);
            activityVO.setMsg("验证码错误!");
            return jsonMapper.toJson(activityVO);
        } catch (AuthenticationException e) {//其他异常
            activityVO.setCode(-3);
            activityVO.setMsg("未知错误，请刷新页面重新登录！");
            return jsonMapper.toJson(activityVO);
        }
    }

7.realm认证

    /**
     * 为当限前登录的用户授予角色和权限
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {

        return null;
    }

    /**
     * 验证当前登录的用户
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        //接收输入的用户名
        String mobile = (String) token.getPrincipal();
        //查看UsernamePasswordToken可知，getCredentials()方法的返回值是char []类型的，所以不能直接转化成string。
        char [] ch = (char[]) token.getCredentials();
        //接收输入的密码或验证码
        String password = new String(ch);
        UserUser user;
            user = icUserUserService.findUserUserByMobile(mobile) ;
            if (user != null) {
                //用户不为空则到缓存中去取验证码，获取验证码后我将验证码存入了ehcache缓存，过期时间3分钟
                String cacheCode = (String) CacheUtils.get("codeCache", key);
                //判断验证码是否正确
                if (!cacheCode.equals(password)) {
                   throw new IncorrectCredentialsException();
                }
                AuthenticationInfo authcInfo = new SimpleAuthenticationInfo(mobile, password,null,getName());
                return authcInfo;
            }else {
                return null;
            }
    }

8.shiro.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd"
       default-lazy-init="true">

    <description>Shiro security Manager</description>


         <!-- 自定义Realm类所在的位置 -->
        <bean id="myRealm" class="cn.xxx.xxx.xxx.xxx.ShiroRealm"/>

         <!-- 安全管理器 与自定义realm关联-->
         <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
            <property name="realm" ref="myRealm"/>
             <property name="cacheManager" ref="shiroEhcacheManager"/>
         </bean>

         <!-- Shiro过滤器 -->
         <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
             <!-- Shiro的核心安全接口,这个属性是必须的 -->
             <property name="securityManager" ref="securityManager"/>
             <!-- 身份认证失败，则跳转到登录页面的配置 -->
             <property name="loginUrl" value="/index.html"/>
            <!-- 权限认证失败，则跳转到指定页面 -->
             <property name="unauthorizedUrl" value="/unauthorized.jsp"/>
             <!-- Shiro连接约束配置,即过滤链的定义 -->
             <property name="filterChainDefinitions">
                 <value>
                     <!--所有接口都不需要认证-->
                     /*=anon
                 </value>
             </property>
         </bean>


        <!-- 用户授权信息Cache, 采用EhCache -->
        <bean id="shiroEhcacheManager" class="org.apache.shiro.cache.ehcache.EhCacheManager">
            <property name="cacheManagerConfigFile" value="classpath:ehcache/ehcache-shiro.xml"/>
        </bean>

         <!-- 保证实现了Shiro内部lifecycle函数的bean执行 -->
         <bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor"/>


    <!-- 开启Shiro注解 -->
        <bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator" depends-on="lifecycleBeanPostProcessor"/>
               <bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">
            <property name="securityManager" ref="securityManager"/>
         </bean>



</beans>

 9.ehcache-shiro.xml

<?xml version="1.0" encoding="UTF-8"?>
<ehcache updateCheck="false" name="shiroCache">

     <!--maxElementsInMemory 缓存最大个数。 -->
    <defaultCache
            maxElementsInMemory="10000"
            eternal="true"
            timeToIdleSeconds="20"
            timeToLiveSeconds="20"
            overflowToDisk="true"
            diskPersistent="false"
            diskExpiryThreadIntervalSeconds="120"
    />

</ehcache>

10.登录后设置rememberMe为true，即为让客户端浏览器记住当前subject的登录状态，可以访问一些user用户的接口，在下面这个地方配置

             <property name="filterChainDefinitions">
                 <value>
                     <!--所有接口都不需要认证-->
                     /*=user
                 </value>
             </property>

   rememberMe实际上是通过cookie将subject的信息保存于浏览器当中，可以在xml中配置rememberMeCookie的保存策略，它只是表示当前subject曾经来过，并不表示登录状态，

subject.isAuthenticated()为true时，才表示当前用户为登录状态

在某些需要authc认证的接口，rememberMe是不能访问的。项目只是做了一个简单的登录，并没有涉及到角色和权限那一块，

      web.xml中filter配置 

<filter>
  <filter-name>shiroFilter</filter-name>
  <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
  <init-param>
    <param-name>targetFilterLifecycle</param-name>
    <param-value>true</param-value>
  </init-param>
</filter>
<filter-mapping>
  <filter-name>shiroFilter</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>
有不对的地方，还望批评指正，感谢！！！

原文链接:https://blog.csdn.net/MODjie/article/details/79229658