10、 Spring Boot Shiro 权限管理

使用Shiro以前用在spring MVC中，是经过XML文件进行配置。 

将Shiro应用到Spring Boot中，本地已经完成了SpringBoot使用Shiro的实例，将配置方法共享一下。

先简单介绍一下Shiro，对于没有用过Shiro的朋友，也算是作个简介吧。 
Shiro是Apache下的一个开源项目，咱们称之为Apache Shiro。它是一个很易用与Java项目的的安全框架，提供了认证、受权、加密、会话管理，与 Spring Security 同样都是作一个权限的安全框架，可是与Spring Security 相比，在于 Shiro 使用了比较简单易懂易于使用的受权方式。

Apache Shiro 的三大核心组件 
 
- Subject 当前用户操做 
- SecurityManager 用于管理全部的Subject 
- Realms 用于进行权限信息的验证，也是咱们须要本身实现的。

咱们须要实现Realms的Authentication 和 Authorization。其中 Authentication 是用来验证用户身份，Authorization 是受权访问控制，用于对用户进行的操做受权，证实该用户是否容许进行当前操做，如访问某个连接，某个资源文件等。

Apache Shiro 核心经过 Filter 来实现，就好像SpringMvc 经过DispachServlet 来主控制同样。 
既然是使用 Filter 通常也就能猜到，是经过URL规则来进行过滤和权限校验，因此咱们须要定义一系列关于URL的规则和访问权限。

另外咱们能够经过Shiro 提供的会话管理来获取Session中的信息。Shiro 也提供了缓存支持，使用 CacheManager 来管理。

官方网站：http://shiro.apache.org/ 
完整架构图： 

下面咱们经过代码实战来看下Spring Boot 中应用Shiro： 
一、建立数据库表 

表（t_permission） id permissionname role_id ------ -------------- --------- 1 add 2 2 del 1 3 update 2 4 query 3 5 user:query 1 6 user:edit 2 表（t_role） id rolename ------ ---------- 1 admin 2 manager 3 normal 表（t_user） id username password ------ -------- ---------- 1 tom 123456 2 jack 123456 3 rose 123456 表（t_user_role） user_id role_id ------- --------- 1 1 1 3 2 2 2 3 3 3

上面3张表是我测试别的用的，能够忽略。

下面是，数据库脚本和测试数据。

