精华内容
下载资源
问答
  • 菜单权限技术

    2012-08-09 11:10:08
    PB 菜单 权限 技术
  • Easyui+ashx+Jq权限菜单权限管理框架

    千次下载 热门讨论 2013-03-08 15:32:11
    Easyui+ashx+Jq权限菜单权限管理框架,前台完全html+jq+easyui 后台ashx三层 角色、权限、组织、用户管理,通过菜单控制访问权限
  • 好看的菜单权限分配

    2019-08-13 10:21:47
    非常漂亮的菜单权限分配页面样式,所有的系统都用得上。。。各浏览器兼容
  • 菜单权限demo

    2012-05-13 10:22:57
    这是一个小demo,实现用dtree来操作菜单权限的显示
  • 本篇文章主要介绍了react实现菜单权限控制的方法,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 非常漂亮的菜单权限分配页面样式,所有的系统都用得上。。。各浏览器兼容
  • Easyui+ashx权限菜单权限管理框架
  • 菜单权限管理系统

    2014-04-02 13:13:38
    是基于asp.net的菜单权限管理系统,主要是相关资料和等等。
  • 设计了一种面向用户的菜单权限的设置方法,建立了所需的权限表,给出了面向用户的菜单权限的授予和收回方法、菜单权限的检查方法的算法描述。在设计和实现过程中,利用动态生成、获取和设置菜单属性的方法,实现用户...
  • 本篇文章主要介绍了SpringMVC+ZTree实现树形菜单权限配置的方法,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 菜单权限tree建议使用大家使用ztree这个是我刚工作是弄的,想下载看看可以。。。。。。。菜单权限tree菜单权限tree菜单权限tree
  • easyui后台管理系统,包括菜单权限,按钮权限,后台使用springMVC+hibernate,mysql数据库,jsp
  • 用户菜单权限表建表语句以及数据插入语句,后台管理系统搭建必备,学习专用。 如果使用外键关联,在对表进行数据操作时就考虑另一张关联的表,相当于两张表就绑在一起了,操作这张表就必须考虑另一张关联表。我们...
  • 使用easyui + s2sh做的菜单权限管理,源码共享, 使用mysql数据库,数据库sql文件在webcontent文件夹下
  • 菜单权限设计

    2016-07-28 07:41:36
    菜单设计
  • 权限管理设计之菜单权限

    千次阅读 2016-10-23 22:45:33
    实现功能:后台管理系统中,每个登录的用户,有多个不同的角色,而每个角色都有不同的权限,针对每个用户所拥有的权限列表,根据其中菜单权限的等级进行划分归类,显示在操作菜单栏中。 菜单结构如下:   权限...

     权限菜单的显示

     

    MVC框架:struts2 + spring + hibernate

    实现功能:后台管理系统中,每个登录的用户,有多个不同的角色,而每个角色都有不同的权限,针对每个用户所拥有的权限列表,根据其中菜单权限的等级进行划分归类,显示在操作菜单栏中。

    菜单结构如下:


     

    权限表设计如下:

           涉及的实体有部门、用户、角色及权限 ,部门-用户 是一对多关系,用户-角色是多对多关系,角色-权限也是多对多关系。在权限表中,权限等级取值可以是 1 、2、3,分别代表一级菜单、二级菜单、三级菜单,父级权限编号可以找到父级权限 ,一级菜单的父级权限默认是0,通过查询这个字段也可以找出某个菜单的子一级菜单列表。

           通过这样的设计,就可以在用户登录后,获取用户拥有的所有角色,再根据每个角色拥有的权限进行汇总筛选,去除掉角色之间可能重复的权限,组合成分层次的权限结构,最后返回到页面中,根据权限等级划分层次显示即可。

     

    以下是实体类的代码:

    import java.util.List;
    import javax.persistence.*;
    import org.hibernate.annotations.GenericGenerator;
    import com.ylzinfo.psBusiness.app.entity.power.JGInfo;
    import com.ylzinfo.psBusiness.app.entity.power.Role;
    @Entity
    @Table(name="SYS_USER") 
    public class User {
    
    	private String userid; // 用户ID(关键字)
    	private String username; // 用户名(用户登录时的用户名 请确保登录名唯一)
    	private String passwd; // 密码
    	private String realname; // 真实姓名
    	private String createtime; // 注册时间
    	private String lastlogontime;// 上次登陆时间
    	private String lockstate; // 账户锁定状态:0正常,1账户停用
    	private String loginedcount; // 已登陆次数
    	private String remark; // 备注
    	private JGInfo baz001;//所属部门
    
    	private String email;//邮箱地址
    	private String reset_pw;//重置密码验证码(格式:验证码_有效时间)
    	
    	private List<Role> roles;//角色列表
    	public User() {
    		super();
    	}
    
    	@Id
    	@GeneratedValue(generator = "paymentableGenerator")  
    	@GenericGenerator(name = "paymentableGenerator", strategy = "uuid")
    	public String getUserid() {
    		return userid;
    	}
    
    	public void setUserid(String userid) {
    		this.userid = userid;
    	}
    	@Column(name="username")
    	public String getUsername() {
    		return username;
    	}
    
    	public void setUsername(String username) {
    		this.username = username;
    	}
    	@Column(name="passwd")
    	public String getPasswd() {
    		return passwd;
    	}
    
    	public void setPasswd(String passwd) {
    		this.passwd = passwd;
    	}
    	@Column(name="realname")
    	public String getRealname() {
    		return realname;
    	}
    
    	public void setRealname(String realname) {
    		this.realname = realname;
    	}
    	@Column(name="createtime")
    	public String getCreatetime() {
    		return createtime;
    	}
    
    	public void setCreatetime(String createtime) {
    		this.createtime = createtime;
    	}
    	@Column(name="lastlogontime")
    	public String getLastlogontime() {
    		return lastlogontime;
    	}
    
    	public void setLastlogontime(String lastlogontime) {
    		this.lastlogontime = lastlogontime;
    	}
    	@Column(name="lockstate")
    	public String getLockstate() {
    		return lockstate;
    	}
    
    	public void setLockstate(String lockstate) {
    		this.lockstate = lockstate;
    	}
    	@Column(name="loginedcount")
    	public String getLoginedcount() {
    		return loginedcount;
    	}
    
    	public void setLoginedcount(String loginedcount) {
    		this.loginedcount = loginedcount;
    	}
    	@Column(name="remark")
    	public String getRemark() {
    		return remark;
    	}
    
    	public void setRemark(String remark) {
    		this.remark = remark;
    	}
    
    
    
    	@Column(name="email")
    	public String getEmail() {
    		return email;
    	}
    
    
    
    	public void setEmail(String email) {
    		this.email = email;
    	}
    
    
    	@Column(name="reset_pw")
    	public String getReset_pw() {
    		return reset_pw;
    	}
    
    
    
    	public void setReset_pw(String resetPw) {
    		reset_pw = resetPw;
    	}
    
    
    	@ManyToOne(fetch = FetchType.LAZY)
    	@JoinColumn(name = "baz001")
    	public JGInfo getBaz001() {
    		return baz001;
    	}
    
    
    
    	public void setBaz001(JGInfo baz001) {
    		this.baz001 = baz001;
    	}
    
    
    
    	@ManyToMany(targetEntity = Role.class, fetch = FetchType.LAZY)  
    	@JoinTable(name = "USER_ROLE", joinColumns = @JoinColumn(name = "USER_ID"), inverseJoinColumns = @JoinColumn(name = "ROLE_ID")) 
    	public List<Role> getRoles() {
    		return roles;
    	}
    
    
    
    
    	public void setRoles(List<Role> roles) {
    		this.roles = roles;
    	}
    
    	
    	
    }

     

    import java.io.Serializable;
    import java.util.Date;
    import java.util.List;
    import javax.persistence.*;
    import org.hibernate.annotations.GenericGenerator;
    
    @Entity
    @Table(name="SYS_ROLE") 
    public class Role implements Serializable{
    
    	/**
    	 * 
    	 */
    	private static final long serialVersionUID = 1L;
    	private String role_id;//角色ID
    	private String role_name;//角色名称
    	private Date cre_time;//创建时间
    	private String parent_id;//父级角色ID
    	private String describe;//描述
    	private int sort;//排序序号
    	
    	private List<Right> rights;//角色的权限列表
    	
    	@Id
    	@GeneratedValue(generator = "paymentableGenerator")  
    	@GenericGenerator(name = "paymentableGenerator", strategy = "uuid")
    	public String getRole_id() {
    		return role_id;
    	}
    	public void setRole_id(String roleId) {
    		role_id = roleId;
    	}
    	@Column(name="role_name")
    	public String getRole_name() {
    		return role_name;
    	}
    	public void setRole_name(String roleName) {
    		role_name = roleName;
    	}
    	@Column(name="cre_time")
    	public Date getCre_time() {
    		return cre_time;
    	}
    	public void setCre_time(Date creTime) {
    		cre_time = creTime;
    	}
    	@Column(name="parent_id")
    	public String getParent_id() {
    		return parent_id;
    	}
    	public void setParent_id(String parentId) {
    		parent_id = parentId;
    	}
    	@Column(name="describe")
    	public String getDescribe() {
    		return describe;
    	}
    	public void setDescribe(String describe) {
    		this.describe = describe;
    	}
    	@Column(name="sort")
    	public int getSort() {
    		return sort;
    	}
    	public void setSort(int sort) {
    		this.sort = sort;
    	}
    	@ManyToMany(targetEntity = Right.class, fetch = FetchType.LAZY)  
    	@JoinTable(name = "ROLE_RIGHT", joinColumns = @JoinColumn(name = "ROLE_ID"), inverseJoinColumns = @JoinColumn(name = "RIGHT_ID"))  
    	public List<Right> getRights() {
    		return rights;
    	}
    	public void setRights(List<Right> rights) {
    		this.rights = rights;
    	}
    	@Override
    	public String toString() {
    		return "Role [cre_time=" + cre_time + ", describe=" + describe
    				+ ", parent_id=" + parent_id + ", role_id=" + role_id
    				+ ", role_name=" + role_name + ", sort=" + sort + "]";
    	}
    	@Override
    	public boolean equals(Object obj) {
    		// TODO Auto-generated method stub
    		if(obj.getClass() == this.getClass())
    		{
    			if(this.getRole_id().equals(((Role)obj).getRole_id()))
    				return true;
    			else
    				return false;
    		}
    		return super.equals(obj);
    	}
    	
    	
    }
    

     

     

    import java.io.Serializable;
    import java.util.ArrayList;
    import java.util.List;
    
    import javax.persistence.Column;
    import javax.persistence.Entity;
    import javax.persistence.GeneratedValue;
    import javax.persistence.Id;
    import javax.persistence.Table;
    import javax.persistence.Transient;
    
    import org.hibernate.annotations.GenericGenerator;
    
    @Entity
    @Table(name="SYS_RIGHTS") 
    public class Right implements Serializable{
    
    	/**
    	 * 
    	 */
    	private static final long serialVersionUID = 1L;
    	private String right_id;//权限ID
    	private String right_name;//权限名称
    	private String url;//权限URL
    	private String resource_path;//权限图片显示资源路径(可选)
    	private String parent_id;//父级权限ID
    	private String describe;//描述
    	private int lev;//权限等级
    	private Integer sort; //排序序号
    	
    	
    	private List<Right> rights;
    	
    	public Right(){
    		rights = new ArrayList();
    	}
    	
    	@Id
    	@GeneratedValue(generator = "paymentableGenerator")  
    	@GenericGenerator(name = "paymentableGenerator", strategy = "uuid")
    	public String getRight_id() {
    		return right_id;
    	}
    	public void setRight_id(String rightId) {
    		right_id = rightId;
    	}
    	@Column(name="right_name")
    	public String getRight_name() {
    		return right_name;
    	}
    	public void setRight_name(String rightName) {
    		right_name = rightName;
    	}
    	@Column(name="url")
    	public String getUrl() {
    		return url;
    	}
    	public void setUrl(String url) {
    		this.url = url;
    	}
    	@Column(name="resource_path")
    	public String getResource_path() {
    		return resource_path;
    	}
    	public void setResource_path(String resourcePath) {
    		resource_path = resourcePath;
    	}
    	@Column(name="parent_id")
    	public String getParent_id() {
    		return parent_id;
    	}
    	public void setParent_id(String parentId) {
    		parent_id = parentId;
    	}
    	@Column(name="describe")
    	public String getDescribe() {
    		return describe;
    	}
    	public void setDescribe(String describe) {
    		this.describe = describe;
    	}
    	@Column(name="lev")
    	public int getLev() {
    		return lev;
    	}
    	public void setLev(int lev) {
    		this.lev = lev;
    	}
    	
    	//@Transient表示该属性并非一个到数据库表的字段的映射,ORM框架将忽略该属性
    	@Transient
    	public List<Right> getRights() {
    		return rights;
    	}
    	public void setRights(List<Right> rights) {
    		this.rights = rights;
    	}
    	
    	@Column(name="sort")
    	public Integer getSort() {
    		return sort;
    	}
    
    	public void setSort(Integer sort) {
    		this.sort = sort;
    	}
    	
    	@Override
    	public String toString() {
    		return "Right [describe=" + describe + ", lev=" + lev + ", parent_id="
    				+ parent_id + ", resource_path=" + resource_path
    				+ ", right_id=" + right_id + ", right_name=" + right_name
    				+ ", url=" + url + "]";
    	}
    
    	
    	public boolean equals(Right obj) {
    		// TODO Auto-generated method stub
    		if(this.right_id.equals(obj.getRight_id()))
    			return true;
    		else
    			return false;
    				
    	}
    	
    	
    	
    }
    

     
     最后是系统确认用户名及密码正确后,需要执行的操作,即加载及筛选合适的权限列表的核心算法。

    public void initPower(){
    		//初始化一级菜单
    		List<Role> rlist = user.getRoles(); 	//获取用户的所有角色
    		List<Right> rightList = new ArrayList();//初始化返回到页面的权限List
    		//遍历每一个角色,并获取每个角色拥有的一级菜单保存到权限列表中
    		for(Role role : rlist){
    			List<Right> rights = role.getRights();
    			for(Right rig : rights){
    				if(rig.getLev() == 1){
    					if(!rightList.contains(rig))
    						rightList.add(rig);
    				}
    			}
    		}
    		//初始化二级菜单
    		//同样遍历角色列表,拿出所有角色的二级子权限放入列表
    		for(Role role : rlist){
    			List<Right> rights = role.getRights();
    			for(Right rig : rights){
    				if(rig.getLev() == 2){
    					for(Right rig2 : rightList){
    						if(rig.getParent_id().equals(rig2.getRight_id())){
    							if(!rig2.getRights().contains(rig))
    								rig2.getRights().add(rig);
    						}
    					}
    					
    				}
    			}
    		}
    		//初始化三级菜单
    		//再次遍历角色列表获取所有三级子权限放入到权限列表中
    		for(Role role : rlist){
    			List<Right> rights = role.getRights();
    			for(Right rig : rights){
    				if(rig.getLev() == 3){
    					for(Right rig2 : rightList){
    						for(Right rig3 : rig2.getRights()){
    							if(rig.getParent_id().equals(rig3.getRight_id())){
    								if(!rig3.getRights().contains(rig))
    										rig3.getRights().add(rig);
    							}
    						}
    						
    					}
    					
    				}
    			}
    		}
    		//根据Right类的sort字段将一级菜单列表由小到大进行排序
    		Collections.sort(rightList, new ComparatorRight());
    		for(Right right:rightList){
    			//对每个一级菜单的二级子菜单进行排序
    			Collections.sort(right.getRights(),new ComparatorRight());
    			for(Right right2:right.getRights()){
    				//对每个二级菜单的三级子菜单进行排序
    				Collections.sort(right2.getRights(),new ComparatorRight());
    			}
    		}
    		//将用户所拥有的菜单权限列表保存到Session中
    		request.getSession().setAttribute("rights", rightList);
    	}

     

    展开全文
  • 1、菜单权限 2、角色权限 3、接口权限 4、数据权限 无论是什么类型的权限,数据库的设计极为重要!! 这次先分享一下菜单权限、角色权限的实现以及数据库的设计 首先是菜单的数据库设计: 字段名 类型 注释 ...

    随着spring cloud项目越做越多,接触到很多以前没接触过的知识。
    这次接触到的是权限管理方面的任务。
    我涉及到的权限管理分为一下几种:

    1、菜单权限
    2、角色权限
    3、接口权限
    4、数据权限
    

    无论是什么类型的权限,数据库的设计极为重要!!
    这次先分享一下菜单权限、角色权限的实现以及数据库的设计

    首先是菜单的数据库设计:

    字段名类型注释
    menu_idint菜单Id
    menu_namevarchar菜单名称
    menu_keyvarchar菜单标识
    componentvarchar菜单布局
    parent_idint父菜单布局
    targetvarchar打开方式
    order_numint显示顺序
    menu_typechar菜单类型(M目录 C菜单 F按钮)
    visibleint菜单状态(0显示 1隐藏)
    permsvarchar权限标识
    pathvarchar链接
    redirectvarchar重定向
    hidden_childrenint强制菜单显示为Item而不是SubItem
    hidden_headerint特殊 隐藏 PageHeader 组件中的页面带的 面包屑和页面标题栏
    create_byvarchar创建者
    create_timedatetime创建时间
    update_byvarchar更新者
    update_timedatetime更新时间
    remarkvarchar备注

    这边给出目录和菜单的定义:
    在这里插入图片描述
    当某个菜单定义为目录或菜单时,menu_key菜单标识和component菜单布局,一定要有!!!!他是用来前端对接使用的。如果按钮的权限要求不是那么严格,那么按钮这两个字段可以不要。

    然后是角色数据库的设计:
    在这里插入图片描述
    这里参考了若依的角色权限设计,role_key角色权限字符串的作用暂时未知。
    有了这两个表,以及这两张表主键的关联表之后。菜单权限就算完成大半了。接下来就是给前端提供查询菜单权限的接口了,sql语句请自行编写。

    public List<ResUserMenuListVO> selectMenusByUser()
        {
            List<ResUserMenuListVO> menus = new LinkedList<>();
            // 判断登录的角色
            //如果是管理员,则显示所有菜单信息
            if (AuthUtil.isAdmin())
            {
                menus = menuMapper.selectMenuNormalAll();
            }
            //如果是其他角色,就通过角色,查询出所有菜单参数
            else
            {
                menus = menuMapper.selectMenusByUserId(AuthUtil.getCurrentId());
            }
            // 前端自行构造菜单树
            return menus;
        }
    

    在这里插入图片描述
    到此,就完成了菜单权限、角色权限。其他对菜单、角色的增删改查,请自行编写。这里就给出实现的关键步骤。

    展开全文
  • 今天小编就为大家分享一篇使用layui+ajax实现简单的菜单权限管理及排序的方法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • vue项目的菜单权限判断的实现

    千次阅读 2019-03-28 14:36:58
    在后台管理系统中,上一篇文章我们说到了按钮级别的权限判断,请看:GO,还有一个重要的权限判断就是菜单权限的判断,每个角色分给不同的可看菜单时必要做的事情。而且菜单全权限判断相比按钮权限判断会难实现的多。...

    在后台管理系统中,上一篇文章我们说到了按钮级别的权限判断,请看:GO,还有一个重要的权限判断就是菜单权限的判断,每个角色分给不同的可看菜单时必要做的事情。而且菜单全权限判断相比按钮权限判断会难实现的多。菜单权限的控制无非会有这几种思路:

            1.若是角色不多,根据角色分类,例如admin,编辑,游客这样划分的话,可直接根据人员绑定角色,在前端保存路由表,路由表中有权限字段,进入系统根据人员的所属角色去匹配前端保存的路由表里面的权限(admin,编辑还是游客),从而生成可看的路由表。这种方式只适合角色比较少的情况,因为角色是固定在前端定好的。

            2.第二种方式是在原来的基础上,前端只保存所有路由表,包括公共路由,异步路由,在系统我们可以选择用户所能看的菜单,然后保存权限数据在数据库。进入系统后根据前端保存的路由表与获取后端的权限数组进行匹配,从而生成可看的路由表。

            其中第二种方式勾选保存的菜单时,进入系统鉴权又有两种方式:1.直接只保存权限字段数组,用这个权限字段(菜单字段)去匹配前端路由表。2.保存所有菜单数据,包括path,component路径,title,icon等等,然后再自己组装路由表数据。这种方式组装路由表数据太麻烦了,特别是后台给的是一维数组,而不是已经有层级的树形数据时,而且我做的时候遇到组装component时菜单可显示,但是点击组件却跳转不了的问题,报component为undefined。最后果断放弃了,若有知道什么原因的小伙伴可留言探讨,多谢。

    组装方式为:component:() => import(`@/page/${file}/${name}.vue`)

         做权限判断最有可能遇到的坑:死循环。当获取权限数据为空时,你保存在本地或者vuex中的权限数组就为空,所以当登入成功后要进入首页,判断vuex中的权限数据是否为空,为空则去拉取用户权限信息,获取的权限数据又为空,则如此死循环不停的去调接口拉取用户数据。所以在调试时一点要查看获取的权限数据,且给判断,若为空则特殊处理。

    下面我们就从登入开始梳理菜单鉴权的所有逻辑思路,默认后端已经保存了权限数组(这个数组就是勾选的哪些菜单可看的字段,也可以说是菜单的name值),该数组我取的是每个路由表的name,因为保证这是唯一的即可。

    login.vue:

    调用登录接口,保存token,进入首页

     var md5Password = self.$md5(self.loginForm.password.toUpperCase())
              var para = {
                userName: self.loginForm.username,
                password: md5Password
              }
              var params = Qs.stringify(para)
              console.log('查询传入参数', para)
              login(params).then(res => {
                console.log('登录信息', res)
                if (res.token) {
                  self.$store.dispatch('Settoken', res.token)
                } else {
                  // 登入成功返回的数据中没有token
                  self.$message.error('登录不成功,请重试...')
                }
                if (res.code === 1) {
                  self.$message({
                    type: 'success',
                    message: '登入成功'
                  })
                  // 登入成功则进入首页
                  self.$router.push({ path: '/dashboardPage/dashboard' })
                } else if (res.code === 0) {
                  self.$message.error('登录不成功,请重试...')
                }
              })

     

    permission.js:

    在main.js中引入,菜单鉴权最重要的部分,在路由守卫中鉴权,包含了token鉴定,登入页面登入,地址栏输入地址是否可进的各种判断

    import router from './router'
    import store from './store'
    import NProgress from 'nprogress' // Progress 进度条
    import 'nprogress/nprogress.css'// Progress 进度条样式
    import { Message } from 'element-ui'
    import { getToken } from '@/utils/auth' // 验权,从cookie中取得token
    
    /** roleMenu:后台获取的菜单权限 ,Toname:要去路由的组件名称*/
    function hasPermission(roleMenu, Toname) {
      var commonMenu = ['dashboardPage/dashboard', '/401', '/404', '/login'] // 定义公共页面数组
      if (roleMenu.indexOf(Toname) >= 0 || commonMenu.indexOf(Toname)) {
        // 若是公共页面数组或者在权限路由中,页面可进
        return true
      } else {
        return false
      }
    }
    const whiteList = ['/login'] // 不重定向白名单
    router.beforeEach((to, from, next) => { // 注册一个路由前置守卫
      NProgress.start() // 进度条开始
      // 拉取本地token
      if (getToken()) {
        console.log('totototot', to)
        /* has token,有token*/
        if (to.path === '/login') {
          // 有token且进入的是登入页面,则直接进入首页
          next({ path: '/' })
          NProgress.done()
        } else {
          console.log('不是login进入')
          /* 有token不是login页面的情况(正常的路由切换),每次页面刷新清空vuex的roleMenu后都会重新去拉取权限数据,保证是最新的权限数据*/
          if (store.getters.roleMenu.length === 0) { // vuex中没有用户信息,手动输入url或者刷新浏览器,vuex数据失效情况,
            console.log('无用户信息进入')
            store.dispatch('GetInfoPower').then(res => { // 根据cookie的token调用接口拉取用户信息存储到vuex
              if (res !== -1 && res.length > 0) {
                // 实际项目拉取用户所拥有的权限
                var roleMenu = res
                store.dispatch('GetRouters', roleMenu).then(() => { // 根据roles权限生成可访问的路由表
                  router.addRoutes(store.getters.lookRouter) // 动态添加可访问路由表
                  next({ ...to, replace: true }) // hack方法 确保addRoutes已完成 ,set the replace: true so the navigation will not leave a history record
                })
              } else {
                // TOKEN过期
                store.dispatch('FedLogOut').then(() => {
                  Message.error('用户信息已过期,请重新登入')
                  next({ path: '/' })
                })
              }
            }).catch((err) => {
              // 拉取用户信息失败,重新登入
              console.log(err)
              store.dispatch('FedLogOut').then(() => {
                Message.error('获取用户信息失败,请重新登入')
                next({ path: '/' })
              })
            })
          } else {
            // 权限判断,防止在地址栏直接输入地址进入()
            if (hasPermission(store.getters.roleMenu, to.path)) { // vuex中有用户信息,且有权限
              next() // 有权限直接进入
            } else {
              // 无权限,进401页面
              next({ path: '401' })
            }
            // next()
          }
        }
      } else {
        console.log('无token进入')
        // 当cookie中没有token时
        if (whiteList.indexOf(to.path) !== -1) { // 当前页面为值得信任的页面免验证的页面则直接进入(要进入的页面能够在白名单中找到)
          next()
        } else {
          next({ path: '/login' })
          NProgress.done()
        }
      }
    })
    router.afterEach(() => { // 后置守卫,导航被确认
      NProgress.done() // 结束Progress
    })
    

     vuex部分:

    import { logout, getInfo } from '@/api/login'
    import { setToken, removeToken, getToken } from '@/utils/auth'
    import Qs from 'qs'
    
    const user = {
      state: {
        token: getToken(),
        userName: '', // 用户名
        powerPort: [], // 权限接口
        roleMenu: [] // 后端返回的权限菜单字段数组集合
    
      },
    
      mutations: {
        SET_TOKEN: (state, token) => {
          state.token = token
        },
        SET_NAME: (state, userName) => { // 保存用户名
          state.userName = userName
        },
        SET_MENU: (state, roleMenu) => {
          state.roleMenu = roleMenu // 有权限路由菜单(动态添加该路由)
        },
        SET_PORT: (state, powerPort) => { // 保存可操作接口
          state.powerPort = powerPort
        }
    
      },
    
      actions: {
        // 保存token到vuex
        Settoken({ commit }, token) {
          setToken(token) // 存储调用API返回的token到cookie中
          commit('SET_TOKEN', token) // 存储token到vuex中
        },
        // 获取用户信息
        GetInfoPower({ commit, state }) {
          return new Promise((resolve, reject) => {
            var tokenObj = {
              token: state.token
            }
            var tokenPara = Qs.stringify(tokenObj)
            getInfo(tokenPara).then(response => {
              var data = response.rows
              console.log('权限数据', response)
              if (data !== undefined && data.length > 0) {
                commit('SET_NAME', response.userName)
                sessionStorage.setItem('userName', response.userName)
                var powerPort = [] // 可看操作接口
                var roleMenu = [] // 可看权限菜单字段
                // 遍历权限数组,只取code字段
                for (var i = 0; i < data.length; i++) {
                  if (data[i].type === 0) {
                    powerPort.push(data[i].code)
                  } else {
                    roleMenu.push(data[i].code)
                  }
                }
                commit('SET_MENU', roleMenu)
                commit('SET_PORT', powerPort) // 保存获取数据库按钮权限数组到vuex
                sessionStorage.setItem('powerHandle', powerPort)
                resolve(roleMenu)
              } else {
                resolve(response.code)
              }
            }).catch(error => {
              reject(error)
            })
          })
        },
        // 登出
        LogOut({ commit, state }) {
          return new Promise((resolve, reject) => {
            console.log('登出', state.token)
            var tokenPara = {
              token: state.token
            }
            var tokenParams = Qs.stringify(tokenPara)
            logout(tokenParams).then(() => {
              commit('SET_TOKEN', '') // 退出登入时清空vuex中的token和roles
              commit('SET_MENU', [])
              commit('SET_NAME', '')
              console.log('登出')
              removeToken() // 退出登入移除token
              resolve()
            }).catch(error => {
              reject(error)
            })
          })
        },
    
        // 前端 登出
        FedLogOut({ commit }) {
          return new Promise(resolve => {
            commit('SET_TOKEN', '')
            removeToken()
            console.log('前端登出')
            resolve()
          })
        },
      }
    }
    
    export default user

    vuex中的permission.js:

    根据获取的权限字段数组与本地的异步路由表进行匹配,生成可访问的路由表:

    import { asyncRouterMap, constantRouterMap } from '@/router' // 引入权限路由和非权限路由
    
    // 去前端保存的路由表中匹配路由
    function findRouter(roles, route) {
      if (route.name) { // 若存在路由权限表,通过路由表中的name和后端保存的权限数组进行匹配判断
        return roles.indexOf(route.name) >= 0 // 检测roles中是否有在路由权限表中能找到的元素
      } else {
        return true
      }
    }
    // 过滤路由表
    function filterAsyncRouterInmyRouter(asyncRouterMap, roles) {
      const accessedRouters = asyncRouterMap.filter(route => {
        if (findRouter(roles, route)) { // 存在路由权限
          if (route.children && route.children.length) { // 存在子路由
            route.children = filterAsyncRouterInmyRouter(route.children, roles)
          }
          return true
        }
        return false
      })
      return accessedRouters
    }
    
    const permission = {
      state: {
        lookRouter: [], // 可访问的权限路由
        AllRouter: constantRouterMap // 公共路由与异步权限路由拼接
      },
      mutations: {
        SET_LOOKROUTERS: (state, routers) => {
          state.lookRouter = routers // 可访问的权限路由
          state.AllRouter = constantRouterMap.concat(routers) // 公共路由与异步权限路由拼接
        }
      },
      actions: {
        GetRouters({ commit }, data) {
          return new Promise(resolve => {
            var accessedRouters = filterAsyncRouterInmyRouter(asyncRouterMap, data)
            var object = { path: '*', redirect: '/404', hidden: true }
            accessedRouters.push(object)
            commit('SET_LOOKROUTERS', accessedRouters) // 传入异步可访问的权限路由
            resolve()
          })
        }
      }
    }
    
    export default permission
    

     

    vuex中的getter.js:

    保存在vuexs的getter中,并

    const getters = {
      token: state => state.user.token,
      userName: state => state.user.userName,
      roleMenu: state => state.user.roleMenu, // 权限菜单字段数组
      lookRouter: state => state.permission.lookRouter, // 异步权限路由数组(动态加载的路由)
      AllRouter: state => state.permission.AllRouter, // 公共页面的路由数
    
    }
    export default getters

    vuex的store.js文件:

    import Vue from 'vue'
    import Vuex from 'vuex'
    import user from './modules/user'
    import getters from './getters''
    import permission from './modules/permission'
    
    Vue.use(Vuex)
    
    const store = new Vuex.Store({
    // 引入modules中的各个模块
      modules: {
        user,
        permission
    
      },
      getters // 引入getters中的计算属性模块
    })
    
    export default store

    在侧边栏获取并渲染权限菜单:

    mapGetters 映射到本地即可

    <script>
    import { mapGetters } from 'vuex'
    import SidebarItem from './SidebarItem'
    import logo from './logo'
    export default {
      components: { SidebarItem, logo },
      computed: {
        ...mapGetters([
          'sidebar', // 侧边栏状态及是否有动画
          'AllRouter' // 公共页面路由与异步权限路由拼接的总路由表
        ]),
        isCollapse() { // 侧边栏展开与否
          return !this.sidebar.opened
        }
      },
      created() {
        console.log('路由表', this.AllRouter)
      }
    }
    </script>

    菜单鉴权从登陆,到路由守卫的鉴权,再到获取权限数据,保存到vuex,到从获取vuex中权限数据渲染在侧边栏,注释都非常清楚。若有什么需要改进或者错误的地方,欢迎指出,谢谢。

    展开全文
  • ThinkPHP6.0整合Hui-Admin后台模板 Auth菜单权限,简单地写了几个增删改查的例子,用到了中间件的使用
  • Eclipse plug-in通过PropertyTest控制菜单权限文档
  • abp菜单权限配置

    千次阅读 2017-07-19 11:07:42
    1)在core层Authorization下找到AppPermissions.cs文件,定义自己的菜单权限码  public const string Pages = "Pages";//一级菜单,二级菜单应为:Pages.one... 2)在Localization本地化处,将将菜单...

    1)在core层Authorization下找到AppPermissions.cs文件,定义自己的菜单权限码

          public const string Pages = "Pages";//一级菜单,二级菜单应为:Pages.one...

    2)在Localization本地化处,将将菜单名称进行本地化

    3)在core层Authorization下找到xxxAuthorizationProvider,进行创建菜单

    var pages = context.GetPermissionOrNull(AppPermissions.Pages) ?? context.CreatePermission(AppPermissions.Pages, L("Pages"));

    4)在web层AppStart/Navigation/PageName,编写菜单权限码,用于标识菜单显示位置

     public const string BasicInfos = "BasicInfos";

    5)在web层area/xxx/startup/xxxNavigationProvider处生成菜单,添加每一项菜单

     //HOME
         .AddItem(new MenuItemDefinition(
                        PageNames.Frontend.Home,
                        L("HomePage"),
                        url: ""
                        )

    6)前端控制菜单标识位置用  ViewBag.CurrentPageName = 第四步设置的权限菜单码

     

    欢迎加公众号进行互动交流:

    mj趣味汇

    展开全文
  • Vue 项目 菜单权限及按钮级权限控制

    千次阅读 2020-06-24 12:05:50
    1.页面展示需要鉴权的所有按钮,需要先鉴权菜单权限的显示与隐藏。 2.勾选每个角色或者用户所能看的权限保存在数据库。该权限数据是一个权限字段的数组。 3.全局自定义指令(directive)控制按钮权限数据的方法,...
  • 学习之作,OUTLOOKBAR使用网上其他朋友的资源,只是将菜单和OUTLOOKBAR控件进行了结合,菜单权限自己配上数据库对应的表和前台配合就能实现
  • 【商城应用】菜单权限设计

    千次阅读 2018-08-21 22:21:43
    今天给大家介绍一下后台管理系统中权限功能的开发,先给大家介绍一下权限功能产品部分的...这边说的权限指的是后台菜单权限,而不是指shiro或者spring security的接口权限,当然也可以采用今天所讲的权限设计来设计s...
  • easyUi实现菜单权限管理

    千次阅读 热门讨论 2018-05-25 09:25:20
    先看效果:1,我先用管理员账户登陆看到的菜单是:2,给角色分菜单权限:3,给用户分配角色4.用新用户登陆:5.具体代码后期加上。或者想要的先关注下我的博客。...
  • 通过SQL SERVER2005数据库+VS2008编写的菜单权限,可供初学者学习。
  • pb 设置用户的菜单权限 pb9版

    热门讨论 2010-11-28 08:38:45
    pb 实现用户的菜单权限 运行效果图http://p.blog.csdn.net/images/p_blog_csdn_net/newease/EntryImages/20090707/菜单授权.jpg
  • RBAC基础角色用户菜单权限管理

    千次阅读 2019-09-07 22:23:13
    用户表 角色表 用户-多角色表-关系表(某一.../////// 当前用户的菜单权限 取出 (张三-开发的菜单 并集 张三-测试的菜单)去重 ---1.查询用户的信息-根据用户名密码 select * from user where username='zhang...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 182,956
精华内容 73,182
关键字:

菜单权限