Spring shiro 初次使用小结

　　首先引入一段关于shiro的介绍：

　　开发系统中，少不了权限，目前java里的权限框架有SpringSecurity和Shiro(以前叫做jsecurity)，对于SpringSecurity：功能太过强大以至于功能比较分散，使用起来也比较复杂，跟Spring结合的比较好。对于初学Spring Security者来说，曲线还是较大，需要深入学习其源码和框架，配置起来也需要费比较大的力气，扩展性也不是特别强。

　　对于新秀Shiro来说，好评还是比较多的，使用起来比较简单，功能也足够强大，扩展性也较好。听说连Spring的官方都不用Spring Security，用的是Shiro，足见Shiro的优秀。网上找到两篇介绍：http://www.infoq.com/cn/articles/apache-shiro http://www.ibm.com/developerworks/cn/opensource/os-cn-shiro/，http://itindex.net/detail/50410-apache-shiro-%E4%BD%BF%E7%94%A8%E6%89%8B%E5%86%8C，官网http://shiro.apache.org/ ，使用和配置起来还是比较简单。

　　下面只是简单介绍下我们是如何配置和使用Shiro的。

　　pom.xml引入相关jar包

 1             <!-- spring结合 -->
 2             <dependency>
 3                 <groupId>org.apache.shiro</groupId>
 4                 <artifactId>shiro-spring</artifactId>
 5                 <version>1.4.0</version>
 6             </dependency>
 7             <!--缓存包-->
 8             <dependency>
 9                 <groupId>org.apache.shiro</groupId>
10                 <artifactId>shiro-ehcache</artifactId>
11                 <version>1.4.0</version>
12             </dependency>
13             <!--核心包-->
14             <dependency>
15                 <groupId>org.apache.shiro</groupId>
16                 <artifactId>shiro-core</artifactId>
17                 <version>1.4.0</version>
18             </dependency>

 

web.xml增加过滤

 1     <!-- shiro 权限控制的过滤器 -->
 2     <filter>
 3         <filter-name>shiroFilter</filter-name>
 4         <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
 5     </filter>
 6 
 7     <filter-mapping>
 8         <filter-name>shiroFilter</filter-name>
 9         <url-pattern>/*</url-pattern>
10     </filter-mapping>

 

增加一个shiro.xml的配置文件

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:jee="http://www.springframework.org/schema/jee"
 4     xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"
 5     xmlns:util="http://www.springframework.org/schema/util"
 6     xsi:schemaLocation="
 7     http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
 8     http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd 
 9     http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.0.xsd 
10     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
11     http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd"
12     default-lazy-init="false">
13 
14     <!-- 缓存管理器 使用memory实现 -->
15 
16 
17     <!--rememberMe 30天 -->
18     <bean id="rememberMeCookie" class="org.apache.shiro.web.servlet.SimpleCookie">
19         <constructor-arg value="COOKIE_NAME" />
20         <property name="httpOnly" value="true" />
21         <property name="maxAge" value="2592000" />
22 
23     </bean>
24 
25     <!-- rememberMe管理器 -->
26     <bean id="rememberMeManager" class="org.apache.shiro.web.mgt.CookieRememberMeManager">
27         <property name="cipherKey" value="#{T(org.apache.shiro.codec.Base64).decode('4AvVhmFLUs0KTA3Kprsdag==')}" />
28         <property name="cookie" ref="rememberMeCookie" />
29     </bean>
30 
31     <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
32         <!-- 继承AuthorizingRealm的类-->
33         <property name="realm" ref="userRealm" />
34         <property name="rememberMeManager" ref="rememberMeManager" />
35     </bean>
36 
37     <!-- Shiro Filter -->
38     <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
39         <property name="securityManager" ref="securityManager" />
40         <property name="loginUrl" value="/openid" />
41         <property name="successUrl" value="/manage" />
42         <property name="unauthorizedUrl" value="/openid" />
43         <property name="filterChainDefinitions">
44             <value>
45                 /api/**=anon
46                 /res/**=anon
47                 /src/**=anon
48                 /health/**=anon
49                 /logout=authc
50                 /openid=anon
51                 /callback=anon
52                 /=authc
53                 /**=anon
54             </value>
55         </property>
56     </bean>
57 
58 
59     <!-- Shiro生命周期处理器 -->
60     <bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor" />
61 
62 </beans>
View Code

 

对bean的扫描配置

1     <!-- shiro相关的配置文件和路径扫描的配置必须要放在项目的mvc的配置文件(即xxx-servlet.xml)里 -->
2     <aop:config proxy-target-class="true" />
3 
4     <bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">
5         <property name="securityManager" ref="securityManager" />
6     </bean>

 

UserRealm

 1 @Component
 2 public class UserRealm extends AuthorizingRealm {
 3 
 4     private Logger logger = org.slf4j.LoggerFactory.getLogger(UserRealm.class);
 5 
 6     public final static String CREDENTIALS = "openid";
 7 
 8     @Autowired
 9     private SessionService sessionService;
10     @Autowired
11     private PermissionService permissionService;
12 
13     // 记录是否已经设置过PemissionResover
14     private boolean hasSetPemissionResover = false;
15 
16     @Override
17     public PermissionResolver getPermissionResolver() {
18         if (!hasSetPemissionResover) {
19             setPermissionResolver(new WildcardExtPermissionResolver());
20             hasSetPemissionResover = true;
21         }
22         return super.getPermissionResolver();
23     }
24 
25     /**
26      * 获取授权信息
27      *
28      * @param principals
29      * @return
30      */
31     @Override
32     protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
33         try {
34             Iterator<String> iter = principals.fromRealm(getName()).iterator();
35             if (!iter.hasNext()) {
36                 logger.info("shiro 验证 无权限");
37                 return null;
38             }
39             String email = iter.next();
40             if (!Strings.isNullOrEmpty(email)) {
41                 // set session
42                 SessionObject so = sessionService.getSession(email);
43                 if (so == null) {
44                     logger.info("so 缓存为空");
45                     return null;
46                 }
47                 SessionUtils.setSo(so);
48 
49                 // set auth
50                 SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
51                 info.addStringPermissions(permissionService.getPermsForUser(so.getRoleId()));
52                 return info;
53             }
54             logger.info("邮箱为空");
55             return null;
56         } catch (Exception e) {
57             logger.error("shiro 权限获取异常:", e);
58             return null;
59         }
60     }
61 
62     /**
63      * 获取身份验证相关信息：
64      *
65      * @param authcToken
66      * @return
67      * @throws AuthenticationException
68      */
69     @Override
70     protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authcToken) throws AuthenticationException {
71         try {
72             UsernamePasswordToken token = (UsernamePasswordToken) authcToken;
73             String email = token.getUsername();
74             String password = new String(token.getPassword());
75             if (!StringUtils.isEmpty(email) && CREDENTIALS.equals(password)) {
76                 SessionObject so = SessionUtils.getSo();
77                 sessionService.addOrUpdateSession(so);
78                 return new SimpleAuthenticationInfo(email, CREDENTIALS, getName());
79             }
80             logger.info("登录验证失败，shiro 不添加权限信息");
81             return null;
82         } catch (Exception e) {
83             logger.error("shiro 身份验证异常:", e);
84             return null;
85         }
86     }
87 
88 
89 }
View Code

