SpringMVC+Shiro权限管理

最新推荐文章于 2023-12-27 17:19:24 发布
最新推荐文章于 2023-12-27 17:19:24 发布
阅读量521 收藏
点赞数
分类专栏： Spring 文章标签： spring shiro

什么是权限呢？举个简单的例子：
我有一个论坛，注册的用户分为normal用户，manager用户。
对论坛的帖子的操作有这些：
添加，删除，更新，查看，回复
我们规定：
normal用户只能：添加，查看，回复
manager用户可以：删除，更新

normal，manager对应的是角色（role）
添加，删除，更新等对应的是权限（permission）

我们采用下面的逻辑创建权限表结构（不是绝对的，根据需要修改）

一个用户可以有多种角色（normal,manager,admin等等）
一个角色可以有多个用户（user1,user2,user3等等）
一个角色可以有多个权限（save,update,delete,query等等）
一个权限只属于一个角色（delete只属于manager角色）


 

 我们创建四张表：
t_user用户表:设置了3个用户
-------------------------------
id + username   + password
---+----------------+----------
1  +   tom           +  000000
2  +   jack           +  000000
3  +   rose          +  000000
---------------------------------
t_role角色表：设置3个角色
--------------
id + rolename 
---+----------
1  + admin
2  + manager
3  + normal
--------------
t_user_role用户角色表：tom是admin和normal角色，jack是manager和normal角色，rose是normal角色
---------------------
user_id  +  role_id
-----------+-----------
1            +     1
1            +     3
2            +     2
2            +     3
3            +     3
---------------------
t_permission权限表：admin角色可以删除，manager角色可以添加和更新，normal角色可以查看
-----------------------------------
id  +  permissionname  +  role_id
----+------------------------+-----------
1   +   add                     +     2
2   +   del                       +    1
3   +   update                +     2
4   +   query                   +    3
-----------------------------------

?
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
package  com.cn.pojo;
import  java.util.HashSet;
import  java.util.List;
import  java.util.Set;
import  javax.persistence.Entity;
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 {
private  Integer id;
@NotEmpty (message= "用户名不能为空" )
private  String username;
@NotEmpty (message= "密码不能为空" )
private  String password;
private  List<Role> roleList; //一个用户具有多个角色
@Id
@GeneratedValue (strategy=GenerationType.IDENTITY)
public  Integer getId() {
return  id;
}
public  void  setId(Integer id) {
this .id = id;
}
public  String getUsername() {
return  username;
}
public  void  setUsername(String username) {
this .username = username;
}
public  String getPassword() {
return  password;
}
public  void  setPassword(String password) {
this .password = password;
}
@ManyToMany
@JoinTable (name= "t_user_role" ,joinColumns={ @JoinColumn (name= "user_id" )},inverseJoinColumns={ @JoinColumn (name= "role_id" )})
public  List<Role> getRoleList() {
return  roleList;
}
public  void  setRoleList(List<Role> roleList) {
this .roleList = roleList;
}
@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;
}
}

  

?
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
package  com.cn.pojo;
import  java.util.ArrayList;
import  java.util.List;
import  javax.persistence.Entity;
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 {
private  Integer id;
private  String rolename;
private  List<Permission> permissionList; //一个角色对应多个权限
private  List<User> userList; //一个角色对应多个用户
@Id
@GeneratedValue (strategy=GenerationType.IDENTITY)
public  Integer getId() {
return  id;
}
public  void  setId(Integer id) {
this .id = id;
}
public  String getRolename() {
return  rolename;
}
public  void  setRolename(String rolename) {
this .rolename = rolename;
}
@OneToMany (mappedBy= "role" )
public  List<Permission> getPermissionList() {
return  permissionList;
}
public  void  setPermissionList(List<Permission> permissionList) {
this .permissionList = permissionList;
}
@ManyToMany
@JoinTable (name= "t_user_role" ,joinColumns={ @JoinColumn (name= "role_id" )},inverseJoinColumns={ @JoinColumn (name= "user_id" )})
public  List<User> getUserList() {
return  userList;
}
public  void  setUserList(List<User> userList) {
this .userList = userList;
}
@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;
}
}
?
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
package  com.cn.pojo;
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 {
private  Integer id;
private  String permissionname;
private  Role role; //一个权限对应一个角色
@Id
@GeneratedValue (strategy=GenerationType.IDENTITY)
public  Integer getId() {
return  id;
}
public  void  setId(Integer id) {
this .id = id;
}
public  String getPermissionname() {
return  permissionname;
}
public  void  setPermissionname(String permissionname) {
this .permissionname = permissionname;
}
@ManyToOne
@JoinColumn (name= "role_id" )
public  Role getRole() {
return  role;
}
public  void  setRole(Role role) {
this .role = role;
}
}

 使用SHIRO的步骤：
