Spring+Shiro权限控制

Spring+Shiro权限控制

权限控制在做项目中,是必不可少的。而关于权限控制,目前跟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


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<!-- 这个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中添加上去


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

shiro里面的内容

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
<?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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
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


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
@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

字段 类型 大小
id int 11
user_name varchar 255
pass_word varchar 255
status int 1
group_id int 11
add_time datetime 0

adminGrop

字段 类型 大小
id int 11
group_name varchar 255
info varchar 255
status int 11
add_time datetime 0

字段 类型 大小
id int 11
navigation_name varchar 255
navigation_url varchar 255
parent_id int 11

permission (关联navigation表跟adminGroup表)

字段 类型 大小
id int 11
group_id int 11
navigation_id int 11

然后你创建两个用户组,一个用户组的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权限管理算是完成了,在后面我加了动态数据库读取权限,还有个自定义的配置。关于动态更新不需要重启服务器还有点问题,如果小伙伴们有想法,可以联系我一起讨论或者在下面留言~

文章目录
  1. 1. 需要的jar包
  2. 2. 在web.xml中加入filter
  3. 3. 创建一个shiro.xml文件
  4. 4. shiro里面的内容
  5. 5. MyRealM.java
  6. 6. LoginController.java
  7. 7. 数据库设置:
    1. 7.1. adminUser
    2. 7.2. adminGrop
    3. 7.3. navigation(这里存放的就是各个资源的路径)
    4. 7.4. permission (关联navigation表跟adminGroup表)
  8. 8. 借鉴的大神的网站博客
,