Shiro 授权(Authorization)

最新推荐文章于 2024-08-29 07:30:00 发布
最新推荐文章于 2024-08-29 07:30:00 发布
阅读量604 收藏 1
点赞数
分类专栏： Spring Boot 文章标签： shiro spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45857926/article/details/108676577
版权

Shiro 授权（Authorization）

术语简介

授权

授权，也叫访问控制，即在应用中控制谁能访问哪些资源（如访问页面/编辑数据/页面操作等）。在授权中需要了解的几个关键对象：主体（Subject）、资源（Resource）、权限（Permission）、角色（Role）。

主体

主体，即访问应用的用户，在 Shiro 中使用 Subject 代表该用户。用户只有授权后才允许访问相应的资源。

资源

在应用中用户可以访问的任何东西，比如访问 JSP 页面、查看/编辑某些数据、访问某个业务方法、打印文本等等都是资源。用户只有授权后才能访问。

权限

安全策略中的原子授权单位，通过权限我们可以表示在应用中用户有没有操作某个资源的权力。即权限表示在应用中用户能不能访问某个资源，如:访问用户列表页面、查看/新增/修改/删除用户数据（即很多时候都是 CRUD（增查改删）式权限控制)、打印文档等等。如上可以看出，权限代表了用户有没有操作某个资源的权力，即反映在某个资源上的操作允不允许，不反映谁去执行这个操作。所以后续还需要把权限赋予给用户，即定义哪个用户允许在某个资源上做什么操作（权限)，Shiro不会去做这件事情，而是由实现人员提供。
Shiro支持粗粒度权限（如用户模块的所有权限）和细粒度权限（操作某个用户的权限，
即实例级别的)。

角色

角色代表了操作集合，可以理解为权限的集合，一般情况下我们会赋予用户角色而不是权限，即这样用户可以拥有一组权限，赋予权限时比较方便。典型的如:项目经理、技术总监、CTO、开发工程师等都是角色，不同的角色拥有一组不同的权限。

授权（Authorization）

基本操作

  1. 配置 shiro.ini
#对用户信息进行配置
[users]
#用户账号和密码
#配置规则: 用户账号=密码,角色1,角色2
hxy=123456,管理员
zhangsan=000000,项目经理

#对权限信息进行配置,基于角色配置
[roles]
#角色和权限
#配置规则:角色=权限1,权限2。权限字符串可使用通配符配置
#管理员能够对用户和角色进行所有操作
管理员=user:*,role:*
#客户经理只能对用户进行列表和详情的查看操作
客户经理=user:list,user:view
  1. 测试
@Test
public void testShiro() {
    //1.创建Realm(安全数据源)
    //通过shiro.ini配置文件创建Realm
    IniRealm realm = new IniRealm("classpath:shiro.ini");
    //2.配置SecurityManager
    DefaultSecurityManager securityManager = new DefaultSecurityManager();

    //注入创建的Realm(安全数据源)
    securityManager.setRealm(realm);
    SecurityUtils.setSecurityManager(securityManager);
    //3.操作Subject,进行认证
    Subject subject = SecurityUtils.getSubject();
    //封装一个令牌
    UsernamePasswordToken token = new UsernamePasswordToken("hxy", "123456");
    try {
        subject.login(token);
    } catch (AuthenticationException e) {
        System.out.println("认证异常:");
        e.printStackTrace();
    }
    System.out.println("是否通过认证:" + subject.isAuthenticated());
    System.out.println("身份信息:" + subject.getPrincipal());

    //认证通过后进行权限验证
    System.out.println("是否为管理员角色:"+subject.hasRole("管理员"));//判断是否为某角色
    System.out.println("是否能操作用户查看功能:"+subject.isPermitted("user:view"));//判断是否拥有某权限
    //也可以使用check方法判断是否拥有某权限,但是失败的情况下会抛出UnauthorizedException异常
    //subject.checkPermission("user:view");
}

执行结果:
在这里插入图片描述

授权流程

