权限控制在做项目中，是必不可少的。而关于权限控制，目前跟spring兼容比较好的有spring security和shiro。我的上个项目用的就是shiro，但是我另一个同事写的，这次想自己尝试下，研究了下shiro。
shiro官方文档中说shiro的操作都是基于subject，而subject来自securityManager。所以spring整个shiro就是对securityManager的整合，在用户访问的时候需要交给shiro进行拦截。shiro会进行验证。如果你有这个资源或者角色的权限，就能正常访问，否则会进行拦截。
本文适合未曾接触shiro但是对spring等基础框架有了解及经验的小伙伴。因为本人也是小白一枚，如有不对之处，请不吝赐教。 ٩(๑❛ᴗ❛๑)۶~~

需要的jar包

shiro需要的jar包就一个，我这里用的是shiro-all-1.3.2.jar

在web.xml中加入filter

<!-- 这个filter要写在所有filter的最前面，保证他是过滤器中第一个起作用的-->

  <filter>
       <filter-name>shiroFilter</filter-name>
       <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
       <init-param>
    <!-- 缺省为false，表示由SpringApplicationContext管理生命周期，置为true则表示由ServletContainer管理 -->
          <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>

创建一个shiro.xml文件

然后在web.xml中添加上去

<!-- 加载所有的配置文件 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml,classpath:shiro.xml</param-value>
    </context-param>

shiro里面的内容

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.3.xsd
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd">

    <!-- 配置shiro -->
   <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
       <!-- 指定Shiro验证用户登录的类为自定义的Realm（若有多个Realm，可用[realms]属性代替） -->
       <property name="realm">
           <bean class="com.xx.shiro.MyRealm"/>
       </property>
    </bean>

<!-- Shiro Filter--> 
<bean id="simplePermFilter" class="org.apache.shiro.web.filter.authz.PermissionsAuthorizationFilter"></bean> 

<bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean ">
<!-- Shiro的核心安全接口，这个属性是必须的 -->
    <property name="securityManager" ref="securityManager"/>

<!-- 要求登录时的链接（可根据项目的URL进行替换），非必须的属性，默认会找Web工程根目录下的[/login.jsp] -->
    <property name="loginUrl" value="/sys/toLogin"/>
 <!-- 登录成功后要跳转的连接（本例中此属性用不到，因为登录成功后的处理逻辑已在LoginController中硬编码为main.jsp） -->
    <property name="successUrl" value="/sys/login"/>
 <!--用户访问未授权的资源时，所显示的连接 -->
    <property name="unauthorizedUrl" value="/sys/toLogin"/>
    <!-- 权限配置 -->
     <property name="filters">    
           <map>    
               <entry key="roles" value-ref="simplePermFilter"/>  
           </map>    
       </property>   
    <!--
        anon：它对应的过滤器里面是空的，什么都没做，另外.do和.jsp后面的*表示参数，比方说[login.jsp?main]这种
        authc：该过滤器下的页面必须验证后才能访问，它是内置的org.apache.shiro.web.filter.authc.FormAuthenticationFilter
        注意：对于相似的资源，需要将anon的设置放在authc前面，anon才会生效，因为Shiro是从上往下匹配URL的，匹配成功便不再匹配了
    --> 
     <property name="filterChainDefinitions">
        <value>
            /sys/toLogin        = anon
        /sys/Login          = anon
        /sys/videoList      = authc,rolse[管理员]
        </value>
    </property> 
</bean>
<!-- 保证实现了Shiro内部lifecycle函数的bean执行 -->
<bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor"/>

<!--自定义拦截器，目前用不到，后面再说可以不写-->
<!--<bean id="anyRoles" class="com.xx.shiro.CustomRolesAuthorizationFilter" />  -->
</beans>

shiro的xml写完就需要写shiro验证用户登录的类MyRealm.java,我这里就直接在数据库里面读取了。

MyRealM.java

import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.apache.commons.lang3.builder.ReflectionToStringBuilder;
import org.apache.commons.lang3.builder.ToStringStyle;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
import org.apache.shiro.authc.UnknownAccountException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.session.Session;
import org.apache.shiro.subject.PrincipalCollection;
import org.apache.shiro.subject.Subject;
import org.springframework.beans.factory.annotation.Autowired;
import com.liaoliao.admin.entity.AdminUser;
import com.liaoliao.admin.entity.Permission;
import com.liaoliao.admin.service.AdminUserService;
import com.liaoliao.admin.service.PermissionService;


