SpringMVC+Shiro权限管理

最新推荐文章于 2024-05-29 20:10:49 发布
最新推荐文章于 2024-05-29 20:10:49 发布
阅读量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
    评论
专栏目录
Spring Gateway、Sa-Token、nacos完成认证/鉴权
m88997766的博客
04-03 1922
之前进行鉴权、授权都要写一大堆代码。如果使用像Spring Security这样的框架，又要花好多时间学习，拿过来一用，好多配置项也不知道是干嘛用的，又不想了解。要是不用Spring Security，token的生成、校验、刷新，权限的验证分配，又全要自己写，想想都头大。Spring Security太重而且配置繁琐。自己实现所有的点必须又要顾及到，更是麻烦。最近看到一个权限认证框架，真是够简单高效。这里分享一个使用Sa-Token的gateway鉴权demo。
Shiro简介及简单入门demo
m0_67402026的博客
03-28 984
Shiro 安全框架：简单说对访问权限进行控制，安全性包括用户认证和用户授权。 用户认证一般要求用户提供用户名和密码，系统通过校验两者来完成认证。 用户授权指验证某个用户是否有权限执行某个操作。 一般来说，系统会为不同的用户分配不同的角色，而每个角色对应一系列权限。 1.什么是Shiro Shiro是apache的一个开源框架，将软件系统的安全认证相关的功能抽取出来，实现用户身份认证，权限授权，加密，会话管理等，组成一个通用的安全认证框架。 1.1 Shiro模块内容具体意义 Subject 即“
spring+springMVC+mybaits实现角色权限管理脚手架系统实战开发教程
01-22
本课程将把ssm框架基本原理进行深度讲解，并带大家从基础的hello world开始，逐步写出一个能够实际运用的角色权限系统，即通用任何系统的的脚手架系统，可以用在任何管理类系统中。
基于SpringMVC的注解式权限控制
研客驿站的博客
02-10 573
1. 开发目标 在Shiro的权限分配中，存在@RequiresPermissions注解进行权限的控制，该注解规定了所进行了注解的方法，只能被具有某些权限的人进行访问，且权限之间为&的关系。这个权限控制是不符合我们所需要的权限控制需求的。（我们所需要的是具有某些权限之一的用户可以访问，同时具有这些权限的子权限也可以访问与具有这些权限本身和其父权限才能进行访问的这两种情况区分开）...
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生成验证码图片
springMVC整合shiro框架
02-12
springMVC整合shiro框架，下载后直接可以运行，包含全部jar包，只需要springmvc和shiro jar包的也可以下载
基于springsecurity+springmvc+spring+hibernate的权限管理系统（免积分）
01-16
基于springsecurity+springmvc+spring+hibernate的权限管理系统，实现资源、用户、权限、角色的增删改查，角色-资源管理，用户-角色管理等基础功能，可以作为springmvc+spring+hibernate的增删改查入门项目，也可以对spring-security简单了解，界面使用bootstrap3，非常简洁，免积分
简单的shiro-jwt-demo实例
qq_19342829的博客
03-28 642
使用shiro jwt redis实现的简单登录，权限验证demo
shiro 简单登录demo
热门推荐
风雨过后的博客
01-07 1万+
1.shiro 是java强大的安全认证框架 shiro框架的核心功能：认证，授权，会话管理，加密 shiro框架认证流程   Application Code：应用程序代码，由开发人员负责开发的 Subject：框架提供的接口，代表当前用户对象 SecurityManager：框架提供的接口，代表安全管理器对象 Realm：可以开发人员编写，框架也提供一些，类似于ＤＡＯ，用于访问权...
Java 框架技术：SpringMVC的用户权限控制
最新发布
qq_66493659的博客
05-29 389
能够使用Spring MVC实现简单的后台系统登录验证
Shiro Demo
y19910825的博客
01-10 415
Shiro Demo 准备工作 转自：http://www.sojson.com/shiro 运行前申明 请看完本页面的所有细节，对你掌握这个项目来说很重要，别一上来就搞，你不爽，我也不爽。本项目需要一定的Java功底，需要对SpringMvc，Mybatis，有基本的了解，其次对Redis有了解和使用更佳。本项目理论上，只需要一个Redis，然后一个Mysql和一个有Maven
SpringMvc整合shiro相关配置
m0_71975719的博客
12-01 957
- shiro过滤器，DelegatingFilterProxy通过代理模式将spring容器中的bean和filter关联起来 -->-- 设置spring容器的filter的bean的id，如果不设置则查找与filter名称一致的bean-->--shiro过虑器链定义，从上向下顺序执行，一般将/**放在最下边 -->--注销过滤器，这个地址无关紧要-->--配置sessionManager的bean-->--去除重定向生成的sessionid-->-- 1.Shiro 的Web过滤器 -->
Java：Shiro+SpringMVC 的集成实践
IT老兵的驿站
11-15 559
原帖位于IT老兵博客，沉淀着一个IT老兵对于这个行业的认知。 Java：Shiro+SpringMVC的集成实践。 前言 个人感觉，Shiro的官网有一个问题，讲的不够清楚，尽管看上去好像讲的挺明白，但是我总是感觉很多地方不够清楚，事实上，在阅读了很多帖子之后，发现很多人都对这一点存在疑问，那就不是我一个人的问题了。 Shiro的官网缺乏完整的例子，而且我所处理的项目是Spring的项目，如何清...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值