Shiro实战Demo

最新推荐文章于 2024-05-17 08:58:37 发布
最新推荐文章于 2024-05-17 08:58:37 发布
阅读量564 收藏
点赞数
分类专栏： Java 文章标签： shiro redis java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37296487/article/details/109711332
版权

Shiro 使用

hello shiro

  1. 首先创建Maven项目并引入最新的shiro依赖

            <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-core</artifactId>
            <version>1.7.0</version>
        </dependency>

  2. 在项目的resources目录下新建shiro.ini文件，并在文件中配置用户名和密码

    [users]
zhangsan=123

  3. 在src目录下新建类HelloShiro

    public class HelloShiro {

    public static void main(String[] args) {

        // 1.创建默认的SecurityManager管理器
        DefaultSecurityManager defaultSecurityManager = new DefaultSecurityManager();

        // 2. 加载Realm
        defaultSecurityManager.setRealm(new IniRealm("classpath:shiro.ini"));

        // 3. 将SecurityManager交给SecurityUtils管理
        SecurityUtils.setSecurityManager(defaultSecurityManager);

        // 4. 获取认证授权主体
        Subject subject = SecurityUtils.getSubject();

        // 5. 创建具有用户名和密码的认证授权token
        UsernamePasswordToken token = new UsernamePasswordToken("zhangsan", "123");

        try {
            // 6. 进行登录，如果登录失败则会进入异常
            subject.login(token);
            System.out.println("是否登录成功：" + subject.isAuthenticated());
        } catch (UnknownAccountException e) {
            System.out.println("帐号错误");
            e.printStackTrace();
        } catch (IncorrectCredentialsException e) {
            System.out.println("密码错误");
            e.printStackTrace();
        }

    }
}

Hello Shiro的登录流程查看

shiro登录认证过程讲解

自定义Realm实现认证授权

自定义Realm实现认证

  1. Maven引入shiro依赖

  2. 自定义CustomRealm类并继承AuthorizingRealm抽象类

    public class CustomRealm extends AuthorizingRealm {
    
    // 授权
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        return null;
    }

    // 认证
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {

        // 获取认证帐号
        String username = (String) token.getPrincipal();
        
        // 其中“zhangsan”和“123”是从数据库中查出来的（这里省略了数据库查询操作）
        if (username != null && username.equals("zhangsan")) {
            return new SimpleAuthenticationInfo("zhangsan", "123", this.getName())''
        }

        return null;
    }
}

  3. 新建类进行登录，验证自定义的Realm。在该类中因为是自定义的Realm，所以在SecurityManager加载Realm与HelloShiro有所不同， 具体如下：

    public class ConstomRealmAuthentication {
    public static void main(String[] args) {
        DefaultSecurityManager defaultSecurityManager = new DefaultSecurityManager();

        // 这里直接加载自定义的Realm
        defaultSecurityManager.setRealm(new CustomRealm());

        SecurityUtils.setSecurityManager(defaultSecurityManager);

        Subject subject = SecurityUtils.getSubject();

        try {
            subject.login(new UsernamePasswordToken("zhangsan", "123"));
            System.out.println("登录是否成功：" + subject.isAuthenticated());
        } catch (UnknownAccountException e) {
            System.out.println("账户错误");
            e.printStackTrace();
        } catch (IncorrectCredentialsException e) {
            System.out.println("密码错误");
            e.printStackTrace();
        }
    }
}

自定义Realm实现授权

步骤大体与自定义Realm认证相同，只不过授权需要更改CustomRealm类中的doGetAuthorizationInfo的方法。其自定义Realm类如下：

public class CustomRealm extends AuthorizingRealm {

    // 授权
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {

        // 获取登录名
        String username = (String) principals.getPrimaryPrincipal();

        // 这里的admin，user：update：01, order：*:*，字符串假设是从数剧库中查到的
        if (username.equals("zhangsan")) {
            SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
            info.addRole("admin");
            info.addStringPermission("user:update:01");
            info.addStringPermission("order:*:*");
            return info;
        }
        return null;
    }

    // 认证
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {

        String username = (String) token.getPrincipal();

        if (username != null && username.equals("zhangsan")) {
            return new SimpleAuthenticationInfo("zhangsan", "123", this.getName());
        }

        return null;
    }
}

其中对用户角色和权限的验证代码如下：

