Shiro的简单使用

最新推荐文章于 2024-05-14 12:42:30 发布
最新推荐文章于 2024-05-14 12:42:30 发布
阅读量170 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44342481/article/details/116043979
版权

流程

Shiro的执行流程：
Subject --> SecurityManager --> Realm

Subject：主体，相当于当前用户，所有用户将由SecurityManager来管理
SecurityManager：安全管理器，它管理着所有 Subject，它是 Shiro 的核心
Realm：域，Shiro 从从 Realm 获取安全数据，SecurityManager需要从Realm中获取数据进行校验

所需依赖

	<dependency>
        <groupId>commons-logging</groupId>
        <artifactId>commons-logging</artifactId>
        <version>1.1.3</version>
    </dependency>
    <dependency>
        <groupId>org.apache.shiro</groupId>
        <artifactId>shiro-core</artifactId>
        <version>1.7.1</version>
    </dependency>

Shiro 身份验证

在resource目录创建shiro.ini文件

[users]
zhang=123
wang=123

[User]下的键值对形式的数据，左边为帐号，右边为密码。

Test类：验证帐号密码是否正确

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.config.IniSecurityManagerFactory;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.subject.Subject;

public class Test1 {
    public static void main(String[] args) {
        //1、加载配置文件得到安全管理工厂类对象
        IniSecurityManagerFactory factory = new IniSecurityManagerFactory("classpath:shiro.ini");
        //2、获取安全管理类对象
        SecurityManager securityManager = factory.getInstance();
        //3、绑定使用的管理器
        SecurityUtils.setSecurityManager(securityManager);
        //4、得到Subject主体用户对象
        Subject subject = SecurityUtils.getSubject();
        //5、及创建用户名/密码身份验证Token（即用户身份/凭证）
        UsernamePasswordToken token = new UsernamePasswordToken("zhang", "123");
        try {
            //6、用户登录，如果不发生异常，用户登录成功
            subject.login(token);
        } catch (AuthenticationException e) {
            e.printStackTrace();
            /**
             * 如果身份验证失败请捕获 AuthenticationException 或其子类，常见的如：
             * DisabledAccountException（禁用的帐号）
             * LockedAccountException（锁定的帐号）、
             * UnknownAccountException（错误的帐号）、
             * ExcessiveAttemptsException（登录失败次数过多）、
             * IncorrectCredentialsException （错误的凭证）、
             * ExpiredCredentialsException（过期的凭证）等，具体请查看其继承关系；
             * 对于页面的错误消息展示，最好使用如 “用户名 / 密码错误” 而不是 “用户名错误”/“密码错误”，
             * 防止一些恶意用户非法扫描帐号库；
             */
        }
        //7、判断用户登录状态
        boolean authenticated = subject.isAuthenticated();
        if (authenticated) {
            System.out.println("用户登录成功");
        }else {
            System.out.println("用户登录失败");
        }
        subject.logout();
    }
}

执行 subject.login(token)后，shiro根据shiro.ini文件数据进行比对。
注意创建安全管理类对象，这是shiro的核心，我们验证用户登录让主题把用login()方法，其他事情shiro会帮我们搞定。

授权（文件方式）

在resource目录创建shiro.ini文件

[users]
zhang=123,role1,role2
wang=123456
[roles]
role1=user:create,user:update
role2=user:create,user:delete

分配角色，在密码的后用逗号隔开写上拥有的角色
[roles]代表角色，role1代表拥有user角色的create权限和update权限。

Test类：验证权限

import com.entor.realm.RoleRealm;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.mgt.DefaultSecurityManager;
import org.apache.shiro.subject.Subject;

