Shiro

• 登陆、授权、拦截
• 按钮权限控制

一、目标

• Maven+Spring+shiro
• 自定义登陆、授权
• 自定义拦截器
• 加载数据库资源构建拦截链

使用总结：

1、需要设计的数据库：用户、角色、权限、资源

2、可以通过，角色，权限，两个拦截器同时确定是否能访问

3、角色与权限的关系，

role1=permission1,permission2，多级的权限：sys:permission1,拥有高级权限同时用于低级权限。

4、perms["permission1"] 为权限

5、拦截器机制介绍了拦截角色还是权限

6、角色与权限 是两个概念

7、权限-资源，一对一。资源分为上下级，因此权限分为父权限，子权限。创建资源的时候，创建权限。权限里资源的别名

8、角色-权限，一对多。角色里权限的别名

9、按钮是通过权限来控制的

10、防止有父级资源可以访问，子级资源不能访问的情况，不适用 sys:add 权限写法

二、代码

1、Pom.xml

1     
     
       2         
      
       4.3.4.RELEASE
       3 
      4 
     
       5 
      
       junit
       6 
      
       junit
       7 
      
       4.9
       8 
      9 
     
       10 
      
       commons-logging
       11 
      
       commons-logging
       12 
      
       1.1.3
       13 
      14 
     
       15 
      
       org.apache.shiro
       16 
      
       shiro-core
       17 
      
       1.2.2
       18 
      19 
     
       20 
      
       org.apache.shiro
       21 
      
       shiro-spring
       22 
      
       1.2.2
       23 
      24 
     
       25 
      
       javax.servlet
       26 
      
       javax.servlet-api
       27 
      
       3.0.1
       28 
      
       provided
       29 
      30 
     
       31 
      
       org.springframework
       32 
      
       spring-web
       33 
      
       ${spring.version}
       34 
      35 
     
       36 
      
       org.apache.shiro
       37 
      
       shiro-ehcache
       38 
      
       1.2.2
       39 
      40 
     
       41 
      
       org.springframework
       42 
      
       spring-context
       43 
      
       ${spring.version}
       44 
      45 
     
       46 
      
       org.apache.shiro
       47 
      
       shiro-web
       48 
      
       1.2.2
       49 
      50 
     
       51 
      
       net.sf.ehcache
       52 
      
       ehcache
       53 
      
       2.10.1
       54 
     

2、web.xml

　　Servlet拦截访问，使用注解更方便，需要删除项目中的servlet使用javax.servlet-api 3.0 包