public class MyRealm extends AuthorizingRealm {
    
    @Autowired
    private AdminUserService adminUserService;
    
    @Autowired
    private PermissionService permissionService;
    
    
    /**
     * 为当前登录的Subject授予角色和权限
     * -----------------------------------------------------------------------------------------------
     * 经测试：本例中该方法的调用时机为需授权资源被访问时
     * 经测试：并且每次访问需授权资源时都会执行该方法中的逻辑，这表明本例中默认并未启用AuthorizationCache
     * 个人感觉若使用了Spring3.1开始提供的ConcurrentMapCache支持，则可灵活决定是否启用AuthorizationCache
     * 比如说这里从数据库获取权限信息时，先去访问Spring3.1提供的缓存，而不使用Shior提供的AuthorizationCache
     * -----------------------------------------------------------------------------------------------
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals){
        //获取当前登录的用户名
        String currentUsername = (String)super.getAvailablePrincipal(principals);
        //从数据库中获取当前登录用户的详细信息
        AdminUser adminUser = adminUserService.findByUserName(currentUsername);
        SimpleAuthorizationInfo simpleAuthorInfo = new SimpleAuthorizationInfo();
     //   Set<String>  perlist = new HashSet<String>();
       if(adminUser != null){
        //在这里添加的role对应的就是权限的名，比如说，你给一个url添加了roles[管理员]，有个叫mopoint的用户登录了，
        //他想要访问这个url，那么在这里就需要给他赋予管理员这个权限，也就是说
        //这里面simpleAuthorInfo.addRole("管理员");加上的就是管理员三个字。
         simpleAuthorInfo.addRole(adminUser.getAdminGroup().getGroupName());

        //这里我是通过数据库读取出来然后放入集合里面去的。
         /* List<Permission> pers = permissionService.findByGroupId(adminUser.getAdminGroup().getId());
            if(pers!=null && pers.size()>0){
                for(Permission p:pers){
                    perlist.add(p.getNavigation().getNavigationUrl());
                }
                simpleAuthorInfo.addStringPermissions(perlist);
            } */

        //这里的perlist就是你能访问的url，比如说你数据库存放的一个url：/sys/videoList;这个url需要权限[管理员]。 
        //在上面已经给你的账号mopoint加上了role：[管理员]，对应的，这里需要加上这个url。然后你的账号就能访问这个url了。
      //比如配置在shiro.xml中的是/sys/videoList，那么这里的url就是"/sys/videoList";
         String url="/sys/videoList";
         simpleAuthorInfo.addStringPermissions(url);
         return simpleAuthorInfo;
         }else{
        //如果返回空表示用户访问失败，会自动跳转到刚才unauthorizedUrl指定的地址。配置在shiro.xml里面
             return null;
         }
    }

    

    /**
     * 验证当前登录的Subject
     * 当在登录时执行Subject.login()，就会调用下面的这个接口：
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authcToken) throws AuthenticationException {
    //实际上这个authcToken在用户登录时通过currentUser.login(token)传过来的。
        UsernamePasswordToken token = (UsernamePasswordToken)authcToken;
        if(token.getUsername()==null){
    //没有返回登录用户名对应的SimpleAuthenticationInfo对象时，就会在LoginController中抛出UnknownAccountException异常
            return null;
        }
        AdminUser adminUser = adminUserService.findByUserName(token.getUsername());
        if(null != adminUser){
            String username = adminUser.getUserName();
            String password = adminUser.getPassWord();
            AuthenticationInfo authcInfo = new SimpleAuthenticationInfo(username, password, this.getName());
            this.setAuthenticationSession(adminUser);
            return authcInfo;
        }else{
            throw new  UnknownAccountException("用户帐号不存在！");
        }
    }

    /**
     * 将一些数据放到ShiroSession中，以便于其它地方使用
     * 比如Controller里面，使用时直接用HttpSession.getAttribute(key)就可以取到
     */
    private void setAuthenticationSession(Object value){
     /*   Subject currentUser = SecurityUtils.getSubject();
        if(null != currentUser){
            Session session = currentUser.getSession();
            session.setTimeout(1000 * 60 * 60 * 2);
            session.setAttribute("currentUser", value);
        }*/
    }
}