登录调用

             UsernamePasswordToken token = new UsernamePasswordToken(
                     "username", "password", true);
 
             SecurityUtils.getSubject().login(token);
View Code

退出调用

1 SecurityUtils.getSubject().logout();
View Code

权限注解

@RequiresPermissions(value = {"ROLE_KEY"})

 

以上的配置走完以后就可以用，下面讲讲个人需求，以及踩过的坑：

1、如何修改cookie的名称，默认名称“rememberMe”太丑了有木有？

首先丢一篇文章，关于该cookie的：http://blog.csdn.net/lhacker/article/details/19341735

我的理解是Shiro 的 SimpleCookie 其实提供了修改cookie名称的方法，方法有两个：

一是直接通过构造函数的方法修改cookie的名称，就像我展示的配置文件shiro的中一样：

 1 <constructor-arg value="COOKIE_NAME" /> 

其实调用的是SimpleCookie这个方法：

1     public SimpleCookie(String name) {
2         this();
3         this.name = name;
4     }
SimpleCookie 其实还提供了其它构造方法可以使用，详见源码。

第二个方法则是通过给SimpleCookie的name字段赋值的方法，这个方法就和我给的链接中的方法一样：

 1 <property name="name" value="COOKIE_NAME" /> 

除此之外，还可以配置SimpleCookie的其它字段，源码中给出的可以配置字段如下：

1     private String name;
2     private String value;
3     private String comment;
4     private String domain;
5     private String path;
6     private int maxAge;
7     private int version;
8     private boolean secure;
9     private boolean httpOnly;
View Code

 

2、明明配置了权限注解，为什么没有调用doGetAuthorizationInfo获取授权信息的方法？

注解生效需要在servlet.xml中配置如下：

 

    <bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">
        <property name="securityManager" ref="securityManager" />
    </bean>

 

 

 

3、一个接口可以被不同的页面调用，但这个页面分别属于不同的权限？

我们在使用权限注解时，往往会遇到这样的问题，接口可以重复使用，权限却要分开，怎么办呢？

首先看看@RequiresPermissions注解的源码：

 1 @Target({ElementType.TYPE, ElementType.METHOD})
 2 @Retention(RetentionPolicy.RUNTIME)
 3 public @interface RequiresPermissions {
 4 
 5     /**
 6      * The permission string which will be passed to {@link org.apache.shiro.subject.Subject#isPermitted(String)}
 7      * to determine if the user is allowed to invoke the code protected by this annotation.
 8      */
 9     String[] value();
10     
11     /**
12      * The logical operation for the permission checks in case multiple roles are specified. AND is the default
13      * @since 1.1.0
14      */
15     Logical logical() default Logical.AND; 
16 
17 }

