Shiro学习笔记（2）——身份验证之Realm

最新推荐文章于 2022-10-07 15:21:44 发布
最新推荐文章于 2022-10-07 15:21:44 发布
阅读量152 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44943599/article/details/89736780
版权
                       

环境准备

  • 创建java工程

  • 需要的jar包

这里写图片描述

  • 大家也可以使用maven，参考官网

什么是Realm

  • 在我所看的学习资料中，关于Realm的定义，写了整整一长串，但是对于初学者来说，看定义实在是太头疼了。

  • 对于什么是Realm，我使用过之后，个人总结一下：shiro要进行身份验证，就要从realm中获取相应的身份信息来进行验证，简单来说，我们可以自行定义realm，在realm中，从数据库获取身份信息，然后和                                                      用户输入的身份信息进行匹配。这一切都由我们自己来定义。

为什么要用Realm

在Shiro学习笔记（1）——shiro入门中，我们将身份信息（用户名/密码/角色/权限）写在配置文件中，但是实际开发中，这些身份信息应该保存在数据中，因此我们需要自定义Realm来从数据中获取身份信息，进行验证。

自定义Realm

  • 定义一个MyRealm，继承AuthorizingRealm
package com.shiro.realm;import java.util.HashSet;import java.util.Set;import org.apache.shiro.authc.AuthenticationException;import org.apache.shiro.authc.AuthenticationInfo;import org.apache.shiro.authc.AuthenticationToken;import org.apache.shiro.authc.IncorrectCredentialsException;import org.apache.shiro.authc.SimpleAuthenticationInfo;import org.apache.shiro.authc.UnknownAccountException;import org.apache.shiro.authc.UsernamePasswordToken;import org.apache.shiro.authz.AuthorizationInfo;import org.apache.shiro.authz.SimpleAuthorizationInfo;import org.apache.shiro.realm.AuthorizingRealm;import org.apache.shiro.realm.Realm;import org.apache.shiro.subject.PrincipalCollection;import org.slf4j.Logger;import org.slf4j.LoggerFactory;public class MyRealm1 extends AuthorizingRealm{    private static final transient Logger log = LoggerFactory.getLogger(Main.class);    /**     * 获取身份信息，我们可以在这个方法中，从数据库获取该用户的权限和角色信息     */    @Override    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {        log.info("----------doGetAuthorizationInfo方法被调用----------");        String username = (String) getAvailablePrincipal(principals);        //我们可以通过用户名从数据库获取权限/角色信息        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();        //权限        Set<String> s = new HashSet<String>();        s.add("printer:print");        s.add("printer:query");        info.setStringPermissions(s);        //角色        Set<String> r = new HashSet<String>();        r.add("role1");        info.setRoles(r);        return info;    }    /**     * 在这个方法中，进行身份验证     */    @Override    protected AuthenticationInfo doGetAuthenticationInfo(            AuthenticationToken token) throws AuthenticationException {        //用户名        String username = (String) token.getPrincipal();        log.info("username:"+username);        //密码        String password = new String((char[])token.getCredentials());        log.info("password:"+password);        //从数据库获取用户名密码进行匹配，这里为了方面，省略数据库操作        if(!"admin".equals(username)){            throw new UnknownAccountException();        }        if(!"123".equals(password)){            throw new IncorrectCredentialsException();        }        //身份验证通过,返回一个身份信息        AuthenticationInfo aInfo = new SimpleAuthenticationInfo(username,password,getName());        return aInfo;    }}
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 让我们定义的Realm起作用，就要在配置文件中配置（shiro-realm.ini）
#声明一个realm  MyRealm1=com.shiro.realm.MyRealm1 #指定securityManager的realms实现  securityManager.realms=$MyRealm1
  
  
  • 1
  • 2
  • 3
  • 4
  • 测试
package com.shiro.realm;import org.apache.shiro.SecurityUtils;import org.apache.shiro.authc.AuthenticationException;import org.apache.shiro.authc.IncorrectCredentialsException;import org.apache.shiro.authc.LockedAccountException;import org.apache.shiro.authc.UnknownAccountException;import org.apache.shiro.authc.UsernamePasswordToken;import org.apache.shiro.config.IniSecurityManagerFactory;import org.apache.shiro.mgt.SecurityManager;import org.apache.shiro.subject.Subject;import org.apache.shiro.util.Factory;import org.slf4j.Logger;import org.slf4j.LoggerFactory;public class Main {    private static final transient Logger log = LoggerFactory.getLogger(Main.class);    public static void main(String[] args) {        //获取SecurityManager的实例        Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro-realm.ini");        SecurityManager securityManager = factory.getInstance();        SecurityUtils.setSecurityManager(securityManager);        Subject currenUser = SecurityUtils.getSubject();        //如果还未认证        if(!currenUser.isAuthenticated()){            UsernamePasswordToken token = new UsernamePasswordToken("admin","123");            token.setRememberMe(true);            try {                currenUser.login(token);            } catch (UnknownAccountException uae) {                log.info("没有该用户： " + token.getPrincipal());            } catch (IncorrectCredentialsException ice) {                log.info( token.getPrincipal() + " 的密码不正确!");            } catch (LockedAccountException lae) {                log.info( token.getPrincipal() + " 被锁定 ，请联系管理员");            }catch (AuthenticationException ae) {                //其他未知的异常            }        }        if(currenUser.isAuthenticated())            log.info("用户 "+currenUser.getPrincipal() +" 登录成功");        //是否有role1这个角色        if(currenUser.hasRole("role1")){            log.info("有角色role1");        }else{            log.info("没有角色role1");        }        //是否有对打印机进行打印操作的权限        if(currenUser.isPermitted("printer:print")){            log.info("可以对打印机进行打印操作");        }else {            log.info("不可以对打印机进行打印操作");        }    }}
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 测试结果
    这里写图片描述
 

从结果截图中，我们可以看到，自定义的Realm中的doGetAuthorizationInfo 方法被调用了两次，并且分别在currenUser.hasRole() 和currenUser.isPermitted 方法调用时调用

散列算法支持

一般我们存入数据库的密码都是通过加密的，比如将“原密码+盐”进行一次或多次MD5计算，shiro提供了对散列算法的支持

package com.shiro.realm;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.authz.AuthorizationInfo;import org.apache.shiro.realm.AuthorizingRealm;import org.apache.shiro.subject.PrincipalCollection;import org.apache.shiro.util.ByteSource;public class UserRealm extends AuthorizingRealm {    private String salt = "hehe";//盐    @Override    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection arg0) {        // TODO Auto-generated method stub        return null;    }    @Override    protected AuthenticationInfo doGetAuthenticationInfo(            AuthenticationToken token) throws AuthenticationException {        //用户输入的用户名        String username = (String) token.getPrincipal();        //如果数据库中没有这个用户，则返回null，登录失败        if(!username.equals("xiaozhou"))            return null;        //从数据库中查询密码        String password = "42029a889cc26562c986346114c02367";        SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(username,                password, ByteSource.Util.bytes(salt), getName());        return info;    }}
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40

使用MD5的realm和一般的realm没有太多区别，唯一的区别在于：不使用散列算法（即对密码加密）的话，从数据库查询出来的密码是明文，否则查询出来的是密文，我们没法使用密文来直接比对判断密码是否正确，为了让shiro自动帮我们先加密再比对，我们要在配置文件ini中告诉shiro使用什么算法

[main]#密码匹配器credentialsMatcher=org.apache.shiro.authc.credential.HashedCredentialsMatcher#匹配器使用md5credentialsMatcher.hashAlgorithmName=md5#进行几次散列（用md5算法做几次运算）credentialsMatcher.hashIterations=1#realmuserRealm=com.shiro.realm.UserRealm#该realm使用的匹配器是哪个userRealm.credentialsMatcher=$credentialsMatcher#使用哪个realmsecurityManager.realms=$userRealm
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

多个Realm

  • 有时候，我们需要进行多次身份验证，我们可以定义多个Realm，如同流水线一样，shiro会依次调用Realm

  • MyRealm1

package com.shiro.mutilrealm;import java.util.HashSet;import java.util.Set;import org.apache.shiro.authc.AuthenticationException;import org.apache.shiro.authc.AuthenticationInfo;import org.apache.shiro.authc.AuthenticationToken;import org.apache.shiro.authc.IncorrectCredentialsException;import org.apache.shiro.authc.SimpleAuthenticationInfo;import org.apache.shiro.authc.UnknownAccountException;import org.apache.shiro.authc.UsernamePasswordToken;import org.apache.shiro.authz.AuthorizationInfo;import org.apache.shiro.authz.SimpleAuthorizationInfo;import org.apache.shiro.realm.AuthorizingRealm;import org.apache.shiro.realm.Realm;import org.apache.shiro.subject.PrincipalCollection;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import com.shiro.realm.Main;public class MyRealm1 extends AuthorizingRealm{    private static final transient Logger log = LoggerFactory.getLogger(Main.class);    @Override    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {        String username = (String) getAvailablePrincipal(principals);        //通过用户名从数据库获取权限字符串        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();        //权限        Set<String> s = new HashSet<String>();        s.add("printer:print");        s.add("printer:query");        info.setStringPermissions(s);        //角色        Set<String> r = new HashSet<String>();        r.add("role1");        info.setRoles(r);        return info;    }    @Override    protected AuthenticationInfo doGetAuthenticationInfo(            AuthenticationToken token) throws AuthenticationException {        log.info("MyRealm1开始认证。。。。。。");        //用户名        String username = (String) token.getPrincipal();        log.info("username:"+username);        //密码        String password = new String((char[])token.getCredentials());        log.info("password:"+password);        //从数据库获取用户名密码进行匹配，这里为了方面，省略数据库操作        if(!"admin".equals(username)){            throw new UnknownAccountException();        }        if(!"123".equals(password)){            throw new IncorrectCredentialsException();        }        //身份验证通过        AuthenticationInfo aInfo = new SimpleAuthenticationInfo(username,password,getName());        return aInfo;    }}
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • MyRealm2和MyRealm1 代码其实基本上是一样的，直接复制一份即可。当然，如果有需求，我们可以自由地定义修改Realm。这里只做个示例而已。

配置Authenticator和AuthenticationStrategy

  • 这两个东东是啥玩意？

     

    上面我们配置了多个Realm进行身份验证，假设一下：MyRealm1 验证通过了，MyRealm2验证不通过怎么办，这就需要定义一个验证策略来处理这种情况。Strategy的意思就是策略。Authenticator就是验证器

  • 配置文件（shiro-mutil-realm.ini）

#声明一个realm  MyRealm1=com.shiro.mutilrealm.MyRealm1MyRealm2=com.shiro.mutilrealm.MyRealm2#配置验证器authenticator = org.apache.shiro.authc.pam.ModularRealmAuthenticator#配置策略# AllSuccessfulStrategy 表示 MyRealm1和MyRealm2 认证都通过才算通过authcStrategy = org.apache.shiro.authc.pam.AllSuccessfulStrategy#将验证器和策略关联起来authenticator.authenticationStrategy = $authcStrategy#配置验证器所使用的Realmauthenticator.realms=$MyRealm2,$MyRealm1#把Authenticator设置给securityManagersecurityManager.authenticator = $authenticator########################################################################### 1. AtLeastOneSuccessfulStrategy ：如果一个（或更多）Realm 验证成功，则整体的尝试被认# 为是成功的。如果没有一个验证成功，则整体尝试失败。# 2. FirstSuccessfulStrategy 只有第一个成功地验证的Realm 返回的信息将被使用。所有进一步# 的Realm 将被忽略。如果没有一个验证成功，则整体尝试失败# 3. AllSucessfulStrategy 为了整体的尝试成功，所有配置的Realm 必须验证成功。如果没有一# 个验证成功，则整体尝试失败。# ModularRealmAuthenticator 默认的是AtLeastOneSuccessfulStrategy###########################################################################
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
 
  •  
  • 验证的策略有三种，在配置文件中我用注释都写好了，就不再详细说明了
  •  
  • 测试
package com.shiro.mutilrealm;import java.util.List;import org.apache.shiro.SecurityUtils;import org.apache.shiro.authc.AuthenticationException;import org.apache.shiro.authc.IncorrectCredentialsException;import org.apache.shiro.authc.LockedAccountException;import org.apache.shiro.authc.UnknownAccountException;import org.apache.shiro.authc.UsernamePasswordToken;import org.apache.shiro.config.IniSecurityManagerFactory;import org.apache.shiro.mgt.SecurityManager;import org.apache.shiro.subject.PrincipalCollection;import org.apache.shiro.subject.Subject;import org.apache.shiro.util.Factory;import org.slf4j.Logger;import org.slf4j.LoggerFactory;public class Main {    private static final transient Logger log = LoggerFactory.getLogger(Main.class);    public static void main(String[] args) {        //获取SecurityManager的实例        Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro-mutil-realm.ini");        SecurityManager securityManager = factory.getInstance();        SecurityUtils.setSecurityManager(securityManager);        Subject currenUser = SecurityUtils.getSubject();        //如果还未认证        if(!currenUser.isAuthenticated()){            UsernamePasswordToken token = new UsernamePasswordToken("admin","123");            token.setRememberMe(true);            try {                currenUser.login(token);            } catch (UnknownAccountException uae) {                log.info("没有该用户： " + token.getPrincipal());            } catch (IncorrectCredentialsException ice) {                log.info( token.getPrincipal() + " 的密码不正确!");            } catch (LockedAccountException lae) {                log.info( token.getPrincipal() + " 被锁定 ，请联系管理员");            }catch (AuthenticationException ae) {                //其他未知的异常            }        }        if(currenUser.isAuthenticated())            log.info("用户 "+currenUser.getPrincipal() +" 登录成功");        //得到一个身份集合        PrincipalCollection principalCollection = currenUser.getPrincipals();    }}
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 运行结果
    这里写图片描述
 

结果很明显，MyRealm1和MyRealm2依次执行

自定义AuthenticationStrategy（验证策略）

  • 上面我们使用了shiro自带的AuthenticationStrategy，其实我们也可以自己定义。
package com.shiro.authenticationstrategy;import java.util.Collection;import org.apache.shiro.authc.AuthenticationException;import org.apache.shiro.authc.AuthenticationInfo;import org.apache.shiro.authc.AuthenticationToken;import org.apache.shiro.authc.pam.AbstractAuthenticationStrategy;import org.apache.shiro.realm.Realm;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import com.shiro.realm.Main;public class MyAuthenticationStrategy extends AbstractAuthenticationStrategy{    private static final transient Logger log = LoggerFactory.getLogger(MyAuthenticationStrategy.class);    /**     * 所有Realm验证之前调用     */    @Override    public AuthenticationInfo beforeAllAttempts(            Collection<? extends Realm> realms, AuthenticationToken token)            throws AuthenticationException {        log.info("===============beforeAllAttempts方法被调用==================");        return super.beforeAllAttempts(realms, token);    }    /**     * 每一个Realm验证之前调用     */    @Override    public AuthenticationInfo beforeAttempt(Realm realm,            AuthenticationToken token, AuthenticationInfo aggregate)            throws AuthenticationException {        log.info("===============beforeAttempt方法被调用==================");        return super.beforeAttempt(realm, token, aggregate);    }    /**     * 每一个Realm验证之后调用     */    @Override    public AuthenticationInfo afterAttempt(Realm realm,            AuthenticationToken token, AuthenticationInfo singleRealmInfo,            AuthenticationInfo aggregateInfo, Throwable t)            throws AuthenticationException {        log.info("===============afterAttempt方法被调用==================");        return super.afterAttempt(realm, token, singleRealmInfo, aggregateInfo, t);    }    /**     * 所有Realm验证之后调用     */    @Override    public AuthenticationInfo afterAllAttempts(AuthenticationToken token,            AuthenticationInfo aggregate) throws AuthenticationException {        log.info("===============afterAllAttempts方法被调用==================");        return super.afterAllAttempts(token, aggregate);    }}
  
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
 

我们所继承的 AbstractAuthenticationStrategy 中，各个方法并不是抽象的，也就是说并一定要重写，我们可以根据需求重写需要的方法即可

  • 配置文件

     

    要让我们自定义的AuthenticationStrategy起作用，只要将上面配置文件（shiro-mutil-realm.ini）中
       authcStrategy = org.apache.shiro.authc.pam.AllSuccessfulStrategy 
      改为authcStrategy = com.shiro.authenticationstrategy.MyAuthenticationStrategy 即可

  • 测试代码不变

  • 结果
    这里写图片描述

 

从截图中也可以清除的看到自定义的策略中，各个方法被调用的顺序。有了这些，我们就可以随心所欲的根据需求进行操作了

多个Realm验证顺序

  • 隐式排列

    • 当你配置多个realm的时候，处理的顺序默认就是你配置的顺序。
    • 这种情况通常就是只定义了realm，而没有配置securityManager的realms

  • 显式排列

    • 也就是显示的配置securityManager.realms，那么执行的顺序就是你配置该值的realm的顺序。
    • 通常更推荐显示排列。
 

我们可以简单的理解为，多个Realm验证的顺序，就是我们配置的顺序

           
好烦好烦方法
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
浅谈关于shiro——SimpleAuthenticationInfo中的参数
李公子的博客
09-20 1万+
/** * 执行认证逻辑 */ @Override protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken arg0) throws AuthenticationException { System.out.println("执行认证逻辑"); ...
http basic认证
码农小麦
07-01 1684
basic基本认证是从HTTP/1.0定义的认证方式，就是在http请求头部添加Authorization字段，传值: Basic + base64编码的(用户名:密码)。
自定义Realm实现授权
京北游戏官方
12-24 8702
1，授权流程 2，为使用要使用自定义Realm实现授权 与上边认证自定义realm一样，大部分情况是要从数据库获取权限数据，这里直接实现基于资源的授权。 3，UserRealm实现代码 public class UserRealm extends AuthorizingRealm { @Override public String getName() { return "UserRealm"; } //用于认证 @Override protected AuthenticationInfo
接口测试 之 HTTP 1.1 认证之BASIC认证
weixin_39472415的博客
09-22 1659
basic认证介绍认证步骤步骤图解BASIC 认证的的缺点测试：认证失败测试：认证成功 介绍 BASIC 认证（基本认证）是从HTTP/1. 1 就定义的认证方式，是Web服务器与通信客户端之间进行的认证 认证步骤 步骤1：当请求的资源需要 BASIC 认证时，服务器会随状态码 401 Authorization Required，返回 WWW-Authenticate 首部字段（响应头）的响应。该字段内包含认证的方式（BASIC）及Request-URI 安全域字符串（realm）。 步骤2：接收到状
Shiro学习
瑾年
04-06 147
Shiro1、shiro2、Shiro核心框架3、Spring Boot整合Shiro 1、shiro 什么是shiro 官网：https://shiro.apache.org/ 是一款主流的java安全框架，，不依赖任何容器，可以运行再JavaEE 和 javaSE项目中，它的主要作用是对访问系统的用户进行身份认证、授权、会话管理、加密等操作。 Shiro 就是用来解决安全管理的系统化框架 2、Shiro核心框架 用户、角色、权限 给角色赋予权限，给用户赋予角色 1、UsernamePasswordTok
基于spring boot 2和shiro实现身份验证案例
08-19
主要介绍了基于spring boot 2和shiro实现身份验证案例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Shiro学习第一式身份验证2
02-25
Shiro学习第一式身份验证,关于单个Realm，多个Realm以及JDBC Realm之类的，有需要的下了，免积分!
shiro学习笔记
04-03
shiro学习笔记以及代码，包括权限基础、shiro入门、shiro实例等
shiro学习笔记.rar
10-06
这是shiro的学习笔记，包括学习时候自己写的代码，主要内容就是使用springboot整合shiro，实现对用户的认证和授权，以及图片验证码的实现
shiro实现不同身份使用不同Realm进行验证
热门推荐
Alan_Xiang的博客
02-01 3万+
假设现在有这样一种需求：存在两张表user和admin，分别记录普通用户和管理员的信息。并且现在要实现普通用户和管理员的分开登录，即需要两个Realm——UserRealm和AdminRealm，分别处理普通用户和管理员的验证功能。 　　但是正常情况下，当定义了两个Realm，无论是普通用户登录，还是管理员登录，都会由这两个Realm共同处理。这是因为，当配置了多个Realm时，我们通常使用的认证
shiroConfig和UserRealm的写法
wuyiCguanxi的博客
10-07 364
shiroConfig的写法
【笔记】05.自定义Realm实现认证
Gu_jiaguaren的博客
04-15 142
05自定义Realm实现认证 Shiro默认使用自带的IniRealm，IniRealm从ini配置文件中读取用户的信息，大部分情况下需要从系统的数据库中读取用户信息，所以需要自定义Realm 1.Realm接口 最基础的是Realm接口，CachingRealm负责缓存处理，AuthenticatingRealm负责认证，AuthorizingRealm负责授权，通常已定义的realm继承AuthorizingRealm 2.实现步骤 1.创建项目 2.创建User类 package com.d
Spring Boot(十二)：Shiro登录认证和权限管理
qq_25432245的博客
10-30 1170
前言 这篇文章来学习如何使用 Spring Boot 集成 Apache Shiro 。安全应该是互联网公司的一道生命线，几乎任何的公司都会涉及到这方面的需求。在 Java 领域一般有 Spring Security、 Apache Shiro 等安全框架，但是由于 Spring Security 过于庞大和复杂，并且依赖spring环境；而Apache Shiro就相对独立，最主要是因为shi...
Shiro基础知识
Rk的博客
10-29 965
一、Shiro简介 1、什么是Shiro 1、Apache Shiro 是一个Java 的安全（权限）框架。 2、Shiro 可以非常容易的开发出足够好的应用，其不仅可以用在JavaSE环境，也可以用在JavaEE环境。 3、Shiro可以完成，认证，授权，加密，会话管理，Web集成，缓存等。 2、Shiro架构 Shiro三大对象:Sub............
第五章：Realm
weixin_34363171的博客
04-29 137
一，UserRealm 1,UserRealm父类AuthorizingRealm将获取Subject相关信息分成两步： 1.1，获取身份验证信息（doGetAuthenticationInfo）： 首先根据传入的用户名获取User信息；然后如果user为空，那么抛出没找到帐号异常UnknownAccountException；如果user找到但锁定了抛出锁定异常LockedAccountE...
秒懂HTTP之基本认证(Basic Authentication)
ShuSheng007的程序人生
04-27 1万+
版权申明】非商业目的注明出处可自由转载 博文地址： 出自：shusheng007 文章目录概述HTTP 的认证机制什么是认证HTTP 基本认证HTTP 基本认证的优缺点优点缺点HTTP 基本认证使用场景总结 概述 毫无疑问在现今的中国，网络已经成为广大人民群众日常的基本生活资料，我相信网络在极大丰富人民群众日常生活的同时，网络安全问题在中国将变得日益突出，如果你有志于投身计算机行业，相信网络安...
Shiro学习笔记之自定义Realm实现认证和授权
wsb_2526的博客
07-26 249
为什么要自定义Realm 我们之前通过配置文件去获取用户角色权限的信息，但是有些时候希望从数据库中读取权限信息，此时就需要用到自定义Realm。 创建实体类 public class User { private String username; private String password; public String getUsername() { return username; } public void setUsername(String username) {
shiro配置shiroConfig和UserRealm文件出错
weixin_40571937的博客
08-04 612
问题描述： 在配置shiro认证和权限功能的时候，对这个文件进行配置。按照网页教程，发现几个报错。 错误一： 直接全部按照网页配置，运行之后报错 解决办法： 错误二： @Qualified注解报红 如下图所示，依赖的bean的名字设置完全一样 解决办法： 可能是版本更新使得securityManager这个关键词重名了，我们换一个bean的名字代替即可。 这里我用MySecurityManager代替原来的securityManger。 ...
Springboot学习笔记之springboot+shiro+cas
最新发布
05-21
CAS 是一个单点登录（SSO）协议，可以实现用户在多个应用系统中使用同一个身份验证。 下面是一个简单的 Spring Boot + Shiro + CAS 的示例应用程序： 1. 创建一个 Spring Boot 应用程序，并添加依赖： ```xml ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值