shiro:hasPermission 标签 ：验证当前用户是否拥有指定权限

最新推荐文章于 2022-08-24 02:15:09 发布
最新推荐文章于 2022-08-24 02:15:09 发布
阅读量2.5w 收藏 38
点赞数 6
分类专栏： # shiro
原文链接：https://www.cnblogs.com/hoge66/p/9923476.html
版权

1、这些值是存在数据库里的，在哪里找呢？sys_menu 中的permission列。

<shiro:hasPermission name=“cms:article:edit”>
在这里插入图片描述
他是怎么入库的呢？非菜单项的权限是怎么加入，怎么取出来使用的？

取出来的sql：

SELECT
    a.id ,
    a.parent_id AS "parent.id" ,
    a.parent_ids ,
    a. NAME ,
    a.href ,
    a.target ,
    a.icon ,
    a.sort ,
    a.is_show ,
    a.permission ,
    a.remarks ,
    a.create_by AS "createBy.id" ,
    a.create_date ,
    a.update_by AS "updateBy.id" ,
    a.update_date ,
    a.del_flag ,
    p. NAME AS "parent.name"
FROM
    sys_menu a
LEFT JOIN sys_menu p ON p.id = a.parent_id
WHERE
    a.del_flag = 0
ORDER BY
    a.sort

同一个表里的id与parentid之间的连接；

程序代码是在：com.thinkgem.jeesite.modules.sys.security 这个包里

/**
     * 授权查询回调函数, 进行鉴权但缓存中无用户的授权信息时调用
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        Principal principal = (Principal) getAvailablePrincipal(principals);
        // 获取当前已登录的用户
        if (!Global.TRUE.equals(Global.getConfig("user.multiAccountLogin"))){
            Collection<Session> sessions = getSystemService().getSessionDao().getActiveSessions(true, principal, UserUtils.getSession());
            if (sessions.size() > 0){
                // 如果是登录进来的，则踢出已在线用户
                if (UserUtils.getSubject().isAuthenticated()){
                    for (Session session : sessions){
                        getSystemService().getSessionDao().delete(session);
                    }
                }
                // 记住我进来的，并且当前用户已登录，则退出当前用户提示信息。
                else{
                    UserUtils.getSubject().logout();
                    throw new AuthenticationException("msg:账号已在其它地方登录，请重新登录。");
                }
            }
        }
        User user = getSystemService().getUserByLoginName(principal.getLoginName());
        if (user != null) {
            SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
            List<Menu> list = UserUtils.getMenuList();
            for (Menu menu : list){
                if (StringUtils.isNotBlank(menu.getPermission())){
                    // 添加基于Permission的权限信息
                    for (String permission : StringUtils.split(menu.getPermission(),",")){
                        info.addStringPermission(permission);
                    }
                }
            }
            // 添加用户权限
            info.addStringPermission("user");
            // 添加用户角色信息
            for (Role role : user.getRoleList()){
                info.addRole(role.getEnname());
            }
            // 更新登录IP和时间
            getSystemService().updateUserLoginInfo(user);
            // 记录登录日志
            LogUtils.saveLog(Servlets.getRequest(), "系统登录");
            return info;
        } else {
            return null;
        }
    }
    

List<Menu> list = UserUtils.getMenuList();
            for (Menu menu : list){
                if (StringUtils.isNotBlank(menu.getPermission())){
                    // 添加基于Permission的权限信息
                    for (String permission : StringUtils.split(menu.getPermission(),",")){
                        info.addStringPermission(permission);
                    }
                }
            }

这一段；
3、那么JSP页面上是什么时候判断的呢？这些数据是什么时候初始化到数据库中的呢？
在使用Shiro标签库前，首先需要在JSP引入shiro标签：

<%@ taglib prefix="shiro" uri="/WEB-INF/tlds/shiros.tld" %>

当展示一个jsp页面时，页面中如果遇到<shiro:hasPermission name=“item:update”>，shiro调用realm获取数据库中的权限信息，看item:update是否在权限数据中存在，如果不存在就拒绝访问，如果存在就授权通过。

package com.thinkgem.jeesite.modules.sys.security;
 
import java.io.Serializable;
import java.util.Collection;
import java.util.List;
 
import javax.annotation.PostConstruct;
 
import org.apache.commons.lang3.StringUtils;
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.credential.HashedCredentialsMatcher;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.Permission;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.session.Session;
import org.apache.shiro.subject.PrincipalCollection;
import org.apache.shiro.util.ByteSource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
 
import com.thinkgem.jeesite.common.config.Global;
import com.thinkgem.jeesite.common.servlet.ValidateCodeServlet;
import com.thinkgem.jeesite.common.utils.Encodes;
import com.thinkgem.jeesite.common.utils.SpringContextHolder;
import com.thinkgem.jeesite.common.web.Servlets;
import com.thinkgem.jeesite.modules.sys.entity.Menu;
import com.thinkgem.jeesite.modules.sys.entity.Role;
import com.thinkgem.jeesite.modules.sys.entity.User;
import com.thinkgem.jeesite.modules.sys.service.SystemService;
import com.thinkgem.jeesite.modules.sys.utils.LogUtils;
import com.thinkgem.jeesite.modules.sys.utils.UserUtils;
import com.thinkgem.jeesite.modules.sys.web.LoginController;
 
/**
 * 系统安全认证实现类
 * @author ThinkGem
 * @version 2014-7-5
 */
