Shiro 学习笔记

最新推荐文章于 2024-09-26 12:42:43 发布
最新推荐文章于 2024-09-26 12:42:43 发布
阅读量179 收藏 1
点赞数
分类专栏： SpringBoot 文章标签： shiro java spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43989102/article/details/119216099
版权

Shiro

1、什么是Shiro?

  • Apache Shiro 是一个功能强大且易于使用的 Java 安全（权限）框架。
  • Apache Shiro 可以完成认证、授权、加密、会话管理、Web 集成、缓存等。
  • Apache Shiro 有易于理解的 API，可以快速轻松地保护任何应用程序, 其不仅可以用在 JavaSE 环境，也可以用在 JavaEE 环境。
  • 下载地址：http://shiro.apache.org/index.html

2、Shiro有什么功能？

img

  • Authentication：身份认证 / 登录，验证用户是不是拥有相应的身份；
  • Authorization：授权，即权限验证，验证某个已认证的用户是否拥有某个权限；即判断用户是否能做事情，常见的如：验证某个用户是否拥有某个角色。
  • Session Management：会话管理，即用户登录后就是一次会话，在没退出之前，它的所有信息都在会话中；会话可以是JavaSE环境，也可以是Web 环境。
  • Cryptography：加密，保护数据的安全性，如密码加密存储到数据库，而不是明文存储；
  • Web Support：Web 支持，可以非常容易的集成到 Web 环境；
  • Caching：缓存，比如用户登录后，其用户信息、拥有的角色 / 权限不必每次去查，这样可以提高效率；
  • Concurrency：shiro 支持多线程应用的并发验证，即如在一个线程中开启另一个线程，能把权限自动传播过去；
  • Testing：提供测试支持；
  • Run As：允许一个用户假装为另一个用户（如果他们允许）的身份进行访问；
  • Remember Me：记住我，这个是非常常见的功能，即一次登录后，下次再来的话不用登录了。

3、Shiro的外部架构

img

  • Subject：主体，代表了当前 “用户”，这个用户不一定是一个具体的人，与当前应用交互的任何东西都是 Subject，如网络爬虫，机器人等；即一个抽象概念；所有 Subject 都绑定到 SecurityManager，与 Subject 的所有交互都会委托给 SecurityManager；可以把 Subject 认为是一个门面；SecurityManager 才是实际的执行者；

  • SecurityManager：安全管理器；即所有与安全有关的操作都会与 SecurityManager 交互；且它管理着所有 Subject；可以看出它是 Shiro 的核心，它负责与后边介绍的其他组件进行交互，如果学习过 SpringMVC，你可以把它看成 DispatcherServlet 前端控制器；

  • Realm：域，Shiro 从 Realm 获取安全数据（如用户、角色、权限），就是说 SecurityManager 要验证用户身份，那么它需要从 Realm 获取相应的用户进行比较以确定用户身份是否合法；也需要从 Realm 得到用户相应的角色 / 权限进行验证用户是否能进行操作；可以把 Realm 看成 DataSource，即安全数据源。

4、Shiro的内部框架

img

  • Subject：主体，可以看到主体可以是任何可以与应用交互的 “用户”；
  • SecurityManager：相当于 SpringMVC 中的 DispatcherServlet 或者 Struts2 中的 FilterDispatcher；是 Shiro 的心脏；所有具体的交互都通过 SecurityManager 进行控制；它管理着所有 Subject、且负责进行认证和授权、及会话、缓存的管理。
  • Authenticator：认证器，负责主体认证的，这是一个扩展点，如果用户觉得 Shiro 默认的不好，可以自定义实现；其需要认证策略（Authentication Strategy），即什么情况下算用户认证通过了；
  • Authorizer：授权器，或者访问控制器，用来决定主体是否有权限进行相应的操作；即控制着用户能访问应用中的哪些功能；
  • Realm：可以有 1 个或多个 Realm，可以认为是安全实体数据源，即用于获取安全实体的；可以是 JDBC 实现，也可以是 LDAP 实现，或者内存实现等等；由用户提供；注意：Shiro 不知道你的用户 / 权限存储在哪及以何种格式存储；所以我们一般在应用中都需要实现自己的 Realm；
  • SessionManager：如果写过 Servlet 就应该知道 Session 的概念，Session 呢需要有人去管理它的生命周期，这个组件就是 SessionManager；而 Shiro 并不仅仅可以用在 Web 环境，也可以用在如普通的 JavaSE 环境、EJB 等环境；所以呢，Shiro 就抽象了一个自己的 Session 来管理主体与应用之间交互的数据；这样的话，比如我们在 Web 环境用，刚开始是一台 Web 服务器；接着又上了台 EJB 服务器；这时想把两台服务器的会话数据放到一个地方，这个时候就可以实现自己的分布式会话（如把数据放到 Memcached 服务器）；
  • SessionDAO：DAO 大家都用过，数据访问对象，用于会话的 CRUD，比如我们想把 Session 保存到数据库，那么可以实现自己的 SessionDAO，通过如 JDBC 写到数据库；比如想把 Session 放到 Memcached 中，可以实现自己的 Memcached SessionDAO；另外 SessionDAO 中可以使用 Cache 进行缓存，以提高性能；
  • CacheManager：缓存控制器，来管理如用户、角色、权限等的缓存的；因为这些数据基本上很少去改变，放到缓存中后可以提高访问的性能
  • Cryptography：密码模块，Shiro 提供了一些常见的加密组件用于如密码加密 / 解密的。