在这里插入图片描述
4. 首先调用 Subject.isPermitted*/hasRole* 接口，其会委托给 SecurityManager，而
SecurityManager 接着会委托给 Authorizer ;
5. Authorizer 是真正的授权者，如果我们调用如 isPermitted(“user:view”)，其首先会通
过 PermissionResolver 把字符串转换成相应的 Permission 实例;
6. 在进行授权之前，其会调用相应的 Realm 获取 Subject 相应的角色/权限用于匹配传
入的角色/权限;
7. Authorizer 会判断 Realm 的角色/权限是否和传入的匹配，如果有多个 Realm，会委托
给 ModularRealmAuthorizer 进行循环判断，isPermitted*/hasRole* 如果匹配会返回
true ，否则返回 false 表示授权失败。

授权方式

Shiro 支持四种方式的授权验证（权限控制）：

  1. 代码级别权限控制：通过写 if/else 授权代码块完成，前面测试类中即该方式
Subject subject = SecurityUtils.getSubject();
if(subject.hasRole("管理员")){
	//有权限
}else{
	//无权限
}
  1. 页面标签权限控制：在页面通过相应的标签完成
<shiro:hasRole name="管理员">
	<!-有权限->
</shiro:hasRole>
  1. 方法注解权限控制：通过在执行的 Java 方法上添加相应的注解完成
@RequiresRoles("管理员")
public String add(Model model){	
	//有权限
}
  1. URL 拦截器权限控制：在 ShiroFilterFactoryBean 对象中配置 URL 拦截器规则完成
filterChainDefinitionMap.put("/login","anon");

filterChainDefinitionMap.put("/user/add","perms[用户添加]");
filterChainDefinitionMap.put("/user/modify","perms[用户编辑]");
filterChainDefinitionMap.put("/user/del","perms[用户删除]");*/

SpringBoot(API)+Shiro 授权

静态授权

静态授权(将权限信息写死)
在这里插入图片描述

  1. 自定义 Realm 授予权限
import com.hxy.crm.pojo.Right;
import com.hxy.crm.pojo.Role;
import com.hxy.crm.pojo.User;
import com.hxy.crm.service.UserService;
import org.apache.shiro.authc.*;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;

import javax.annotation.Resource;
import java.util.Set;

public class MyShiroRealm extends AuthorizingRealm {//安全数据源

    @Resource
    private UserService userService;

    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        System.out.println("调用MyShiroRealm.doGetAuthorizationInfo获取权限信息!");
        //获得权限信息
        User user = (User) principalCollection.getPrimaryPrincipal();
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();

        //静态授权:授权主体(用户)相应的角色和权限
        info.addRole(user.getRole().getRoleName());
        info.addStringPermission("用户列表");//所有用户拥有用户列表权限
        if("管理员".equals(user.getRole().getRoleName())){//管理员拥有"增删改"权限
            info.addStringPermission("用户添加");
            info.addStringPermission("用户编辑");
            info.addStringPermission("用户删除");
        }

        return info;
    }

    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        System.out.println("调用MyShiroRealm.doGetAuthenticationInfo获取身份信息!");
        //获得身份信息
        UsernamePasswordToken token = (UsernamePasswordToken)authenticationToken;
        String userName = token.getUsername();
        User user = userService.getUserByUserName(userName);
        if(user==null){
            throw new UnknownAccountException();//账号错误
        }
        if(user.getUserFlag()==null||user.getUserFlag().intValue()==0){
            throw new LockedAccountException();//账号锁定
        }
        SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(
                user,//身份(根据用户名查询数据库获得的用户)
                user.getUserPassword(),//凭证(查询数据库获得密码)
                getName()//Realm对象的名称
        );
        //返回身份信息
        return info;

    }

}
  1. 配置 ShiroConfig 拦截 URL
import com.hxy.crm.pojo.Right;
import com.hxy.crm.service.RoleService;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.annotation.Resource;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

@Configuration
public class ShiroConfig {
    @Bean
    public MyShiroRealm myShiroRealm(){//自定义Realm
        MyShiroRealm shiroRealm = new MyShiroRealm();
        return shiroRealm;
    }

    @Bean
    public SecurityManager securityManager(){//安全管理器SecurityManager
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        //注入Realm
        securityManager.setRealm(myShiroRealm());
        return securityManager;
    }