public class Test2 {
    public static void main(String[] args) {
        //创建安全管理器对象
        DefaultSecurityManager securityManager = new DefaultSecurityManager();
        //设置realm对象
        securityManager.setRealm(new RoleRealm());
        //绑定安全管理器
        SecurityUtils.setSecurityManager(securityManager);
        //获取用户主体对象
        Subject subject = SecurityUtils.getSubject();
        //创建用户名/密码身份验证Token（即用户身份/凭证）
        UsernamePasswordToken token = new UsernamePasswordToken("zhang", "123");
        try {
            subject.login(token);
        } catch (AuthenticationException e) {
            e.printStackTrace();
        }
        //7、判断用户登录状态
        boolean authenticated = subject.isAuthenticated();
        if (authenticated) {
            System.out.println("用户登录成功");
        } else {
            System.out.println("用户登录失败");
        }
        boolean role1 = subject.hasRole("role1");
        if (role1) {
            System.out.println("有role1角色");
        } else {
            System.out.println("没有role1角色");
        }
        boolean role2 = subject.hasRole("role2");
        if (role2) {
            System.out.println("有role2角色");
        } else {
            System.out.println("没有role2角色");
        }
        //判断用户是否拥有权限
        boolean permitted = subject.isPermitted("user:create");
        if (permitted) {
            System.out.println("拥有权限user:create");
        } else {
            System.out.println("没有权限user:create");
        }
        permitted = subject.isPermitted("user:delete");
        if (permitted) {
            System.out.println("拥有权限user:delete");
        } else {
            System.out.println("没有权限user:delete");
        }
        subject.logout();
    }
}

自定义Realm(用自定义的Realm来进行认证)

在resource目录创建shiro.ini文件

;声明一个Realm
testRealm=com.entor.realm.TestRealm
;指定securityManager的Realm
securityManager.realms=$testRealm

自定义Realm

import org.apache.shiro.authc.*;
import org.apache.shiro.realm.Realm;

/**
 * 自定义Realm,处理认证逻辑
 */
public class TestRealm implements Realm {
    public String getName() {
        return "TestRealm";
    }

    /**
     * 该Realm支持的Token类型，返回false表示不支持，true表示支持，支持才会执行对应的认证的方法
     *
     * @param token
     * @return
     */
    public boolean supports(AuthenticationToken token) {
        //仅支持UsernamePasswordToken类型的Token
        return token instanceof UsernamePasswordToken;
    }

    /**
     * 认证方法
     */
    public AuthenticationInfo getAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        UsernamePasswordToken token1 = (UsernamePasswordToken) token;
        String username = token1.getUsername();
        String password = new String(token1.getPassword());
        if (!username.equals("zhang")) {
            throw new UnknownAccountException("未知用户");
        }

        if (!password.equals("123")) {
            throw new IncorrectCredentialsException("密码错误");
        }

        SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(username, password, getName());
        return info;
    }
}

SecurityManager最终调用Realm来处理我们的认证功能，我们可以注入自己的Reaml。

Test1类

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.config.IniSecurityManagerFactory;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.subject.Subject;

public class Test1 {
    public static void main(String[] args) {
        //1、加载配置文件得到安全管理工厂类对象
        IniSecurityManagerFactory factory = new IniSecurityManagerFactory("classpath:shiro.ini");
        //2、获取安全管理类对象
        SecurityManager securityManager = factory.getInstance();
        //3、绑定使用的管理器
        SecurityUtils.setSecurityManager(securityManager);
        //4、得到Subject主体用户对象
        Subject subject = SecurityUtils.getSubject();
        //5、及创建用户名/密码身份验证Token（即用户身份/凭证）
        UsernamePasswordToken token = new UsernamePasswordToken("zhang", "123");
        try {
            //6、用户登录，如果不发生异常，用户登录成功
            subject.login(token);
        } catch (AuthenticationException e) {
            e.printStackTrace();
            /**
             * 如果身份验证失败请捕获 AuthenticationException 或其子类，常见的如：
             * DisabledAccountException（禁用的帐号）
             * LockedAccountException（锁定的帐号）、
             * UnknownAccountException（错误的帐号）、
             * ExcessiveAttemptsException（登录失败次数过多）、
             * IncorrectCredentialsException （错误的凭证）、
             * ExpiredCredentialsException（过期的凭证）等，具体请查看其继承关系；
             * 对于页面的错误消息展示，最好使用如 “用户名 / 密码错误” 而不是 “用户名错误”/“密码错误”，
             * 防止一些恶意用户非法扫描帐号库；
             */
        }
        //7、判断用户登录状态
        boolean authenticated = subject.isAuthenticated();
        if (authenticated) {
            System.out.println("用户登录成功");
        }else {
            System.out.println("用户登录失败");
        }
        subject.logout();
    }
}

