SpringMVC+Shiro权限管理

SpringMVC+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
-----------------------------------

 建立对应的POJO：

Java代码  

  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. }

Java代码  

  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. }

Java代码  

  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中配置如下：

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中的配置：

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>

Java代码  

  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

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>

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

Java代码  

  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:

Html代码  

  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:

Html代码  

  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:

Html代码

    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>
时间： 2024-10-25 16:17:55

SpringMVC+Shiro权限管理的相关文章

SpringMVC+Shiro权限管理【转】

1.权限的简单描述 2.实例表结构及内容及POJO 3.Shiro-pom.xml 4.Shiro-web.xml 5.Shiro-MyShiro-权限认证,登录认证 6.Shiro-applicationContext-shiro.xml 7.HomeController三个JSP文件 什么是权限呢?举个简单的例子:我有一个论坛,注册的用户分为normal用户,manager用户.对论坛的帖子的操作有这些:添加,删除,更新,查看,回复我们规定:normal用户只能:添加,查看,回复manage

Spring Boot Shiro 权限管理 【转】

http://blog.csdn.net/catoop/article/details/50520958 主要用于备忘 本来是打算接着写关于数据库方面,集成MyBatis的,刚好赶上朋友问到Shiro权限管理,就先总结下发出来了. 使用Shiro之前用在spring MVC中,是通过XML文件进行配置. 既然现在在写Spring Boot的帖子,就将Shiro应用到Spring Boot中,我本地已经完成了SpringBoot使用Shiro的实例,将配置方法共享一下. 先简单介绍一下Shiro,

spring boot shiro -权限管理

spring boot shiro -权限管理 定义 java最常用的框架有spring security 和Apache shiro,因为spring security 庞大和负责,一般使用都是Apache shiro. Apache shiro 是一个功能强大,灵活,开源的安全框架,它可以处理身份验证,授权,企业会话管理,加密等. shiro 易于理解和使用,一个好的框架 应该屏蔽复杂性,向外提供简单,直观的api,简化开发人员实行应用程序安全所发费的时间和精力. shiro 可以做什么:

springboot配置shiro权限管理,网搜搜采集网站权限控制代码

import outshine.shiro.authc.AccountSubjectFactory; import outshine.shiro.filter.AuthenticatedFilter; import outshine.shiro.realm.AccountRealm; import org.apache.shiro.cache.CacheManager; import org.apache.shiro.cache.ehcache.EhCacheManager; import or

十、 Spring Boot Shiro 权限管理

使用Shiro之前用在spring MVC中,是通过XML文件进行配置. 将Shiro应用到Spring Boot中,本地已经完成了SpringBoot使用Shiro的实例,将配置方法共享一下. 先简单介绍一下Shiro,对于没有用过Shiro的朋友,也算是做个简介吧. Shiro是Apache下的一个开源项目,我们称之为Apache Shiro.它是一个很易用与Java项目的的安全框架,提供了认证.授权.加密.会话管理,与 Spring Security 一样都是做一个权限的安全框架,但是与S

Shiro权限管理详解&lt;转载&gt;

1 权限管理1.1 什么是权限管理 基本上涉及到用户参与的系统都要进行权限管理,权限管理属于系统安全的范畴,权限管理实现对用户访问系统的控制,按照安全规则或者安全策略控制用户可以访问而且只能访问自己被授权的资源. 权限管理包括用户身份认证和授权两部分,简称认证授权.对于需要访问控制的资源用户首先经过身份认证,认证通过后用户具有该资源的访问权限方可访问. 1.2 用户身份认证1.2.1 概念 身份认证,就是判断一个用户是否为合法用户的处理过程.最常用的简单身份认证方式是系统通过核对用户输入的用户名

【zheng阅读系列】shiro权限管理

一.配置文件 upms-server/springMVC-servlet.xml <?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:mvc=&qu

Spring boot整合shiro权限管理

apache shiro: https://shiro.apache.org/ Apache Shiro是一个强大且易用的Java安全框架,执行身份验证.授权.密码学和会话管理.使用Shiro的易于理解的API,您可以快速.轻松地获得任何应用程序,从最小的移动应用程序到最大的网络和企业应用程序. shiro的三个核心组件: Subject, SecurityManager 和 Realms. Subject:即"当前操作用户".但是,在Shiro中,Subject这一概念并不仅仅指人,

Shiro权限管理

1.简介 Apache Shiro是Java的一个安全框架,对比Spring Security,没有Spring Security功能强大,但在实际工作时可能并不需要那么复杂,所以使用小而简单的Shiro就足够了. Shiro可以非常容易的开发出足够好的应用,其不仅可以用在JavaSE环境,也可以用在JavaEE环境. shiro满足的功能: Shiro可以帮助我们完成:认证.授权.会话管理.加密等,并且提供与web集成.缓存.rememberMed等功能. 2.Shiro的工作模型 应用程序直