    @Bean
    public ShiroFilterFactoryBean shiroFilterFactory(SecurityManager securityManager){//Shiro过滤器:权限验证
        ShiroFilterFactoryBean shiroFilterFactory = new ShiroFilterFactoryBean();
        //注入SecurityManager
        shiroFilterFactory.setSecurityManager(securityManager);
        //权限验证:使用Filter控制资源(URL)的访问
        shiroFilterFactory.setLoginUrl("/login");
        shiroFilterFactory.setSuccessUrl("/main");
        shiroFilterFactory.setUnauthorizedUrl("/403");
        Map<String,String> filterChainDefinitionMap = new LinkedHashMap<String,String>();//必须使用LinkedHashMap(有序集合)
        //配置可以匿名访问的资源(URL): 静态资源
        filterChainDefinitionMap.put("/statics/css/**","anon");
        filterChainDefinitionMap.put("/statics/fonts/**","anon");
        filterChainDefinitionMap.put("/statics/images/**","anon");
        filterChainDefinitionMap.put("/statics/js/**","anon");
        filterChainDefinitionMap.put("/statics/localcss/**","anon");
        filterChainDefinitionMap.put("/statics/lcaljs/**","anon");

        filterChainDefinitionMap.put("/login","anon");
        filterChainDefinitionMap.put("/logout","logout");//注销过滤器,自动注销

        //配置需要特定权限才能访问的资源(URL)
        //静态授权:包括全部需要特定权限才能访问的资源(URL)
        filterChainDefinitionMap.put("/user/list","perms[用户列表]");
        filterChainDefinitionMap.put("/user/add","perms[用户添加]");
        filterChainDefinitionMap.put("/user/modify","perms[用户编辑]");
        filterChainDefinitionMap.put("/user/del","perms[用户删除]");

        //配置认证访问,其他资源(URL)必须认证通过才能访问
        filterChainDefinitionMap.put("/**","authc");//必须放在过滤器链的后面

        shiroFilterFactory.setFilterChainDefinitionMap(filterChainDefinitionMap);
        return shiroFilterFactory;
    }

}

URL 拦截权限控制

过滤器简称对应的 java 类说明
anonAnonymousFilter匿名拦截，即不需要登录即可访间;一般用于静态资源过滤
authcFormAuthenticationFilter基于表单的拦截，如果没有登录会跳到相应的登录页面登录
authcBasicBasicHttpAuthenticationFilterBasic HTTP 身份验证拦截
permsPermissionsAuthorizationFilter权限授权拦截，验证用户是否拥有指定权限;例如:perms[用户列表]
portPortFilter端口拦截
restHttpMethodPermissionFilterrest风格拦截，自动根据请求方法构建权限字符串
rolesRolesAuthorizationFilter角色授权拦截，验证用户是否拥有所有角色;
sslSslFiltersSL拦截，只有请求协议是 https才能通过:
userUserFilter用户拦截，用户已经身份验证/记住我登录的都可
logoutLogoutFilter退出拦截

页面标签权限控制

  1. pom.xml 添加依赖
<dependency>
    <groupId>com.github.theborakompanioni</groupId>
    <artifactId>thymeleaf-extras-shiro</artifactId>
    <version>2.0.0</version>
</dependency>
  1. ShiroConfig.java 配置类中添加配置
@Bean(name = "shiroDialect")
public ShiroDialect shiroDialect(){//thymeleaf 页面上使用 shiro 标签
	return new ShiroDialect ();
}
  1. 页面头部导入标签库
<html lang="en" xmlns:shiro="http://www.pollix.at/thymeleaf/shiro"
	xmlns:th="http://www.thymeleaf.org"
	xmlns:layout="http://www.ultraq.net.nz/web/thymeleaf/layout"
	layout:decorate="main">
  1. 使用标签
<a href="/user/add" th:href="@{/user/add}" shiro:hasPermission="用户添加">新增</a>

表示用户拥有 “用户添加” 权限则显示 “新增” 按钮

动态授权

在这里插入图片描述

在这里插入图片描述