以上资料查阅w3cschool

5、快速开始

官网10分钟快速入门： http://shiro.apache.org/10-minute-tutorial.html

快速开始GitHub案例：https://github.com/apache/shiro/tree/main/samples/quickstart

1、 创建maven项目

在这里插入图片描述

2、快速开始案例代码

pom.xml

<!-- https://mvnrepository.com/artifact/org.apache.shiro/shiro-core -->
<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-core</artifactId>
    <version>1.4.1</version>
</dependency>
<!-- configure logging -->
<!-- https://mvnrepository.com/artifact/org.slf4j/jcl-over-slf4j -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>jcl-over-slf4j</artifactId>
    <version>1.7.30</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-log4j12 -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>1.7.30</version>
</dependency>
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

log4j.properties

log4j.rootLogger=INFO, stdout

log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m %n

# General Apache libraries
log4j.logger.org.apache=WARN

# Spring
log4j.logger.org.springframework=WARN

# Default Shiro logging
log4j.logger.org.apache.shiro=INFO

# Disable verbose logging
log4j.logger.org.apache.shiro.util.ThreadContext=WARN
log4j.logger.org.apache.shiro.cache.ehcache.EhCache=WARN

shiro.ini

[users]
# user 'root' with password 'secret' and the 'admin' role
root = secret, admin
# user 'guest' with the password 'guest' and the 'guest' role
guest = guest, guest
# user 'presidentskroob' with password '12345' ("That's the same combination on
# my luggage!!!" ;)), and role 'president'
presidentskroob = 12345, president
# user 'darkhelmet' with password 'ludicrousspeed' and roles 'darklord' and 'schwartz'
darkhelmet = ludicrousspeed, darklord, schwartz
# user 'lonestarr' with password 'vespa' and roles 'goodguy' and 'schwartz'
lonestarr = vespa, goodguy, schwartz

# -----------------------------------------------------------------------------
# Roles with assigned permissions
#
# Each line conforms to the format defined in the
# org.apache.shiro.realm.text.TextConfigurationRealm#setRoleDefinitions JavaDoc
# -----------------------------------------------------------------------------
[roles]
# 'admin' role has all permissions, indicated by the wildcard '*'
admin = *
# The 'schwartz' role can do anything (*) with any lightsaber:
schwartz = lightsaber:*
# The 'goodguy' role is allowed to 'drive' (action) the winnebago (type) with
# license plate 'eagle5' (instance specific id)
goodguy = winnebago:drive:eagle5

Quickstart.java

/**
 * Simple Quickstart application showing how to use Shiro's API.
 * @since 0.9 RC2
 */
public class Quickstart {

    private static final transient Logger log = LoggerFactory.getLogger(Quickstart.class);