自定义AuthorizingRealm来授权

在resource目录创建shiro.ini文件

[main]
;声明一个Realm
roleRealm=com.entor.realm.RoleRealm
;指定securityManager的Realm
securityManager.realm=$roleRealm

自定义AuthorizingRealm：先认证后授权

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 org.apache.shiro.util.ByteSource;

import java.util.ArrayList;


public class RoleRealm extends AuthorizingRealm {

    /**
     * 获取用户授权信息
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        //获取当前登录认证的用户名
        String name = (String) principalCollection.getPrimaryPrincipal();
        //真实做法：根据用户名去数据库查询对应的角色和权限到AuthorizationInfo对象中
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        //用户拥有的角色列表
        ArrayList<String> roles = new ArrayList<String>();
        roles.add("role1");
        //用户拥有的权限列表
        ArrayList<String> permission = new ArrayList<String>();
        permission.add("user:create");
        permission.add("user:update");
        //添加角色
        info.addRoles(roles);
        //添加授权
        info.addStringPermissions(permission);
        return info;
    }

    /**
     * 获取用户认证信息
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        UsernamePasswordToken token1 = (UsernamePasswordToken) token;
        String username = token1.getUsername();
     	String password = new String(token1.getPassword());
        if (!username.equals("zhang")) {
            throw new UnknownAccountException("未知用户");
        }
        if (!password.equals("123")) {
            throw new IncorrectCredentialsException("密码错误");
        }
        SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(username, password, getName());
        return info;
    }
}

TestRole类

import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.config.IniSecurityManagerFactory;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.subject.Subject;

public class TestRole {
    public static void main(String[] args) {

        //1、加载配置文件得到安全管理工厂类对象
        IniSecurityManagerFactory factory = new IniSecurityManagerFactory("classpath:shiro-role.ini");
        //2、获取安全管理类对象
        SecurityManager securityManager = factory.getInstance();
        //3、绑定使用的管理器
        SecurityUtils.setSecurityManager(securityManager);
        //4、得到Subject主体用户对象
        Subject subject = SecurityUtils.getSubject();
        //5、创建用户名/密码身份验证Token（即用户身份/凭证）
        String usernmae = "zhang";
        String password = "123";
        String salt = "123456";

        UsernamePasswordToken token = new UsernamePasswordToken(usernmae, password);
        try {
            //6、用户登录，如果不发生异常，用户登录成功
            subject.login(token);
        } catch (AuthenticationException e) {
            e.printStackTrace();
            /**
             * 如果身份验证失败请捕获 AuthenticationException 或其子类，常见的如：
             * DisabledAccountException（禁用的帐号）
             * 、LockedAccountException（锁定的帐号）、
             * UnknownAccountException（错误的帐号）、
             * ExcessiveAttemptsException（登录失败次数过多）、
             * IncorrectCredentialsException （错误的凭证）、
             * ExpiredCredentialsException（过期的凭证）等，具体请查看其继承关系；
             * 对于页面的错误消息展示，最好使用如 “用户名 / 密码错误” 而不是 “用户名错误”/“密码错误”，
             * 防止一些恶意用户非法扫描帐号库；
             */
        }
        //7、判断用户登录状态
        boolean authenticated = subject.isAuthenticated();
        if (authenticated) {
            System.out.println("用户登录成功");
        } else {
            System.out.println("用户登录失败");
        }
        boolean role1 = subject.hasRole("role1");
        if (role1) {
            System.out.println("有role1角色");
        } else {
            System.out.println("没有role1角色");
        }
        boolean role2 = subject.hasRole("role2");
        if (role2) {
            System.out.println("有role2角色");
        } else {
            System.out.println("没有role2角色");
        }
        //判断用户是否拥有权限
        boolean permitted = subject.isPermitted("user:create");
        if (permitted) {
            System.out.println("拥有权限user:create");
        } else {
            System.out.println("没有权限user:create");
        }
        permitted = subject.isPermitted("user:delete");
        if (permitted) {
            System.out.println("拥有权限user:delete");
        } else {
            System.out.println("没有权限user:delete");
        }
        subject.logout();
    }
}