@Service
//@DependsOn({"userDao","roleDao","menuDao"})
public class SystemAuthorizingRealm extends AuthorizingRealm {
 
    private Logger logger = LoggerFactory.getLogger(getClass());
     
    private SystemService systemService;
     
    public SystemAuthorizingRealm() {
        this.setCachingEnabled(false);
    }
 
    /**
     * 认证回调函数, 登录时调用
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authcToken) {
        UsernamePasswordToken token = (UsernamePasswordToken) authcToken;
         
        int activeSessionSize = getSystemService().getSessionDao().getActiveSessions(false).size();
        if (logger.isDebugEnabled()){
            logger.debug("login submit, active session size: {}, username: {}", activeSessionSize, token.getUsername());
        }
         
        // 校验登录验证码
        if (LoginController.isValidateCodeLogin(token.getUsername(), false, false)){
            Session session = UserUtils.getSession();
            String code = (String)session.getAttribute(ValidateCodeServlet.VALIDATE_CODE);
            if (token.getCaptcha() == null || !token.getCaptcha().toUpperCase().equals(code)){
                throw new AuthenticationException("msg:验证码错误, 请重试.");
            }
        }
         
        // 校验用户名密码
        User user = getSystemService().getUserByLoginName(token.getUsername());
        if (user != null) {
            if (Global.NO.equals(user.getLoginFlag())){
                throw new AuthenticationException("msg:该已帐号禁止登录.");
            }
            byte[] salt = Encodes.decodeHex(user.getPassword().substring(0,16));
            return new SimpleAuthenticationInfo(new Principal(user, token.isMobileLogin()),
                    user.getPassword().substring(16), ByteSource.Util.bytes(salt), getName());
        } else {
            return null;
        }
    }
     
    /**
     * 获取权限授权信息，如果缓存中存在，则直接从缓存中获取，否则就重新获取， 登录成功后调用
     */
    protected AuthorizationInfo getAuthorizationInfo(PrincipalCollection principals) {
        if (principals == null) {
            return null;
        }
         
        AuthorizationInfo info = null;
 
        info = (AuthorizationInfo)UserUtils.getCache(UserUtils.CACHE_AUTH_INFO);
 
        if (info == null) {
            info = doGetAuthorizationInfo(principals);
            if (info != null) {
                UserUtils.putCache(UserUtils.CACHE_AUTH_INFO, info);
            }
        }
 
        return info;
    }
 
