CREATE TABLE `t_right` ( `id` int(11) NOT NULL AUTO_INCREMENT, `common` bit(1) DEFAULT NULL, `right_code` bigint(20) DEFAULT NULL, `right_desc` varchar(255) DEFAULT NULL, `right_name` varchar(255) DEFAULT NULL, `right_pos` int(11) DEFAULT NULL, `right_url` varchar(255) DEFAULT NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8 CREATE TABLE `t_role` ( `id` int(11) NOT NULL AUTO_INCREMENT, `role_desc` varchar(255) DEFAULT NULL, `role_name` varchar(255) DEFAULT NULL, `role_value` varchar(255) DEFAULT NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8 CREATE TABLE `t_role_right` ( `id` int(11) NOT NULL AUTO_INCREMENT, `role_id` int(11) DEFAULT NULL, `right_id` int(11) DEFAULT NULL, PRIMARY KEY (`id`), KEY `FK2A2639BE64C16BC1` (`role_id`), KEY `FK2A2639BEEDAF4F53` (`right_id`), CONSTRAINT `FK2A2639BEEDAF4F53` FOREIGN KEY (`right_id`) REFERENCES `t_right` (`id`), CONSTRAINT `FK2A2639BE64C16BC1` FOREIGN KEY (`role_id`) REFERENCES `t_role` (`id`) ) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8 CREATE TABLE `t_user` ( `id` int(11) NOT NULL AUTO_INCREMENT, `user_name` varchar(255) DEFAULT NULL, `password` varchar(255) DEFAULT NULL, `tel` varchar(255) DEFAULT NULL, `sex` varchar(255) DEFAULT NULL, `description` varchar(255) DEFAULT NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB AUTO_INCREMENT=11 DEFAULT CHARSET=utf8 CREATE TABLE `t_user_role` ( `id` int(11) NOT NULL AUTO_INCREMENT, `user_id` int(11) DEFAULT NULL, `role_id` int(11) DEFAULT NULL, PRIMARY KEY (`id`), KEY `FK331DEE5F9559BAB9` (`role_id`), KEY `FK331DEE5F9EC2FA1` (`user_id`), CONSTRAINT `FK331DEE5F9EC2FA1` FOREIGN KEY (`user_id`) REFERENCES `t_user` (`id`), CONSTRAINT `FK331DEE5F9559BAB9` FOREIGN KEY (`role_id`) REFERENCES `t_right` (`id`) ) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8
@Entity
@Table(name = "t_right")
public class Right extends BaseEntity implements Serializable{
/**
*
*/
private static final long serialVersionUID = 1444825234975317847L;
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private int id;
@Column(name = "right_name")
private String rightName = "";
@Column(name = "right_url")
private String rightUrl;
@Column(name = "right_desc")
private String rightDesc;
@Column(name = "right_code")
private long rightCode;
@Column(name = "right_pos")
private int rightPos;
@Column(name = "common")
private boolean common ;
public int getId() {
return id;
}
public String getRightName() {
return rightName;
}
public String getRightUrl() {
return rightUrl;
}
public String getRightDesc() {
return rightDesc;
}
public long getRightCode() {
return rightCode;
}
public int getRightPos() {
return rightPos;
}
public boolean isCommon() {
return common;
}
public void setId(int id) {
this.id = id;
}
public void setRightName(String rightName) {
this.rightName = rightName;
}
public void setRightUrl(String rightUrl) {
this.rightUrl = rightUrl;
}
public void setRightDesc(String rightDesc) {
this.rightDesc = rightDesc;
}
public void setRightCode(long rightCode) {
this.rightCode = rightCode;
}
public void setRightPos(int rightPos) {
this.rightPos = rightPos;
}
public void setCommon(boolean common) {
this.common = common;
}
}
@Entity
@Table(name = "t_role")
public class Role extends BaseEntity implements Serializable{
/**
*
*/
private static final long serialVersionUID = -3249248953909188737L;
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private int id;
@Column(name = "role_name")
private String roleName;
@Column(name = "role_value")
private String roleValue;
@Column(name = "role_desc")
private String roleDesc;
@ManyToMany(targetEntity = Right.class, fetch = FetchType.LAZY)
@JoinTable(name = "t_role_right", joinColumns = @JoinColumn(name = "role_id"), inverseJoinColumns = @JoinColumn(name = "right_id"))
private List<Right> rights;
public int getId() {
return id;
}
public String getRoleName() {
return roleName;
}
public String getRoleValue() {
return roleValue;
}
public String getRoleDesc() {
return roleDesc;
}
public List<Right> getRights() {
return rights;
}
public void setId(int id) {
this.id = id;
}
public void setRoleName(String roleName) {
this.roleName = roleName;
}
public void setRoleValue(String roleValue) {
this.roleValue = roleValue;
}
public void setRoleDesc(String roleDesc) {
this.roleDesc = roleDesc;
}
public void setRights(List<Right> rights) {
this.rights = rights;
}
}
@Entity
@Table(name = "t_user")
public class User extends BaseEntity implements Serializable{
/**
*
*/
private static final long serialVersionUID = -1461963356403533227L;
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private int id;
@Column(name = "user_name")
private String userName;
@Column(name = "password")
private String password;
@Column(name = "tel")
private String tel;
@Column(name = "sex")
private String sex;
@Column(name = "description")
private String description;
@ManyToMany(targetEntity = Right.class, fetch = FetchType.LAZY)
@JoinTable(name = "t_user_role", joinColumns = @JoinColumn(name = "user_id"), inverseJoinColumns = @JoinColumn(name = "role_id"))
private List<Role> roles;
@Transient
private long[] rightSum;
public List<Role> getRoles() {
return roles;
}
public void setRoles(List<Role> roles) {
this.roles = roles;
}
public String getUserName() {
return userName;
}
public String getPassword() {
return password;
}
public String getTel() {
return tel;
}
public String getSex() {
return sex;
}
public String getDescription() {
return description;
}
public void setUserName(String userName) {
this.userName = userName;
}
public void setPassword(String password) {
this.password = password;
}
public void setTel(String tel) {
this.tel = tel;
}
public void setSex(String sex) {
this.sex = sex;
}
public void setDescription(String description) {
this.description = description;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((description == null) ? 0 : description.hashCode());
result = prime * result + id;
result = prime * result + ((password == null) ? 0 : password.hashCode());
result = prime * result + ((sex == null) ? 0 : sex.hashCode());
result = prime * result + ((tel == null) ? 0 : tel.hashCode());
result = prime * result + ((userName == null) ? 0 : userName.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
User other = (User) obj;
if (description == null) {
if (other.description != null)
return false;
} else if (!description.equals(other.description))
return false;
if (id != other.id)
return false;
if (password == null) {
if (other.password != null)
return false;
} else if (!password.equals(other.password))
return false;
if (sex == null) {
if (other.sex != null)
return false;
} else if (!sex.equals(other.sex))
return false;
if (tel == null) {
if (other.tel != null)
return false;
} else if (!tel.equals(other.tel))
return false;
if (userName == null) {
if (other.userName != null)
return false;
} else if (!userName.equals(other.userName))
return false;
return true;
}
@Override
public String toString() {
return "User [id=" + id + ", userName=" + userName + ", password=" + password + ", tel="
+ tel + ", sex=" + sex + ", description=" + description + "]";
}
public void calculateRightSum() {
int pos = 0;
long code = 0;
for(Role role: roles){
if("-1".equals(role.getRoleValue())){
roles = null;
return;
}
for(Right right: role.getRights()){
pos = right.getRightPos();
code = right.getRightCode();
rightSum[pos] = rightSum[pos] | code;
}
}
roles = null;
}
public boolean hasRight(Right r){
int pos = r.getRightPos();
long code = r.getRightCode();
return !((rightSum[pos] & code) == 0);
}
}
public class RightFilterInterceptor implements HandlerInterceptor {
@Resource
RightService rightService;
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
Object handler)
throws Exception {
String requestUri = request.getRequestURI();
String contextPath = request.getContextPath();
String url = requestUri.substring(contextPath.length());
int hasRight = RightValidateUtil.hasRight(url, request);
switch (hasRight) {
case RightValidateUtil.NORIGHTS:
response.sendRedirect(request.getContextPath() + "/web/user/error.action");
return false;
case RightValidateUtil.NOLOGIN:
response.sendRedirect(request.getContextPath() + "/web/user/login.action");
return false;
case RightValidateUtil.HASRIGHTS:
return true;
default:
return true;
}
}
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
ModelAndView modelAndView)
throws Exception {
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response,
Object handler, Exception ex)
throws Exception {
}
}
@Component
public class RightValidateUtil implements InitializingBean{
public static final int HASRIGHTS = 1;
public static final int NORIGHTS = -1;
public static final int NOLOGIN = 0;
@Resource
RightService rightService;
public static Map<String,Right> map = new HashMap<String, Right>();
public static boolean isValid(String url) {
return !(url == null || "".equals(url.trim()));
}
public static boolean isValid(Collection col) {
if (col == null || col.isEmpty()) {
return false;
}
return true;
}
public static boolean isValid(Object[] arr) {
if (arr == null || arr.length == 0) {
return false;
}
return true;
}
// -1 否 0 未登录 1 真
public static int hasRight(String url, HttpServletRequest request) {
HttpSession session = request.getSession();
// Map<String, Right> map = (Map<String, Right>) session.getAttribute("all_rights_map");
Right r = map.get(url);
if (r == null || r.isCommon()) {
return RightValidateUtil.HASRIGHTS;
} else {
User user = (User) session.getAttribute(Constants.USER);
if (user == null) {
return RightValidateUtil.NOLOGIN;
} else {
if (user.hasRight(r)) {
return RightValidateUtil.HASRIGHTS;
} else {
return RightValidateUtil.NORIGHTS;
}
}
}
}
@Override
public void afterPropertiesSet() throws Exception {
map.clear();
List<Right> rights = rightService.findAll();
for (Right right : rights) {
map.put(right.getRightUrl(), right) ;
}
}
}
<mvc:interceptor> <mvc:mapping path="/web/**" /> <bean class="com.curiousby.baoyou.cn.interceptor.RightFilterInterceptor" /> </mvc:interceptor>
捐助开发者
在兴趣的驱动下,写一个免费的东西，有欣喜，也还有汗水，希望你喜欢我的作品，同时也能支持一下。 当然，有钱捧个钱场（右上角的爱心标志，支持支付宝和PayPal捐助），没钱捧个人场，谢谢各位。
谢谢您的赞助，我会做的更好！
相关推荐
该压缩包文件包含了一个基于SpringMVC、Hibernate和Spring框架的权限管理系统完整项目，适合学习和实战。这个项目的核心目标是实现对用户权限的有效管理，包括用户登录、角色分配、资源权限控制等功能。以下是关于...
【基于Spring SpringMVC Hibernate的网上书城】项目是一个典型的Java Web应用，它利用了Spring框架的核心特性，SpringMVC的 MVC 设计模式以及Hibernate的持久化能力来构建一个功能完善的网上书店。该项目包含了多种...
本项目“spring springmvc hibernate mySql图书管理系统完整项目+book.sql”全面展示了SSH框架与MySQL数据库的集成运用，提供了完整的权限管理模块，并实现了诸如Ajax异步刷新、文件上传、访问拦截及数据校验等多种...
SpringMVC+Hibernate+annotation+Easyui权限管理系统，Session过期控制（包括Ajax请求的过期控制），访问权限控制（权限控制到按钮），hibernate数据库用户名与密码加密，其它的不说了，绝对物有所值
Hibernate支持实体类、会话管理、事务处理、缓存策略等功能，大大降低了数据库操作的复杂性。在SpringMVC项目中，Hibernate通常与Spring Data JPA结合使用，实现便捷的数据访问。 【EasyUI】 EasyUI是一个基于...
《SpringMVC+Hibernate+Easyui权限管理系统》 在当今的Web开发领域，SpringMVC、Hibernate和EasyUI是三个非常重要的技术组件，它们分别在不同的层面上为开发者提供了强大的支持。SpringMVC作为Spring框架的一部分，...
《SpringMVC+Hibernate后台管理系统详解》 在IT行业中，构建高效的后台管理系统是至关重要的，它需要具备良好的架构设计、强大的功能以及稳定的性能。本文将深入探讨基于SpringMVC和Hibernate技术栈的后台管理系统...
《权限管理系统：Hibernate+Spring+SpringMVC整合实践》 在现代企业级应用开发中，权限管理系统是不可或缺的一部分，它负责管理和控制用户对系统资源的访问权限，确保系统的安全性和数据的完整性。本项目采用经典的...
Spring MVC 和 Hibernate 是两个在Java Web开发中广泛使用的框架，它们分别是用于构建应用程序的前端控制器和持久层管理的工具。这个压缩包包含了这两个框架的核心库，使得开发者能够快速搭建一个基于Spring MVC和...
综上所述，这个项目是一个利用Maven进行项目管理，结合SpringMVC作为Web框架，Spring作为IoC容器和事务管理器，Hibernate作为ORM工具，EasyUI为前端展示的权限管理系统。项目结构清晰，职责分明，遵循了Maven的模块...
【SpringMVC+Hibernate 用户权限管理源码解析】 在现代Web应用开发中，用户权限管理是不可或缺的一部分，它确保了不同级别的用户只能访问其被授权的功能和数据。本项目采用SpringMVC作为前端控制器，Hibernate作为...
springMVC+hibernate全注解实现的简易自动化办公系统(OA)，实现功能有文件的上传、下载、MVC控制器控制权限、JSON的使用等，使用ORALCE数据库，包含建表语句，更改用户名及密码即可运行。
该项目是一个综合性的Web应用开发框架，它利用了多个开源技术栈来构建一个具有权限管理功能的系统。下面将详细介绍每个组件及其在项目中的作用。 **Maven**：Maven 是一个项目管理和综合工具，用于自动化构建、依赖...
springmvc+hibernate+extjs4mvc 权限管理springmvc+hibernate+extjs4mvc 权限管理springmvc+hibernate+extjs4mvc 权限管理
整合EhCache，对Mybatis的二级缓存进行管理和对spring进行缓存管理 整合FastJson对指定http类型的数据进行转换 整合hibernate.validator校验器对controller接口参数进行校验 使用了springmvc统一异常处理 使用了...
Spring 提供了事务管理、AOP（面向切面编程）、MVC（模型-视图-控制器）框架以及对其他技术（如 JDBC、Hibernate）的支持，使得开发过程更加模块化和高效。在订餐系统中，Spring 可能用于管理服务层和数据访问层的...
### SpringMVC+Shiro权限管理系统详解 #### 权限管理概述 权限管理在软件开发中扮演着至关重要的角色，特别是在涉及多用户交互的应用场景下。通过合理的权限控制，可以确保不同用户仅能访问和操作他们被授权的功能...
在本项目中，"springmvc+权限管理系统" 是一个结合了 Spring MVC 框架和权限管理功能的系统，旨在提供安全、高效的用户访问控制。 1. **Spring MVC 基础** - **模型-视图-控制器**：Spring MVC 将应用程序逻辑分为...