加密方式

/*      //jdk自带的加密 
        String str = "hello";
        System.out.println("编码前："+str);
        String encode = java.util.Base64.getEncoder().encodeToString(str.getBytes(StandardCharsets.UTF_8));
        System.out.println("编码后："+encode);
        String decode = Base64.decodeToString(encode);
        System.out.println("解码后："+decode);*/

/*      //Base64加密  
        String str = "hello";
        System.out.println("编码前："+str);
        String encode = Base64.encodeToString(str.getBytes(StandardCharsets.UTF_8));
        System.out.println("编码后："+encode);
        String decode = Base64.decodeToString(encode);
        System.out.println("解码后："+decode);*/

/*      //使用16进制的方式工具类Hex类编码解码
        String str = "hello";
        System.out.println("编码前："+str);
        String encode = Hex.encodeToString(str.getBytes());
        System.out.println("编码后："+encode);
        String decode = new String(Hex.decode(encode.getBytes()));
        System.out.println("解码后："+decode);*/
        
/*      //MD5加密  
        String str = "hello";
        String salt = "123";
        Md5Hash md5Hash = new Md5Hash(str, salt,1);
        String md5 = md5Hash.toString();//还可以转换为 toBase64()/toHex()
        System.out.println("md5:"+md5);//86fcb4c0551ea48ede7df5ed9626eee7
        System.out.println("base64:"+md5Hash.toBase64());
        System.out.println("hex:"+md5Hash.toHex());*/

        //Shiro 还提供了通用的散列支持
        String str = "hello";
        String salt = "123";
        //内部使用MessageDigest 常用SHA-1 SHA-256 SHA-512 MD5
        String simpleHash = new SimpleHash("SHA-1", str, salt).toString();
        System.out.println(simpleHash);

Shiro加密

在resource目录创建shiro.ini文件

[main]
credentialsMatcher=com.entor.matcher.MyHashedCredentialsMatcher
credentialsMatcher.hashAlgorithmName=md5
credentialsMatcher.hashIterations=2
credentialsMatcher.storedCredentialsHexEncoded=true
;声明一个Realm
roleRealm=com.entor.realm.RoleRealm
roleRealm.credentialsMatcher=$credentialsMatcher
;指定securityManager的Realm
securityManager.realm=$roleRealm

credentialsMatcher是用来设置加密规则的

加密规则类:MyHashedCredentialsMatcher

import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.credential.HashedCredentialsMatcher;

/**
 * 自定义密码校验器
 */
public class MyHashedCredentialsMatcher extends HashedCredentialsMatcher {
    @Override
    public boolean doCredentialsMatch(AuthenticationToken token, AuthenticationInfo info) {
        return super.doCredentialsMatch(token, info);
    }
}

自定义AuthorizingRealm 来认证

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 org.apache.shiro.util.ByteSource;

import java.util.ArrayList;


public class RoleRealm extends AuthorizingRealm {