    /**
     * 授权查询回调函数, 进行鉴权但缓存中无用户的授权信息时调用
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        Principal principal = (Principal) getAvailablePrincipal(principals);
        // 获取当前已登录的用户
        if (!Global.TRUE.equals(Global.getConfig("user.multiAccountLogin"))){
            Collection<Session> sessions = getSystemService().getSessionDao().getActiveSessions(true, principal, UserUtils.getSession());
            if (sessions.size() > 0){
                // 如果是登录进来的，则踢出已在线用户
                if (UserUtils.getSubject().isAuthenticated()){
                    for (Session session : sessions){
                        getSystemService().getSessionDao().delete(session);
                    }
                }
                // 记住我进来的，并且当前用户已登录，则退出当前用户提示信息。
                else{
                    UserUtils.getSubject().logout();
                    throw new AuthenticationException("msg:账号已在其它地方登录，请重新登录。");
                }
            }
        }
        User user = getSystemService().getUserByLoginName(principal.getLoginName());
        if (user != null) {
            SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
            List<Menu> list = UserUtils.getMenuList();
            for (Menu menu : list){
                if (StringUtils.isNotBlank(menu.getPermission())){
                    // 添加基于Permission的权限信息
                    for (String permission : StringUtils.split(menu.getPermission(),",")){
                        info.addStringPermission(permission);
                    }
                }
            }
            // 添加用户权限
            info.addStringPermission("user");
            // 添加用户角色信息
            for (Role role : user.getRoleList()){
                info.addRole(role.getEnname());
            }
            // 更新登录IP和时间
            getSystemService().updateUserLoginInfo(user);
            // 记录登录日志
            LogUtils.saveLog(Servlets.getRequest(), "系统登录");
            return info;
        } else {
            return null;
        }
    }
     
    @Override
    protected void checkPermission(Permission permission, AuthorizationInfo info) {
        authorizationValidate(permission);
        super.checkPermission(permission, info);
    }
     
    @Override
    protected boolean[] isPermitted(List<Permission> permissions, AuthorizationInfo info) {
        if (permissions != null && !permissions.isEmpty()) {
            for (Permission permission : permissions) {
                authorizationValidate(permission);
            }
        }
        return super.isPermitted(permissions, info);
    }
     
    @Override
    public boolean isPermitted(PrincipalCollection principals, Permission permission) {
        authorizationValidate(permission);
        return super.isPermitted(principals, permission);
    }
     
    @Override
    protected boolean isPermittedAll(Collection<Permission> permissions, AuthorizationInfo info) {
        if (permissions != null && !permissions.isEmpty()) {
            for (Permission permission : permissions) {
                authorizationValidate(permission);
            }
        }
        return super.isPermittedAll(permissions, info);
    }
     
    /**
     * 授权验证方法
     * @param permission
     */
    private void authorizationValidate(Permission permission){
        // 模块授权预留接口
    }
     
    /**
     * 设定密码校验的Hash算法与迭代次数
     */
    @PostConstruct
    public void initCredentialsMatcher() {
        HashedCredentialsMatcher matcher = new HashedCredentialsMatcher(SystemService.HASH_ALGORITHM);
        matcher.setHashIterations(SystemService.HASH_INTERATIONS);
        setCredentialsMatcher(matcher);
    }
     
//  /**
//   * 清空用户关联权限认证，待下次使用时重新加载
//   */
//  public void clearCachedAuthorizationInfo(Principal principal) {
//      SimplePrincipalCollection principals = new SimplePrincipalCollection(principal, getName());
//      clearCachedAuthorizationInfo(principals);
//  }
 
    /**
     * 清空所有关联认证
     * @Deprecated 不需要清空，授权缓存保存到session中
     */
    @Deprecated
    public void clearAllCachedAuthorizationInfo() {
//      Cache<Object, AuthorizationInfo> cache = getAuthorizationCache();
//      if (cache != null) {
//          for (Object key : cache.keys()) {
//              cache.remove(key);
//          }
//      }
    }
 
    /**
     * 获取系统业务对象
     */
    public SystemService getSystemService() {
        if (systemService == null){
            systemService = SpringContextHolder.getBean(SystemService.class);
        }
        return systemService;
    }
     
    /**
     * 授权用户信息
     */
    public static class Principal implements Serializable {
 
        private static final long serialVersionUID = 1L;
         
        private String id; // 编号
        private String loginName; // 登录名
        private String name; // 姓名
        private boolean mobileLogin; // 是否手机登录
         
//      private Map<String, Object> cacheMap;
 
        public Principal(User user, boolean mobileLogin) {
            this.id = user.getId();
            this.loginName = user.getLoginName();
            this.name = user.getName();
            this.mobileLogin = mobileLogin;
        }
 
        public String getId() {
            return id;
        }
 
        public String getLoginName() {
            return loginName;
        }
 
        public String getName() {
            return name;
        }
 
        public boolean isMobileLogin() {
            return mobileLogin;
        }
 
//      @JsonIgnore
//      public Map<String, Object> getCacheMap() {
//          if (cacheMap==null){
//              cacheMap = new HashMap<String, Object>();
//          }
//          return cacheMap;
//      }
 
        /**
         * 获取SESSIONID
         */
        public String getSessionid() {
            try{
                return (String) UserUtils.getSession().getId();
            }catch (Exception e) {
                return "";
            }
        }
         
        @Override
        public String toString() {
            return id;
        }
 
    }
}

