SpringMVC+Shiro权限管理

博文目录

  1. 权限的简单描述
  2. 实例表结构及内容及POJO
  3. Shiro-pom.xml
  4. Shiro-web.xml
  5. Shiro-MyShiro-权限认证,登录认证层
  6. Shiro-applicationContext-shiro.xml
  7. HomeController
  8. 三个JSP文件

什么是权限呢?举个简单的例子:
我有一个论坛,注册的用户分为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
-----------------------------------

 建立对应的POJO:

  1. package com.cn.pojo;
  2. import java.util.HashSet;
  3. import java.util.List;
  4. import java.util.Set;
  5. import javax.persistence.Entity;
  6. import javax.persistence.GeneratedValue;
  7. import javax.persistence.GenerationType;
  8. import javax.persistence.Id;
  9. import javax.persistence.JoinColumn;
  10. import javax.persistence.JoinTable;
  11. import javax.persistence.ManyToMany;
  12. import javax.persistence.Table;
  13. import javax.persistence.Transient;
  14. import org.hibernate.validator.constraints.NotEmpty;
  15. @Entity
  16. @Table(name="t_user")
  17. public class User {
  18. private Integer id;
  19. @NotEmpty(message="用户名不能为空")
  20. private String username;
  21. @NotEmpty(message="密码不能为空")
  22. private String password;
  23. private List<Role> roleList;//一个用户具有多个角色
  24. @Id
  25. @GeneratedValue(strategy=GenerationType.IDENTITY)
  26. public Integer getId() {
  27. return id;
  28. }
  29. public void setId(Integer id) {
  30. this.id = id;
  31. }
  32. public String getUsername() {
  33. return username;
  34. }
  35. public void setUsername(String username) {
  36. this.username = username;
  37. }
  38. public String getPassword() {
  39. return password;
  40. }
  41. public void setPassword(String password) {
  42. this.password = password;
  43. }
  44. @ManyToMany
  45. @JoinTable(name="t_user_role",joinColumns={@JoinColumn(name="user_id")},inverseJoinColumns={@JoinColumn(name="role_id")})
  46. public List<Role> getRoleList() {
  47. return roleList;
  48. }
  49. public void setRoleList(List<Role> roleList) {
  50. this.roleList = roleList;
  51. }
  52. @Transient
  53. public Set<String> getRolesName(){
  54. List<Role> roles=getRoleList();
  55. Set<String> set=new HashSet<String>();
  56. for (Role role : roles) {
  57. set.add(role.getRolename());
  58. }
  59. return set;
  60. }
  61. }
  1. package com.cn.pojo;
  2. import java.util.ArrayList;
  3. import java.util.List;
  4. import javax.persistence.Entity;
  5. import javax.persistence.GeneratedValue;
  6. import javax.persistence.GenerationType;
  7. import javax.persistence.Id;
  8. import javax.persistence.JoinColumn;
  9. import javax.persistence.JoinTable;
  10. import javax.persistence.ManyToMany;
  11. import javax.persistence.OneToMany;
  12. import javax.persistence.Table;
  13. import javax.persistence.Transient;
  14. @Entity
  15. @Table(name="t_role")
  16. public class Role {
  17. private Integer id;
  18. private String rolename;
  19. private List<Permission> permissionList;//一个角色对应多个权限
  20. private List<User> userList;//一个角色对应多个用户
  21. @Id
  22. @GeneratedValue(strategy=GenerationType.IDENTITY)
  23. public Integer getId() {
  24. return id;
  25. }
  26. public void setId(Integer id) {
  27. this.id = id;
  28. }
  29. public String getRolename() {
  30. return rolename;
  31. }
  32. public void setRolename(String rolename) {
  33. this.rolename = rolename;
  34. }
  35. @OneToMany(mappedBy="role")
  36. public List<Permission> getPermissionList() {
  37. return permissionList;
  38. }
  39. public void setPermissionList(List<Permission> permissionList) {
  40. this.permissionList = permissionList;
  41. }
  42. @ManyToMany
  43. @JoinTable(name="t_user_role",joinColumns={@JoinColumn(name="role_id")},inverseJoinColumns={@JoinColumn(name="user_id")})
  44. public List<User> getUserList() {
  45. return userList;
  46. }
  47. public void setUserList(List<User> userList) {
  48. this.userList = userList;
  49. }
  50. @Transient
  51. public List<String> getPermissionsName(){
  52. List<String> list=new ArrayList<String>();
  53. List<Permission> perlist=getPermissionList();
  54. for (Permission per : perlist) {
  55. list.add(per.getPermissionname());
  56. }
  57. return list;
  58. }
  59. }
  1. package com.cn.pojo;
  2. import javax.persistence.Entity;
  3. import javax.persistence.GeneratedValue;
  4. import javax.persistence.GenerationType;
  5. import javax.persistence.Id;
  6. import javax.persistence.JoinColumn;
  7. import javax.persistence.ManyToOne;
  8. import javax.persistence.Table;
  9. @Entity
  10. @Table(name="t_permission")
  11. public class Permission {
  12. private Integer id;
  13. private String permissionname;
  14. private Role role;//一个权限对应一个角色
  15. @Id
  16. @GeneratedValue(strategy=GenerationType.IDENTITY)
  17. public Integer getId() {
  18. return id;
  19. }
  20. public void setId(Integer id) {
  21. this.id = id;
  22. }
  23. public String getPermissionname() {
  24. return permissionname;
  25. }
  26. public void setPermissionname(String permissionname) {
  27. this.permissionname = permissionname;
  28. }
  29. @ManyToOne
  30. @JoinColumn(name="role_id")
  31. public Role getRole() {
  32. return role;
  33. }
  34. public void setRole(Role role) {
  35. this.role = role;
  36. }
  37. }

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