try {
	 subject.login(new UsernamePasswordToken("zhangsan", "123"));
     System.out.println("登录是否成功：" + subject.isAuthenticated());

     boolean admin = subject.hasRole("admin");
     System.out.println("用户具有admin角色：" + admin);

     boolean permitted = subject.isPermitted("user:update:01");
     System.out.println("用户具有对user模块的01实例进行update的权限：" + permitted);

     boolean permitted1 = subject.isPermitted("order:update:*");
     System.out.println("用户具有对order模块的所有实例进行update权限：" + permitted1);

 } catch (UnknownAccountException e) {
     System.out.println("账户错误");
     e.printStackTrace();
 } catch (IncorrectCredentialsException e) {
     System.out.println("密码错误");
     e.printStackTrace();
 }

在权限中使用user:update:01是资源通配符，其规则是 资源标识符：操作：对象实例 ID ，表示为可对那个资源的那个实例进行什么操作。

加密

  1. 首先通过shiro中的Md5Hash类来加密，模拟从数据库中取出的已经加密的密码

    // 原密码：123456, salt：7G&;-，散列次数：1024
Md5Hash ceshi = new Md5Hash("123456", "7G&;-", 1024);
System.out.println(ceshi.toHex()); // output：1e923b90f26d3078e0c6611427d1ace9

  2. 如果要实现加密认证，首先更改原本的自定义Realm中的认证方法

        // 认证
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {

        String username = (String) token.getPrincipal();
        
        if (username != null && username.equals("zhangsan")) {
            
            // 这里的密码和salt是直接从数据库中查出来的
            return new SimpleAuthenticationInfo("zhangsan", 
                    "1e923b90f26d3078e0c6611427d1ace9", 
                    ByteSource.Util.bytes("ceshi"), this.getName());
        }

        return null;
    }

  3. 然后更改认证的类，在自定义realm中设置相应的密码匹配器

    DefaultSecurityManager defaultSecurityManager = new DefaultSecurityManager();

CustomRealm realm = new CustomRealm();

// 这里设置认证凭证匹配器
HashedCredentialsMatcher credentialsMatcher = new HashedCredentialsMatcher();
// 设置加密方式
credentialsMatcher.setHashAlgorithmName("md5");
// 设置散列次数
credentialsMatcher.setHashIterations(1024);
realm.setCredentialsMatcher(credentialsMatcher);

defaultSecurityManager.setRealm(realm);

SecurityUtils.setSecurityManager(defaultSecurityManager);

Subject subject = SecurityUtils.getSubject();

try {
    UsernamePasswordToken zhangsan = new UsernamePasswordToken("zhangsan", "123456");
    subject.login(zhangsan);
    System.out.println("登录是否成功：" + subject.isAuthenticated());
} catch (UnknownAccountException e) {
    System.out.println("账户错误");
    e.printStackTrace();
} catch (IncorrectCredentialsException e) {
    System.out.println("密码错误");
    e.printStackTrace();
}

spring boot整合shiro

初始化数据库

首先创建数据库，数剧看中有5张表，分别是用户表，角色表， 用户角色关系表， 权限表，角色权限表