1，导入jar
2，配置web.xml
3，建立dbRelm
4，在Spring中配置

pom.xml中配置如下：

?
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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
< project  xmlns = "http://maven.apache.org/POM/4.0.0"  xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd" >
   < modelVersion >4.0.0</ modelVersion >
   < groupId >com.hyx</ groupId >
   < artifactId >springmvc</ artifactId >
   < packaging >war</ packaging >
   < version >0.0.1-SNAPSHOT</ version >
   < name >springmvc Maven Webapp</ name >
   < url >http://maven.apache.org</ url >
   < dependencies >
     < dependency >
       < groupId >junit</ groupId >
       < artifactId >junit</ artifactId >
       < version >3.8.1</ version >
       < scope >test</ scope >
     </ dependency >
     <!-- SpringMVC核心jar -->
     < dependency >
< groupId >org.springframework</ groupId >
< artifactId >spring-webmvc</ artifactId >
< version >3.2.4.RELEASE</ version >
</ dependency >
     <!-- springmvc连接数据库需要的jar -->
     < dependency >
< groupId >org.springframework</ groupId >
< artifactId >spring-jdbc</ artifactId >
< version >3.2.4.RELEASE</ version >
</ dependency >
< dependency >
< groupId >org.springframework</ groupId >
< artifactId >spring-orm</ artifactId >
< version >3.2.4.RELEASE</ version >
</ dependency >
<!-- ************************************ -->
     <!-- Hibernate相关jar -->
     < dependency >
< groupId >org.hibernate</ groupId >
< artifactId >hibernate-core</ artifactId >
< version >4.2.5.Final</ version >
</ dependency >
< dependency >
< groupId >org.hibernate</ groupId >
< artifactId >hibernate-ehcache</ artifactId >
< version >4.2.5.Final</ version >
</ dependency >
< dependency >
< groupId >net.sf.ehcache</ groupId >
< artifactId >ehcache</ artifactId >
< version >2.7.2</ version >
</ dependency >
< dependency >
< groupId >commons-dbcp</ groupId >
< artifactId >commons-dbcp</ artifactId >
< version >1.4</ version >
</ dependency >
     < dependency >
< groupId >mysql</ groupId >
< artifactId >mysql-connector-java</ artifactId >
< version >5.1.26</ version >
</ dependency >
<!-- javax提供的annotation -->
< dependency >
< groupId >javax.inject</ groupId >
< artifactId >javax.inject</ artifactId >
< version >1</ version >
</ dependency >        
<!-- **************************** -->
<!-- hibernate验证 -->
< dependency >
< groupId >org.hibernate</ groupId >
< artifactId >hibernate-validator</ artifactId >
< version >5.0.1.Final</ version >
</ dependency >
     <!-- 用于对@ResponseBody注解的支持 -->
     < dependency >
< groupId >org.codehaus.jackson</ groupId >
< artifactId >jackson-mapper-asl</ artifactId >
< version >1.9.13</ version >
</ dependency >        
     <!-- 提供对c标签的支持 -->
     < dependency >
< groupId >javax.servlet</ groupId >
< artifactId >jstl</ artifactId >
< version >1.2</ version >
</ dependency >
<!-- servlet api -->
< dependency >
   < groupId >javax.servlet</ groupId >
   < artifactId >servlet-api</ artifactId >
   < version >2.5</ version >
</ dependency >
<!--Apache Shiro所需的jar包-->  
     < dependency >  
       < groupId >org.apache.shiro</ groupId >  
       < artifactId >shiro-core</ artifactId >  
       < version >1.2.2</ version >  
     </ dependency >  
     < dependency >  
       < groupId >org.apache.shiro</ groupId >  
       < artifactId >shiro-web</ artifactId >  
       < version >1.2.2</ version >  
     </ dependency >  
     < dependency >  
       < groupId >org.apache.shiro</ groupId >  
       < artifactId >shiro-spring</ artifactId >  
       < version >1.2.2</ version >  
     </ dependency > 
   </ dependencies >
   
   < build >
     < finalName >springmvc</ finalName >
     <!-- maven的jetty服务器插件 -->
     < plugins >
     < plugin >
   < groupId >org.mortbay.jetty</ groupId >
   < artifactId >jetty-maven-plugin</ artifactId >
   < configuration >
     < scanIntervalSeconds >10</ scanIntervalSeconds >
     < webApp >
       < contextPath >/</ contextPath >
     </ webApp >
     <!-- 修改jetty的默认端口 -->
     < connectors >
        < connector  implementation = "org.eclipse.jetty.server.nio.SelectChannelConnector" >
           < port >80</ port >
           < maxIdleTime >60000</ maxIdleTime >
        </ connector >
     </ connectors >
   </ configuration >