上面配置方面的工作已经做完了，现在就到登录的controller中使用。

LoginController.java

@Controller("adminLogin")
@RequestMapping("/sys")
public class LoginController {

    /**
     * 跳转到登录页面
     * @param request
     * @return
     */
    @RequestMapping("/toLogin")
    public String toLogin(HttpServletRequest request){
        return "page/login";
    }

    //用户退出
       @RequestMapping("/logout")
        public String logout(HttpSession session){
            String currentUser = (String)session.getAttribute("currentUser");
            System.out.println("用户[" + currentUser + "]准备登出");
            SecurityUtils.getSubject().logout();
            System.out.println("用户[" + currentUser + "]已登出");
            return InternalResourceViewResolver.REDIRECT_URL_PREFIX + "/login";
        }

    /**
     * 验证登录：
     * @param request
     * @param response
     * @param userName
     * @param passCode
     * @return
     */
    @RequestMapping("/Login")
    public String Login(HttpServletRequest request,HttpServletResponse response,String userName,String passWord){
            UsernamePasswordToken token=new UsernamePasswordToken();
            token.setRememberMe(true);
            //获取当前的Subject
            Subject currentUser = SecurityUtils.getSubject();
            try {
                currentUser.login(token);
                System.out.println("对用户[" + token.getUsername() + "]进行登录验证...验证通过");
            }catch(Exception e){
            //这里细分，大概有五种异常，有兴趣可以点击文章最后的链接去看看。
                e.printStackTrace();
                System.out.println("用户名或密码不正确");
                request.setAttribute("message_login", "用户名或密码不正确");
                return InternalResourceViewResolver.FORWARD_URL_PREFIX +"/sys/toLogin";
            }    
            //验证是否登录成功，这里的isAuthenticated()方法有时候不怎么灵通，具体我也不知道啥原因，欢迎小伙伴找我探讨~
            if(currentUser.isAuthenticated()){
                AminUser au=adminUserService.findByUserName(userName);
                AdminUser sessionAu= (AdminUser) request.getSession().getAttribute("adminUser");
                if(au == null && sessionAu == null){
                    System.out.println(111);
                    return InternalResourceViewResolver.FORWARD_URL_PREFIX +"/sys/toLogin";
                }
                request.setAttribute("adminUser", au);
                HttpSession session = request.getSession();
                session.setAttribute("adminUser", au);
                session.setAttribute("token", token);
                List<Permission> pList=permissionService.findByGroupId(au.getAdminGroup().getId());
                request.setAttribute("list", pList);    
                return "forward:/sys/theHome";
            }else{
                System.out.println("未通过！");
                token.clear();
                return InternalResourceViewResolver.REDIRECT_URL_PREFIX +"/sys/toLogin";
            }
      }

}

上面的登录方法就算是写完了，下面是我的数据库设置：

数据库设置：

adminUser

adminGrop

navigation（这里存放的就是各个资源的路径）

permission (关联navigation表跟adminGroup表)

然后你创建两个用户组，一个用户组的groupName是管理员，另一个叫人事；然后在创建一个用户admin是属于管理员这个用户组的，创建一个用户aaa是属于人事这个用户组的，你
用admin账号登录的时候是可以访问配置在shiro.xml这个文件里面的那个url：/sys/videoList；如果是用aaa登录的话，你访问/sys/videoList这个路径是会跳转到/sys/toLogin这个登录页面的。

借鉴的大神的网站博客

http://jadyer.cn/2013/09/30/springmvc-shiro
http://jinnianshilongnian.iteye.com/blog/2024723
http://www.sojson.com/shiro#so604570995

写到这里，这个第一版的简陋的shiro权限管理算是完成了，在后面我加了动态数据库读取权限，还有个自定义的配置。关于动态更新不需要重启服务器还有点问题，如果小伙伴们有想法，可以联系我一起讨论或者在下面留言~