/* SQLyog Ultimate v10.00 Beta1 MySQL - 5.5.28 : Database - test ********************************************************************* */ /*!40101 SET NAMES utf8 */; /*!40101 SET SQL_MODE=''*/; /*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */; /*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */; /*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */; /*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */; CREATE DATABASE /*!32312 IF NOT EXISTS*/`test` /*!40100 DEFAULT CHARACTER SET utf8 */; USE `test`; /*Table structure for table `t_permission` */ DROP TABLE IF EXISTS `t_permission`; CREATE TABLE `t_permission` ( `id` int(11) NOT NULL AUTO_INCREMENT, `permissionname` varchar(32) DEFAULT NULL, `role_id` int(11) DEFAULT NULL, KEY `id` (`id`) ) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8; /*Data for the table `t_permission` */ insert into `t_permission`(`id`,`permissionname`,`role_id`) values (1,'add',2),(2,'del',1),(3,'update',2),(4,'query',3),(5,'user:query',1),(6,'user:edit',2); /*Table structure for table `t_role` */ DROP TABLE IF EXISTS `t_role`; CREATE TABLE `t_role` ( `id` int(11) NOT NULL AUTO_INCREMENT, `rolename` varchar(32) DEFAULT NULL, KEY `id` (`id`) ) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8; /*Data for the table `t_role` */ insert into `t_role`(`id`,`rolename`) values (1,'admin'),(2,'manager'),(3,'normal'); /*Table structure for table `t_user` */ DROP TABLE IF EXISTS `t_user`; CREATE TABLE `t_user` ( `id` int(11) NOT NULL AUTO_INCREMENT, `username` varchar(32) DEFAULT NULL, `password` varchar(32) DEFAULT NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8; /*Data for the table `t_user` */ insert into `t_user`(`id`,`username`,`password`) values (1,'tom','123456'),(2,'jack','123456'),(3,'rose','123456'); /*Table structure for table `t_user_role` */ DROP TABLE IF EXISTS `t_user_role`; CREATE TABLE `t_user_role` ( `user_id` int(11) DEFAULT NULL, `role_id` int(11) DEFAULT NULL ) ENGINE=InnoDB DEFAULT CHARSET=utf8; /*Data for the table `t_user_role` */ insert into `t_user_role`(`user_id`,`role_id`) values (1,1),(1,3),(2,2),(2,3),(3,3); /*!40101 SET SQL_MODE=@OLD_SQL_MODE */; /*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */; /*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */; /*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;

二、建立对应实体类 
User.java

package org.springboot.sample.entity; import java.util.HashSet; import java.util.List; import java.util.Set; import javax.persistence.Entity; import javax.persistence.FetchType; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; import javax.persistence.JoinColumn; import javax.persistence.JoinTable; import javax.persistence.ManyToMany; import javax.persistence.Table; import javax.persistence.Transient; import org.hibernate.validator.constraints.NotEmpty; /** * 用户 * */ @Entity @Table(name = "t_user") public class User { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Integer id; @NotEmpty(message = "用户名不能为空") private String username; @NotEmpty(message = "密码不能为空") private String password; @ManyToMany(fetch=FetchType.EAGER) @JoinTable(name = "t_user_role", joinColumns = { @JoinColumn(name = "user_id") }, inverseJoinColumns = { @JoinColumn(name = "role_id") }) private List<Role> roleList;// 一个用户具备多个角色 public User() { super(); } public User(String username, String password) { super(); this.username = username; this.password = password; } // 省略 get set 方法 @Transient public Set<String> getRolesName() { List<Role> roles = getRoleList(); Set<String> set = new HashSet<String>(); for (Role role : roles) { set.add(role.getRolename()); } return set; } }

Role.java

package org.springboot.sample.entity; import java.util.ArrayList; import java.util.List; import javax.persistence.Entity; import javax.persistence.FetchType; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; import javax.persistence.JoinColumn; import javax.persistence.JoinTable; import javax.persistence.ManyToMany; import javax.persistence.OneToMany; import javax.persistence.Table; import javax.persistence.Transient; /** * 角色（管理员，普通用户等） * */ @Entity @Table(name = "t_role") public class Role { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Integer id; private String rolename; @OneToMany(mappedBy = "role", fetch=FetchType.EAGER) private List<Permission> permissionList;// 一个角色对应多个权限 @ManyToMany @JoinTable(name = "t_user_role", joinColumns = { @JoinColumn(name = "role_id") }, inverseJoinColumns = { @JoinColumn(name = "user_id") }) private List<User> userList;// 一个角色对应多个用户 // 省略 get set 方法 @Transient public List<String> getPermissionsName() { List<String> list = new ArrayList<String>(); List<Permission> perlist = getPermissionList(); for (Permission per : perlist) { list.add(per.getPermissionname()); } return list; } }

Permission.java

package org.springboot.sample.entity; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id; import javax.persistence.JoinColumn; import javax.persistence.ManyToOne; import javax.persistence.Table; /** * 权限（增删改查等） * */ @Entity @Table(name = "t_permission") public class Permission { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Integer id; private String permissionname; @ManyToOne @JoinColumn(name = "role_id") private Role role;// 一个权限对应一个角色 // 省略 get set } 

三、Shiro 配置，至关于SpringMVC 中的XML配置 
ShiroConfiguration.java

package org.springboot.sample.config; import java.util.LinkedHashMap; import java.util.Map; import org.apache.shiro.cache.ehcache.EhCacheManager; import org.apache.shiro.spring.LifecycleBeanPostProcessor; import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor; import org.apache.shiro.spring.web.ShiroFilterFactoryBean; import org.apache.shiro.web.mgt.DefaultWebSecurityManager; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springboot.sample.dao.IScoreDao; import org.springboot.sample.security.MyShiroRealm; import org.springboot.sample.service.StudentService; import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator; import org.springframework.boot.context.embedded.FilterRegistrationBean; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.web.filter.DelegatingFilterProxy; /** * Shiro 配置 * */ @Configuration public class ShiroConfiguration { private static final Logger logger = LoggerFactory.getLogger(ShiroConfiguration.class); @Bean public EhCacheManager getEhCacheManager() { EhCacheManager em = new EhCacheManager(); em.setCacheManagerConfigFile("classpath:ehcache-shiro.xml"); return em; } @Bean(name = "myShiroRealm") public MyShiroRealm myShiroRealm(EhCacheManager cacheManager) { MyShiroRealm realm = new MyShiroRealm(); realm.setCacheManager(cacheManager); return realm; } /** * 注册DelegatingFilterProxy（Shiro） * 集成Shiro有2种方法： * 1. 按这个方法本身组装一个FilterRegistrationBean（这种方法更为灵活，能够本身定义UrlPattern， * 在项目使用中你可能会由于一些很但疼的问题最后采用它， 想使用它你可能须要看官网或者已经很了解Shiro的处理原理了） * 2. 直接使用ShiroFilterFactoryBean（这种方法比较简单，其内部对ShiroFilter作了组装工做，没法本身定义UrlPattern， * 默认拦截 /*） * * @param dispatcherServlet * @return */ // @Bean // public FilterRegistrationBean filterRegistrationBean() { // FilterRegistrationBean filterRegistration = new FilterRegistrationBean(); // filterRegistration.setFilter(new DelegatingFilterProxy("shiroFilter")); // // 该值缺省为false,表示生命周期由SpringApplicationContext管理,设置为true则表示由ServletContainer管理 // filterRegistration.addInitParameter("targetFilterLifecycle", "true"); // filterRegistration.setEnabled(true); // filterRegistration.addUrlPatterns("/*");// 能够本身灵活的定义不少，避免一些根本不须要被Shiro处理的请求被包含进来 // return filterRegistration; // } @Bean(name = "lifecycleBeanPostProcessor") public LifecycleBeanPostProcessor getLifecycleBeanPostProcessor() { return new LifecycleBeanPostProcessor(); } @Bean public DefaultAdvisorAutoProxyCreator getDefaultAdvisorAutoProxyCreator() { DefaultAdvisorAutoProxyCreator daap = new DefaultAdvisorAutoProxyCreator(); daap.setProxyTargetClass(true); return daap; } @Bean(name = "securityManager") public DefaultWebSecurityManager getDefaultWebSecurityManager(MyShiroRealm myShiroRealm) { DefaultWebSecurityManager dwsm = new DefaultWebSecurityManager(); dwsm.setRealm(myShiroRealm); // <!-- 用户受权/认证信息Cache, 采用EhCache 缓存 --> dwsm.setCacheManager(getEhCacheManager()); return dwsm; } @Bean public AuthorizationAttributeSourceAdvisor getAuthorizationAttributeSourceAdvisor(DefaultWebSecurityManager securityManager) { AuthorizationAttributeSourceAdvisor aasa = new AuthorizationAttributeSourceAdvisor(); aasa.setSecurityManager(securityManager); return aasa; } /** * 加载shiroFilter权限控制规则（从数据库读取而后配置） * */ private void loadShiroFilterChain(ShiroFilterFactoryBean shiroFilterFactoryBean, StudentService stuService, IScoreDao scoreDao){ /////////////////////// 下面这些规则配置最好配置到配置文件中 /////////////////////// Map<String, String> filterChainDefinitionMap = new LinkedHashMap<String, String>(); // authc：该过滤器下的页面必须验证后才能访问，它是Shiro内置的一个拦截器org.apache.shiro.web.filter.authc.FormAuthenticationFilter filterChainDefinitionMap.put("/user", "authc");// 这里为了测试，只限制/user，实际开发中请修改成具体拦截的请求规则 // anon：它对应的过滤器里面是空的,什么都没作 logger.info("##################从数据库读取权限规则，加载到shiroFilter中##################"); filterChainDefinitionMap.put("/user/edit/**", "authc,perms[user:edit]");// 这里为了测试，固定写死的值，也能够从数据库或其余配置中读取 filterChainDefinitionMap.put("/login", "anon"); filterChainDefinitionMap.put("/**", "anon");//anon 能够理解为不拦截 shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap); } /** * ShiroFilter<br/> * 注意这里参数中的 StudentService 和 IScoreDao 只是一个例子，由于咱们在这里能够用这样的方式获取到相关访问数据库的对象， * 而后读取数据库相关配置，配置到 shiroFilterFactoryBean 的访问规则中。实际项目中，请使用本身的Service来处理业务逻辑。 * * @param myShiroRealm * @param stuService * @param scoreDao * @return */ @Bean(name = "shiroFilter") public ShiroFilterFactoryBean getShiroFilterFactoryBean(DefaultWebSecurityManager securityManager, StudentService stuService, IScoreDao scoreDao) { ShiroFilterFactoryBean shiroFilterFactoryBean = new MShiroFilterFactoryBean(); // 必须设置 SecurityManager shiroFilterFactoryBean.setSecurityManager(securityManager); // 若是不设置默认会自动寻找Web工程根目录下的"/login.jsp"页面 shiroFilterFactoryBean.setLoginUrl("/login"); // 登陆成功后要跳转的链接 shiroFilterFactoryBean.setSuccessUrl("/user"); shiroFilterFactoryBean.setUnauthorizedUrl("/403"); loadShiroFilterChain(shiroFilterFactoryBean, stuService, scoreDao); return shiroFilterFactoryBean; } } 

/** * 继承 ShiroFilterFactoryBean 处理拦截资源文件问题。 * */ public class MShiroFilterFactoryBean extends ShiroFilterFactoryBean { // 对ShiroFilter来讲，须要直接忽略的请求 private Set<String> ignoreExt; public MShiroFilterFactoryBean() { super(); ignoreExt = new HashSet<>(); ignoreExt.add(".jpg"); ignoreExt.add(".png"); ignoreExt.add(".gif"); ignoreExt.add(".bmp"); ignoreExt.add(".js"); ignoreExt.add(".css"); } @Override protected AbstractShiroFilter createInstance() throws Exception { SecurityManager securityManager = getSecurityManager(); if (securityManager == null) { String msg = "SecurityManager property must be set."; throw new BeanInitializationException(msg); } if (!(securityManager instanceof WebSecurityManager)) { String msg = "The security manager does not implement the WebSecurityManager interface."; throw new BeanInitializationException(msg); } FilterChainManager manager = createFilterChainManager(); PathMatchingFilterChainResolver chainResolver = new PathMatchingFilterChainResolver(); chainResolver.setFilterChainManager(manager); return new MSpringShiroFilter((WebSecurityManager) securityManager, chainResolver); } private final class MSpringShiroFilter extends AbstractShiroFilter { protected MSpringShiroFilter(WebSecurityManager webSecurityManager, FilterChainResolver resolver) { super(); if (webSecurityManager == null) { throw new IllegalArgumentException("WebSecurityManager property cannot be null."); } setSecurityManager(webSecurityManager); if (resolver != null) { setFilterChainResolver(resolver); } } @Override protected void doFilterInternal(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain chain) throws ServletException, IOException { HttpServletRequest request = (HttpServletRequest)servletRequest; String str = request.getRequestURI().toLowerCase(); // 由于ShiroFilter 拦截全部请求（在上面咱们配置了urlPattern 为 * ，固然你也能够在那里精确的添加要处理的路径，这样就不须要这个类了），而在每次请求里面都作了session的读取和更新访问时间等操做，这样在集群部署session共享的状况下，数量级的加大了处理量负载。 // 因此咱们这里将一些能忽略的请求忽略掉。 // 固然若是你的集群系统使用了动静分离处理，静态资料的请求不会到Filter这个层面，即可以忽略。 boolean flag = true; int idx = 0; if(( idx = str.indexOf(".")) > 0){ str = str.substring(idx); if(ignoreExt.contains(str.toLowerCase())) flag = false; } if(flag){ super.doFilterInternal(servletRequest, servletResponse, chain); }else{ chain.doFilter(servletRequest, servletResponse); } } } }

其中的 ehcache-shiro.xml 在 src/main/resources 下面，内容为：

<?xml version="1.0" encoding="UTF-8"?> <ehcache updateCheck="false" name="shiroCache"> <defaultCache maxElementsInMemory="10000" eternal="false" timeToIdleSeconds="120" timeToLiveSeconds="120" overflowToDisk="false" diskPersistent="false" diskExpiryThreadIntervalSeconds="120" /> </ehcache>

四、继承 AuthorizingRealm 实现认证和受权2个方法 
MyShiroRealm.java

package org.springboot.sample.security; import java.util.List; import org.apache.commons.lang3.builder.ReflectionToStringBuilder; import org.apache.commons.lang3.builder.ToStringStyle; 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.UsernamePasswordToken; import org.apache.shiro.authz.AuthorizationInfo; import org.apache.shiro.authz.SimpleAuthorizationInfo; import org.apache.shiro.realm.AuthorizingRealm; import org.apache.shiro.subject.PrincipalCollection; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springboot.sample.dao.IUserDao; import org.springboot.sample.entity.Role; import org.springboot.sample.entity.User; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; /** * MyShiroRealm * */ public class MyShiroRealm extends AuthorizingRealm{ private static final Logger logger = LoggerFactory.getLogger(MyShiroRealm.class); @Autowired private IUserDao userDao; /** * 权限认证，为当前登陆的Subject授予角色和权限 * @see 经测试：本例中该方法的调用时机为需受权资源被访问时 * @see 经测试：而且每次访问需受权资源时都会执行该方法中的逻辑，这代表本例中默认并未启用AuthorizationCache * @see 经测试：若是连续访问同一个URL（好比刷新），该方法不会被重复调用，Shiro有一个时间间隔（也就是cache时间，在ehcache-shiro.xml中配置），超过这个时间间隔再刷新页面，该方法会被执行 */ @Override protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) { logger.info("##################执行Shiro权限认证##################"); //获取当前登陆输入的用户名，等价于(String) principalCollection.fromRealm(getName()).iterator().next(); String loginName = (String)super.getAvailablePrincipal(principalCollection); //到数据库查是否有此对象 User user=userDao.findByName(loginName);// 实际项目中，这里能够根据实际状况作缓存，若是不作，Shiro本身也是有时间间隔机制，2分钟内不会重复执行该方法 if(user!=null){ //权限信息对象info,用来存放查出的用户的全部的角色（role）及权限（permission） SimpleAuthorizationInfo info=new SimpleAuthorizationInfo(); //用户的角色集合 info.setRoles(user.getRolesName()); //用户的角色对应的全部权限，若是只使用角色定义访问权限，下面的四行能够不要 List<Role> roleList=user.getRoleList(); for (Role role : roleList) { info.addStringPermissions(role.getPermissionsName()); } // 或者按下面这样添加 //添加一个角色,不是配置意义上的添加,而是证实该用户拥有admin角色 // simpleAuthorInfo.addRole("admin"); //添加权限 // simpleAuthorInfo.addStringPermission("admin:manage"); // logger.info("已为用户[mike]赋予了[admin]角色和[admin:manage]权限"); return info; } // 返回null的话，就会致使任何用户访问被拦截的请求时，都会自动跳转到unauthorizedUrl指定的地址 return null; } /** * 登陆认证 */ @Override protected AuthenticationInfo doGetAuthenticationInfo( AuthenticationToken authenticationToken) throws AuthenticationException { //UsernamePasswordToken对象用来存放提交的登陆信息 UsernamePasswordToken token=(UsernamePasswordToken) authenticationToken; logger.info("验证当前Subject时获取到token为：" + ReflectionToStringBuilder.toString(token, ToStringStyle.MULTI_LINE_STYLE)); //查出是否有此用户 User user=userDao.findByName(token.getUsername()); if(user!=null){ // 若存在，将此用户存放到登陆认证info中，无需本身作密码对比，Shiro会为咱们进行密码对比校验 return new SimpleAuthenticationInfo(user.getUsername(), user.getPassword(), getName()); } return null; } }

注意：其中 userDao.findByName 这个代码就不贴上了，也没啥可贴的，根据姓名查询一个对象而已。

五、编写测试的 Controller 和测试 jsp 页面 
ShiroController.java

package org.springboot.sample.controller; import java.util.Map; import javax.validation.Valid; import org.apache.shiro.SecurityUtils; import org.apache.shiro.authc.AuthenticationException; import org.apache.shiro.authc.ExcessiveAttemptsException; import org.apache.shiro.authc.IncorrectCredentialsException; import org.apache.shiro.authc.LockedAccountException; import org.apache.shiro.authc.UnknownAccountException; import org.apache.shiro.authc.UsernamePasswordToken; import org.apache.shiro.subject.Subject; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springboot.sample.dao.IUserDao; import org.springboot.sample.entity.User; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Controller; import org.springframework.ui.Model; import org.springframework.validation.BindingResult; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.servlet.mvc.support.RedirectAttributes; /** * Shiro测试Controller * */ @Controller public class ShiroController { private static final Logger logger = LoggerFactory.getLogger(ShiroController.class); @Autowired private IUserDao userDao; @RequestMapping(value="/login",method=RequestMethod.GET) public String loginForm(Model model){ model.addAttribute("user", new User()); return "login"; } @RequestMapping(value="/login",method=RequestMethod.POST) public String login(@Valid User user,BindingResult bindingResult,RedirectAttributes redirectAttributes){ if(bindingResult.hasErrors()){ return "login"; } String username = user.getUsername(); UsernamePasswordToken token = new UsernamePasswordToken(user.getUsername(), user.getPassword()); //获取当前的Subject Subject currentUser = SecurityUtils.getSubject(); try { //在调用了login方法后,SecurityManager会收到AuthenticationToken,并将其发送给已配置的Realm执行必须的认证检查 //每一个Realm都能在必要时对提交的AuthenticationTokens做出反应 //因此这一步在调用login(token)方法时,它会走到MyRealm.doGetAuthenticationInfo()方法中,具体验证方式详见此方法 logger.info("对用户[" + username + "]进行登陆验证..验证开始"); currentUser.login(token); logger.info("对用户[" + username + "]进行登陆验证..验证经过"); }catch(UnknownAccountException uae){ logger.info("对用户[" + username + "]进行登陆验证..验证未经过,未知帐户"); redirectAttributes.addFlashAttribute("message", "未知帐户"); }catch(IncorrectCredentialsException ice){ logger.info("对用户[" + username + "]进行登陆验证..验证未经过,错误的凭证"); redirectAttributes.addFlashAttribute("message", "密码不正确"); }catch(LockedAccountException lae){ logger.info("对用户[" + username + "]进行登陆验证..验证未经过,帐户已锁定"); redirectAttributes.addFlashAttribute("message", "帐户已锁定"); }catch(ExcessiveAttemptsException eae){ logger.info("对用户[" + username + "]进行登陆验证..验证未经过,错误次数过多"); redirectAttributes.addFlashAttribute("message", "用户名或密码错误次数过多"); }catch(AuthenticationException ae){ //经过处理Shiro的运行时AuthenticationException就能够控制用户登陆失败或密码错误时的情景 logger.info("对用户[" + username + "]进行登陆验证..验证未经过,堆栈轨迹以下"); ae.printStackTrace(); redirectAttributes.addFlashAttribute("message", "用户名或密码不正确"); } //验证是否登陆成功 if(currentUser.isAuthenticated()){ logger.info("用户[" + username + "]登陆认证经过(这里能够进行一些认证经过后的一些系统参数初始化操做)"); return "redirect:/user"; }else{ token.clear(); return "redirect:/login"; } } @RequestMapping(value="/logout",method=RequestMethod.GET) public String logout(RedirectAttributes redirectAttributes ){ //使用权限管理工具进行用户的退出，跳出登陆，给出提示信息 SecurityUtils.getSubject().logout(); redirectAttributes.addFlashAttribute("message", "您已安全退出"); return "redirect:/login"; } @RequestMapping("/403") public String unauthorizedRole(){ logger.info("------没有权限-------"); return "403"; } @RequestMapping("/user") public String getUserList(Map<String, Object> model){ model.put("userList", userDao.getList()); return "user"; } @RequestMapping("/user/edit/{userid}") public String getUserList(@PathVariable int userid){ logger.info("------进入用户信息修改-------"); return "user_edit"; } }

login.jsp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%> <%@ taglib prefix="form" uri="http://www.springframework.org/tags/form"%> <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> <html> <head> <title>Login</title> </head> <body> <h1>登陆页面----${message }</h1> <img alt="" src="${pageContext.request.contextPath }/pic.jpg"> <form:form action="${pageContext.request.contextPath }/login" commandName="user" method="post"> 用户名：<form:input path="username" /> <form:errors path="username" cssClass="error" /> <br /> 密码：<form:password path="password" /> <form:errors path="password" cssClass="error" /> <br /> <form:button name="button">提交</form:button> </form:form> </body> </html>

user.jsp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%> <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> <%@ taglib prefix="shiro" uri="http://shiro.apache.org/tags" %> <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> <html> <head> <title>用户列表</title> </head> <body> <h1>${message }</h1> <h1>用户列表--<a href="${pageContext.request.contextPath }/logout">退出登陆</a> </h1> <h2>权限列表</h2> <shiro:authenticated>用户已经登陆显示此内容<br/></shiro:authenticated><br/> <shiro:hasRole name="manager">manager角色登陆显示此内容<br/></shiro:hasRole> <shiro:hasRole name="admin">admin角色登陆显示此内容<br/></shiro:hasRole> <shiro:hasRole name="normal">normal角色登陆显示此内容<br/></shiro:hasRole><br/> <shiro:hasAnyRoles name="manager,admin">manager or admin 角色用户登陆显示此内容<br/></shiro:hasAnyRoles><br/> <shiro:principal/>-显示当前登陆用户名<br/><br/> <shiro:hasPermission name="add">add权限用户显示此内容<br/></shiro:hasPermission> <shiro:hasPermission name="user:query">user:query权限用户显示此内容<br/></shiro:hasPermission> <shiro:lacksPermission name="user:query">不具备user:query权限的用户显示此内容 <br/></shiro:lacksPermission> <br/>全部用户列表：<br/> <ul> <c:forEach items="${userList }" var="user"> <li>用户名：${user.username }----密码：${user.password }----<a href="${pageContext.request.contextPath }/user/edit/${user.id}">修改用户（测试根据不一样用户可访问权限不一样，本例tom无权限，jack有权限）</a></li> </c:forEach> </ul> <img alt="" src="${pageContext.request.contextPath }/pic.jpg"> <script type="text/javascript" src="${pageContext.request.contextPath }/webjarslocator/jquery/jquery.js"></script> </body> </html>

user.jsp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%> <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> <%@ taglib prefix="shiro" uri="http://shiro.apache.org/tags" %> <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> <html> <head> <title>用户列表</title> </head> <body> <h1>${message }</h1> <h1>用户列表--<a href="${pageContext.request.contextPath }/logout">退出登陆</a> </h1> <h2>权限列表</h2> <shiro:authenticated>用户已经登陆显示此内容<br/></shiro:authenticated><br/> <shiro:hasRole name="manager">manager角色登陆显示此内容<br/></shiro:hasRole> <shiro:hasRole name="admin">admin角色登陆显示此内容<br/></shiro:hasRole> <shiro:hasRole name="normal">normal角色登陆显示此内容<br/></shiro:hasRole><br/> <shiro:hasAnyRoles name="manager,admin">manager or admin 角色用户登陆显示此内容<br/></shiro:hasAnyRoles><br/> <shiro:principal/>-显示当前登陆用户名<br/><br/> <shiro:hasPermission name="add">add权限用户显示此内容<br/></shiro:hasPermission> <shiro:hasPermission name="user:query">user:query权限用户显示此内容<br/></shiro:hasPermission> <shiro:lacksPermission name="user:query">不具备user:query权限的用户显示此内容 <br/></shiro:lacksPermission> <br/>全部用户列表：<br/> <ul> <c:forEach items="${userList }" var="user"> <li>用户名：${user.username }----密码：${user.password }----<a href="${pageContext.request.contextPath }/user/edit/${user.id}">修改用户（测试根据不一样用户可访问权限不一样，本例tom无权限，jack有权限）</a></li> </c:forEach> </ul> <img alt="" src="${pageContext.request.contextPath }/pic.jpg"> <script type="text/javascript" src="${pageContext.request.contextPath }/webjarslocator/jquery/jquery.js"></script> </body> </html>

403.jsp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%> <%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %> <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> <html> <head> <title>权限错误</title> </head> <body> <h1>对不起，您没有权限请求此链接！</h1> <img alt="" src="${pageContext.request.contextPath }/pic.jpg"> </body> </html>

其中的pic.jpg 是测试代码遗留的，没有任何用处。关于 Controller 和 JSP 页面本文不作介绍，关于Spring Boot 使用Controller 和 JSP ，前面已经有文章介绍。

启动服务后访问 http://localhost:8080/myspringboot/user 会自动跳到 login 页面。 
登陆成功后，会打开 user 页面（关于默认登陆页、成功成功URL、没有权限URL，在 ShiroConfiguration 中已经配置）。 
在 user 页面上，不一样用户会根据权限不一样显示不一样的内容，下面的修改操做也已经有文字说明，更换帐号测试便知。

而后咱们在实际项目中：不但要在页面上控制不一样权限隐藏或将某些操做设置为不可用状态，还要在实际上控制那个操做背后的请求是真的不可使用的。（例如：页面上的修改按钮已经灰化了，而我知道了修改按钮正常状况下点击会触发的请求，此时我直接模拟这个修改请求，应当是没有权限的才对，这样才算是真正的控制了权限。）

---

附： 
Filter Chain定义说明 
一、一个URL能够配置多个Filter，使用逗号分隔 
二、当设置多个过滤器时，所有验证经过，才视为经过 
三、部分过滤器可指定参数，如perms，roles

Shiro内置的FilterChain

 

Filter Name	Class
anon	org.apache.shiro.web.filter.authc.AnonymousFilter
authc	org.apache.shiro.web.filter.authc.FormAuthenticationFilter
authcBasic	org.apache.shiro.web.filter.authc.BasicHttpAuthenticationFilter
perms	org.apache.shiro.web.filter.authz.PermissionsAuthorizationFilter
port	org.apache.shiro.web.filter.authz.PortFilter
rest	org.apache.shiro.web.filter.authz.HttpMethodPermissionFilter
roles	org.apache.shiro.web.filter.authz.RolesAuthorizationFilter
ssl	org.apache.shiro.web.filter.authz.SslFilter
user	org.apache.shiro.web.filter.authc.UserFilter