</ plugin >
     </ plugins >
   </ build >
</ project >

web.xml中的配置：

?
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
<? xml  version = "1.0"  encoding = "UTF-8"  ?>
< web-app  version = "2.5" 
xmlns = "http://java.sun.com/xml/ns/javaee" 
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
   < display-name >Archetype Created Web Application</ display-name >
   
   <!-- spring-orm-hibernate4的OpenSessionInViewFilter -->
   < filter >
   < filter-name >opensessioninview</ filter-name >
   < filter-class >org.springframework.orm.hibernate4.support.OpenSessionInViewFilter</ filter-class >
   </ filter >
   < filter-mapping >
   < filter-name >opensessioninview</ filter-name >
   < url-pattern >/*</ url-pattern >
   </ filter-mapping >
   
   <!-- 配置springmvc servlet -->
   < servlet >
   < servlet-name >springmvc</ servlet-name >
   < servlet-class >org.springframework.web.servlet.DispatcherServlet</ servlet-class >
   < load-on-startup >1</ load-on-startup >
   </ servlet >
   < servlet-mapping >
   < servlet-name >springmvc</ servlet-name >
   <!-- / 表示所有的请求都要经过此serlvet -->
   < url-pattern >/</ url-pattern >
   </ servlet-mapping >
   
   <!-- spring的监听器 -->
   < context-param >
< param-name >contextConfigLocation</ param-name >
< param-value >classpath:applicationContext*.xml</ param-value >
   </ context-param >
   < listener >
< listener-class >
org.springframework.web.context.ContextLoaderListener
</ listener-class >
   </ listener >
   
   <!-- Shiro配置 -->  
   < filter >  
     < filter-name >shiroFilter</ filter-name >  
     < filter-class >org.springframework.web.filter.DelegatingFilterProxy</ filter-class >  
   </ filter >  
   < filter-mapping >  
     < filter-name >shiroFilter</ filter-name >  
     < url-pattern >/*</ url-pattern >  
   </ filter-mapping >
   
</ web-app >
?
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
package  com.cn.service;
import  java.util.List;
import  javax.inject.Inject;
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.springframework.stereotype.Service;
import  org.springframework.transaction.annotation.Transactional;
import  com.cn.pojo.Role;
import  com.cn.pojo.User;
@Service
@Transactional
public  class  MyShiro  extends  AuthorizingRealm{
@Inject
private  UserService userService;
/**
  * 权限认证
  */
@Override
protected  AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
//获取登录时输入的用户名
String loginName=(String) principalCollection.fromRealm(getName()).iterator().next();
//到数据库查是否有此对象
User user=userService.findByName(loginName);
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());
}
return  info;
}
return  null ;
}
/**
  * 登录认证;
  */
@Override
protected  AuthenticationInfo doGetAuthenticationInfo(
AuthenticationToken authenticationToken)  throws  AuthenticationException {
//UsernamePasswordToken对象用来存放提交的登录信息
UsernamePasswordToken token=(UsernamePasswordToken) authenticationToken;
//查出是否有此用户
User user=userService.findByName(token.getUsername());
if (user!= null ){
//若存在，将此用户存放到登录认证info中
return  new  SimpleAuthenticationInfo(user.getUsername(), user.getPassword(), getName());
}
return  null ;
}
}

在spring的配置文件中配置，为了区别spring原配置和shiro我们将shiro的配置独立出来。

applicationContext-shiro.xml

?
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
<? 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:aop = "http://www.springframework.org/schema/aop"
        xmlns:tx = "http://www.springframework.org/schema/tx"
        xmlns:context = "http://www.springframework.org/schema/context"
        xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