pom.xml中配置如下:

  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  2. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  3. <modelVersion>4.0.0</modelVersion>
  4. <groupId>com.hyx</groupId>
  5. <artifactId>springmvc</artifactId>
  6. <packaging>war</packaging>
  7. <version>0.0.1-SNAPSHOT</version>
  8. <name>springmvc Maven Webapp</name>
  9. <url>http://maven.apache.org</url>
  10. <dependencies>
  11. <dependency>
  12. <groupId>junit</groupId>
  13. <artifactId>junit</artifactId>
  14. <version>3.8.1</version>
  15. <scope>test</scope>
  16. </dependency>
  17. <!-- SpringMVC核心jar -->
  18. <dependency>
  19. <groupId>org.springframework</groupId>
  20. <artifactId>spring-webmvc</artifactId>
  21. <version>3.2.4.RELEASE</version>
  22. </dependency>
  23. <!-- springmvc连接数据库需要的jar -->
  24. <dependency>
  25. <groupId>org.springframework</groupId>
  26. <artifactId>spring-jdbc</artifactId>
  27. <version>3.2.4.RELEASE</version>
  28. </dependency>
  29. <dependency>
  30. <groupId>org.springframework</groupId>
  31. <artifactId>spring-orm</artifactId>
  32. <version>3.2.4.RELEASE</version>
  33. </dependency>
  34. <!-- ************************************ -->
  35. <!-- Hibernate相关jar -->
  36. <dependency>
  37. <groupId>org.hibernate</groupId>
  38. <artifactId>hibernate-core</artifactId>
  39. <version>4.2.5.Final</version>
  40. </dependency>
  41. <dependency>
  42. <groupId>org.hibernate</groupId>
  43. <artifactId>hibernate-ehcache</artifactId>
  44. <version>4.2.5.Final</version>
  45. </dependency>
  46. <dependency>
  47. <groupId>net.sf.ehcache</groupId>
  48. <artifactId>ehcache</artifactId>
  49. <version>2.7.2</version>
  50. </dependency>
  51. <dependency>
  52. <groupId>commons-dbcp</groupId>
  53. <artifactId>commons-dbcp</artifactId>
  54. <version>1.4</version>
  55. </dependency>
  56. <dependency>
  57. <groupId>mysql</groupId>
  58. <artifactId>mysql-connector-java</artifactId>
  59. <version>5.1.26</version>
  60. </dependency>
  61. <!-- javax提供的annotation -->
  62. <dependency>
  63. <groupId>javax.inject</groupId>
  64. <artifactId>javax.inject</artifactId>
  65. <version>1</version>
  66. </dependency>
  67. <!-- **************************** -->
  68. <!-- hibernate验证 -->
  69. <dependency>
  70. <groupId>org.hibernate</groupId>
  71. <artifactId>hibernate-validator</artifactId>
  72. <version>5.0.1.Final</version>
  73. </dependency>
  74. <!-- 用于对@ResponseBody注解的支持 -->
  75. <dependency>
  76. <groupId>org.codehaus.jackson</groupId>
  77. <artifactId>jackson-mapper-asl</artifactId>
  78. <version>1.9.13</version>
  79. </dependency>
  80. <!-- 提供对c标签的支持 -->
  81. <dependency>
  82. <groupId>javax.servlet</groupId>
  83. <artifactId>jstl</artifactId>
  84. <version>1.2</version>
  85. </dependency>
  86. <!-- servlet api -->
  87. <dependency>
  88. <groupId>javax.servlet</groupId>
  89. <artifactId>servlet-api</artifactId>
  90. <version>2.5</version>
  91. </dependency>
  92. <!--Apache Shiro所需的jar包-->
  93. <dependency>
  94. <groupId>org.apache.shiro</groupId>
  95. <artifactId>shiro-core</artifactId>
  96. <version>1.2.2</version>
  97. </dependency>
  98. <dependency>
  99. <groupId>org.apache.shiro</groupId>
  100. <artifactId>shiro-web</artifactId>
  101. <version>1.2.2</version>
  102. </dependency>
  103. <dependency>
  104. <groupId>org.apache.shiro</groupId>
  105. <artifactId>shiro-spring</artifactId>
  106. <version>1.2.2</version>
  107. </dependency>
  108. </dependencies>
  109. <build>
  110. <finalName>springmvc</finalName>
  111. <!-- maven的jetty服务器插件 -->
  112. <plugins>
  113. <plugin>
  114. <groupId>org.mortbay.jetty</groupId>
  115. <artifactId>jetty-maven-plugin</artifactId>
  116. <configuration>
  117. <scanIntervalSeconds>10</scanIntervalSeconds>
  118. <webApp>
  119. <contextPath>/</contextPath>
  120. </webApp>
  121. <!-- 修改jetty的默认端口 -->
  122. <connectors>
  123. <connector implementation="org.eclipse.jetty.server.nio.SelectChannelConnector">
  124. <port>80</port>
  125. <maxIdleTime>60000</maxIdleTime>
  126. </connector>
  127. </connectors>
  128. </configuration>
  129. </plugin>
  130. </plugins>
  131. </build>
  132. </project>

 web.xml中的配置:

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <web-app version="2.5"
  3. xmlns="http://java.sun.com/xml/ns/javaee"
  4. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  5. xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
  6. http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
  7. <display-name>Archetype Created Web Application</display-name>
  8. <!-- spring-orm-hibernate4的OpenSessionInViewFilter -->
  9. <filter>
  10. <filter-name>opensessioninview</filter-name>
  11. <filter-class>org.springframework.orm.hibernate4.support.OpenSessionInViewFilter</filter-class>
  12. </filter>
  13. <filter-mapping>
  14. <filter-name>opensessioninview</filter-name>
  15. <url-pattern>/*</url-pattern>
  16. </filter-mapping>
  17. <!-- 配置springmvc servlet -->
  18. <servlet>
  19. <servlet-name>springmvc</servlet-name>
  20. <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  21. <load-on-startup>1</load-on-startup>
  22. </servlet>
  23. <servlet-mapping>
  24. <servlet-name>springmvc</servlet-name>
  25. <!-- / 表示所有的请求都要经过此serlvet -->
  26. <url-pattern>/</url-pattern>
  27. </servlet-mapping>
  28. <!-- spring的监听器 -->
  29. <context-param>
  30. <param-name>contextConfigLocation</param-name>
  31. <param-value>classpath:applicationContext*.xml</param-value>
  32. </context-param>
  33. <listener>
  34. <listener-class>
  35. org.springframework.web.context.ContextLoaderListener
  36. </listener-class>
  37. </listener>
  38. <!-- Shiro配置 -->
  39. <filter>
  40. <filter-name>shiroFilter</filter-name>
  41. <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
  42. </filter>
  43. <filter-mapping>
  44. <filter-name>shiroFilter</filter-name>
  45. <url-pattern>/*</url-pattern>
  46. </filter-mapping>
  47. </web-app>
  1. package com.cn.service;
  2. import java.util.List;
  3. import javax.inject.Inject;
  4. import org.apache.shiro.authc.AuthenticationException;
  5. import org.apache.shiro.authc.AuthenticationInfo;
  6. import org.apache.shiro.authc.AuthenticationToken;
  7. import org.apache.shiro.authc.SimpleAuthenticationInfo;
  8. import org.apache.shiro.authc.UsernamePasswordToken;
  9. import org.apache.shiro.authz.AuthorizationInfo;
  10. import org.apache.shiro.authz.SimpleAuthorizationInfo;
  11. import org.apache.shiro.realm.AuthorizingRealm;
  12. import org.apache.shiro.subject.PrincipalCollection;
  13. import org.springframework.stereotype.Service;
  14. import org.springframework.transaction.annotation.Transactional;
  15. import com.cn.pojo.Role;
  16. import com.cn.pojo.User;
  17. @Service
  18. @Transactional
  19. public class MyShiro extends AuthorizingRealm{
  20. @Inject
  21. private UserService userService;
  22. /**
  23. * 权限认证
  24. */
  25. @Override
  26. protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
  27. //获取登录时输入的用户名
  28. String loginName=(String) principalCollection.fromRealm(getName()).iterator().next();
  29. //到数据库查是否有此对象
  30. User user=userService.findByName(loginName);
  31. if(user!=null){
  32. //权限信息对象info,用来存放查出的用户的所有的角色(role)及权限(permission)
  33. SimpleAuthorizationInfo info=new SimpleAuthorizationInfo();
  34. //用户的角色集合
  35. info.setRoles(user.getRolesName());
  36. //用户的角色对应的所有权限,如果只使用角色定义访问权限,下面的四行可以不要
  37. List<Role> roleList=user.getRoleList();
  38. for (Role role : roleList) {
  39. info.addStringPermissions(role.getPermissionsName());
  40. }
  41. return info;
  42. }
  43. return null;
  44. }
  45. /**
  46. * 登录认证;
  47. */
  48. @Override
  49. protected AuthenticationInfo doGetAuthenticationInfo(
  50. AuthenticationToken authenticationToken) throws AuthenticationException {
  51. //UsernamePasswordToken对象用来存放提交的登录信息
  52. UsernamePasswordToken token=(UsernamePasswordToken) authenticationToken;
  53. //查出是否有此用户
  54. User user=userService.findByName(token.getUsername());
  55. if(user!=null){
  56. //若存在,将此用户存放到登录认证info中
  57. return new SimpleAuthenticationInfo(user.getUsername(), user.getPassword(), getName());
  58. }
  59. return null;
  60. }
  61. }

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