怎么入库的呢？看截图，还是菜单管理中的操作：
在这里插入图片描述
4、控制器controller中的权限控制，对应在后台添加菜单时，需要在控制器的方法上添加注解：
@RequiresPermissions(“cms:view”)
在这里插入图片描述
对应后台添加菜单时：
在这里插入图片描述

dxyzhbb
关注
  • 6
    点赞
  • 踩
  • 38
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
shiro:shiro基于url做的权限系统
03-11
四郎 shiro基于url做的权限系统
＜shiro:hasPermission name=“...“＞咋用啊
m0_59834108的博客
07-27 3933
如有错误欢迎指正 shiro：haspermission这个标签，对应的是官网给出的一个类，可以判断是否有操作权限，name属性呢，可以理解为名为sys:menu:add的一个操作，传入标签以后，标签来判断一下这个sys:menu:add操作有没有权限运行 如有错误欢迎指正 ...
【Shiro原理一】shiro:hasPermission 隐藏页面无权访问的资源
朱赤墨黑
09-03 5485
shiro:hasPermission 隐藏页面无权访问的资源，因为层层调用方法，下面可能有点儿乱，注意上下结合看方法名。 jsp： organ_list.jsp &lt;shiro:hasPermission name="jigouxinxi-xinzeng"&gt; &lt;button class="layui-btn layui-btn-primary" onclick="a...
Shiro 权限验证原理
PinkCoder
02-14 2078
Shiro 权限验证原理
spingsecurity中haspermission用法以及配置自定义PermissionEvaluator
热门推荐
xmj_0422的博客
08-13 1万+
一、原理剖析 先看一段官方文档对haspermission的描述（文档链接：https://docs.spring.io/spring-security/site/docs/5.2.7.BUILD-SNAPSHOT/reference/htmlsingle/#el-permission-evaluator） 开头的意思是haspermission的注解会委托给PermissionEvaluator接口，而这个接口默认实现是DenyAllPermissionEvaluator(源码如下) 这个类的两个
Shiro权限
Brooks Lv
11-06 4328
什么是授权 授权就是在认证的基础上给用户进行角色和权限的授予。权限定义了一个用户是否可以执行某个操作。角色是一组权限的集合，我们通常把一组权限绑定到一种角色上，再吧一个或者多个角色赋给一个用户，这样就是实现了权限的控制。 Shiro授权核心概念 权限 : 即操作资源的权利，比如访问某个页面，以及对某个模块的数据的添加，修改，删除，查看的权利 角色 : 是权限的集合，一种角色可以包含多种权限 用户 ...
Spring Boot-Shiro-Vue的权限管理思路.前后端都加以控制,做到按钮/接口级别的权限
最新发布
10-17
基于 RBAC新解 . 通常我们的权限设计都是 用户--角色--权限 ,其中角色是我们写代码的人没法...角色的作用其实只是用来管理分配权限的,真正的验证只验证权限 ,而不去管你是否是那种角色.体现在代码上就是接口上注解为
将 Shiro 作为应用的权限基础 三：基于注解实现的授权认证过程.docx
02-22
授权，即访问控制，是 Shiro 的核心功能之一，用于决定用户是否能够访问特定的资源。在 Shiro 中，用户权限通常由三个主要实体组成：LoginAccount（用户信息）、Role（角色）和 Permission（权限）。LoginAccount ...
【SpringBoot】廿三、SpringBoot中整合Shiro实现权限管理.pdf
12-17
3. 在Thymeleaf模板中使用Shiro标签，例如`<shiro:hasRole>`和`<shiro:hasPermission>`，实现基于角色和权限的页面元素显示控制。 4. 在Controller层，使用Shiro的注解进行方法级别的权限控制，如`@...
【SpringBoot】廿三、SpringBoot中整合Shiro实现权限管理.docx
12-17
- Thymeleaf-extras-shiro库允许在Thymeleaf模板中使用Shiro标签，如`<shiro:hasPermission name="admin">`来控制页面元素的显示。 4. **Shiro会话管理** - Shiro的会话管理可以替代SpringBoot默认的会话管理，...
@shiro.hasPermission 使用
ywb201314的专栏
10-26 3335
在页面上加上@shiro.hasPermission 如下用.ftl为例子： 当加上shiro标签后，会与后台代码结合使用： 需要继承AuthorizingRealm 下的protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection)进行业务的处理。 关系点：@shiro.hasPermission name=的值要与authorizatio...
Shiro介绍以及各功能的使用
weixin_43967582的博客
12-18 988
Shiro学习 官方文档 什么是shiro Apache Shiro 是一个强大而灵活的开源安全框架，可是实现身份验证、授权、企业会话管理和加密。 整体框架 Subject：当前与软件交互的实体（用户、第 3 方服务、cron 作业等）的特定于安全的“视图”。 SecurityManager： 是 Shiro 的心脏；所有具体的交互都通过 SecurityManager 进行拦截并控制；它管理着所有 Subject、且负责进行认证和授权、及会话、缓存的管理 Authenticator：认证
Shiro ＜shiro:hasPermission ＞标签不生效，shiro权限不生效原因
cristianoxm的博客
12-01 2925
第一个可能配置文件：shiroConfig.java没加这个 /** * 开启Shiro的注解(如@RequiresRoles,@RequiresPermissions),需借助SpringAOP扫描使用Shiro注解的类,并在必要时进行安全逻辑验证 * 配置以下两个bean(DefaultAdvisorAutoProxyCreator和AuthorizationAttributeSourceAdvisor)即可实现此功能 * @return */ @Bean @ConditionalO
Shiro ＜shiro:hasPermission 标签不生效，shiro权限不生效原因
ZGIT的博客
07-16 7289
第一个可能配置文件：shiroConfig.java没加这个 /** * 开启Shiro的注解(如@RequiresRoles,@RequiresPermissions),需借助SpringAOP扫描使用Shiro注解的类,并在必要时进行安全逻辑验证 * 配置以下两个bean(DefaultAdvisorAutoProxyCreator和AuthorizationAttributeSourceAdvisor)即可实现此功能 * @return */ @Bean @ConditionalO
【Shiro】三、Apache Shiro授权功能的主要流程
KevinBrain的博客
04-01 279
一、Shiro框架的授权功能简介 授权，也称为访问控制，是确定对应用程序中资源的访问权限的过程。换句话说，确定“谁有权访问什么”。授权用于回答安全性问题，例如“是否允许用户编辑帐户”，“是否允许该用户查看此网页”，“该用户是否有权访问此按钮？”这些都是决定用户有权访问哪些内容的决定，因此，所有决定都代表授权检查。 授权是任何应用程序的关键要素，但它很快就会变得非常复杂。Shiro的目标是消除授权方面的许多复杂性，以便您可以更轻松地构建安全的软件。下面是Shiro授权功能的重点。 优点： 基于主.
Shiro ＜shirohasPermission 标签不生效，shiro权限不生效原因
m0_54850467的博客
08-24 732
第一层级权限为：【b2b:contract】,第二层级为：【b2b:contract:view】，第三层级为：【b2b:contract:add】，这个使用坑就出现了。当你使用【b2b:contract】权限时，意味着后面包含b2b:contract的都有权限了，只修改了 就好了。供应商合同 b2b:contract:view。添加 b2b:contract:add。删除 b2b:contract:del。
shiro
qq_32295383的博客
04-29 177
Shiro核心api subject： 用户主体（把操作交给SecurityManager） SecurityManager：安全管理器(关联Realm) Realm：shiro连接数据库的桥梁 --------------------------------用户认证 1.Controller //使用shiro编写认证 Subject subject=SecurityUtils.ge...
【SaaS - Export项目】24 - Shiro授权，shiro授权校验，查看用户是否拥有访问权限，无权限拦截请求
m0_67391870的博客
04-11 897
文章目录 Shiro授权功能介绍 通过邮箱查询用户的权限 在中给用户授权 授权校验的几种实现方式 1. 硬编码方式（拦截方法） 2. 配置xml过滤器方式【***推荐使用】 配置用户没有权限访问时的跳转页面 3. 注解方式 4. 使用shiro提供的标签（拦截页面元素：按钮，表格等） Shiro授权功能介绍 1）什么是授权 授权，也叫做授权访问校验，比如在登陆认证后，系统校验用户是否有权限访问资源，就叫授权。 2）实现授权步骤 登陆认证成功后，获取用户的权限 （
shiro框架了解
ABestRookie的博客
06-28 439
shiro框架
shiro:hasPermission
08-03
[1]当展示一个JSP页面时，如果遇到shiro:hasPermission标签，Shiro会调用Realm获取数据库中的权限信息，然后判断该权限是否在权限数据中存在。如果权限存在，则授权通过，允许用户访问相应的内容；如果权限不存在，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值