    public static void main(String[] args) {

        Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro.ini");
        SecurityManager securityManager = factory.getInstance();
        SecurityUtils.setSecurityManager(securityManager);

        // Now that a simple Shiro environment is set up, let's see what you can do:
        // 获取当前的用户对象： Subject
        Subject currentUser = SecurityUtils.getSubject();

        // 通过当前用户拿到 Session
        Session session = currentUser.getSession();
        session.setAttribute("someKey", "aValue");              // session 设置值
        String value = (String) session.getAttribute("someKey");     // 获取 session 值
        if (value.equals("aValue")) {
            log.info("Retrieved the correct value! [" + value + "]");
        }

        // 判断当前用户是否被认证
        if (!currentUser.isAuthenticated()) {
            // Token: 令牌
            UsernamePasswordToken token = new UsernamePasswordToken("lonestarr", "vespa");
            token.setRememberMe(true);      // 设置记住我
            try {
                currentUser.login(token);   // 执行了登录操作
            } catch (UnknownAccountException uae) {     // 用户不存在
                log.info("There is no user with username of " + token.getPrincipal());
            } catch ( ) {   // 密码错误
                log.info("Password for account " + token.getPrincipal() + " was incorrect!");
            } catch (LockedAccountException lae) {      // 用户被锁定
                log.info("The account for username " + token.getPrincipal() + " is locked.  " +
                        "Please contact your administrator to unlock it.");
            }
            // ... catch more exceptions here (maybe custom ones specific to your application?
            catch (AuthenticationException ae) {    // 认证异常
                //unexpected condition?  error?
            }
        }

        //say who they are:
        //print their identifying principal (in this case, a username):
        log.info("User [" + currentUser.getPrincipal() + "] logged in successfully.");

        //test a role:
        if (currentUser.hasRole("schwartz")) {
            log.info("May the Schwartz be with you!");
        } else {
            log.info("Hello, mere mortal.");
        }

        // 粗粒度
        //test a typed permission (not instance-level)
        if (currentUser.isPermitted("lightsaber:wield")) {
            log.info("You may use a lightsaber ring.  Use it wisely.");
        } else {
            log.info("Sorry, lightsaber rings are for schwartz masters only.");
        }

        // 细粒度
        //a (very powerful) Instance Level permission:
        if (currentUser.isPermitted("winnebago:drive:eagle5")) {
            log.info("You are permitted to 'drive' the winnebago with license plate (id) 'eagle5'.  " +
                    "Here are the keys - have fun!");
        } else {
            log.info("Sorry, you aren't allowed to drive the 'eagle5' winnebago!");
        }

        // 注销
        //all done - log out!
        currentUser.logout();

        System.exit(0);
    }
}
3、总结
Subject currentUser = SecurityUtils.getSubject(); 	// 获取当前的用户对象： Subject
Session session = currentUser.getSession();  		// 通过当前用户拿到 Session
currentUser.isAuthenticated();						// 判断当前用户是否被认证
currentUser.getPrincipal();							// 获得当前用户的认证
currentUser.hasRole("schwartz");					// 获得用户所拥有的角色
currentUser.isPermitted("lightsaber:wield");		// 获得当前用户的权限
currentUser.logout();								// 注销

6、SpringBoot 整合 Shiro 环境搭建

1、新建 SpringBoot 项目勾选 spring web依赖, 写个首页和controller测试项目
@Controller
public class MyController {

    @RequestMapping({"/", "/index"})
    public String toIndex(Model model){
        model.addAttribute("msg", "Hello Shiro");
        return "index";
    }
}

templates/index.html

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <h1>首页</h1>
    <p th:text="${msg}"></p>
</body>
</html>

启动并测试

2、导入 jar 包
<!--
    Subject:  用户
    SecurityManager：  管理所有用户
    Realm:  连数据库
-->

<!-- shrio 整合 springboot 的包  -->
<!-- https://mvnrepository.com/artifact/org.apache.shiro/shiro-spring -->
<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-spring</artifactId>
    <version>1.7.1</version>
</dependency>
3、新建config包编写 ShiroConfig类 和 UserRealm类
// 自定义的 UserRealm   extends AuthorizingRealm
public class UserRealm extends AuthorizingRealm {
    // 授权
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        System.out.println("执行了=>授权 doGetAuthorizationInfo");
        return null;
    }
    // 认证
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        System.out.println("执行了=>认证 doGetAuthenticationInfo");
        return null;
    }
}

@Configuration
public class ShiroConfig {