    /**
     * 获取用户授权信息
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        //获取当前登录认证的用户名
        String name = (String) principalCollection.getPrimaryPrincipal();
        //真实做法：根据用户名去数据库查询对应的角色和权限到AuthorizationInfo对象中
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        //用户拥有的角色列表
        ArrayList<String> roles = new ArrayList<String>();
        roles.add("role1");
        //用户拥有的权限列表
        ArrayList<String> permission = new ArrayList<String>();
        permission.add("user:create");
        permission.add("user:update");
        //添加角色
        info.addRoles(roles);
        //添加授权
        info.addStringPermissions(permission);
        return null;
    }

    /**
     * 获取用户认证信息
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
        UsernamePasswordToken token1 = (UsernamePasswordToken) token;
        String username = token1.getUsername();
        String password = "cfb13c831a62c3873ceaa206d7acecc5";
        if (!username.equals("zhang")) {
            throw new UnknownAccountException("未知用户");
        }

//        if (!password.equals("cfb13c831a62c3873ceaa206d7acecc5")) {
//            throw new IncorrectCredentialsException("密码错误");
//        }
        SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(username, password, getName());
        //注入加密的盐，
        info.setCredentialsSalt(ByteSource.Util.bytes(username+123456));
        return info;
    }
}

TestRole类：

public class TestRole {
    public static void main(String[] args) {

        //1、加载配置文件得到安全管理工厂类对象
        IniSecurityManagerFactory factory = new IniSecurityManagerFactory("classpath:shiro-role.ini");
        //2、获取安全管理类对象
        SecurityManager securityManager = factory.getInstance();
        //3、绑定使用的管理器
        SecurityUtils.setSecurityManager(securityManager);
        //4、得到Subject主体用户对象
        Subject subject = SecurityUtils.getSubject();
        //5、创建用户名/密码身份验证Token（即用户身份/凭证）
        String usernmae = "zhang";
        String password = "123";
        String salt = "123456";

/*        //2次md5加密
        password = new SimpleHash("MD5", password, usernmae+salt, 2).toString();
        System.out.println(password);//cfb13c831a62c3873ceaa206d7acecc5*/

        UsernamePasswordToken token = new UsernamePasswordToken(usernmae, password);
        try {
            //6、用户登录，如果不发生异常，用户登录成功
            subject.login(token);
        } catch (AuthenticationException e) {
            e.printStackTrace();
            /**
             * 如果身份验证失败请捕获 AuthenticationException 或其子类，常见的如：
             * DisabledAccountException（禁用的帐号）
             * 、LockedAccountException（锁定的帐号）、
             * UnknownAccountException（错误的帐号）、
             * ExcessiveAttemptsException（登录失败次数过多）、
             * IncorrectCredentialsException （错误的凭证）、
             * ExpiredCredentialsException（过期的凭证）等，具体请查看其继承关系；
             * 对于页面的错误消息展示，最好使用如 “用户名 / 密码错误” 而不是 “用户名错误”/“密码错误”，
             * 防止一些恶意用户非法扫描帐号库；
             */
        }
        //7、判断用户登录状态
        boolean authenticated = subject.isAuthenticated();
        if (authenticated) {
            System.out.println("用户登录成功");
        } else {
            System.out.println("用户登录失败");
        }
        boolean role1 = subject.hasRole("role1");
        if (role1) {
            System.out.println("有role1角色");
        } else {
            System.out.println("没有role1角色");
        }
        boolean role2 = subject.hasRole("role2");
        if (role2) {
            System.out.println("有role2角色");
        } else {
            System.out.println("没有role2角色");
        }
        //判断用户是否拥有权限
        boolean permitted = subject.isPermitted("user:create");
        if (permitted) {
            System.out.println("拥有权限user:create");
        } else {
            System.out.println("没有权限user:create");
        }
        permitted = subject.isPermitted("user:delete");
        if (permitted) {
            System.out.println("拥有权限user:delete");
        } else {
            System.out.println("没有权限user:delete");
        }
        subject.logout();
    }
}