#权限表
CREATE TABLE `sys_right` (
  `right_code` varchar(50) COLLATE utf8_unicode_ci NOT NULL,
  `right_parent_code` varchar(50) COLLATE utf8_unicode_ci DEFAULT NULL,
  `right_type` varchar(20) COLLATE utf8_unicode_ci DEFAULT NULL,
  `right_text` varchar(50) COLLATE utf8_unicode_ci DEFAULT NULL,
  `right_url` varchar(100) COLLATE utf8_unicode_ci DEFAULT NULL,
  `right_tip` varchar(50) COLLATE utf8_unicode_ci DEFAULT NULL,
  PRIMARY KEY (`right_code`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;

#角色权限关联表
CREATE TABLE `sys_role_right` (
  `rf_id` bigint(20) NOT NULL AUTO_INCREMENT,
  `rf_role_id` bigint(20) DEFAULT NULL,
  `rf_right_code` varchar(50) COLLATE utf8_unicode_ci DEFAULT NULL,
  PRIMARY KEY (`rf_id`),
  KEY `sys_role_right_ibfk_1` (`rf_right_code`),
  KEY `FK_sys_role_right` (`rf_role_id`),
  CONSTRAINT `FK_sys_role_right` FOREIGN KEY (`rf_role_id`) REFERENCES `sys_role` (`role_id`),
  CONSTRAINT `sys_role_right_ibfk_1` FOREIGN KEY (`rf_right_code`) REFERENCES `sys_right` (`right_code`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;

Right.java 实体类

import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import javax.persistence.*;
import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;

@Entity
@Table(name="sys_right")
@JsonIgnoreProperties(value = {"hibernateLazyInitializer","handler"})
public class Right implements Serializable {
	@Id
	@Column(name = "right_code")
	private String rightCode;
	@Column(name = "right_parent_code")
	private String rightParentCode;
	@Column(name = "right_type")
	private String rightType;
	@Column(name = "right_text")
	private String rightText;
	@Column(name = "right_url")
	private String rightUrl;
	@Column(name = "right_tip")
	private String rightTip;
	
	@ManyToMany(targetEntity = Role.class,mappedBy = "rights")
	@JsonIgnore
	private Set<Role> roles = new HashSet<Role>(0);
	}

修改 Role.java 实体类

@Entity
@Table(name = "sys_role")
@JsonIgnoreProperties(value = {"hibernateLazyInitializer","handler"})
public class Role implements Serializable {
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	@Column(name = "role_id")
	private Long roleId;
	@Column(name = "role_name")
	private String roleName;
	@Column(name = "role_desc")
	private String roleDesc;
	@Column(name = "role_flag")
	private Integer roleFlag;
	@OneToMany(targetEntity = User.class, fetch = FetchType.LAZY, cascade = {CascadeType.PERSIST, CascadeType.REMOVE}, mappedBy = "role")
	private Set<User> users = new HashSet<User>();
	
	//多对多
	@ManyToMany(targetEntity = Right.class,fetch = FetchType.EAGER)
	@JoinTable(name = "sys_role_right",joinColumns = {@JoinColumn(name = "rf_role_id")},inverseJoinColumns = {@JoinColumn(name = "rf_right_code")})
	@OrderBy(value = "rightCode")
	private Set<Right> rights = new HashSet<Right>(0);
	}

开发RightRepository

public interface RightRepository extends JpaRepository<Right,String> {
    public List<Right> findRightsByRolesOrderByRightCode(Role role);
}

调整 MyShiroRealm

public class MyShiroRealm extends AuthorizingRealm {//安全数据源

    @Resource
    private UserService userService;

    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        System.out.println("调用MyShiroRealm.doGetAuthorizationInfo获取权限信息!");
        //获得权限信息
        User user = (User) principalCollection.getPrimaryPrincipal();
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();

        //静态授权:授权主体(用户)相应的角色和权限
        /*info.addRole(user.getRole().getRoleName());
        info.addStringPermission("用户列表");//所有用户拥有用户列表权限
        if("管理员".equals(user.getRole().getRoleName())){//管理员拥有"增删改"权限
            info.addStringPermission("用户添加");
            info.addStringPermission("用户编辑");
            info.addStringPermission("用户删除");
        }*/

        //动态授权
        Role role = user.getRole();
        if(role!=null){
            info.addRole(user.getRole().getRoleName());
            Set<Right> rights = role.getRights();
            if(rights!=null && rights.size()>0){
                for (Right right :rights){
                    info.addStringPermission(right.getRightCode());
                }
            }
        }
        return info;
    }

    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        System.out.println("调用MyShiroRealm.doGetAuthenticationInfo获取身份信息!");
        //获得身份信息
        UsernamePasswordToken token = (UsernamePasswordToken)authenticationToken;
        String userName = token.getUsername();
        User user = userService.getUserByUserName(userName);
        if(user==null){
            throw new UnknownAccountException();//账号错误
        }
        if(user.getUserFlag()==null||user.getUserFlag().intValue()==0){
            throw new LockedAccountException();//账号锁定
        }
        SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(
                user,//身份(根据用户名查询数据库获得的用户)
                user.getUserPassword(),//凭证(查询数据库获得密码)
                getName()//Realm对象的名称
        );
        //返回身份信息
        return info;

    }

}

修改ShiroConfig

public class ShiroConfig {

    @Resource
    private RoleService roleService;

    @Bean
    public MyShiroRealm myShiroRealm(){//自定义Realm
        MyShiroRealm shiroRealm = new MyShiroRealm();
        return shiroRealm;
    }

    @Bean
    public SecurityManager securityManager(){//安全管理器SecurityManager
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        //注入Realm
        securityManager.setRealm(myShiroRealm());
        return securityManager;
    }

    @Bean
    public ShiroFilterFactoryBean shiroFilterFactory(SecurityManager securityManager){//Shiro过滤器:权限验证
        ShiroFilterFactoryBean shiroFilterFactory = new ShiroFilterFactoryBean();
        //注入SecurityManager
        shiroFilterFactory.setSecurityManager(securityManager);
        //权限验证:使用Filter控制资源(URL)的访问
        shiroFilterFactory.setLoginUrl("/login");
        shiroFilterFactory.setSuccessUrl("/main");
        shiroFilterFactory.setUnauthorizedUrl("/403");
        Map<String,String> filterChainDefinitionMap = new LinkedHashMap<String,String>();//必须使用LinkedHashMap(有序集合)
        //配置可以匿名访问的资源(URL): 静态资源
        filterChainDefinitionMap.put("/statics/css/**","anon");
        filterChainDefinitionMap.put("/statics/fonts/**","anon");
        filterChainDefinitionMap.put("/statics/images/**","anon");
        filterChainDefinitionMap.put("/statics/js/**","anon");
        filterChainDefinitionMap.put("/statics/localcss/**","anon");
        filterChainDefinitionMap.put("/statics/lcaljs/**","anon");

        filterChainDefinitionMap.put("/login","anon");
        filterChainDefinitionMap.put("/logout","logout");//注销过滤器,自动注销

        //配置需要特定权限才能访问的资源(URL)
        //静态授权:包括全部需要特定权限才能访问的资源(URL)
        /*filterChainDefinitionMap.put("/lists","perms[用户列表]");
        filterChainDefinitionMap.put("/adds","perms[用户添加]");
        filterChainDefinitionMap.put("/saves","perms[用户添加]");
        filterChainDefinitionMap.put("/modifys/**","perms[用户编辑]");
        filterChainDefinitionMap.put("/modifyss","perms[用户编辑]");
        filterChainDefinitionMap.put("/del","perms[用户删除]");*/

        //动态授权
        List<Right> rights = roleService.findAllRights();
        for (Right right : rights){
            if(right.getRightUrl()!=null && !right.getRightUrl().trim().equals("")){
                filterChainDefinitionMap.put(right.getRightUrl(),"perms["+right.getRightCode()+"]");
            }
        }

        //配置认证访问,其他资源(URL)必须认证通过才能访问
        filterChainDefinitionMap.put("/**","authc");//必须放在过滤器链的后面

        shiroFilterFactory.setFilterChainDefinitionMap(filterChainDefinitionMap);
        return shiroFilterFactory;
    }

}
小 柯
关注
专栏目录
Shiro 安全框架——验证与授权
热心网友
08-21 250
身份验证 身份验证，即在应用中谁能证明他就是他本人。一般提供如他们的身份 ID 一些标识信息来表明他就是他本人，如提供身份证，用户名 / 密码来证明。 在 shiro 中，用户需要提供 principals （身份）和 credentials（证明）给 shiro，从而应用能验证用户身份： principals：身份，即主体的标识属性，可以是任何东西，如用户名、邮箱等，唯一即可。一个主体可以...
Shiro授权（Authorization）
qq_49670207的博客
09-19 745
Shiro授权（Authorization）术语简介授权主体资源权限 术语简介 授权 授权，也叫访问控制，即在应用中控制谁能访问哪些资源（如访问页面/编辑数据/页面操作等）。在授权中需了解的几个关键对象：主体（Subject）、资源（Resource）、权限（Permission）、角色（Role）。 主体 主体，即访问应用的用户，在Shiro中使用Subject代表该用户，用户只有授权后才允许访问相应的资源。 资源 在应用中用户可以访问的任何东西，比如访问JSP页面、查看/编辑某些数据、访问某个业务方法、
Shiro学习笔记（3）——授权（Authorization）
热门推荐
君君的专栏
05-28 1万+
什么是授权 授权三要素 Shiro的三种授权方式 1 编码方式授权 2 基于注解的授权 3 JSP标签授权1.什么是授权授权，就是访问控制，控制某个用户在应用程序中是否有权限做某件事2.授权三要素 权限 请看Shiro学习笔记（1）——shiro入门中权限部分内容角色 通常代表一组行为或职责.这些行为演化为你在一个软件应用中能或者不能做的事情。角色通常是分配给用户帐户的，因此，通过分配，用户
详解Asp.Net Core管道模型中的五种过滤器的适用场景与用法
最新发布
dotnet研习社
08-29 1050
在 ASP.NET Core 中，过滤器是一种用于对请求管道进行前置或后置处理的组件。它们可以在请求处理的不同阶段干预和修改请求和响应，以实现一些通用的处理逻辑或功能增强。ASP.NET Core 的管道模型由多个中间件组成，而过滤器是这个模型中的一部分。它们可以在中间件之前或之后执行，并且可以应用于整个应用程序、控制器、动作方法或特定的路由。过滤器可以用于多种场景，例如添加身份验证、授权、缓存、异常处理等。本文我将介绍 .NET Core 中常用的几种 过滤器。
shiro学习26-shiro提供的filter-AuthorizationFilter类
iteye_14612的博客
02-19 628
这个抽象类也是继承自AccessControlFilter。他是用于处理登陆后的权限检查   他有一个属性unauthorizedUrl，表示如果没有对应的权限的话应该调到哪个页面。，这个可以不用配置，但是如果不配置的话默认为空，就会返回一个浏览器默认的401的页面。 看他的子类： ·HostFilter ·PermissionAuthorizationFilter ·PortFi...
Apache Shiro安全框架(3)-授权
一点点的积累
07-10 373
权限系统中的权限一般是通过用户、角色、权限来管理。每个用户可以对应多个角色；每个角色对应多个权限；每个权限标识一个资源。这样系统中的每个资源都可以通过这种方式来控制，一般情况下一个接口代表一个资源授权方式shiro有三种授权方式：编程式Subject subject = SecurityUtils.getSubject(); if(subject.hasRole("admin")) { /...
shiro 重写AuthorizationFilter 让shiro没有权限的时候不重定向，而是执行一个回显操作(初探)
qq_43077857的博客
07-08 6168
这里在项目需求完成的过程 以前没有权限直接跳转403.html 这样代码非常不灵活 而且前端如果不是html的页面没有权限经常跳不到403的页面 会报一个302的错误 我这里想重写下这个配置后直接跳转到403页面的方式 最好能够返回一段json 这样我前端直接判断json中的数据后前端做跳转到403页面 找了一下shiro中页面重定向的代码是这个AccessControlFilter中的onAc...
Apache Shiro 使用手册(三) Shiro授权
09-15
Apache Shiro 是一款强大的安全管理框架，它提供了身份验证（Authentication）、授权（Authorization）和会话管理（Session Management）等功能。本篇文章将详细讲解 Shiro 的授权机制，即如何控制用户在应用程序中...
shiro授权设计的两种思路
05-03
在Shiro授权设计中，主要存在两种思路，分别是基于角色的访问控制（Role-Based Access Control, RBAC）和基于权限的访问控制（Permission-Based Access Control）。这两种思路各有特点，适用于不同的应用场景。 **1...
shiro授权 shiro和企业项目整合开发
10-14
Shiro 的授权（Authorization）主要负责确定用户是否有权限执行某个操作。这通过角色（Role）和权限（Permission）来实现。角色是权限的集合，而权限则定义了用户可以做什么。例如，一个“管理员”角色可能包含了...
Shiro登录授权认证功能
09-26
Apache Shiro 是一个强大且易用的 Java 安全框架，它提供了身份验证（Authentication）、授权（Authorization）和会话管理（Session Management）等功能，简化了应用安全的开发。在这个项目中，我们主要关注的是...
shiro自定义权限过滤器
chengmi6360的博客
03-31 2404
1.创建一个类继承PermissionsAuthorizationFilter public class AiSellPermissionsAuthorizationFilter extends PermissionsAuthorizationFilter { @Overri...
SSM项目中自定义Shiro权限过滤器实现多个权限的或操作
YuFeng_12138的博客
06-02 952
我在做ssm+shiro的项目过程中的学习经验，记录一下。
shiro实战系列(六)之Authorization(授权)
weixin_34290096的博客
06-10 355
授权，又称作为访问控制，是对资源的访问管理的过程。换句话说，控制谁有权限在应用程序中做什么。 授权检查的例子是：该用户是否被允许访问这个网页，编辑此数据，查看此按钮，或打印到这台打印机？这些都是 决定哪些是用户能够访问的。 授权的要素: Apache Shiro 中的权限代表着安全政策中最基础的元素。它们从根本上作出了对行为的声明，并明...
Shiro笔记五：Shiro内置Filter过滤器
m0_54853420的博客
04-22 1109
Shiro笔记五：Shiro内置Filter过滤器 shiro内置的过滤器 核心过滤器类：DefaultFilter，配置哪个路径对应哪个拦截器进行处理。 authc：org.apache.shiro.web.filter.authc.FormAuthenticationFilter 需要认证登录才能访问 user：org.apache.shiro.web.filter.authc.UserFilter 用户拦截器，表示必须存在用户。 anon：org.apache.shiro.web.f
（五）设计模式之迭代器模式（Iterator）
卷心菜投手
11-21 224
前言： 参考图书：软件设计模式与体系结构 参考博客：https://www.cnblogs.com/wanson/articles/9277813.html   正题：         迭代器（iterator）有时又称游标（cursor）是程序设计的软件设计模式，可在容器（container，例如链表或阵列）上遍访的接口，设计人员无需关心容器的内容。 代码示例： 1 MyIt...
Spring Security安全框架---动态授权
qq_32923295的博客
04-19 520
上一篇文章说了spring security的认证登陆，这章说一下动态授权 在文章的代码基础下，新增sys_user_role表和sys_role表 CREATE TABLE `sys_user_role` ( `user_id` int(11) NOT NULL, `role_id` int(11) NOT NULL, PRIMARY KEY (`user_id`,`role_id`), KEY `fk_role_id` (`role_id`), CONSTRAINT `fk_r
shiro使用更改过滤拦截器的方法完成认证授权返回json格式信息
醉死梦红尘的博客
08-18 697
先介绍一下常用的拦截器 有关认证的拦截器： 拦截器名 默认拦截器类 说明 authc FormAuthenticationFilter 需要认证才可以访问–主要属性：loginUrl：登录的url，默认login.jsp，如果被这个过滤器拦截后，会重定向这个url，successUrl：登录成功后重定向的url user UserFilter 需要认证或记住我才可以访问 logout LogoutFilter 退出url主要属性：redirectUrl：退出后重定向的url，默认"/
小米用户画像实践与Shiro授权缓存管理
Shiro 的核心功能包括认证（Authentication）和授权（Authorization）。认证是指验证用户的身份，而授权则是确定已认证的用户可以访问哪些资源。在 Shiro 中，`AuthorizingRealm` 是实现这两个功能的关键类，它负责...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值