# 用户表
CREATE TABLE `t_users` (
  `id` int NOT NULL AUTO_INCREMENT,
  `username` varchar(40) DEFAULT NULL,
  `password` varchar(45) DEFAULT NULL,
  `salt` varchar(45) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;

# 角色表
CREATE TABLE `t_roles` (
  `id` int NOT NULL AUTO_INCREMENT,
  `name` varchar(45) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;

# 用户角色关系表
CREATE TABLE `t_user_role` (
  `id` int NOT NULL AUTO_INCREMENT,
  `user_id` int NOT NULL,
  `role_id` int NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;

# 权限表
CREATE TABLE `t_perms` (
  `id` int NOT NULL AUTO_INCREMENT,
  `name` varchar(45) NOT NULL,
  `url` varchar(45) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;

# 权限角色关系表
CREATE TABLE `t_role_perm` (
  `id` int NOT NULL AUTO_INCREMENT,
  `role_id` int NOT NULL,
  `perm_id` int NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;

接下来引入依赖

在pom文件中引入mysql数据库连接坐标，mybatis，shiro、spring boot的坐标

整合spring boot实现登录认证

spring 项目中使用shiro做认证授权时，会启动shiro的WebEnvironment，然后通过WebEnvironment中的ShiroFilter对请求进行认证授权。

  1. 因为使用了Spring Boot，因此不能像之前那样直接在main方法中编写登录的认证，需要将shiro的SecurityManager注入到spring容器中，交给spring进行管理。shiro的配置如下：

    @Configuration
public class ShiroConfig {

    @Bean
    public ShiroFilterFactoryBean shiroFilterFactoryBean(DefaultWebSecurityManager defaultWebSecurityManager) {

        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        shiroFilterFactoryBean.setSecurityManager(defaultWebSecurityManager);
        
        // 配置请求的过滤策略
        Map<String, String> map = new HashMap<>();
        map.put("/register.jsp", "anon");
        map.put("/login.jsp", "anon");
        map.put("/user/login", "anon");
        map.put("/user/register", "anon");
        map.put("/**", "authc");
        shiroFilterFactoryBean.setFilterChainDefinitionMap(map);

        return shiroFilterFactoryBean;
    }

    @Bean
    public DefaultWebSecurityManager defaultWebSecurityManager(Realm realm) {
        DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();
        defaultWebSecurityManager.setRealm(realm);

        return defaultWebSecurityManager;
    }

    @Bean
    public Realm realm() {
        CustomerRealm customerRealm = new CustomerRealm();
        HashedCredentialsMatcher credentialsMatcher = new HashedCredentialsMatcher();
        credentialsMatcher.setHashAlgorithmName("md5");
        credentialsMatcher.setHashIterations(1024);
        customerRealm.setCredentialsMatcher(credentialsMatcher);

        return customerRealm;
    }
}

    在上传代码中有提到请求的过滤策略，其中anon、authc是DefaultFilter枚举中的值（具体含义可以查看源码或shiro文档，在此不在赘述😂）。其可选值如下：

在这里插入图片描述

  1. 定义自定义realm

    在自定义realm中需要根据用户账户查询数据库，因此需要用到一个工具类，该工具类能够获取Dao的bean。

    • 根据名字获取bean的工具类

      @Component
public class ApplicationContextUtil implements ApplicationContextAware {

    private static ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        ApplicationContextUtil.applicationContext = applicationContext;
    }

    /**
     * 根据名字获取bean
     * @param name
     * @return
     */
    public static Object getBean(String name) {

        return applicationContext.getBean(name);
    }
}

    • 自定义Realm

      public class CustomerRealm extends AuthorizingRealm {
    /**
     * 授权
     * @param principals
     * @return
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {

        String username = (String) principals.getPrimaryPrincipal();

        UserService userService = (UserService) ApplicationContextUtil.getBean("userServiceImpl");
        RoleService roleService = (RoleService) ApplicationContextUtil.getBean("roleServiceImpl");
        User user = userService.selectUserAndRolesByUsername(username);
        if (user != null) {
            SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();

            for (Roles role: user.getRoles()) {
                info.addRole(role.getName());

                // 获取权限
                List<Roles> roles = roleService.selectRoleAndPermByRoleId(role.getId());
                for (Roles r : roles) {
                    r.getPerms().forEach(item -> info.addStringPermission(item.getName()));
                }
            }

            return info;
        }

        return null;
    }

    /**
     * 认证
     * @param token
     * @return
     * @throws AuthenticationException
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {

        String username = (String) token.getPrincipal();

        UserService userService = (UserService) ApplicationContextUtil.getBean("userServiceImpl");
        System.out.println("认证");
        User user = userService.selectByUsername(username);
        if (user != null) {
            return new SimpleAuthenticationInfo(username,
                    user.getPassword(),
                    // ByteSource.Util.bytes(user.getSalt()),
                    new MyByteSource(user.getSalt()),
                    this.getName());
        }

        return null;
    }
}

  2. 编写Controller层程序

    @RequestMapping("/login")
public String login(String username, String password) {

    Subject subject = SecurityUtils.getSubject();

    try {
        subject.login(new UsernamePasswordToken(username, password));
        return "redirect:/index.jsp";
    } catch (UnknownAccountException e) {
        e.printStackTrace();
        System.out.println("用戶名錯誤");
        return "redirect:/login.jsp";
    } catch (IncorrectCredentialsException e) {
        e.printStackTrace();
        System.out.println("密碼错误");
        return "redirect:/login.jsp";
    }
}

    其中关于授权的验证有多种方式，可以直接通过subject.hasRole("admin")这种方式，也可以通过@RequiresRoles(value = {"admin"})这种方式进行判断，当然授权也是如此。具体使用可以查看官方文档。

spring boot整合shiro使用redis缓存

  1. 添加redis的依赖

    <dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-redis</artifactId>
    <version>2.4.0</version>
</dependency>
<dependency>
    <groupId>io.lettuce</groupId>
    <artifactId>lettuce-core</artifactId>
    <version>6.0.1.RELEASE</version>
</dependency>

  2. 实现Redis缓存类

    在shiro缓存是通过CacheManager实现的，因此实现的连个Redis缓存类，一个需要实现CacheManager， 另一个需要实现Cache（因为CacheManager中的getCache方法需要返回的是实现Cache接口的类）

    • 实现CacheManager的类

      public class RedisCacheManager implements CacheManager {

    @Override
    public <K, V> Cache<K, V> getCache(String s) throws CacheException {
        System.out.println("redisCacheManager:" + s);
        return new RedisCache<K, V>(s);
    }
}

    • 实现Cache的类

      public class RedisCache<K, V> implements Cache<K, V> {

    private String cacheName;

    public RedisCache() {
    }

    public RedisCache(String cacheName) {
        this.cacheName = cacheName;
    }

    @Override
    public V get(K k) throws CacheException {
        System.out.println("redisCache-get:" + k);
        RedisTemplate redisTemplate = (RedisTemplate) ApplicationContextUtil.getBean("redisTemplate");
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
//        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        return (V) redisTemplate.opsForHash().get(this.cacheName, k.toString());
    }

    @Override
    public V put(K k, V v) throws CacheException {
        System.out.println("redisCanche-put:" + k);
        System.out.println("-------------  :" + v);
        RedisTemplate redisTemplate = (RedisTemplate) ApplicationContextUtil.getBean("redisTemplate");
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
//        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.opsForHash().put(this.cacheName, k.toString(), v);
        return null;
    }

    @Override
    public V remove(K k) throws CacheException {
        RedisTemplate redisTemplate = (RedisTemplate) ApplicationContextUtil.getBean("redisTemplate");
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        return (V) redisTemplate.opsForHash().delete(this.cacheName, k.toString());
    }

    @Override
    public void clear() throws CacheException {
        RedisTemplate redisTemplate = (RedisTemplate) ApplicationContextUtil.getBean("redisTemplate");
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.delete(this.cacheName);
    }

    @Override
    public int size() {
        RedisTemplate redisTemplate = (RedisTemplate) ApplicationContextUtil.getBean("redisTemplate");
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        return redisTemplate.opsForHash().size(this.cacheName).intValue();
    }

    @Override
    public Set<K> keys() {
        RedisTemplate redisTemplate = (RedisTemplate) ApplicationContextUtil.getBean("redisTemplate");
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        return redisTemplate.opsForHash().keys(this.cacheName);
    }

    @Override
    public Collection<V> values() {
        RedisTemplate redisTemplate = (RedisTemplate) ApplicationContextUtil.getBean("redisTemplate");
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        return redisTemplate.opsForHash().values(this.cacheName);
    }
}

    整个spring boot集成shiro并使用redis缓存的代码

    https://github.com/StudyRecording/shiro-learn

码代马
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
shiro 权限认证以及授权demo
09-10
shiro 权限认证以及授权demo
Shiro 完整教程及样例demo
web15687102624的博客
08-24 683
Apache?Shiro是?Java??的一个安全框架。我们经常看到它被拿来和?Spring??的?Security??来对比。大部分人认为?Shiro??比?Security??要简单。首先?Shiro??确实和?Security??是同类型的框架，主要用来做安全，也就是我们俗称的权限校验（控制）。居多人对?Shiro??的定义为好入门。我选型为?Shiro??，主要的原因扩展太easy了，而且我要的功能它都有。，具体配置在中。定义了5个拦截器，具体功能看代码以及代码注释。util:map在?
Spring Boot集成Shiro快速入门Demo
最新发布
HBLOG
05-17 729
Shiro是一个功能强大、灵活的，开源的安全框架，主要可以帮助我们解决程序开发中认证和权限等问题。基于拦截器做的权限系统，权限控制的粒度有限，为了方便各种各样的常用的权限管理需求的实现，我们有必要使用比较好的安全框架。早期Spring security 作为一个比较完善的安全框架比较火，但是Springsecurity学习成本比较高，于是就出现了shiro安全框架，学习成本降低了很多，而且基本的功能也比较完善。Shiro的架构Subject：主题。被验证的对象，一般指的当前用户对象。
Shiro简介及简单入门demo
m0_67402026的博客
03-28 984
Shiro 安全框架：简单说对访问权限进行控制，安全性包括用户认证和用户授权。 用户认证一般要求用户提供用户名和密码，系统通过校验两者来完成认证。 用户授权指验证某个用户是否有权限执行某个操作。 一般来说，系统会为不同的用户分配不同的角色，而每个角色对应一系列权限。 1.什么是Shiro Shiro是apache的一个开源框架，将软件系统的安全认证相关的功能抽取出来，实现用户身份认证，权限授权，加密，会话管理等，组成一个通用的安全认证框架。 1.1 Shiro模块内容具体意义 Subject 即“
SpringMVC+Shiro权限管理
LzwGlory的专栏
02-24 2456
博文目录 权限的简单描述实例表结构及内容及POJOShiro-pom.xmlShiro-web.xmlShiro-MyShiro-权限认证,登录认证层Shiro-applicationContext-shiro.xmlHomeController三个JSP文件  什么是权限呢？举个简单的例子： 我有一个论坛，注册的用户分为normal用户，manager用户。 对论坛的帖子的操
shiro-demo:一个简单的shiro演示项目，包括认证、授权、加密、会话管理、缓存管理，并且结合了redis进行会话和缓存的进一步扩展 JDBC采用Mybatis，数据库脚本文件shir.sql
05-13
shiro 项目介绍 一个简单的shiro演示项目，包括认证、授权、加密、会话管理、缓存管理，并且结合了redis进行会话和缓存的进一步扩展 JDBC采用Mybatis，数据库脚本文件shir.sql。
shiro_demo
02-18
`shiro_demo` 演示了如何在 Java 应用程序中集成并使用 Apache Shiro 进行权限管理。通过这个项目，我们可以深入理解 Shiro 的基本工作原理和配置方式。 1. **Shiro 概述** Apache Shiro 不仅仅是一个安全框架，它...
shiro_demo.rar
01-06
《SpringBoot整合Shiro实战详解》 在现代Java Web开发中，SpringBoot以其简洁的配置、快速的开发效率以及强大的生态系统，已经成为主流的框架选择。而Shiro作为一款轻量级的安全框架，提供了身份验证、授权、会话...
shiro权限案例demo
07-18
在这个"shiro权限案例demo"中，我们将深入探讨Shiro如何实现用户权限的管理。 首先，让我们了解Shiro的核心组件： 1. **Subject**：是Shiro的中心概念，代表了当前“安全的用户”。它提供了进行认证、授权、会话...
spring-boot-shiro-demo
04-22
【Spring Boot整合Shiro实战详解】 在现代Java后端开发中，Spring Boot因其简洁的配置和强大的集成能力而被广泛采用。而Shiro作为一款轻量级的安全框架，提供了身份认证、授权、会话管理和安全控制等功能。本项目...
Shiro_Demo 一个简单的Shiro验证框架实例
04-07
Shiro_Demo 一个简单的Shiro验证框架实例
Java SSM整合shiro demo
04-29
Java SSM整合shiro demo。 SSM整合shiro的配置以及相关shiro特殊功能实现，包括登录错误次数账号锁定、并发用户登录数控制、记住密码等 shiro
shiro使用简单Demo
11-01
基于url和注解的权限管理shiro简单易用的例子，好用易上手,适合初次接触shiro的人员，使用中如有疑问，可以留言，我修改了积分，只需要1积分便可下载，目的分享资源，不为其他。
shiro入门demo(三)身份认证+授权+拦截
w_t_y_y的博客
12-27 508
2、Realm：这里没有连接数据库，在UserConstants中假设数据。
Springboot整合Shiro框架入门
web15285868498的博客
04-08 5459
Springboot整合Shiro框架入门 1、快速开始demo 2、Springboot集成Shiro 2.1、环境搭建 2.2、shiro的拦截 2.3、shiro的认证 2.4、整合mybatis 2.5、shiro进行授权 2.6、shiro整合thymeleaf 3、小结 1、快速开始demo 来到shiro的官网：shiro官方网站： 下载官方在git仓库上提供的源码，下载后解压： 官方提供了在多种场景下使用的demo，等一下会用到sample里面的东西。下面直接按官方推荐
shiro 简单登录demo
热门推荐
风雨过后的博客
01-07 1万+
1.shiro 是java强大的安全认证框架 shiro框架的核心功能：认证，授权，会话管理，加密 shiro框架认证流程   Application Code：应用程序代码，由开发人员负责开发的 Subject：框架提供的接口，代表当前用户对象 SecurityManager：框架提供的接口，代表安全管理器对象 Realm：可以开发人员编写，框架也提供一些，类似于ＤＡＯ，用于访问权...
shiro的原理理解
weixin_34061482的博客
04-07 834
1、shiro原理图如下: 框架解释：  subject：主体，可以是用户也可以是程序，主体要访问系统，系统需要对主体进行认证、授权。 securityManager：安全管理器，主体进行认证和授权都 是通过securityManager进行。它包含下面的认证器和授权器。 authenticator：认证器，主体进行认证最终通过authenticator进行的。  authorizer：授权器，主...
全面解析：Apache Shiro实战教程
"Shiro学习教程，涵盖了从基础到高级的Shiro使用方法，包括身份验证、授权、配置、Web集成、拦截器、JSP标签、会话管理和缓存机制等内容，适合初学者和进阶者参考。" Apache Shiro是一个强大且易用的Java安全框架，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值