源码很简单，不难发现，注解中权限的key存放在value数组中，另外还有一个Logical用来存放多个权限之间关系，所以当我们一个方法需要满足多个权限时，可以这样：

@RequiresPermissions(value = { "key1", "key2" }, logical = Logical.AND)

当一个方法满足任意权限key时，可以这样

@RequiresPermissions(value = { "key1", "key2" }, logical = Logical.OR)

 

4、采用非用户密码的方式登录怎么办？

遇到这个问题，我的处理办法是验证方式我们事先处理掉，然后再调用subject的login，大致流程如下：

// 处理登录逻辑
验证手机验证码等......
// 调用subject login
UsernamePasswordToken token = new UsernamePasswordToken(
                    email, "openid", true);
// username 字段可以放id/账号/手机号/邮箱等唯一值
// password  则存放一个当前账号必带的一个信息，若有在验证过程中有密码则可以存放密码，可以直接存放任意string，这个都没关系，这里就存放了一个string字符"openid"
SecurityUtils.getSubject().login(token);

subject 的 login方法会间接调用到doGetAuthenticationInfo获取验证相关信息的方法，上面给出了一个方法的源码

 1 protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authcToken) throws AuthenticationException {
 2         try {
 3             UsernamePasswordToken token = (UsernamePasswordToken) authcToken;
 4             String email = token.getUsername();
 5             String password = new String(token.getPassword());
 6             if (!StringUtils.isEmpty(email) && "openid".equals(password)) {
 7 // 这里做简单的判断，username不为空，且 password 为我们给定的字符串
 8 // 如果是则可以进行权限验证，否则失败
 9 // 这里除了放username 还可以放其它内容，也可以将整个user的信息从数据库取出来，放入SimpleAuthenticationInfo的principal字段中
10                 return new SimpleAuthenticationInfo("希望存入cookie的内容","openid", getName());
11             }
12             logger.info("登录验证失败，shiro 不添加权限信息");
13             return null;
14         } catch (Exception e) {
15             logger.error("shiro 身份验证异常:", e);
16             return null;
17         }
18     }

 

5、存入cookie的数据无法序列化？

放入放入SimpleAuthenticationInfo的principal字段常常遇到序列化的问题，这是由于我们平时写的model都没有实现Serializable，所以我们只要让对应的model实现一下即可，如：

1 public class User implements Serializable{
2      ......      
3 }

 

6、shiro.xml中配置和注解分别做啥用？

 注解和shiro.xml中配置的filter是shiro提供的两套权限验证流程，他们的调用并不一样

这篇文档对filter中的相关注解错了比较详细的介绍：http://blog.csdn.net/clj198606061111/article/details/24185023

我截取一段关于shiro.xml中关于ShiroFilterFactoryBean配置的说明，如下：

 

securityManager：这个属性是必须的。

 

loginUrl：没有登录的用户请求需要登录的页面时自动跳转到登录页面，不是必须的属性，不输入地址的话会自动寻找项目web项目的根目录下的”/login.jsp”页面。

 

successUrl：登录成功默认跳转页面，不配置则跳转至”/”。如果登陆前点击的一个需要登录的页面，则在登录自动跳转到那个需要登录的页面。不跳转到此。

 

unauthorizedUrl：没有权限默认跳转的页面。

 

 

 

过滤器简称

对应的java类

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

logout

org.apache.shiro.web.filter.authc.LogoutFilter

 

 

 

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是授权过滤器

 

 

注解中的权限信息，则是通过获取授权信息方法实现：

 

@Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        try {
            Iterator<String> iter = principals.fromRealm(getName()).iterator();
            if (!iter.hasNext()) {
                logger.info("shiro 验证 无权限");
                return null;
            }
            String email = iter.next();
            if (!Strings.isNullOrEmpty(email)) {
                // 通过email可以实时获取权限信息，当然也可以在iter中本身就带有权限信息，不在进行数据库或者redis的查询
        // set auth
                SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
                info.addStringPermissions(new ArrayList<String>("权限集合"));
                return info;
            }
            logger.info("邮箱为空");
            return null;
        } catch (Exception e) {
            logger.error("shiro 权限获取异常:", e);
            return null;
        }
    }

 

总结：

第一次使用shiro做权限验证，个人感觉shiro的权限验证比较灵活易懂，且比较适合新手接入，权限的控制也比较简单。上面提出的几个问题，即是本人在随着项目的所遇到的问题，只是给出了个人的解决方法，若有更适合的方法还请指出，多谢。

posted @ 2017-11-28 11:10  Weagle  阅读(14319)  评论(0)  编辑  收藏  举报