applicationContext-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"
  4. xmlns:aop="http://www.springframework.org/schema/aop"
  5. xmlns:tx="http://www.springframework.org/schema/tx"
  6. xmlns:context="http://www.springframework.org/schema/context"
  7. xsi:schemaLocation="
  8. http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
  9. http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
  10. http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
  11. http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
  12. <!-- 配置权限管理器 -->
  13. <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
  14. <!-- ref对应我们写的realm  MyShiro -->
  15. <property name="realm" ref="myShiro"/>
  16. <!-- 使用下面配置的缓存管理器 -->
  17. <property name="cacheManager" ref="cacheManager"/>
  18. </bean>
  19. <!-- 配置shiro的过滤器工厂类,id- shiroFilter要和我们在web.xml中配置的过滤器一致 -->
  20. <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
  21. <!-- 调用我们配置的权限管理器 -->
  22. <property name="securityManager" ref="securityManager"/>
  23. <!-- 配置我们的登录请求地址 -->
  24. <property name="loginUrl" value="/login"/>
  25. <!-- 配置我们在登录页登录成功后的跳转地址,如果你访问的是非/login地址,则跳到您访问的地址 -->
  26. <property name="successUrl" value="/user"/>
  27. <!-- 如果您请求的资源不再您的权限范围,则跳转到/403请求地址 -->
  28. <property name="unauthorizedUrl" value="/403"/>
  29. <!-- 权限配置 -->
  30. <property name="filterChainDefinitions">
  31. <value>
  32. <!-- anon表示此地址不需要任何权限即可访问 -->
  33. /static/**=anon
  34. <!-- perms[user:query]表示访问此连接需要权限为user:query的用户 -->
  35. /user=perms[user:query]
  36. <!-- roles[manager]表示访问此连接需要用户的角色为manager -->
  37. /user/add=roles[manager]
  38. /user/del/**=roles[admin]
  39. /user/edit/**=roles[manager]
  40. <!--所有的请求(除去配置的静态资源请求或请求地址为anon的请求)都要通过登录验证,如果未登录则跳到/login-->
  41. /** = authc
  42. </value>
  43. </property>
  44. </bean>
  45. <bean id="cacheManager" class="org.apache.shiro.cache.MemoryConstrainedCacheManager" />
  46. <bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor" />
  47. </beans>

 用于登录,登出,权限跳转的控制:

  1. package com.cn.controller;
  2. import javax.validation.Valid;
  3. import org.apache.shiro.SecurityUtils;
  4. import org.apache.shiro.authc.AuthenticationException;
  5. import org.apache.shiro.authc.UsernamePasswordToken;
  6. import org.springframework.stereotype.Controller;
  7. import org.springframework.ui.Model;
  8. import org.springframework.validation.BindingResult;
  9. import org.springframework.web.bind.annotation.RequestMapping;
  10. import org.springframework.web.bind.annotation.RequestMethod;
  11. import org.springframework.web.servlet.mvc.support.RedirectAttributes;
  12. import com.cn.pojo.User;
  13. @Controller
  14. public class HomeController {
  15. @RequestMapping(value="/login",method=RequestMethod.GET)
  16. public String loginForm(Model model){
  17. model.addAttribute("user", new User());
  18. return "/login";
  19. }
  20. @RequestMapping(value="/login",method=RequestMethod.POST)
  21. public String login(@Valid User user,BindingResult bindingResult,RedirectAttributes redirectAttributes){
  22. try {
  23. if(bindingResult.hasErrors()){
  24. return "/login";
  25. }
  26. //使用权限工具进行用户登录,登录成功后跳到shiro配置的successUrl中,与下面的return没什么关系!
  27. SecurityUtils.getSubject().login(new UsernamePasswordToken(user.getUsername(), user.getPassword()));
  28. return "redirect:/user";
  29. } catch (AuthenticationException e) {
  30. redirectAttributes.addFlashAttribute("message","用户名或密码错误");
  31. return "redirect:/login";
  32. }
  33. }
  34. @RequestMapping(value="/logout",method=RequestMethod.GET)
  35. public String logout(RedirectAttributes redirectAttributes ){
  36. //使用权限管理工具进行用户的退出,跳出登录,给出提示信息
  37. SecurityUtils.getSubject().logout();
  38. redirectAttributes.addFlashAttribute("message", "您已安全退出");
  39. return "redirect:/login";
  40. }
  41. @RequestMapping("/403")
  42. public String unauthorizedRole(){
  43. return "/403";
  44. }
  45. }

 三个主要的JSP:
login.jsp:

  1. <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
  2. <%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>
  3. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
  4. <html>
  5. <head>
  6. <title>My JSP 'MyJsp.jsp' starting page</title>
  7. </head>
  8. <body>
  9. <h1>登录页面----${message }</h1>
  10. <img alt="" src="/static/img/1.jpg">
  11. <form:form action="/login" commandName="user" method="post">
  12. 用户名:<form:input path="username"/> <form:errors path="username" cssClass="error"/> <br/>
  13. 密 &nbsp;&nbsp;码:<form:password path="password"/> <form:errors path="password" cssClass="error" /> <br/>
  14. <form:button name="button">submit</form:button>
  15. </form:form>
  16. </body>
  17. </html>

user.jsp:

  1. <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
  2. <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
  3. <%@ taglib prefix="shiro" uri="http://shiro.apache.org/tags" %>
  4. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
  5. <html>
  6. <head>
  7. <title>用户列表</title>
  8. </head>
  9. <body>
  10. <h1>${message }</h1>
  11. <h1>用户列表--<a href="/user/add">添加用户</a>---<a href="/logout">退出登录</a>    </h1>
  12. <h2>权限列表</h2>
  13. <shiro:authenticated>用户已经登录显示此内容</shiro:authenticated>
  14. <shiro:hasRole name="manager">manager角色登录显示此内容</shiro:hasRole>
  15. <shiro:hasRole name="admin">admin角色登录显示此内容</shiro:hasRole>
  16. <shiro:hasRole name="normal">normal角色登录显示此内容</shiro:hasRole>
  17. <shiro:hasAnyRoles name="manager,admin">**manager or admin 角色用户登录显示此内容**</shiro:hasAnyRoles>
  18. <shiro:principal/>-显示当前登录用户名
  19. <shiro:hasPermission name="add">add权限用户显示此内容</shiro:hasPermission>
  20. <shiro:hasPermission name="user:query">query权限用户显示此内容<shiro:principal/></shiro:hasPermission>
  21. <shiro:lacksPermission name="user:del"> 不具有user:del权限的用户显示此内容 </shiro:lacksPermission>
  22. <ul>
  23. <c:forEach items="${userList }" var="user">
  24. <li>用户名:${user.username }----密码:${user.password }----<a href="/user/edit/${user.id}">修改用户</a>----<a href="javascript:;" class="del" ref="${user.id }">删除用户</a></li>
  25. </c:forEach>
  26. </ul>
  27. <img alt="" src="/static/img/1.jpg">
  28. <script type="text/javascript" src="http://cdn.staticfile.org/jquery/1.9.1/jquery.min.js"></script>
  29. <script>
  30. $(function(){
  31. $(".del").click(function(){
  32. var id=$(this).attr("ref");
  33. $.ajax({
  34. type:"delete",
  35. url:"/user/del/"+id,
  36. success:function(e){
  37. }
  38. });
  39. });
  40. });
  41. </script>
  42. </body>
  43. </html>

403.jsp:

  1. <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
  2. <%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>
  3. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
  4. <html>
  5. <head>
  6. <title>权限错误</title>
  7. </head>
  8. <body>
  9. <h1>对不起,您没有权限请求此连接!</h1>
  10. <img alt="" src="/static/img/1.jpg">
  11. </body>
  12. </html>

SpringMVC下的Shiro权限框架的使用的更多相关文章

  1. (转) shiro权限框架详解06-shiro与web项目整合(上)

    http://blog.csdn.net/facekbook/article/details/54947730 shiro和web项目整合,实现类似真实项目的应用 本文中使用的项目架构是springM ...

  2. Shiro权限框架简介

    http://blog.csdn.net/xiaoxian8023/article/details/17892041   Shiro权限框架简介 2014-01-05 23:51 3111人阅读 评论 ...

  3. 基于SpringMVC下的Rest服务框架搭建【1、集成Swagger】

    基于SpringMVC下的Rest服务框架搭建[1.集成Swagger] 1.需求背景 SpringMVC本身就可以开发出基于rest风格的服务,通过简单的配置,即可快速开发出一个可供客户端调用的re ...

  4. 在前后端分离的SpringBoot项目中集成Shiro权限框架

    参考[1].在前后端分离的SpringBoot项目中集成Shiro权限框架 参考[2]. Springboot + Vue + shiro 实现前后端分离.权限控制   以及跨域的问题也有涉及

  5. Apache Shiro权限框架在SpringMVC+Hibernate中的应用

    在做网站开发中,用户权限必须要考虑的,权限这个东西很重要,它规定了用户在使用中能进行哪 些操作,和不能进行哪些操作:我们完全可以使用过滤器来进行权限的操作,但是有了权限框架之后,使用起来会非常的方便, ...

  6. SpringMVC整合Shiro权限框架

    尊重原创:http://blog.csdn.net/donggua3694857/article/details/52157313 最近在学习Shiro,首先非常感谢开涛大神的<跟我学Shiro ...

  7. SpringBoot整合Shiro权限框架实战

    什么是ACL和RBAC ACL Access Control list:访问控制列表 优点:简单易用,开发便捷 缺点:用户和权限直接挂钩,导致在授予时的复杂性,比较分散,不便于管理 例子:常见的文件系 ...

  8. Shiro 权限框架使用总结

    我们首先了解下什么是shiro ,Shiro 是 JAVA 世界中新近出现的权限框架,较之 JAAS 和 Spring Security,Shiro 在保持强大功能的同时,还在简单性和灵活性方面拥有巨 ...

  9. shiro权限框架(一)

    不知不觉接触shiro安全框架都快三个月了,这中间配合项目开发踩过无数的坑.现在回想总结下,也算是一种积累,一种分享.中间有不够完美的地方或者不好的地方,希望大家指出来能一起交流.在这里谢谢开涛老师的 ...

随机推荐

  1. fprintf, fscanf,printf,scanf使用时参数注意

    在利用fprintf函数将数据按格式输出到文件中时,通常需要限定数据的格式,例如: FILE *f=fopen("d:\\1.txt","w+"); int a ...

  2. x264源代码 概述 框架分析 架构分析

    函数背景色 函数在图中以方框的形式表现出来.不同的背景色标志了该函数不同的作用: 白色背景的函数:不加区分的普通内部函数. 浅红背景的函数:libx264类库的接口函数(API). 粉红色背景函数:滤 ...

  3. 廖雪峰js教程笔记4 sort排序的一些坑

    排序算法 排序也是在程序中经常用到的算法.无论使用冒泡排序还是快速排序,排序的核心是比较两个元素的大小.如果是数字,我们可以直接比较,但如果是字符串或者两个对象呢?直接比较数学上的大小是没有意义的,因 ...

  4. Spring常用工具类

    Spring框架下自带了丰富的工具类,在我们开发时可以简化很多工作: 1.Resource访问文件资源: 具体有: ResourceUtils.getFile(url); FileSystemReso ...

  5. SpringRMI解析2-RmiServiceExporter逻辑脉络

    配置文件是Spring的核心,在配置文件中我们可以看到,定义了两个bean,其中一个是对接口实现类的发布,而另一个则是对RMI服务的发布,使用org.springframework.remoting. ...

  6. express-15 与生产相关的问题

    执行环境 Express支持执行环境的概念,它是一种在生产.开发或测试模式中运行应用程序的方法.实际上你可以按自己的想法创建很多种不同的环境. 要记住,开发.生产和测试是"标准"环 ...

  7. 字体和壁纸合并后再更改壁纸--《用delphi开发共享软件》-15.2桌面提示器

    procedure TFrmPlay.mnDeskPicClick(Sender: TObject); Var s:String; i:Integer; begin //s:=Path+'SetPic ...

  8. C# 词法分析器(四)构造 NFA

    系列导航 (一)词法分析介绍 (二)输入缓冲和代码定位 (三)正则表达式 (四)构造 NFA (五)转换 DFA (六)构造词法分析器 (七)总结 有了上一节中得到的正则表达式,那么就可以用来构造 N ...

  9. sparklyr包--实现R与Spark接口

    1.sparklyr包简介 Rstudio公司发布的sparklyr包具有以下几个功能: 实现R与Spark的连接: sparklyr包提供了一个完整的dplyr后端,可筛选并聚合Spark数据集,接 ...

  10. Storm分布式实时流计算框架相关技术总结

    Storm分布式实时流计算框架相关技术总结 Storm作为一个开源的分布式实时流计算框架,其内部实现使用了一些常用的技术,这里是对这些技术及其在Storm中作用的概括介绍.以此为基础,后续再深入了解S ...