1 package com.cyd.shiro; 2  3 import java.io.IOException; 4 5 import javax.servlet.ServletException; 6 import javax.servlet.annotation.WebServlet; 7 import javax.servlet.http.HttpServlet; 8 import javax.servlet.http.HttpServletRequest; 9 import javax.servlet.http.HttpServletResponse; 10 11 import org.apache.shiro.SecurityUtils; 12 import org.apache.shiro.authc.AuthenticationException; 13 import org.apache.shiro.authc.IncorrectCredentialsException; 14 import org.apache.shiro.authc.UnknownAccountException; 15 import org.apache.shiro.authc.UsernamePasswordToken; 16 import org.apache.shiro.subject.Subject; 17 import org.apache.shiro.web.util.SavedRequest; 18 import org.apache.shiro.web.util.WebUtils; 19 import org.junit.Test; 20 21 @WebServlet(name = "loginServlet", urlPatterns = "/loginController") 22 public class LoginServlet extends HttpServlet { 23 @Override 24 protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 25 req.getRequestDispatcher("login.jsp").forward(req, resp); 26 } 27 28 @Override 29 protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 30 System.out.println(LoginServlet.class.toString()); 31 String error = null; 32 String username = req.getParameter("username"); 33 String password = req.getParameter("password"); 34 Subject subject = SecurityUtils.getSubject(); 35 UsernamePasswordToken token = new UsernamePasswordToken(username, password); 36 try { 37 subject.login(token); 38 } catch (UnknownAccountException e) { 39 error = "用户名/密码错误"; 40 } catch (IncorrectCredentialsException e) { 41 error = "用户名/密码错误"; 42 } catch (AuthenticationException e) { 43 // 其他错误，比如锁定，如果想单独处理请单独catch处理 44 error = "其他错误：" + e.getMessage(); 45 } 46 if (error != null) { // 出错了，返回登录页面 47 req.setAttribute("error", error); 48 req.getRequestDispatcher("login.jsp").forward(req, resp); 49 } else { // 登录成功 50 //跳转到拦截登陆前的地址 51 SavedRequest request=WebUtils.getSavedRequest(req); 52 String url =request.getRequestURI(); 53 req.getRequestDispatcher(url.substring(url.lastIndexOf('/'))).forward(req, resp); 54 } 55 } 56 57 }

 

3、Spring-shiro.xml

     
      
       
       
       
        
        
        
        
        
         
          
          
         
        
        
        
          /unauthorized.jsp = anon /logoutController=anon /login.jsp=authc 
         
        
       
       
       
        
        
       
       
       
       
       
        
       
       
       
       
     

 

4、Ehcache.xml 缓存

5、登陆Servlet

package com.cyd.shiro;import java.io.IOException;import javax.servlet.ServletException; import javax.servlet.annotation.WebServlet; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import org.apache.shiro.SecurityUtils; import org.apache.shiro.authc.AuthenticationException; import org.apache.shiro.authc.IncorrectCredentialsException; import org.apache.shiro.authc.UnknownAccountException; import org.apache.shiro.authc.UsernamePasswordToken; import org.apache.shiro.subject.Subject; import org.apache.shiro.web.util.SavedRequest; import org.apache.shiro.web.util.WebUtils; @WebServlet(name = "loginServlet", urlPatterns = "/loginController") public class LoginServlet extends HttpServlet { @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { req.getRequestDispatcher("login.jsp").forward(req, resp); } @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { System.out.println(LoginServlet.class.toString()); String error = null; String username = req.getParameter("username"); String password = req.getParameter("password"); Subject subject = SecurityUtils.getSubject(); UsernamePasswordToken token = new UsernamePasswordToken(username, password); try { subject.login(token); } catch (UnknownAccountException e) { error = "用户名/密码错误"; } catch (IncorrectCredentialsException e) { error = "用户名/密码错误"; } catch (AuthenticationException e) { // 其他错误，比如锁定，如果想单独处理请单独catch处理 error = "其他错误：" + e.getMessage(); } if (error != null) { // 出错了，返回登录页面 req.setAttribute("error", error); req.getRequestDispatcher("login.jsp").forward(req, resp); } else { // 登录成功 //跳转到拦截登陆前的地址 SavedRequest request=WebUtils.getSavedRequest(req); String url =request.getRequestURI(); req.getRequestDispatcher(url.substring(url.lastIndexOf('/'))).forward(req, resp); } } }

 

6、自定义登陆、授权。

　　根据需求自定义登陆异常。从数据库查询出当前用户拥有的权限并授权

　　

1 package com.cyd.shiro; 2  3 import java.util.HashSet; 4 import java.util.LinkedList; 5 import java.util.List; 6 import java.util.Set; 7 8 import org.apache.shiro.authc.AuthenticationException; 9 import org.apache.shiro.authc.AuthenticationInfo; 10 import org.apache.shiro.authc.AuthenticationToken; 11 import org.apache.shiro.authc.SimpleAuthenticationInfo; 12 import org.apache.shiro.authc.UnknownAccountException; 13 import org.apache.shiro.authz.AuthorizationInfo; 14 import org.apache.shiro.authz.SimpleAuthorizationInfo; 15 import org.apache.shiro.realm.AuthorizingRealm; 16 import org.apache.shiro.subject.PrincipalCollection; 17 import org.springframework.beans.factory.annotation.Autowired; 18 19 import com.cyd.helloworld.SysRoles; 20 import com.cyd.helloworld.SysUsers; 21 import com.cyd.shiro.admin.SysUsersService; 22 23 public class AdminRealm extends AuthorizingRealm { 24 25 @Autowired 26 private SysUsersService sysusersservice; 27 // 认证登陆 28 @Override 29 protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException { 30 System.out.println("do doGetAuthenticationInfo"); 31 String username = (String) token.getPrincipal(); 32 SysUsers user = sysusersservice.getSysUsers(username); 33 if (user == null) { 34 throw new UnknownAccountException();// 没找到帐号 35 } 36 SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(user.getUserName(), // 用户名 37 user.getPassWorld(), // 密码 38 getName() // realm name 39 ); 40 return authenticationInfo; 41 } 42 43 // 用户授权 44 @Override 45 protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) { 46 System.out.println("do doGetAuthorizationInfo"); 47 String username = (String)principals.getPrimaryPrincipal(); 48 SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo(); 49 //从数据库加载当前用户的角色，例如：[admin] 50 authorizationInfo.setRoles(new HashSet
     
      (sysusersservice.getSysRoles(username))); 51 //从数据库加载当前用户可以访问的资源，例如：[index.jsp, abc.jsp] 52 authorizationInfo.setStringPermissions(new HashSet
      
       (sysusersservice.getSysResource(username))); 53 54 return authorizationInfo; 55 } 56 }
      
     

 

7、自定义拦截器。

　　重写拦截器是因为shiro 验证是否有权限访问是需要当前用户拥有拦截器链的所有权限。一般需求只需要拥有部分权限即可。

       角色验证拦截，hasRole和hasAllRoles 验证是否有权限。

1 package com.cyd.shiro; 2  3 import java.io.IOException; 4 import java.util.Set; 5 6 import javax.servlet.ServletRequest; 7 import javax.servlet.ServletResponse; 8 9 import org.apache.shiro.subject.Subject; 10 import org.apache.shiro.util.CollectionUtils; 11 import org.apache.shiro.web.filter.authz.RolesAuthorizationFilter; 12 13 /** 14 * 通过角色验证权限 15 * @author chenyd 16 * 2017年11月21日 17 */ 18 public class ExtendRolesAuthorizationFilter extends RolesAuthorizationFilter{ 19 20 @Override 21 public boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) throws IOException { 22 23 System.out.println(ExtendRolesAuthorizationFilter.class.toString()); 24 Subject subject = getSubject(request, response); 25 String[] rolesArray = (String[]) mappedValue; 26 27 if (rolesArray == null || rolesArray.length == 0) { 28 //no roles specified, so nothing to check - allow access. 29 return true; 30 } 31 //AbstractFilter 32 Set
     
       roles = CollectionUtils.asSet(rolesArray); 33 34 boolean flag=false; 35 for(String role: roles){ 36 if(subject.hasRole(role)){ 37 flag=true; 38 break; 39 } 40 } 41 return flag; 42 } 43 }
     

       url拦截校验，isPermitted和isPermittedAll验证是否有权限访问，

1 package com.cyd.shiro; 2  3 import java.io.IOException; 4 5 import javax.servlet.ServletRequest; 6 import javax.servlet.ServletResponse; 7 import javax.servlet.http.HttpServletRequest; 8 9 import org.apache.shiro.subject.Subject; 10 import org.apache.shiro.web.filter.authz.PermissionsAuthorizationFilter; 11 /** 12 * 通过字符串验证权限 13 * @author chenyd 14 * 2017年11月21日 15 */ 16 public class URLPermissionsFilter extends PermissionsAuthorizationFilter { 17 18 /** 19 * mappedValue 访问该url时需要的权限 20 * subject.isPermitted 判断访问的用户是否拥有mappedValue权限 21 * 重写拦截器，只要符合配置的一个权限，即可通过 22 */ 23 @Override 24 public boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) 25 throws IOException { 26 System.out.println(URLPermissionsFilter.class.toString()); 27 Subject subject = getSubject(request, response); 28 // DefaultFilterChainManager 29 // PathMatchingFilterChainResolver 30 String[] perms = (String[]) mappedValue; 31 boolean isPermitted = false; 32 if (perms != null && perms.length > 0) { 33 for (String str : perms) { 34 if (subject.isPermitted(str)) { 35 isPermitted = true; 36 } 37 } 38 } 39 40 return isPermitted; 41 } 42 }

8、加载数据库资源构建拦截器链

1 package com.cyd.shiro; 2  3 import java.util.Map; 4 5 import org.apache.shiro.config.Ini; 6 import org.apache.shiro.spring.web.ShiroFilterFactoryBean; 7 import org.apache.shiro.util.CollectionUtils; 8 import org.apache.shiro.web.config.IniFilterChainResolverFactory; 9 import org.springframework.beans.factory.annotation.Autowired; 10 11 import com.cyd.shiro.admin.SysUsersService; 12 13 public class ExtendShiroFilterFactoryBean extends ShiroFilterFactoryBean{ 14 15 @Autowired 16 private SysUsersService sysusersservice; 17 //PathMatchingFilter 18 @Override 19 public void setFilterChainDefinitions(String definitions) { 20 //数据库中获取权限，{/index.jsp=authc,onrole["admin2","admin"], /abc.jsp=authc,onrole["admin2","admin"]} 21 Map
     
       otherChains = sysusersservice.getFilterChain(); 22 Ini ini = new Ini(); 23 ini.load(definitions); 24 Ini.Section section = ini.getSection(IniFilterChainResolverFactory.URLS); 25 if (CollectionUtils.isEmpty(section)) { 26 section = ini.getSection(Ini.DEFAULT_SECTION_NAME); 27 } 28 section.putAll(otherChains); 29 setFilterChainDefinitionMap(section); 30 } 31 32 }
     

 

三、  学习笔记

1、INI文件配置

[users]  #提供了对用户/密码及其角色的配置，用户名=密码，角色1，角色2  zhang=123,admin[roles] #提供了角色及权限之间关系的配置，角色=权限1，权限2 admin=index.jsp [urls] #配置拦截器链，/** 为拦截器链名称（filterChain），authc,roles[admin],perms["index.jsp"]拦截器列表名 /login.jsp=anon /loginController=anon /unauthorized.jsp=anon /**=authc,roles[admin],perms["index.jsp"]

2、拦截器链

　　Shiro的所有拦截器链名定义在源码DefaultFilter中。

anon	例子/admins/**=anon 没有参数，表示可以匿名使用。
authc	例如/admins/user/**=authc表示需要认证(登录)才能使用，没有参数
roles	例子/admins/user/**=roles[admin],参数可以写多个，多个时必须加上引号，    并且参数之间用逗号分割，当有多个参数时，例如admins/user/**=roles["admin,guest"],    每个参数通过才算通过，相当于hasAllRoles()方法。
perms	例子/admins/user/**=perms[user:add:*],参数可以写多个，多个时必须加上引号，并且参数之间用逗号分割，   例如/admins/user/**=perms["user:add:*,user:modify:*"]，当有多个参数时必须每个参数都通过才通过，   想当于isPermitedAll()方法。
rest	例子/admins/user/**=rest[user],根据请求的方法，相当于/admins/user/**=perms[user:method] ,    其中method为post，get，delete等。
port	例子/admins/user/**=port[8081],当请求的url的端口不是8081是跳转到schemal://serverName:8081?queryString,  其中schmal是协议http或https等，serverName是你访问的host,8081是url配置里port的端口，queryString是你访问的url里的？后面的参数。
authcBasic	例如/admins/user/**=authcBasic没有参数表示httpBasic认证
ssl	例子/admins/user/**=ssl没有参数，表示安全的url请求，协议为https
user	例如/admins/user/**=user没有参数表示必须存在用户，当登入操作时不做检查

注：anon，authcBasic，auchc，user是认证过滤器，  

　　perms，roles，ssl，rest，port是授权过滤器  

3、拦截器链源码类关系图

　　

①   NameableFilter有一个name属性，定义每一个filter的名字。

②   OncePerRequestFilter保证客户端请求后该filter的doFilter只会执行一次。

　　doFilterInternal非常重要，在shiro整个filter体系中的核心方法及实质入口。另外，shiro是通过在request中设置一个该filter特定的属性值来保证该filter只会执行一次的。

③   AdviceFilter中主要是对doFilterInternal做了更细致的切分。

　　springmvc中的Interceptor，doFilterInternal会先调用preHandle做一些前置判断，如果返回false则filter链不继续往下执行，

④   AccessControlFilter中的对onPreHandle方法做了进一步细化。

　　isAccessAllowed方法和onAccessDenied方法达到控制效果。这两个方法都是抽象方法，由子类去实现。到这一层应该明白。isAccessAllowed和onAccessDenied方法会影响到onPreHandle方法，而onPreHandle方法会影响到preHandle方法，而preHandle方法会达到控制filter链是否执行下去的效果。所以如果正在执行的filter中isAccessAllowed和onAccessDenied都返回false，则整个filter控制链都将结束，不会到达目标方法（客户端请求的接口），而是直接跳转到某个页面（由filter定义的，将会在authc中看到）。

⑤   FormAuthenticationFiltershiro提供的登录的filter，

　　saveRequestAndRedirectToLogin保存request并拦截到登陆页面，登陆成功后可从WebUtils.getSavedRequest(req);中取出。

四、未实现的功能

• 动态URL权限控制。当修改权限时，重新加载拦截器链。
• 密码加密
• 记住我
• 在线人数控制
• 集成验证码　

五、参考链接

•  spring mvc整合shiro登录 权限验证 　　
• Shiro（4）默认鉴权与自定义鉴权 　　
• 拦截器机制-跟我学shiro 　　　　
• shiro Filter--拦截器源码解释　　
• 动态URL　　
• 重写shirofilterbean方式加载数据库资源权限