<!-- 配置权限管理器 -->
< bean  id = "securityManager"  class = "org.apache.shiro.web.mgt.DefaultWebSecurityManager" >  
         <!-- ref对应我们写的realm  MyShiro -->
         < property  name = "realm"  ref = "myShiro" />  
         <!-- 使用下面配置的缓存管理器 -->
         < property  name = "cacheManager"  ref = "cacheManager" />  
     </ bean >
     
     <!-- 配置shiro的过滤器工厂类，id- shiroFilter要和我们在web.xml中配置的过滤器一致 -->
     < bean  id = "shiroFilter"  class = "org.apache.shiro.spring.web.ShiroFilterFactoryBean" > 
     <!-- 调用我们配置的权限管理器 --> 
         < property  name = "securityManager"  ref = "securityManager" /> 
         <!-- 配置我们的登录请求地址 --> 
         < property  name = "loginUrl"  value = "/login" />  
         <!-- 配置我们在登录页登录成功后的跳转地址，如果你访问的是非/login地址，则跳到您访问的地址 -->
         < property  name = "successUrl"  value = "/user" />  
         <!-- 如果您请求的资源不再您的权限范围，则跳转到/403请求地址 -->
         < property  name = "unauthorizedUrl"  value = "/403" />  
         <!-- 权限配置 -->
         < property  name = "filterChainDefinitions" >  
             < value >  
             <!-- anon表示此地址不需要任何权限即可访问 -->
             /static/**=anon
             <!-- perms[user:query]表示访问此连接需要权限为user:query的用户 -->
             /user=perms[user:query]
             <!-- roles[manager]表示访问此连接需要用户的角色为manager -->
             /user/add=roles[manager]
             /user/del/**=roles[admin]
             /user/edit/**=roles[manager]
             <!--所有的请求(除去配置的静态资源请求或请求地址为anon的请求)都要通过登录验证,如果未登录则跳到/login-->  
                 /** = authc
             </ value >  
         </ property >  
     </ bean >
     
     
     < bean  id = "cacheManager"  class = "org.apache.shiro.cache.MemoryConstrainedCacheManager"  />  
     < bean  id = "lifecycleBeanPostProcessor"  class = "org.apache.shiro.spring.LifecycleBeanPostProcessor"  /> 
</ beans >

用于登录，登出，权限跳转的控制：

?
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
package  com.cn.controller;
import  javax.validation.Valid;
import  org.apache.shiro.SecurityUtils;
import  org.apache.shiro.authc.AuthenticationException;
import  org.apache.shiro.authc.UsernamePasswordToken;
import  org.springframework.stereotype.Controller;
import  org.springframework.ui.Model;
import  org.springframework.validation.BindingResult;
import  org.springframework.web.bind.annotation.RequestMapping;
import  org.springframework.web.bind.annotation.RequestMethod;
import  org.springframework.web.servlet.mvc.support.RedirectAttributes;
import  com.cn.pojo.User;
@Controller
public  class  HomeController {
@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){
try  {
if (bindingResult.hasErrors()){
return  "/login" ;
}
//使用权限工具进行用户登录，登录成功后跳到shiro配置的successUrl中，与下面的return没什么关系！
SecurityUtils.getSubject().login( new  UsernamePasswordToken(user.getUsername(), user.getPassword()));
return  "redirect:/user" ;
}  catch  (AuthenticationException e) {
redirectAttributes.addFlashAttribute( "message" , "用户名或密码错误" );
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(){
return  "/403" ;
}
}

三个主要的JSP：
login.jsp:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<%@ 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 >My JSP 'MyJsp.jsp' starting page</ title >
   </ head >
   
   < body >
   < h1 >登录页面----${message }</ h1 >
   < img  alt = ""  src = "/static/img/1.jpg" >
   < form:form  action = "/login"  commandName = "user"  method = "post" >
   用户名：< form:input  path = "username" /> < form:errors  path = "username"  cssClass = "error" /> < br />
     密 &nbsp;&nbsp;码：< form:password  path = "password" /> < form:errors  path = "password"  cssClass = "error"  /> < br />
     < form:button  name = "button" >submit</ form:button >
   </ form:form >
   </ body >
</ html >

 user.jsp:

?
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
<%@ 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 = "/user/add" >添加用户</ a >---< a  href = "/logout" >退出登录</ a >    </ h1 >
     < h2 >权限列表</ h2 >
     < shiro:authenticated >用户已经登录显示此内容</ shiro:authenticated >
     < shiro:hasRole  name = "manager" >manager角色登录显示此内容</ shiro:hasRole >
     < shiro:hasRole  name = "admin" >admin角色登录显示此内容</ shiro:hasRole >
     < shiro:hasRole  name = "normal" >normal角色登录显示此内容</ shiro:hasRole >
     
     < shiro:hasAnyRoles  name = "manager,admin" >**manager or admin 角色用户登录显示此内容**</ shiro:hasAnyRoles >
     < shiro:principal />-显示当前登录用户名
     < shiro:hasPermission  name = "add" >add权限用户显示此内容</ shiro:hasPermission >
     < shiro:hasPermission  name = "user:query" >query权限用户显示此内容< shiro:principal /></ shiro:hasPermission >
     < shiro:lacksPermission  name = "user:del" > 不具有user:del权限的用户显示此内容 </ shiro:lacksPermission >
     < ul >
     < c:forEach  items = "${userList }"  var = "user" >
     < li >用户名：${user.username }----密码：${user.password }----< a  href = "/user/edit/${user.id}" >修改用户</ a >----< a  href = "javascript:;"  class = "del"  ref = "${user.id }" >删除用户</ a ></ li >
     </ c:forEach >
     </ ul >
     < img  alt = ""  src = "/static/img/1.jpg" >
     < script  type = "text/javascript"  src = "http://cdn.staticfile.org/jquery/1.9.1/jquery.min.js" ></ script >
     < script >
     $(function(){
     $(".del").click(function(){
     var id=$(this).attr("ref");
     $.ajax({
     type:"delete",
     url:"/user/del/"+id,
     success:function(e){
     
     }
     });
     });
     });
     </ script >
   </ body >
</ html >

403.jsp:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
<%@ 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 = "/static/img/1.jpg" >
   
   </ body >
</ html >
夜-feng
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
shiro 权限认证以及授权demo
09-10
shiro 权限认证以及授权demo
Shiro 完整教程及样例demo
web15687102624的博客
08-24 683
Apache?Shiro是?Java??的一个安全框架。我们经常看到它被拿来和?Spring??的?Security??来对比。大部分人认为?Shiro??比?Security??要简单。首先?Shiro??确实和?Security??是同类型的框架，主要用来做安全，也就是我们俗称的权限校验（控制）。居多人对?Shiro??的定义为好入门。我选型为?Shiro??，主要的原因扩展太easy了，而且我要的功能它都有。，具体配置在中。定义了5个拦截器，具体功能看代码以及代码注释。util:map在?
Shiro简介及简单入门demo
m0_67402026的博客
03-28 984
Shiro 安全框架：简单说对访问权限进行控制，安全性包括用户认证和用户授权。 用户认证一般要求用户提供用户名和密码，系统通过校验两者来完成认证。 用户授权指验证某个用户是否有权限执行某个操作。 一般来说，系统会为不同的用户分配不同的角色，而每个角色对应一系列权限。 1.什么是Shiro Shiro是apache的一个开源框架，将软件系统的安全认证相关的功能抽取出来，实现用户身份认证，权限授权，加密，会话管理等，组成一个通用的安全认证框架。 1.1 Shiro模块内容具体意义 Subject 即“
SpringMVC+shiro权限管理
04-02
**SpringMVC+Shiro权限管理** 在现代Web应用程序开发中，权限管理和用户认证是至关重要的组成部分。SpringMVC和Apache Shiro都是Java领域中广泛使用的框架，它们各自在不同的层面上提供了强大的功能。SpringMVC是...
Springboot+Mybatis-plus+ SpringMvc+Shiro+Redis企业级报表后台管理系统
04-19
用了两个多月的时间完成的：Springboot+Mybatis-plus+ SpringMvc+Shiro+Redis企业级开发系统，Springboot作为容器，使用mybatis作为持久层框架 使用官方推荐的thymeleaf做为模板引擎，shiro作为安全框架,主流技术 ...
Springboot+Mybatis-plus+ SpringMvc+Shiro+Redis企业级报表后台管理系统.rar
08-12
shiro作为安全框架,主流技术 几乎零XML，极简配置 两套UI实现(bootstrap+layer ui)，可以自由切换 报表后端采用技术： SpringBoot整合SSM(Spring+Mybatis-plus+ SpringMvc)，spring security 全注解式的权限管理和...
springMvc+spring+mybatis+shiro+redis+ehcache后台管理系统.zip
04-29
本后台管理系统，采用流行的框架springMvc+spring+mybatis+shiro+redis+ehcache开发,实现了权限管理（菜单权限、数据权限），solr全文搜索引擎，activiti工作流程引擎，cas单点登陆等功能，完善的代码生成器 后期还...
spring+springmvc+mybatis项目案例实现用户角色权限管理
03-17
使用spring+springmvc框架 整合了Mybatis持久层框架 整合Druid用于数据库连接，并使用Druid对业务层监控spring jdbc 整合EhCache，对Mybatis的二级缓存进行管理和对spring进行缓存管理 整合FastJson对指定http类型的数据进行转换 整合hibernate.validator校验器对controller接口参数进行校验 使用了springmvc统一异常处理 使用了FormattingConversionServiceFactoryBean对于传入参数中日期或数字字符串进行数据转换和数据格式化 使用了SpringContextHolder方便在自定义线程中调用spring已经实例的bean，如使用service 使用了urlrewrite filter进行地址重写，实现伪静态页面 使用了sitemesh对网页进行布局和修饰 使用了loginFilter对访问进行登录过滤 使用了CheckCodeServlet生成验证码图片
Springboot整合Shiro框架入门
web15285868498的博客
04-08 5528
Springboot整合Shiro框架入门 1、快速开始demo 2、Springboot集成Shiro 2.1、环境搭建 2.2、shiro的拦截 2.3、shiro的认证 2.4、整合mybatis 2.5、shiro进行授权 2.6、shiro整合thymeleaf 3、小结 1、快速开始demo 来到shiro的官网：shiro官方网站： 下载官方在git仓库上提供的源码，下载后解压： 官方提供了在多种场景下使用的demo，等一下会用到sample里面的东西。下面直接按官方推荐
shiro入门demo(三)身份认证+授权+拦截
最新发布
w_t_y_y的博客
12-27 509
2、Realm：这里没有连接数据库，在UserConstants中假设数据。
Spring+SpringMVC练习(后台数据管理系统)
weixin_45394002的博客
01-29 827
Spring练习 01-Spring练习-环境搭建步骤分析(理解) 案例环境搭建步骤： ①创建工程（Project&Module） ②导入静态页面（见jsp页面） ③导入需要坐标（见pom.xml） ④创建包结构（controller、service、dao、domain、utils(工具类)） 在不同的企业中，domain包也叫做多种名字，包括Entity包、POJO包、实质就是一个JavaBean类 ⑤导入数据库脚本（见test.sql） ⑥创建POJO(JavaBean)类（见User.jav
spring+springMVC+mybaits实现角色权限管理脚手架系统实战开发教程
01-22
本课程将把ssm框架基本原理进行深度讲解，并带大家从基础的hello world开始，逐步写出一个能够实际运用的角色权限系统，即通用任何系统的的脚手架系统，可以用在任何管理类系统中。
Shiro实战Demo
我要，我要，我还要
11-15 565
Shiro 使用 hello shiro 首先创建Maven项目并引入最新的shiro依赖 <dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-core</artifactId> <version>1.7.0</version> <
基于SpringMVC的注解式权限控制
研客驿站的博客
02-10 573
1. 开发目标 在Shiro的权限分配中，存在@RequiresPermissions注解进行权限的控制，该注解规定了所进行了注解的方法，只能被具有某些权限的人进行访问，且权限之间为&的关系。这个权限控制是不符合我们所需要的权限控制需求的。（我们所需要的是具有某些权限之一的用户可以访问，同时具有这些权限的子权限也可以访问与具有这些权限本身和其父权限才能进行访问的这两种情况区分开）...
Spring Gateway、Sa-Token、nacos完成认证/鉴权
m88997766的博客
04-03 1922
之前进行鉴权、授权都要写一大堆代码。如果使用像Spring Security这样的框架，又要花好多时间学习，拿过来一用，好多配置项也不知道是干嘛用的，又不想了解。要是不用Spring Security，token的生成、校验、刷新，权限的验证分配，又全要自己写，想想都头大。Spring Security太重而且配置繁琐。自己实现所有的点必须又要顾及到，更是麻烦。最近看到一个权限认证框架，真是够简单高效。这里分享一个使用Sa-Token的gateway鉴权demo。
自定义SpringMVC框架以及权限控制
沐晨~的博客
07-19 484
1、首先配置tomcat加载的web.xml文件 <servlet> <servlet-name>mymvc</servlet-name> <servlet-class>com.lwq.edu.mvcframework.servlet.MyDispatcherServlet</servlet-class> <init-param> <param-name>contextConfigLoca
SpringMVC+Shiro实战：权限控制详解
"SpringMVC与Shiro结合进行权限管理的实践" 在Web开发中，权限管理是一项关键功能，用于控制不同用户对系统资源的访问权限。SpringMVC作为流行的MVC框架，配合Apache Shiro安全框架，可以实现灵活且强大的权限控制...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值