首先在RoleTest中，我们输入的username=“zhang”,password=“123”,其加载到我们自定义的认证器后doGetAuthenticationInfo方法中假设我们从数据库拿到的密码为：cfb13c831a62c3873ceaa206d7acecc5，我们将用户数据info返回前我们设置了我们的加密时用的盐，当doGetAuthenticationInfo()返回后，shiro会从我们的shiro.ini文件中读取到我们的加密规则和我们设置的盐，这就完成一次加密校验。

爱窦
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
shiro入门
trasewell的博客
09-25 848
目录： 1.pom.xml 2.applicationContext.xml 3.applicationContext-mybatis.xml 4.SpringBaseTest 5.优化分页 1.pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4...
shiro的简单使用
afdasfggasdf的博客
04-18 258
一.认证与授权 认证：系统提供的用于识别用户身份的功能，通常登录功能就是认证，让系统知道你是谁，qq登录，微信登录。 授权：系统用户可以访问哪些功能，让系统知道你能做什么。 shiro核心功能，认证，授权、加密 二.基本使用 1.引入框架依赖 <!-- 引入shiro框架的依赖 --> <dependen...
Shiro - Shiro简介；Shiro与Spring Security区别；Spring Boot集成Shiro
热门推荐
MinggeQingchun的博客
08-27 3万+
以下引自百度百科Apache Shiro是一个强大且易用的Java安全框架，执行身份验证、授权、密码和会话管理。使用Shiro的易于理解的API，可以快速、轻松地获得任何应用程序，从最小的移动应用程序到最大的网络和企业应用程序。三个核心组件：Subject，SecurityManager 和 Realms。...
2024年一个批量扫描shiro漏洞的工具_shiro批量检测，2024年最新附架构师必备技术详解
最新发布
2401_84920041的博客
05-14 322
支持 -bypass 1。
shiro权限
天地无名
09-30 667
一、权限框架介绍 1.什么说权限框架? 权限说简单点就是我们字面理解的意思，项目中，例如普通用户和超级管理园 权限管理包括用户身份认证和授权两部分，简称认证授权。对于需要访问控制的资源用户首先经过身份认证，认证通过后用户具有该资源的访问权限方可访问。 1.1 用户身份认证 身份认证，就是判断一个用户是否为合法用户的处理过程。最常用的简单身份认证方式是系统通过核对用户输入的用户名和口令，看其是否与系统中存储的该用户的用户名和口令一致，来判断用户身份是否正确。对于采用指纹等系统，则出示指纹；对于硬件K
授权 - Spring Security简单案例
个人纪录、总结！
10-21 561
Spring Security简单案例 文章目录Spring Security简单案例一、简介二、身份认证方式2.1、加入依赖和编写安全配置类添加`Spring Security`依赖编写安全配置类2.2、 HttpBasic 和HttpForm 认证方式HttpBasic认证方式HttpForm 表单认证方式三、身份认证实践3.1、指定登录跳转地址3.2、用户名和密码的默认名称3.3、将配置更改为动态配置3.4、实现成功处理类3.5、实现失败处理类 一、简介 Spring Security 是基于 Spr
Shiro的简单实现
梦回乌托邦
11-22 409
shiro简单实现
shiro使用简单Demo
11-01
在这个"shiro使用简单Demo"中，我们可以看到作者提供了一个基础的Shiro实现，特别针对URL和注解的权限管理进行演示，这对于初学者来说是一个很好的起点。 首先，我们来看`shiro2.xml`，这是Shiro的配置文件。在该...
shiro--简单使用
10-18
shiro
shiro框架使用简易教程
03-26
Shiro框架使用简易教程 Shiro框架是一个开源的安全框架，在Web开发应用中使用比较多验证和权限管理。它提供了一个灵活的身份验证和授权机制，可以使得开发难度大大降低。下面是Shiro框架使用简易教程的知识点总结：...
shiro-demo使用ehcache做缓存.zip
12-01
在这个“shiro-demo使用ehcache做缓存”的示例中，我们将深入探讨如何结合Apache Shiro和 Ehcache 实现高效的缓存管理。 Ehcache 是一个广泛使用的开源Java缓存解决方案，它提供了内存和磁盘存储，以及对缓存数据的...
Shiro教程（一）：入门概述与基本使用
WwLK123的博客
07-11 4911
Shiro入门概述与基本使用
Shiro简介
hmj2181629495的博客
08-30 5746
shiro是apache的一个开源框架，是一个权限管理的框架，实现 用户认证、用户授权。spring中有spring security (原名Acegi)，是一个权限框架，它和spring依赖过于紧密，没有shiro使用简单。 shiro不依赖于spring，shiro不仅可以实现 web应用的权限管理，还可以实现c/s系统，分布式系统权限管理，shiro属于轻量框架，越来越多企业项目开始使用shiro。...
【基础框架】Shrio安全框架
博客包含书籍、B站、其他博主博客等内容，只为了记录笔记，作业，问题，软件配置等，为了以后方便查阅，如有侵权，请联系删除
03-16 2507
基于主页的权限管理（不同用户使用不同的主页，权限通过主页功能菜单进行限制）基于用户和权限的权限管理基于角色的访问控制认证：对用户的身份进行检查（登录验证）授权：对用户的权限进行检查（是否有对应的操作权限）流程示意图： 认证，验证用户是否有相应的身份—登录认证； 授权，即权限验证；对已经通过认证的用户检查是否具有某个权限或者角色，从而控制是否能够进行某种操作；会话管理，用户在认证成功之后创建会话，在没有退出之前，当前用户的所有信息都会保存在这个会话中；可以是普通的JavaSE应用，也可以是web应用；加密
shiro简单使用
玉爷的博客
08-30 203
一、apache shiro简介 1、shiro框架的核心功能： 认证、授权、会话管理、加密 2、shiro框架认证流程 Application Code：应用程序代码，由开发人员负责开发的 Subject：框架提供的接口，代表当前用户对象 SecurityManager：框架提供的接口，代表安全管理器对象 Realm：可以开发人员编写，框架也提供一些，类似于ＤＡＯ，用于访问权限...
Shiro
小牧的博客
08-03 624
Shiro Apache旗下的一款安全权限框架 shiro可以完成：认证，加密，授权，会话管理，以及web集成， 什么是shiro Shiro是apache旗下一个开源框架，它将软件系统的安全认证相关的功能抽取出来，实现用户身份认证，权限授权、加密、会话管理等功能，组成了一个通用的安全认证框架。 Apache Shiro 特性 Apache Shiro是一个全面的、蕴含丰富功能的安全框架 什么是权限管理 基本上涉及到用户参与的系统都要进行权限管理，权限管理属于系统安全的范畴，权限管理实现`对用户访问系统的
Shiro安全框架详解及springboot使用示例
weixin_46822367的博客
12-28 2840
目录一、认识Shiro1、什么是Shiro？2、有哪些功能？3、Shiro架构（外部）4、Shiro架构（内部） 一、认识Shiro 1、什么是Shiro？ Apache Shiro 是一个Java 的安全（权限）框架。 Shiro 可以非常容易的开发出足够好的应用，其不仅可以用在JavaSE环境，也可以用在JavaEE环 境。 Shiro可以完成，认证，授权，加密，会话管理，Web集成，缓存等。 2、有哪些功能？ Authentication：身份认证、登录，验证用户是不是拥有相应的身份； Aut
vue 使用shiro
08-29
Vue.js 是一个用于构建用户界面...需要注意的是，以上只是一个简单的示例，实际上，使用Vue.js和Shiro进行身份验证和授权会涉及到更多的细节和安全性考虑。具体实现方式还需要根据具体的项目需求和后端框架来进行调整。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值