    // ShiroFilterFactoryBean  第三步
    @Bean
    public ShiroFilterFactoryBean getShiroFilterFactoryBean(@Qualifier("securityManager") DefaultWebSecurityManager securityManager){
        ShiroFilterFactoryBean filterFactoryBean = new ShiroFilterFactoryBean();
        // 设置安全管理器
        filterFactoryBean.setSecurityManager(securityManager);
        return filterFactoryBean;
    }

    // DefaultWebSecurityManager  第二步
    @Bean(name = "securityManager")
    public DefaultWebSecurityManager getDefaultWebSecurityManager(@Qualifier("userRealm") UserRealm userRealm){
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        // 关联 UserRealm
        securityManager.setRealm(userRealm);
        return securityManager;
    }

    // 创建 realm 对象，需要自定义类  第一步
    @Bean
    public UserRealm userRealm(){
        return new UserRealm();
    }
}
7、编写测试界面

新建 templates/user/add.html 和 templates/user/update.html

编写 controller

@RequestMapping("/user/add")
public String add(){
return "user/add";
}

@RequestMapping("/user/update")
public String update(){
return "user/update";
}

编写主页连接

<a th:href="@{/user/add}">add</a>
<a th:href="@{/user/update}">update</a>

7、shiro实现登录拦截

在 /config/ShiroConfig.java 中编写配置

// ShiroFilterFactoryBean  第三步
@Bean
public ShiroFilterFactoryBean getShiroFilterFactoryBean(@Qualifier("securityManager") DefaultWebSecurityManager securityManager){
    ShiroFilterFactoryBean filterFactoryBean = new ShiroFilterFactoryBean();
    // 设置安全管理器
    filterFactoryBean.setSecurityManager(securityManager);
    // 添加shiro的内置过滤器
    /*
     * anon: 无需认证就能访问
     * authc: 必须认证的才能访问
     * user: 必须拥有 记住我 功能才能用
     * perms: 拥有对某个资源的权限才能访问
     * role: 拥有某个角色权限才能访问
     * */
    // 拦截
    Map<String, String> filterMap = new LinkedHashMap<>();
    //filterMap.put("/user/add", "authc");
    //filterMap.put("/user/update", "authc");
    filterMap.put("/user/*", "authc");
    filterFactoryBean.setFilterChainDefinitionMap(filterMap);

    // 设置登录的请求
    filterFactoryBean.setLoginUrl("/toLogin");

    return filterFactoryBean;
}

编写登录界面 和 controller

templates/login.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <h1>登录</h1>
    <hr>
    <form action="">
        <p>用户名： <input type="text" name="username"></p>
        <p>密码： <input type="password" name="password"></p>
        <p><input type="submit"></p>
    </form>
</body>
</html>

@RequestMapping("toLogin")
public String toLogin(){
    return "login";
}

测试是否能够跳转到登录界面。

8、shiro实现用户认证

编写登录的接口

@RequestMapping("/login")
public String login(String username, String password, Model model){
    // 获取当前用户
    Subject subject = SecurityUtils.getSubject();
    // 封装用户的登录数据
    UsernamePasswordToken token = new UsernamePasswordToken(username, password);

    try{
        subject.login(token);   // 执行登录的方法，如果没有异常就可以了    ps:==> 会去执行 Realm 中继承的认证方法
        return "index";
    }catch (UnknownAccountException uae){   // 用户名不存在
        model.addAttribute("msg", "用户名不存在");
        return "login";
    }catch (IncorrectCredentialsException ice){  // 密码错误
        model.addAttribute("msg", "密码错误");
        return "login";
    }
}

登录界面信息显示

<p th:text="${msg}" style="color: red"></p>
<form th:action="@{/login}">
    ...

/config/UserRealm.java 实现登录认证

// 认证
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
    System.out.println("执行了=>认证 doGetAuthenticationInfo");

    // 用户名，密码~~   数据库中取
    String username = "root";
    String password = "123456";

    UsernamePasswordToken userToken = (UsernamePasswordToken) authenticationToken;
    if (!userToken.getUsername().equals(username)){
        return null;    // 抛出异常， UnknownAccountException
    }

    // 密码认证， shiro 本身去做
    return new SimpleAuthenticationInfo("", password,"");
}

运行测试

9、shiro整合Mybatis

导入 jar 包

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.2.6</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.mybatis.spring.boot/mybatis-spring-boot-starter -->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.1.4</version>
</dependency>

配置 src/main/resources/application.yml 文件

spring:
  datasource:
    username: root
    password:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai

    # SpringBoot 默认是不注入这些的，需要自己绑定
    # druid 数据源专有配置
    initialSize: 5
    minIdle: 5
    maxActive: 20
    maxWait: 60000
    timeBetweenEvictionRunsMillis: 60000
    minEvictableIdleTimeMillis: 300000
    validationQuery: SELECT 1 FROM DUAL
    testWhileIdle: true
    testOnBorrow: false
    testOnReturn: false
    poolPreparedStatements: true

    # 配置监控统计拦截的filters，stat：监控统计、log4j：日志记录、wall：防御sql注入
    # 如果允许报错，java.lang.ClassNotFoundException: org.apache.Log4j.Properity
    # 则导入log4j 依赖就行
    filters: stat,wall,log4j
    maxPoolPreparedStatementPerConnectionSize: 20
    useGlobalDataSourceStat: true
    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500

配置 src/main/resources/application.properties 文件 绑定 Mybatis

# 整合 MyBatis
# Mybatis 的别名配置
mybatis.type-aliases-package=com.example.pojo
# Mapper 的地址配置 classpath: 指的是 resource
mybatis.mapper-locations=classpath:mapper/*.xml

创建测试代码进行测试，创建 /mapper/UserMapper.java， /pojo/User.java，/service/UserService，/service/UserServiceImpl.java，src/main/resources/mapper/UserMapper.xml，编写相应代码，查出数据库中的数据。

mapper.xml头部：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- namespace 定义一个对应的 Dao/Mapper 接口 -->
<mapper namespace="com.example.mapper.UserMapper">

</mapper>

数据库：

create table `user` (
	`id` int (20),
	`name` varchar (90),
	`pwd` varchar (90),
	`perms` varchar (300)		## 10、节才添加的 用户授权的字段
);

测试代码：https://github.com/becauseoflife/SpringBoot_StudyCode/tree/master/springboot-07-shiro/springboot-shrio

这样就可从数据库中获取用户了，实现登录的认证了。

// 自定义的 UserRealm   extends AuthorizingRealm
public class UserRealm extends AuthorizingRealm {
    @Autowired
    UserService userService;
    // 认证
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        System.out.println("执行了=>认证 doGetAuthenticationInfo");
        UsernamePasswordToken userToken = (UsernamePasswordToken) authenticationToken;
        // 连接真实的数据库
        User user = userService.queryUserByName(userToken.getUsername());
        if (user == null){
            return null;    // 抛出异常， UnknownAccountException
        }
        // 密码认证， shiro 本身去做
        return new SimpleAuthenticationInfo("", user.getPwd(),"");
    }
}

10、shiro请求授权实现

1、初体验

@Configuration
public class ShiroConfig {
...
     // 授权,正常的情况下，没有授权会跳转到授权的界面
    filterMap.put("/user/add", "perms[user:add]");

    filterMap.put("/user/*", "authc");
    filterFactoryBean.setFilterChainDefinitionMap(filterMap);

    // 设置未授权界面
    filterFactoryBean.setUnauthorizedUrl("/noauth");
 ...
}

controller:
{
    @RequestMapping("/noauth")
    @ResponseBody
    public String unauthorized(){
        return "未经授权无法访问此页面";
    }
}

UserRealm:
// 授权
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
    System.out.println("执行了=>授权 doGetAuthorizationInfo");

    SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
    info.addStringPermission("user:add");

    return info;
}

2、授权

数据库添加 perms 字段，存储授权信息。

// 授权
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
    System.out.println("执行了=>授权 doGetAuthorizationInfo");

    SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();

    // 拿到当前登录的这个对象
    Subject subject = SecurityUtils.getSubject();
    // 拿到 User 对象，在认证中 返回的 SimpleAuthenticationInfo 的由第一个参数传入的
    User currentUser = (User) subject.getPrincipal();

    // 设置当前用户的权限
    info.addStringPermission(currentUser.getPerms());

    return info;
}

11、shiro整合Thymeleaf

导入整合包

<!-- shiro和Thymeleaf整合包 -->
<!-- https://mvnrepository.com/artifact/com.github.theborakompanioni/thymeleaf-extras-shiro -->
<dependency>
    <groupId>com.github.theborakompanioni</groupId>
    <artifactId>thymeleaf-extras-shiro</artifactId>
    <version>2.0.0</version>
</dependency>

进行配置

// 整合 ShiroDialect ： 用来整合 shiro thymeleaf
@Bean
public ShiroDialect shiroDialect(){
    return new ShiroDialect();
}

使用

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org" xmlns:shiro="http://www.pollix.at/thymeleaf/shiro">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <h1>首页</h1>
    <p th:text="${msg}"></p>
    <hr>
    <div shiro:notAuthenticated="">
        <a th:href="@{/toLogin}">登录</a>
    </div>
    <div shiro:hasPermission="user:add">
        <a th:href="@{/user/add}">add</a>
    </div>
    <div shiro:hasPermission="user:update">
        <a th:href="@{/user/update}">update</a>
    </div>
</body>
</html>

进行测试。

稻草人0.0
关注
专栏目录
Shiro
m0_50988781的博客
12-06 3084
shiro
shiro学习笔记
04-03
这份"Shiro学习笔记"可能包含了以下主题： - Shiro的安装与配置 - Shiro基本概念详解 - Realm的创建与使用 - 登录与登出流程 - 权限控制机制 - 缓存管理和会话管理 - Shiro与Spring的整合 - Shiro的Filter链配置 - ...
Shiro的SecurityUtils.getSubject()是如何获取到正确的用户信息
qq_61592687的博客
02-09 3004
Shiro的SecurityUtils.getSubject()是如何获取到正确的用户信息的呢？每次调用SecurityUtils.getSubject()方法，它会去当前所处线程获取用户信息，组装subject返回。如果是没有登录过的，他就会为当前访问的JSESSIONID创建一个subject，只是这个的就是未登录状态。
shiro 在未登录时候获取 SecurityUtils.getSubject() 异常
最新发布
冬阳
09-26 1032
No SecurityManager accessible to the calling code, either bound to the org.apache.shiro.util.ThreadContext or as a vm static singleton. This is an invalid application configuration. shiro 报异常处理方案，以及自定义404 错误页面
【Shiro】Shiro从小白到大神(三)-权限认证(授权)
weixin_34311757的博客
09-22 606
本节讲权限认证，也就是授权 基于角色的访问控制和基于权限的访问控制的小实例 以及注解式授权和JSP标签授权详解 权限认证 权限认证核心要素 权限认证，也就是访问控制，即在应用中控制谁能访问哪些资源 在权限认证中，最核心的三个要素是：权限，角色和用户 (资源也算一个要素，但不是最核心的) 权限，即操作资源的 ...
shiro详解-shiro史上最全学习笔记
m0_55613022的博客
04-08 1679
1.shiro简介 1.1.基本功能点 Shiro 可以非常容易的开发出足够好的应用，其不仅可以用在 JavaSE 环境，也可以用在 JavaEE 环境。Shiro 可以帮助我们完成：认证、授权、加密、会话管理、与 Web 集成、缓存等。其基本功能点如下图所示： Authentication：身份认证 / 登录，验证用户是不是拥有相应的身份； Authorization：授权，即权限验证，验证某个已认证的用户是否拥有某个权限；即判断用户是否能做事情，常见的如：验证某个用户是否拥有某个角色。或者细粒度的验
使用shiro中 工具类方法SecurityUtils.getSubject()和方法subject.getPrincipal()获取当前登录用户
weixin_52654493的博客
12-17 2431
Shiro内置了可以连接大量安全数据源（又名目录）的Realm，如LDAP、关系数据库（JDBC）、类似INI的文本配置资源以及属性文件等。如果系统默认的Realm不能满足需求，你还可以插入代表自定义数据源的自己的Realm实现。它是Shiro框架的核心，典型的Facade模式，Shiro通过SecurityManager来管理内部组件实例，并通过它来提供安全管理的各种服务。也就是说，当对用户执行认证（登录）和授权（访问控制）验证时，Shiro会从应用配置的Realm中查找用户及其权限信息。
shiro学习笔记.rar
10-06
本学习笔记主要涵盖了如何在Spring Boot项目中整合Shiro，并实现用户认证和授权，以及图片验证码的实现。 **1. Shiro 概述** Shiro 的核心组件包括 Realm（域）、Subject（当前操作用户）、Session Manager（会话...
shiro学习笔记0.0.0.0
12-21
尽管这份"shiro学习笔记0.0.0.0"可能内容不多，但通过它，你可以对 Shiro 有个初步的认识，为进一步深入学习打下基础。在实际项目中，根据需求选择合适的 Shiro 组件和配置，可以有效地提升应用的安全性。
shiro学习笔记（四次课，从入门到案例）
06-15
Shiro01-概念、入门、认证的基本使用； Shiro02-认证加密，授权； Shiro03-SpringBoot集成、注册、登录； Shiro04-SpringBoot授权，Shiro注解、Shiro标签
Shiro 权限框架使用总结
guoyiqi
10-17 428
我们首先了解下什么是shiro ，Shiro 是 JAVA 世界中新近出现的权限框架，较之 JAAS 和 Spring Security，Shiro 在保持强大功能的同时，还在简单性和灵活性方面拥有巨大优势 Shiro 是一个强大而灵活的开源安全框架，能够非常清晰的处理认证、授权、管理会话以及密码加密。如下是它所具有的特点： 易于理解的 Java Security API； 简单...
shiro SecurityUtils.getSubject()深度分析
08-10 1919
1.总的来说，SecurityUtils.getSubject()是每个请求创建一个Subject, 并保存到ThreadContext的resources（ThreadLocal<Map<Object, Object>>）变量中，也就是一个http请求一个subject,并绑定到当前线程。 问题来了：.subject.login()登陆认证成功后，下一次请求如何知道是那个用户的请求呢？ 友情提示:本文唯一可以读一下的就是分析这个疑问，如果你已经明白就不用往下看了。 首先给出内...
shiro框架了解
ABestRookie的博客
06-28 466
shiro框架
shiro-授权
crazy_tong的博客
12-02 243
一，shiro 三种授权方式 1.编程式授权 Subject subject = SecurityUtils.getSubject();  if(subject.hasRole(“admin”)) {  //有权限  } else {  //无权限  } 2.注解式 @RequiresRoles("admin")  public void hello() {  //有权限 
SecurityUtils.getSubject().getPrincipal() 为null
坤哥的博客
08-23 5万+
使用shiro时，如果正常登陆（执行subject.login(token)成功）就能在全局通过SecurityUtils.getSubject().getPrincipal()获取用户信息。 之前的项目是OK的，新项目中突然出问题。现在给出我自己问题的解决方案。 shiro的配置中有个use-prefix选项，其配置有两点需要注意： 要在配置文件的最上边（或者相关属性的最前边）； 一定要...
shiro简单配置
热门推荐
都是浮云
04-20 13万+
注：这里只介绍spring配置模式。 因为官方例子虽然中有更加简洁的ini配置形式，但是使用ini配置无法与spring整合。而且两种配置方法一样，只是格式不一样。 涉及的jar包 Jar包名称 版本 核心包shiro-core 1.2.0 Web相关包shiro-web 1.2.0
第三章 授权（一）访问控制
yifanSJ的博客
08-16 2156
一、简介 授权，也叫访问控制，即在应用中控制谁能访问哪些资源（如访问页面/编辑数据/页面操作），其中包括如下对象： 1. 主体 即访问应用的用户，在Shiro中使用Subject代表该用户。用户只有在授权权后才允许访问相应的资源。 2. 资源 在应用中用户可以访问的任何东西，比如访问JSP 页面、查看/编辑某些数据、访问某个业务方法、打印文本等等都是资源。用户只要授权后才能访问。
shiro的权限认证
lqzxpp的博客
01-23 377
用了shiro很长时间了,经常在controller的某个方法前加上注解: @RequiresPermissions("xx:xx")，就可以试用shiro的权限认证。 现在想研究下spring是如何调用这个过程的. 1、 public class AopAllianceAnnotationsAuthorizingMethodInterceptor extends Anno...
SecurityUtils.getSubject().getPrincipal()为null
m0_37635053的博客
10-30 1万+
我在项目中获取getUserId(),和getUserName()获取不到值。 他们都是通过SecurityUtils.getSubject().getPrincipal()去获取的。 反复测试发现原因是 ：在shiroConfig里面： 该方法，注意（是该接口名）被写为anon,不通过验证，即： filterMap.put("/druid/**", “anon”); 这种写法是为了postman...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值